create_exadb_vm_cluster async ¶

async def create_exadb_vm_cluster(
    self,
    display_name: "capo_odb.types.resource_display_name.ResourceDisplayName",
    enabled_ecpu_count: int,
    exascale_db_storage_vault_id: "capo_odb.types.resource_id_or_arn.ResourceIdOrArn",
    grid_image_id: str,
    hostname: "capo_odb.types.hostname.Hostname",
    node_count: int,
    odb_network_id: "capo_odb.types.resource_id_or_arn.ResourceIdOrArn",
    shape: str,
    ssh_public_keys: "capo_odb.types.string_list.StringList",
    total_ecpu_count: int,
    vm_file_system_storage_total_size_in_g_bs: int,
    *,
    config_overrides: Optional[AsyncodbClientConfig] = None,
    cluster_name: Optional["capo_odb.types.cluster_name.ClusterName"] = None,
    data_collection_options: Optional[
        "capo_odb.types.data_collection_options.DataCollectionOptions"
    ] = None,
    license_model: Optional["capo_odb.types.license_model.LicenseModel"] = None,
    scan_listener_port_tcp: Optional[int] = None,
    scan_listener_port_tcp_ssl: Optional[int] = None,
    shape_attribute: Optional[
        "capo_odb.types.shape_attribute.ShapeAttribute"
    ] = None,
    system_version: Optional[str] = None,
    tags: Optional["capo_odb.types.request_tag_map.RequestTagMap"] = None,
    time_zone: Optional[str] = None,
    client_token: Optional[
        "capo_odb.types.general_input_string.GeneralInputString"
    ] = None,
) -> "capo_odb.types.create_exadb_vm_cluster_output.CreateExadbVmClusterOutput":
    """<p>Creates an Exascale VM cluster.</p>

    Args:
        display_name: <p>A user-friendly name for the Exascale VM cluster.</p>
        enabled_ecpu_count: <p>The number of ECPUs to enable for the Exascale VM cluster.</p>
        exascale_db_storage_vault_id: <p>The unique identifier of the Exascale storage vault for this Exascale VM cluster.</p>
        grid_image_id: <p>The Grid Infrastructure software image ID for the Exascale VM cluster.</p>
        hostname: <p>The host name for the Exascale VM cluster.</p>
        node_count: <p>The number of nodes in the Exascale VM cluster.</p>
        odb_network_id: <p>The unique identifier of the ODB network for the Exascale VM cluster.</p>
        shape: <p>The shape of the Exascale VM cluster.</p>
        ssh_public_keys: <p>The public key portion of one or more key pairs used for SSH access to the Exascale VM cluster.</p>
        total_ecpu_count: <p>The total number of ECPUs for the Exascale VM cluster.</p>
        vm_file_system_storage_total_size_in_g_bs: <p>The total amount of file system storage, in gigabytes (GB), for the Exascale VM cluster.</p>
        cluster_name: <p>A name for the Grid Infrastructure cluster. The name isn't case sensitive.</p>
        data_collection_options: <p>The set of preferences for the various diagnostic collection options for the Exascale VM cluster.</p>
        license_model: <p>The Oracle license model to apply to the Exascale VM cluster.</p>
        scan_listener_port_tcp: <p>The port number for TCP connections to the Single Client Access Name (SCAN) listener.</p>
        scan_listener_port_tcp_ssl: <p>The port number for TCP connections with SSL to the Single Client Access Name (SCAN) listener.</p>
        shape_attribute: <p>The shape attribute for the Exascale VM cluster.</p>
        system_version: <p>The version of the operating system of the image for the Exascale VM cluster.</p>
        tags: <p>The list of resource tags to apply to the Exascale VM cluster.</p>
        time_zone: <p>The time zone for the Exascale VM cluster.</p>
        client_token: <p>A unique, case-sensitive identifier that you provide to ensure that the operation completes no more than one time. If you submit the same request twice with the same client token, the service ignores the second request and returns the result of the first. If you don't specify a client token, the AWS SDK automatically generates one. The client token is valid for up to 24 hours after it's first used.</p>

    Raises:
        capo_odb.errors.access_denied_exception.AccessDeniedException: <p>You don't have sufficient access to perform this action. Make sure you have the required permissions and try again.</p>
        capo_odb.errors.conflict_exception.ConflictException: <p>Occurs when a conflict with the current status of your resource. Fix any inconsistencies with your resource and try again.</p>
        capo_odb.errors.internal_server_exception.InternalServerException: <p>Occurs when there is an internal failure in the Oracle Database@Amazon Web Services service. Wait and try again.</p>
        capo_odb.errors.resource_not_found_exception.ResourceNotFoundException: <p>The operation tried to access a resource that doesn't exist. Make sure you provided the correct resource and try again.</p>
        capo_odb.errors.service_quota_exceeded_exception.ServiceQuotaExceededException: <p>You have exceeded the service quota.</p>
        capo_odb.errors.throttling_exception.ThrottlingException: <p>The request was denied due to request throttling.</p>
        capo_odb.errors.validation_exception.ValidationException: <p>The request has failed validation because it is missing required fields or has invalid inputs.</p>
        capo_odb.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_odb.types.create_exadb_vm_cluster_input.CreateExadbVmClusterInput]",
    ) -> AsyncOperationResponse[
        "capo_odb.types.create_exadb_vm_cluster_output.CreateExadbVmClusterOutput"
    ]:
        import capo_odb._operations.odb.create_exadb_vm_cluster

        (
            output,
            http_response,
        ) = await capo_odb._operations.odb.create_exadb_vm_cluster.async_create_exadb_vm_cluster(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("CreateExadbVmCluster")
    )
    input_: capo_odb.types.create_exadb_vm_cluster_input.CreateExadbVmClusterInput = {
        "display_name": display_name,
        "enabled_ecpu_count": enabled_ecpu_count,
        "exascale_db_storage_vault_id": exascale_db_storage_vault_id,
        "grid_image_id": grid_image_id,
        "hostname": hostname,
        "node_count": node_count,
        "odb_network_id": odb_network_id,
        "shape": shape,
        "ssh_public_keys": ssh_public_keys,
        "total_ecpu_count": total_ecpu_count,
        "vm_file_system_storage_total_size_in_g_bs": vm_file_system_storage_total_size_in_g_bs,
    }
    if cluster_name is not None:
        input_["cluster_name"] = cluster_name
    if data_collection_options is not None:
        input_["data_collection_options"] = data_collection_options
    if license_model is not None:
        input_["license_model"] = license_model
    if scan_listener_port_tcp is not None:
        input_["scan_listener_port_tcp"] = scan_listener_port_tcp
    if scan_listener_port_tcp_ssl is not None:
        input_["scan_listener_port_tcp_ssl"] = scan_listener_port_tcp_ssl
    if shape_attribute is not None:
        input_["shape_attribute"] = shape_attribute
    if system_version is not None:
        input_["system_version"] = system_version
    if tags is not None:
        input_["tags"] = tags
    if time_zone is not None:
        input_["time_zone"] = time_zone
    if client_token is None:
        client_token = str(uuid.uuid4())
    input_["client_token"] = client_token

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