create_cloud_vm_cluster ¶

def create_cloud_vm_cluster(
    self,
    cloud_exadata_infrastructure_id: "capo_odb.types.resource_id_or_arn.ResourceIdOrArn",
    cpu_core_count: int,
    display_name: "capo_odb.types.resource_display_name.ResourceDisplayName",
    gi_version: str,
    hostname: "capo_odb.types.hostname.Hostname",
    ssh_public_keys: "capo_odb.types.string_list.StringList",
    odb_network_id: "capo_odb.types.resource_id_or_arn.ResourceIdOrArn",
    *,
    config_overrides: Optional[odbClientConfig] = None,
    cluster_name: Optional["capo_odb.types.cluster_name.ClusterName"] = None,
    data_collection_options: Optional[
        "capo_odb.types.data_collection_options.DataCollectionOptions"
    ] = None,
    data_storage_size_in_t_bs: Optional[float] = None,
    db_node_storage_size_in_g_bs: Optional[int] = None,
    db_servers: Optional["capo_odb.types.string_list.StringList"] = None,
    tags: Optional["capo_odb.types.request_tag_map.RequestTagMap"] = None,
    is_local_backup_enabled: Optional[bool] = None,
    is_sparse_diskgroup_enabled: Optional[bool] = None,
    license_model: Optional["capo_odb.types.license_model.LicenseModel"] = None,
    memory_size_in_g_bs: Optional[int] = None,
    system_version: Optional[str] = None,
    time_zone: Optional[str] = None,
    client_token: Optional[
        "capo_odb.types.general_input_string.GeneralInputString"
    ] = None,
    scan_listener_port_tcp: Optional[int] = None,
) -> "capo_odb.types.create_cloud_vm_cluster_output.CreateCloudVmClusterOutput":
    """<p>Creates a VM cluster on the specified Exadata infrastructure.</p>

    Args:
        cloud_exadata_infrastructure_id: <p>The unique identifier of the Exadata infrastructure for this VM cluster.</p>
        cpu_core_count: <p>The number of CPU cores to enable on the VM cluster.</p>
        display_name: <p>A user-friendly name for the VM cluster.</p>
        gi_version: <p>A valid software version of Oracle Grid Infrastructure (GI). To get the list of valid values, use the <code>ListGiVersions</code> operation and specify the shape of the Exadata infrastructure.</p> <p>Example: <code>19.0.0.0</code> </p>
        hostname: <p>The host name for the VM cluster.</p> <p>Constraints:</p> <ul> <li> <p>Can't be "localhost" or "hostname".</p> </li> <li> <p>Can't contain "-version".</p> </li> <li> <p>The maximum length of the combined hostname and domain is 63 characters.</p> </li> <li> <p>The hostname must be unique within the subnet.</p> </li> </ul>
        ssh_public_keys: <p>The public key portion of one or more key pairs used for SSH access to the VM cluster.</p>
        odb_network_id: <p>The unique identifier of the ODB network for the 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 VM cluster.</p>
        data_storage_size_in_t_bs: <p>The size of the data disk group, in terabytes (TBs), to allocate for the VM cluster.</p>
        db_node_storage_size_in_g_bs: <p>The amount of local node storage, in gigabytes (GB), to allocate for the VM cluster.</p>
        db_servers: <p>The list of database servers for the VM cluster.</p>
        tags: <p>The list of resource tags to apply to the VM cluster.</p>
        is_local_backup_enabled: <p>Specifies whether to enable database backups to local Exadata storage for the VM cluster.</p>
        is_sparse_diskgroup_enabled: <p>Specifies whether to create a sparse disk group for the VM cluster.</p>
        license_model: <p>The Oracle license model to apply to the VM cluster.</p> <p>Default: <code>LICENSE_INCLUDED</code> </p>
        memory_size_in_g_bs: <p>The amount of memory, in gigabytes (GB), to allocate for the VM cluster.</p>
        system_version: <p>The version of the operating system of the image for the VM cluster.</p>
        time_zone: <p>The time zone for the VM cluster. For a list of valid values for time zone, you can check the options in the console.</p> <p>Default: UTC</p>
        client_token: <p>A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If you don't specify a client token, the Amazon Web Services SDK automatically generates a client token and uses it for the request to ensure idempotency. The client token is valid for up to 24 hours after it's first used.</p>
        scan_listener_port_tcp: <p>The port number for TCP connections to the single client access name (SCAN) listener. </p> <p>Valid values: <code>1024–8999</code> with the following exceptions: <code>2484</code>, <code>6100</code>, <code>6200</code>, <code>7060</code>, <code>7070</code>, <code>7085</code>, and <code>7879</code> </p> <p>Default: <code>1521</code> </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.
    """

    def _handler(
        req: "OperationRequest[capo_odb.types.create_cloud_vm_cluster_input.CreateCloudVmClusterInput]",
    ) -> OperationResponse[
        "capo_odb.types.create_cloud_vm_cluster_output.CreateCloudVmClusterOutput"
    ]:
        import capo_odb._operations.odb.create_cloud_vm_cluster

        output, http_response = (
            capo_odb._operations.odb.create_cloud_vm_cluster.create_cloud_vm_cluster(
                req.options, req.input
            )
        )
        return OperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("CreateCloudVmCluster")
    )
    input_: capo_odb.types.create_cloud_vm_cluster_input.CreateCloudVmClusterInput = {
        "cloud_exadata_infrastructure_id": cloud_exadata_infrastructure_id,
        "cpu_core_count": cpu_core_count,
        "display_name": display_name,
        "gi_version": gi_version,
        "hostname": hostname,
        "ssh_public_keys": ssh_public_keys,
        "odb_network_id": odb_network_id,
    }
    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 data_storage_size_in_t_bs is not None:
        input_["data_storage_size_in_t_bs"] = data_storage_size_in_t_bs
    if db_node_storage_size_in_g_bs is not None:
        input_["db_node_storage_size_in_g_bs"] = db_node_storage_size_in_g_bs
    if db_servers is not None:
        input_["db_servers"] = db_servers
    if tags is not None:
        input_["tags"] = tags
    if is_local_backup_enabled is not None:
        input_["is_local_backup_enabled"] = is_local_backup_enabled
    if is_sparse_diskgroup_enabled is not None:
        input_["is_sparse_diskgroup_enabled"] = is_sparse_diskgroup_enabled
    if license_model is not None:
        input_["license_model"] = license_model
    if memory_size_in_g_bs is not None:
        input_["memory_size_in_g_bs"] = memory_size_in_g_bs
    if system_version is not None:
        input_["system_version"] = system_version
    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
    if scan_listener_port_tcp is not None:
        input_["scan_listener_port_tcp"] = scan_listener_port_tcp

    response = execute_pipeline(
        OperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    response.response.close()
    return response.output