create_security_configuration `async` ¶

create_security_configuration(
    client_token: ClientToken,
    name: ResourceNameString,
    security_configuration_data: SecurityConfigurationData,
    *,
    config_overrides: Optional[AsyncEMRcontainersClientConfig] = None,
    container_provider: Optional[ContainerProvider] = None,
    tags: Optional[TagMap] = None,
) -> CreateSecurityConfigurationResponse

Creates a security configuration. Security configurations in Amazon EMR on EKS are templates for different security setups. You can use security configurations to configure the Lake Formation integration setup. You can also create a security configuration to re-use a security setup each time you create a virtual cluster.

Parameters:

client_token (ClientToken) –

The client idempotency token to use when creating the security configuration.
name (ResourceNameString) –

The name of the security configuration.
container_provider (Optional[ContainerProvider], default: None ) –

The container provider associated with the security configuration.
security_configuration_data (SecurityConfigurationData) –

Security configuration input for the request.
tags (Optional[TagMap], default: None ) –

The tags to add to the security configuration.

Raises:

InternalServerException –

This is an internal server exception.
ValidationException –

There are invalid parameters in the client request.
UnknownServiceError –

The service returned an error code this client does not model.

Source code in docs_src/capo_emr_containers/_services/async_em_rcontainers.py

async def create_security_configuration(
    self,
    client_token: "capo_emr_containers.types.client_token.ClientToken",
    name: "capo_emr_containers.types.resource_name_string.ResourceNameString",
    security_configuration_data: "capo_emr_containers.types.security_configuration_data.SecurityConfigurationData",
    *,
    config_overrides: Optional[AsyncEMRcontainersClientConfig] = None,
    container_provider: Optional[
        "capo_emr_containers.types.container_provider.ContainerProvider"
    ] = None,
    tags: Optional["capo_emr_containers.types.tag_map.TagMap"] = None,
) -> "capo_emr_containers.types.create_security_configuration_response.CreateSecurityConfigurationResponse":
    """<p>Creates a security configuration. Security configurations in Amazon EMR on EKS are templates for different security setups. You can use security configurations to configure the Lake Formation integration setup. You can also create a security configuration to re-use a security setup each time you create a virtual cluster.</p>

    Args:
        client_token: <p>The client idempotency token to use when creating the security configuration.</p>
        name: <p>The name of the security configuration.</p>
        container_provider: <p>The container provider associated with the security configuration.</p>
        security_configuration_data: <p>Security configuration input for the request.</p>
        tags: <p>The tags to add to the security configuration.</p>

    Raises:
        capo_emr_containers.errors.internal_server_exception.InternalServerException: <p>This is an internal server exception.</p>
        capo_emr_containers.errors.validation_exception.ValidationException: <p>There are invalid parameters in the client request.</p>
        capo_emr_containers.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_emr_containers.types.create_security_configuration_request.CreateSecurityConfigurationRequest]",
    ) -> AsyncOperationResponse[
        "capo_emr_containers.types.create_security_configuration_response.CreateSecurityConfigurationResponse"
    ]:
        import capo_emr_containers._operations.aws_chicago_web_service.create_security_configuration

        (
            output,
            http_response,
        ) = await capo_emr_containers._operations.aws_chicago_web_service.create_security_configuration.async_create_security_configuration(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("CreateSecurityConfiguration")
    )
    input_: capo_emr_containers.types.create_security_configuration_request.CreateSecurityConfigurationRequest = {
        "client_token": client_token,
        "name": name,
        "security_configuration_data": security_configuration_data,
    }
    if container_provider is not None:
        input_["container_provider"] = container_provider
    if tags is not None:
        input_["tags"] = tags

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

create_security_configuration async ¶

create_security_configuration `async` ¶