create_namespace async ¶

async def create_namespace(
    self,
    namespace_name: "capo_redshift_serverless.types.namespace_name.NamespaceName",
    *,
    config_overrides: Optional[AsyncRedshiftServerlessClientConfig] = None,
    admin_username: Optional[
        "capo_redshift_serverless.types.db_user.DbUser"
    ] = None,
    admin_user_password: Optional[
        "capo_redshift_serverless.types.db_password.DbPassword"
    ] = None,
    db_name: Optional[str] = None,
    kms_key_id: Optional[str] = None,
    default_iam_role_arn: Optional[str] = None,
    iam_roles: Optional[
        "capo_redshift_serverless.types.iam_role_arn_list.IamRoleArnList"
    ] = None,
    log_exports: Optional[
        "capo_redshift_serverless.types.log_export_list.LogExportList"
    ] = None,
    tags: Optional["capo_redshift_serverless.types.tag_list.TagList"] = None,
    manage_admin_password: Optional[bool] = None,
    admin_password_secret_kms_key_id: Optional[
        "capo_redshift_serverless.types.kms_key_id.KmsKeyId"
    ] = None,
    redshift_idc_application_arn: Optional[
        "capo_redshift_serverless.types.redshift_idc_application_arn.RedshiftIdcApplicationArn"
    ] = None,
) -> "capo_redshift_serverless.types.create_namespace_response.CreateNamespaceResponse":
    """<p>Creates a namespace in Amazon Redshift Serverless.</p>

    Args:
        namespace_name: <p>The name of the namespace.</p>
        admin_username: <p>The username of the administrator for the first database created in the namespace.</p>
        admin_user_password: <p>The password of the administrator for the first database created in the namespace.</p> <p>You can't use <code>adminUserPassword</code> if <code>manageAdminPassword</code> is true. </p>
        db_name: <p>The name of the first database created in the namespace.</p>
        kms_key_id: <p>The ID of the Amazon Web Services Key Management Service key used to encrypt your data.</p>
        default_iam_role_arn: <p>The Amazon Resource Name (ARN) of the IAM role to set as a default in the namespace.</p>
        iam_roles: <p>A list of IAM roles to associate with the namespace.</p>
        log_exports: <p>The types of logs the namespace can export. Available export types are <code>userlog</code>, <code>connectionlog</code>, and <code>useractivitylog</code>.</p>
        tags: <p>A list of tag instances.</p>
        manage_admin_password: <p>If <code>true</code>, Amazon Redshift uses Secrets Manager to manage the namespace's admin credentials. You can't use <code>adminUserPassword</code> if <code>manageAdminPassword</code> is true. If <code>manageAdminPassword</code> is false or not set, Amazon Redshift uses <code>adminUserPassword</code> for the admin user account's password. </p>
        admin_password_secret_kms_key_id: <p>The ID of the Key Management Service (KMS) key used to encrypt and store the namespace's admin credentials secret. You can only use this parameter if <code>manageAdminPassword</code> is true.</p>
        redshift_idc_application_arn: <p>The ARN for the Redshift application that integrates with IAM Identity Center.</p>

    Raises:
        capo_redshift_serverless.errors.conflict_exception.ConflictException: <p>The submitted action has conflicts.</p>
        capo_redshift_serverless.errors.internal_server_exception.InternalServerException: <p>The request processing has failed because of an unknown error, exception or failure.</p>
        capo_redshift_serverless.errors.too_many_tags_exception.TooManyTagsException: <p>The request exceeded the number of tags allowed for a resource.</p>
        capo_redshift_serverless.errors.validation_exception.ValidationException: <p>The input failed to satisfy the constraints specified by an Amazon Web Services service.</p>
        capo_redshift_serverless.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_redshift_serverless.types.create_namespace_request.CreateNamespaceRequest]",
    ) -> AsyncOperationResponse[
        "capo_redshift_serverless.types.create_namespace_response.CreateNamespaceResponse"
    ]:
        import capo_redshift_serverless._operations.redshift_serverless.create_namespace

        (
            output,
            http_response,
        ) = await capo_redshift_serverless._operations.redshift_serverless.create_namespace.async_create_namespace(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    def _redact_input(
        input_: "capo_redshift_serverless.types.create_namespace_request.CreateNamespaceRequest",
    ) -> dict[str, Any]:
        import capo_redshift_serverless.types.create_namespace_request

        return capo_redshift_serverless.types.create_namespace_request.redact_sensitive(
            input_
        )

    def _redact_output(
        output: "capo_redshift_serverless.types.create_namespace_response.CreateNamespaceResponse",
    ) -> dict[str, Any]:
        import capo_redshift_serverless.types.create_namespace_response

        return capo_redshift_serverless.types.create_namespace_response.redact_sensitive(
            output
        )

    interceptors_, options_ = self.operation_options(
        config_overrides,
        OperationLogging(
            "CreateNamespace",
            redact_input=_redact_input,
            redact_output=_redact_output,
        ),
    )
    input_: capo_redshift_serverless.types.create_namespace_request.CreateNamespaceRequest = {
        "namespace_name": namespace_name
    }
    if admin_username is not None:
        input_["admin_username"] = admin_username
    if admin_user_password is not None:
        input_["admin_user_password"] = admin_user_password
    if db_name is not None:
        input_["db_name"] = db_name
    if kms_key_id is not None:
        input_["kms_key_id"] = kms_key_id
    if default_iam_role_arn is not None:
        input_["default_iam_role_arn"] = default_iam_role_arn
    if iam_roles is not None:
        input_["iam_roles"] = iam_roles
    if log_exports is not None:
        input_["log_exports"] = log_exports
    if tags is not None:
        input_["tags"] = tags
    if manage_admin_password is not None:
        input_["manage_admin_password"] = manage_admin_password
    if admin_password_secret_kms_key_id is not None:
        input_["admin_password_secret_kms_key_id"] = (
            admin_password_secret_kms_key_id
        )
    if redshift_idc_application_arn is not None:
        input_["redshift_idc_application_arn"] = redshift_idc_application_arn

    response = await aexecute_pipeline(
        AsyncOperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    await response.response.aclose()
    return response.output