create_redshift_idc_application async ¶

async def create_redshift_idc_application(
    self,
    *,
    config_overrides: Optional[AsyncRedshiftClientConfig] = None,
    idc_instance_arn: Optional["capo_redshift.types.string.String"] = None,
    redshift_idc_application_name: Optional[
        "capo_redshift.types.redshift_idc_application_name.RedshiftIdcApplicationName"
    ] = None,
    identity_namespace: Optional[
        "capo_redshift.types.identity_namespace_string.IdentityNamespaceString"
    ] = None,
    idc_display_name: Optional[
        "capo_redshift.types.idc_display_name_string.IdcDisplayNameString"
    ] = None,
    iam_role_arn: Optional["capo_redshift.types.string.String"] = None,
    authorized_token_issuer_list: Optional[
        "capo_redshift.types.authorized_token_issuer_list.AuthorizedTokenIssuerList"
    ] = None,
    service_integrations: Optional[
        "capo_redshift.types.service_integration_list.ServiceIntegrationList"
    ] = None,
    application_type: Optional[
        "capo_redshift.types.application_type.ApplicationType"
    ] = None,
    tags: Optional["capo_redshift.types.tag_list.TagList"] = None,
    sso_tag_keys: Optional["capo_redshift.types.tag_key_list.TagKeyList"] = None,
) -> "capo_redshift.types.create_redshift_idc_application_result.CreateRedshiftIdcApplicationResult":
    """<p>Creates an Amazon Redshift application for use with IAM Identity Center.</p>

    Args:
        idc_instance_arn: <p>The Amazon resource name (ARN) of the IAM Identity Center instance where Amazon Redshift creates a new managed application.</p>
        redshift_idc_application_name: <p>The name of the Redshift application in IAM Identity Center.</p>
        identity_namespace: <p>The namespace for the Amazon Redshift IAM Identity Center application instance. It determines which managed application verifies the connection token.</p>
        idc_display_name: <p>The display name for the Amazon Redshift IAM Identity Center application instance. It appears in the console.</p>
        iam_role_arn: <p>The IAM role ARN for the Amazon Redshift IAM Identity Center application instance. It has the required permissions to be assumed and invoke the IDC Identity Center API.</p>
        authorized_token_issuer_list: <p>The token issuer list for the Amazon Redshift IAM Identity Center application instance.</p>
        service_integrations: <p>A collection of service integrations for the Redshift IAM Identity Center application.</p>
        application_type: <p>The type of application being created. Valid values are <code>None</code> or <code>Lakehouse</code>. Use <code>Lakehouse</code> to enable Amazon Redshift federated permissions on cluster.</p>
        tags: <p>A list of tags.</p>
        sso_tag_keys: <p>A list of tags keys that Redshift Identity Center applications copy to IAM Identity Center. For each input key, the tag corresponding to the key-value pair is propagated.</p>

    Raises:
        capo_redshift.errors.dependent_service_access_denied_fault.DependentServiceAccessDeniedFault: <p>A dependent service denied access for the integration.</p>
        capo_redshift.errors.dependent_service_unavailable_fault.DependentServiceUnavailableFault: <p>Your request cannot be completed because a dependent internal service is temporarily unavailable. Wait 30 to 60 seconds and try again.</p>
        capo_redshift.errors.invalid_tag_fault.InvalidTagFault: <p>The tag is invalid.</p>
        capo_redshift.errors.redshift_idc_application_already_exists_fault.RedshiftIdcApplicationAlreadyExistsFault: <p>The application you attempted to add already exists.</p>
        capo_redshift.errors.redshift_idc_application_quota_exceeded_fault.RedshiftIdcApplicationQuotaExceededFault: <p>The maximum number of Redshift IAM Identity Center applications was exceeded.</p>
        capo_redshift.errors.tag_limit_exceeded_fault.TagLimitExceededFault: <p>You have exceeded the number of tags allowed.</p>
        capo_redshift.errors.unsupported_operation_fault.UnsupportedOperationFault: <p>The requested operation isn't supported.</p>
        capo_redshift.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_redshift.types.create_redshift_idc_application_message.CreateRedshiftIdcApplicationMessage]",
    ) -> AsyncOperationResponse[
        "capo_redshift.types.create_redshift_idc_application_result.CreateRedshiftIdcApplicationResult"
    ]:
        import capo_redshift._operations.redshift_service_version20121201.create_redshift_idc_application

        (
            output,
            http_response,
        ) = await capo_redshift._operations.redshift_service_version20121201.create_redshift_idc_application.async_create_redshift_idc_application(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("CreateRedshiftIdcApplication")
    )
    input_: capo_redshift.types.create_redshift_idc_application_message.CreateRedshiftIdcApplicationMessage = {}
    if idc_instance_arn is not None:
        input_["idc_instance_arn"] = idc_instance_arn
    if redshift_idc_application_name is not None:
        input_["redshift_idc_application_name"] = redshift_idc_application_name
    if identity_namespace is not None:
        input_["identity_namespace"] = identity_namespace
    if idc_display_name is not None:
        input_["idc_display_name"] = idc_display_name
    if iam_role_arn is not None:
        input_["iam_role_arn"] = iam_role_arn
    if authorized_token_issuer_list is not None:
        input_["authorized_token_issuer_list"] = authorized_token_issuer_list
    if service_integrations is not None:
        input_["service_integrations"] = service_integrations
    if application_type is not None:
        input_["application_type"] = application_type
    if tags is not None:
        input_["tags"] = tags
    if sso_tag_keys is not None:
        input_["sso_tag_keys"] = sso_tag_keys

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