<html><body>
<style>

body, h1, h2, h3, div, span, p, pre, a {
  margin: 0;
  padding: 0;
  border: 0;
  font-weight: inherit;
  font-style: inherit;
  font-size: 100%;
  font-family: inherit;
  vertical-align: baseline;
}

body {
  font-size: 13px;
  padding: 1em;
}

h1 {
  font-size: 26px;
  margin-bottom: 1em;
}

h2 {
  font-size: 24px;
  margin-bottom: 1em;
}

h3 {
  font-size: 20px;
  margin-bottom: 1em;
  margin-top: 1em;
}

pre, code {
  line-height: 1.5;
  font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
}

pre {
  margin-top: 0.5em;
}

h1, h2, h3, p {
  font-family: Arial, sans serif;
}

h1, h2, h3 {
  border-bottom: solid #CCC 1px;
}

.toc_element {
  margin-top: 0.5em;
}

.firstline {
  margin-left: 2 em;
}

.method  {
  margin-top: 1em;
  border: solid 1px #CCC;
  padding: 1em;
  background: #EEE;
}

.details {
  font-weight: bold;
  font-size: 14px;
}

</style>

<h1><a href="spanner_v1.html">Cloud Spanner API</a> . <a href="spanner_v1.projects.html">projects</a> . <a href="spanner_v1.projects.instanceConfigs.html">instanceConfigs</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="spanner_v1.projects.instanceConfigs.operations.html">operations()</a></code>
</p>
<p class="firstline">Returns the operations Resource.</p>

<p class="toc_element">
  <code><a href="spanner_v1.projects.instanceConfigs.ssdCaches.html">ssdCaches()</a></code>
</p>
<p class="firstline">Returns the ssdCaches Resource.</p>

<p class="toc_element">
  <code><a href="#close">close()</a></code></p>
<p class="firstline">Close httplib2 connections.</p>
<p class="toc_element">
  <code><a href="#create">create(parent, body=None, x__xgafv=None)</a></code></p>
<p class="firstline">Creates an instance config and begins preparing it to be used. The returned long-running operation can be used to track the progress of preparing the new instance config. The instance config name is assigned by the caller. If the named instance config already exists, `CreateInstanceConfig` returns `ALREADY_EXISTS`. Immediately after the request returns: * The instance config is readable via the API, with all requested attributes. The instance config's reconciling field is set to true. Its state is `CREATING`. While the operation is pending: * Cancelling the operation renders the instance config immediately unreadable via the API. * Except for deleting the creating resource, all other attempts to modify the instance config are rejected. Upon completion of the returned operation: * Instances can be created using the instance configuration. * The instance config's reconciling field becomes false. Its state becomes `READY`. The returned long-running operation will have a name of the format `/operations/` and can be used to track creation of the instance config. The metadata field type is CreateInstanceConfigMetadata. The response field type is InstanceConfig, if successful. Authorization requires `spanner.instanceConfigs.create` permission on the resource parent.</p>
<p class="toc_element">
  <code><a href="#delete">delete(name, etag=None, validateOnly=None, x__xgafv=None)</a></code></p>
<p class="firstline">Deletes the instance config. Deletion is only allowed when no instances are using the configuration. If any instances are using the config, returns `FAILED_PRECONDITION`. Only user managed configurations can be deleted. Authorization requires `spanner.instanceConfigs.delete` permission on the resource name.</p>
<p class="toc_element">
  <code><a href="#get">get(name, x__xgafv=None)</a></code></p>
<p class="firstline">Gets information about a particular instance configuration.</p>
<p class="toc_element">
  <code><a href="#list">list(parent, pageSize=None, pageToken=None, x__xgafv=None)</a></code></p>
<p class="firstline">Lists the supported instance configurations for a given project.</p>
<p class="toc_element">
  <code><a href="#list_next">list_next()</a></code></p>
<p class="firstline">Retrieves the next page of results.</p>
<p class="toc_element">
  <code><a href="#patch">patch(name, body=None, x__xgafv=None)</a></code></p>
<p class="firstline">Updates an instance config. The returned long-running operation can be used to track the progress of updating the instance. If the named instance config does not exist, returns `NOT_FOUND`. Only user managed configurations can be updated. Immediately after the request returns: * The instance config's reconciling field is set to true. While the operation is pending: * Cancelling the operation sets its metadata's cancel_time. The operation is guaranteed to succeed at undoing all changes, after which point it terminates with a `CANCELLED` status. * All other attempts to modify the instance config are rejected. * Reading the instance config via the API continues to give the pre-request values. Upon completion of the returned operation: * Creating instances using the instance configuration uses the new values. * The instance config's new values are readable via the API. * The instance config's reconciling field becomes false. The returned long-running operation will have a name of the format `/operations/` and can be used to track the instance config modification. The metadata field type is UpdateInstanceConfigMetadata. The response field type is InstanceConfig, if successful. Authorization requires `spanner.instanceConfigs.update` permission on the resource name.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="close">close()</code>
  <pre>Close httplib2 connections.</pre>
</div>

<div class="method">
    <code class="details" id="create">create(parent, body=None, x__xgafv=None)</code>
  <pre>Creates an instance config and begins preparing it to be used. The returned long-running operation can be used to track the progress of preparing the new instance config. The instance config name is assigned by the caller. If the named instance config already exists, `CreateInstanceConfig` returns `ALREADY_EXISTS`. Immediately after the request returns: * The instance config is readable via the API, with all requested attributes. The instance config&#x27;s reconciling field is set to true. Its state is `CREATING`. While the operation is pending: * Cancelling the operation renders the instance config immediately unreadable via the API. * Except for deleting the creating resource, all other attempts to modify the instance config are rejected. Upon completion of the returned operation: * Instances can be created using the instance configuration. * The instance config&#x27;s reconciling field becomes false. Its state becomes `READY`. The returned long-running operation will have a name of the format `/operations/` and can be used to track creation of the instance config. The metadata field type is CreateInstanceConfigMetadata. The response field type is InstanceConfig, if successful. Authorization requires `spanner.instanceConfigs.create` permission on the resource parent.

Args:
  parent: string, Required. The name of the project in which to create the instance config. Values are of the form `projects/`. (required)
  body: object, The request body.
    The object takes the form of:

{ # The request for CreateInstanceConfigRequest.
  &quot;instanceConfig&quot;: { # A possible configuration for a Cloud Spanner instance. Configurations define the geographic placement of nodes and their replication. # Required. The InstanceConfig proto of the configuration to create. instance_config.name must be `/instanceConfigs/`. instance_config.base_config must be a Google managed configuration name, e.g. /instanceConfigs/us-east1, /instanceConfigs/nam3.
    &quot;baseConfig&quot;: &quot;A String&quot;, # Base configuration name, e.g. projects//instanceConfigs/nam3, based on which this configuration is created. Only set for user managed configurations. `base_config` must refer to a configuration of type GOOGLE_MANAGED in the same project as this configuration.
    &quot;configType&quot;: &quot;A String&quot;, # Output only. Whether this instance config is a Google or User Managed Configuration.
    &quot;displayName&quot;: &quot;A String&quot;, # The name of this instance configuration as it appears in UIs.
    &quot;etag&quot;: &quot;A String&quot;, # etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a instance config from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform instance config updates in order to avoid race conditions: An etag is returned in the response which contains instance configs, and systems are expected to put that etag in the request to update instance config to ensure that their change will be applied to the same version of the instance config. If no etag is provided in the call to update instance config, then the existing instance config is overwritten blindly.
    &quot;freeInstanceAvailability&quot;: &quot;A String&quot;, # Output only. Describes whether free instances are available to be created in this instance config.
    &quot;labels&quot;: { # Cloud Labels are a flexible and lightweight mechanism for organizing cloud resources into groups that reflect a customer&#x27;s organizational needs and deployment strategies. Cloud Labels can be used to filter collections of resources. They can be used to control how resource metrics are aggregated. And they can be used as arguments to policy management rules (e.g. route, firewall, load balancing, etc.). * Label keys must be between 1 and 63 characters long and must conform to the following regular expression: `a-z{0,62}`. * Label values must be between 0 and 63 characters long and must conform to the regular expression `[a-z0-9_-]{0,63}`. * No more than 64 labels can be associated with a given resource. See https://goo.gl/xmQnxf for more information on and examples of labels. If you plan to use labels in your own code, please note that additional characters may be allowed in the future. Therefore, you are advised to use an internal label representation, such as JSON, which doesn&#x27;t rely upon specific characters being disallowed. For example, representing labels as the string: name + &quot;_&quot; + value would prove problematic if we were to allow &quot;_&quot; in a future release.
      &quot;a_key&quot;: &quot;A String&quot;,
    },
    &quot;leaderOptions&quot;: [ # Allowed values of the &quot;default_leader&quot; schema option for databases in instances that use this instance configuration.
      &quot;A String&quot;,
    ],
    &quot;name&quot;: &quot;A String&quot;, # A unique identifier for the instance configuration. Values are of the form `projects//instanceConfigs/a-z*`.
    &quot;optionalReplicas&quot;: [ # Output only. The available optional replicas to choose from for user managed configurations. Populated for Google managed configurations.
      {
        &quot;defaultLeaderLocation&quot;: True or False, # If true, this location is designated as the default leader location where leader replicas are placed. See the [region types documentation](https://cloud.google.com/spanner/docs/instances#region_types) for more details.
        &quot;location&quot;: &quot;A String&quot;, # The location of the serving resources, e.g. &quot;us-central1&quot;.
        &quot;type&quot;: &quot;A String&quot;, # The type of replica.
      },
    ],
    &quot;reconciling&quot;: True or False, # Output only. If true, the instance config is being created or updated. If false, there are no ongoing operations for the instance config.
    &quot;replicas&quot;: [ # The geographic placement of nodes in this instance configuration and their replication properties.
      {
        &quot;defaultLeaderLocation&quot;: True or False, # If true, this location is designated as the default leader location where leader replicas are placed. See the [region types documentation](https://cloud.google.com/spanner/docs/instances#region_types) for more details.
        &quot;location&quot;: &quot;A String&quot;, # The location of the serving resources, e.g. &quot;us-central1&quot;.
        &quot;type&quot;: &quot;A String&quot;, # The type of replica.
      },
    ],
    &quot;state&quot;: &quot;A String&quot;, # Output only. The current instance config state. Applicable only for USER_MANAGED configs.
  },
  &quot;instanceConfigId&quot;: &quot;A String&quot;, # Required. The ID of the instance config to create. Valid identifiers are of the form `custom-[-a-z0-9]*[a-z0-9]` and must be between 2 and 64 characters in length. The `custom-` prefix is required to avoid name conflicts with Google managed configurations.
  &quot;validateOnly&quot;: True or False, # An option to validate, but not actually execute, a request, and provide the same response.
}

  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # This resource represents a long-running operation that is the result of a network API call.
  &quot;done&quot;: True or False, # If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.
  &quot;error&quot;: { # The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors). # The error result of the operation in case of failure or cancellation.
    &quot;code&quot;: 42, # The status code, which should be an enum value of google.rpc.Code.
    &quot;details&quot;: [ # A list of messages that carry the error details. There is a common set of message types for APIs to use.
      {
        &quot;a_key&quot;: &quot;&quot;, # Properties of the object. Contains field @type with type URL.
      },
    ],
    &quot;message&quot;: &quot;A String&quot;, # A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.
  },
  &quot;metadata&quot;: { # Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.
    &quot;a_key&quot;: &quot;&quot;, # Properties of the object. Contains field @type with type URL.
  },
  &quot;name&quot;: &quot;A String&quot;, # The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.
  &quot;response&quot;: { # The normal, successful response of the operation. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
    &quot;a_key&quot;: &quot;&quot;, # Properties of the object. Contains field @type with type URL.
  },
}</pre>
</div>

<div class="method">
    <code class="details" id="delete">delete(name, etag=None, validateOnly=None, x__xgafv=None)</code>
  <pre>Deletes the instance config. Deletion is only allowed when no instances are using the configuration. If any instances are using the config, returns `FAILED_PRECONDITION`. Only user managed configurations can be deleted. Authorization requires `spanner.instanceConfigs.delete` permission on the resource name.

Args:
  name: string, Required. The name of the instance configuration to be deleted. Values are of the form `projects//instanceConfigs/` (required)
  etag: string, Used for optimistic concurrency control as a way to help prevent simultaneous deletes of an instance config from overwriting each other. If not empty, the API only deletes the instance config when the etag provided matches the current status of the requested instance config. Otherwise, deletes the instance config without checking the current status of the requested instance config.
  validateOnly: boolean, An option to validate, but not actually execute, a request, and provide the same response.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }
}</pre>
</div>

<div class="method">
    <code class="details" id="get">get(name, x__xgafv=None)</code>
  <pre>Gets information about a particular instance configuration.

Args:
  name: string, Required. The name of the requested instance configuration. Values are of the form `projects//instanceConfigs/`. (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A possible configuration for a Cloud Spanner instance. Configurations define the geographic placement of nodes and their replication.
  &quot;baseConfig&quot;: &quot;A String&quot;, # Base configuration name, e.g. projects//instanceConfigs/nam3, based on which this configuration is created. Only set for user managed configurations. `base_config` must refer to a configuration of type GOOGLE_MANAGED in the same project as this configuration.
  &quot;configType&quot;: &quot;A String&quot;, # Output only. Whether this instance config is a Google or User Managed Configuration.
  &quot;displayName&quot;: &quot;A String&quot;, # The name of this instance configuration as it appears in UIs.
  &quot;etag&quot;: &quot;A String&quot;, # etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a instance config from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform instance config updates in order to avoid race conditions: An etag is returned in the response which contains instance configs, and systems are expected to put that etag in the request to update instance config to ensure that their change will be applied to the same version of the instance config. If no etag is provided in the call to update instance config, then the existing instance config is overwritten blindly.
  &quot;freeInstanceAvailability&quot;: &quot;A String&quot;, # Output only. Describes whether free instances are available to be created in this instance config.
  &quot;labels&quot;: { # Cloud Labels are a flexible and lightweight mechanism for organizing cloud resources into groups that reflect a customer&#x27;s organizational needs and deployment strategies. Cloud Labels can be used to filter collections of resources. They can be used to control how resource metrics are aggregated. And they can be used as arguments to policy management rules (e.g. route, firewall, load balancing, etc.). * Label keys must be between 1 and 63 characters long and must conform to the following regular expression: `a-z{0,62}`. * Label values must be between 0 and 63 characters long and must conform to the regular expression `[a-z0-9_-]{0,63}`. * No more than 64 labels can be associated with a given resource. See https://goo.gl/xmQnxf for more information on and examples of labels. If you plan to use labels in your own code, please note that additional characters may be allowed in the future. Therefore, you are advised to use an internal label representation, such as JSON, which doesn&#x27;t rely upon specific characters being disallowed. For example, representing labels as the string: name + &quot;_&quot; + value would prove problematic if we were to allow &quot;_&quot; in a future release.
    &quot;a_key&quot;: &quot;A String&quot;,
  },
  &quot;leaderOptions&quot;: [ # Allowed values of the &quot;default_leader&quot; schema option for databases in instances that use this instance configuration.
    &quot;A String&quot;,
  ],
  &quot;name&quot;: &quot;A String&quot;, # A unique identifier for the instance configuration. Values are of the form `projects//instanceConfigs/a-z*`.
  &quot;optionalReplicas&quot;: [ # Output only. The available optional replicas to choose from for user managed configurations. Populated for Google managed configurations.
    {
      &quot;defaultLeaderLocation&quot;: True or False, # If true, this location is designated as the default leader location where leader replicas are placed. See the [region types documentation](https://cloud.google.com/spanner/docs/instances#region_types) for more details.
      &quot;location&quot;: &quot;A String&quot;, # The location of the serving resources, e.g. &quot;us-central1&quot;.
      &quot;type&quot;: &quot;A String&quot;, # The type of replica.
    },
  ],
  &quot;reconciling&quot;: True or False, # Output only. If true, the instance config is being created or updated. If false, there are no ongoing operations for the instance config.
  &quot;replicas&quot;: [ # The geographic placement of nodes in this instance configuration and their replication properties.
    {
      &quot;defaultLeaderLocation&quot;: True or False, # If true, this location is designated as the default leader location where leader replicas are placed. See the [region types documentation](https://cloud.google.com/spanner/docs/instances#region_types) for more details.
      &quot;location&quot;: &quot;A String&quot;, # The location of the serving resources, e.g. &quot;us-central1&quot;.
      &quot;type&quot;: &quot;A String&quot;, # The type of replica.
    },
  ],
  &quot;state&quot;: &quot;A String&quot;, # Output only. The current instance config state. Applicable only for USER_MANAGED configs.
}</pre>
</div>

<div class="method">
    <code class="details" id="list">list(parent, pageSize=None, pageToken=None, x__xgafv=None)</code>
  <pre>Lists the supported instance configurations for a given project.

Args:
  parent: string, Required. The name of the project for which a list of supported instance configurations is requested. Values are of the form `projects/`. (required)
  pageSize: integer, Number of instance configurations to be returned in the response. If 0 or less, defaults to the server&#x27;s maximum allowed page size.
  pageToken: string, If non-empty, `page_token` should contain a next_page_token from a previous ListInstanceConfigsResponse.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # The response for ListInstanceConfigs.
  &quot;instanceConfigs&quot;: [ # The list of requested instance configurations.
    { # A possible configuration for a Cloud Spanner instance. Configurations define the geographic placement of nodes and their replication.
      &quot;baseConfig&quot;: &quot;A String&quot;, # Base configuration name, e.g. projects//instanceConfigs/nam3, based on which this configuration is created. Only set for user managed configurations. `base_config` must refer to a configuration of type GOOGLE_MANAGED in the same project as this configuration.
      &quot;configType&quot;: &quot;A String&quot;, # Output only. Whether this instance config is a Google or User Managed Configuration.
      &quot;displayName&quot;: &quot;A String&quot;, # The name of this instance configuration as it appears in UIs.
      &quot;etag&quot;: &quot;A String&quot;, # etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a instance config from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform instance config updates in order to avoid race conditions: An etag is returned in the response which contains instance configs, and systems are expected to put that etag in the request to update instance config to ensure that their change will be applied to the same version of the instance config. If no etag is provided in the call to update instance config, then the existing instance config is overwritten blindly.
      &quot;freeInstanceAvailability&quot;: &quot;A String&quot;, # Output only. Describes whether free instances are available to be created in this instance config.
      &quot;labels&quot;: { # Cloud Labels are a flexible and lightweight mechanism for organizing cloud resources into groups that reflect a customer&#x27;s organizational needs and deployment strategies. Cloud Labels can be used to filter collections of resources. They can be used to control how resource metrics are aggregated. And they can be used as arguments to policy management rules (e.g. route, firewall, load balancing, etc.). * Label keys must be between 1 and 63 characters long and must conform to the following regular expression: `a-z{0,62}`. * Label values must be between 0 and 63 characters long and must conform to the regular expression `[a-z0-9_-]{0,63}`. * No more than 64 labels can be associated with a given resource. See https://goo.gl/xmQnxf for more information on and examples of labels. If you plan to use labels in your own code, please note that additional characters may be allowed in the future. Therefore, you are advised to use an internal label representation, such as JSON, which doesn&#x27;t rely upon specific characters being disallowed. For example, representing labels as the string: name + &quot;_&quot; + value would prove problematic if we were to allow &quot;_&quot; in a future release.
        &quot;a_key&quot;: &quot;A String&quot;,
      },
      &quot;leaderOptions&quot;: [ # Allowed values of the &quot;default_leader&quot; schema option for databases in instances that use this instance configuration.
        &quot;A String&quot;,
      ],
      &quot;name&quot;: &quot;A String&quot;, # A unique identifier for the instance configuration. Values are of the form `projects//instanceConfigs/a-z*`.
      &quot;optionalReplicas&quot;: [ # Output only. The available optional replicas to choose from for user managed configurations. Populated for Google managed configurations.
        {
          &quot;defaultLeaderLocation&quot;: True or False, # If true, this location is designated as the default leader location where leader replicas are placed. See the [region types documentation](https://cloud.google.com/spanner/docs/instances#region_types) for more details.
          &quot;location&quot;: &quot;A String&quot;, # The location of the serving resources, e.g. &quot;us-central1&quot;.
          &quot;type&quot;: &quot;A String&quot;, # The type of replica.
        },
      ],
      &quot;reconciling&quot;: True or False, # Output only. If true, the instance config is being created or updated. If false, there are no ongoing operations for the instance config.
      &quot;replicas&quot;: [ # The geographic placement of nodes in this instance configuration and their replication properties.
        {
          &quot;defaultLeaderLocation&quot;: True or False, # If true, this location is designated as the default leader location where leader replicas are placed. See the [region types documentation](https://cloud.google.com/spanner/docs/instances#region_types) for more details.
          &quot;location&quot;: &quot;A String&quot;, # The location of the serving resources, e.g. &quot;us-central1&quot;.
          &quot;type&quot;: &quot;A String&quot;, # The type of replica.
        },
      ],
      &quot;state&quot;: &quot;A String&quot;, # Output only. The current instance config state. Applicable only for USER_MANAGED configs.
    },
  ],
  &quot;nextPageToken&quot;: &quot;A String&quot;, # `next_page_token` can be sent in a subsequent ListInstanceConfigs call to fetch more of the matching instance configurations.
}</pre>
</div>

<div class="method">
    <code class="details" id="list_next">list_next()</code>
  <pre>Retrieves the next page of results.

        Args:
          previous_request: The request for the previous page. (required)
          previous_response: The response from the request for the previous page. (required)

        Returns:
          A request object that you can call &#x27;execute()&#x27; on to request the next
          page. Returns None if there are no more items in the collection.
        </pre>
</div>

<div class="method">
    <code class="details" id="patch">patch(name, body=None, x__xgafv=None)</code>
  <pre>Updates an instance config. The returned long-running operation can be used to track the progress of updating the instance. If the named instance config does not exist, returns `NOT_FOUND`. Only user managed configurations can be updated. Immediately after the request returns: * The instance config&#x27;s reconciling field is set to true. While the operation is pending: * Cancelling the operation sets its metadata&#x27;s cancel_time. The operation is guaranteed to succeed at undoing all changes, after which point it terminates with a `CANCELLED` status. * All other attempts to modify the instance config are rejected. * Reading the instance config via the API continues to give the pre-request values. Upon completion of the returned operation: * Creating instances using the instance configuration uses the new values. * The instance config&#x27;s new values are readable via the API. * The instance config&#x27;s reconciling field becomes false. The returned long-running operation will have a name of the format `/operations/` and can be used to track the instance config modification. The metadata field type is UpdateInstanceConfigMetadata. The response field type is InstanceConfig, if successful. Authorization requires `spanner.instanceConfigs.update` permission on the resource name.

Args:
  name: string, A unique identifier for the instance configuration. Values are of the form `projects//instanceConfigs/a-z*`. (required)
  body: object, The request body.
    The object takes the form of:

{ # The request for UpdateInstanceConfigRequest.
  &quot;instanceConfig&quot;: { # A possible configuration for a Cloud Spanner instance. Configurations define the geographic placement of nodes and their replication. # Required. The user instance config to update, which must always include the instance config name. Otherwise, only fields mentioned in update_mask need be included. To prevent conflicts of concurrent updates, etag can be used.
    &quot;baseConfig&quot;: &quot;A String&quot;, # Base configuration name, e.g. projects//instanceConfigs/nam3, based on which this configuration is created. Only set for user managed configurations. `base_config` must refer to a configuration of type GOOGLE_MANAGED in the same project as this configuration.
    &quot;configType&quot;: &quot;A String&quot;, # Output only. Whether this instance config is a Google or User Managed Configuration.
    &quot;displayName&quot;: &quot;A String&quot;, # The name of this instance configuration as it appears in UIs.
    &quot;etag&quot;: &quot;A String&quot;, # etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a instance config from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform instance config updates in order to avoid race conditions: An etag is returned in the response which contains instance configs, and systems are expected to put that etag in the request to update instance config to ensure that their change will be applied to the same version of the instance config. If no etag is provided in the call to update instance config, then the existing instance config is overwritten blindly.
    &quot;freeInstanceAvailability&quot;: &quot;A String&quot;, # Output only. Describes whether free instances are available to be created in this instance config.
    &quot;labels&quot;: { # Cloud Labels are a flexible and lightweight mechanism for organizing cloud resources into groups that reflect a customer&#x27;s organizational needs and deployment strategies. Cloud Labels can be used to filter collections of resources. They can be used to control how resource metrics are aggregated. And they can be used as arguments to policy management rules (e.g. route, firewall, load balancing, etc.). * Label keys must be between 1 and 63 characters long and must conform to the following regular expression: `a-z{0,62}`. * Label values must be between 0 and 63 characters long and must conform to the regular expression `[a-z0-9_-]{0,63}`. * No more than 64 labels can be associated with a given resource. See https://goo.gl/xmQnxf for more information on and examples of labels. If you plan to use labels in your own code, please note that additional characters may be allowed in the future. Therefore, you are advised to use an internal label representation, such as JSON, which doesn&#x27;t rely upon specific characters being disallowed. For example, representing labels as the string: name + &quot;_&quot; + value would prove problematic if we were to allow &quot;_&quot; in a future release.
      &quot;a_key&quot;: &quot;A String&quot;,
    },
    &quot;leaderOptions&quot;: [ # Allowed values of the &quot;default_leader&quot; schema option for databases in instances that use this instance configuration.
      &quot;A String&quot;,
    ],
    &quot;name&quot;: &quot;A String&quot;, # A unique identifier for the instance configuration. Values are of the form `projects//instanceConfigs/a-z*`.
    &quot;optionalReplicas&quot;: [ # Output only. The available optional replicas to choose from for user managed configurations. Populated for Google managed configurations.
      {
        &quot;defaultLeaderLocation&quot;: True or False, # If true, this location is designated as the default leader location where leader replicas are placed. See the [region types documentation](https://cloud.google.com/spanner/docs/instances#region_types) for more details.
        &quot;location&quot;: &quot;A String&quot;, # The location of the serving resources, e.g. &quot;us-central1&quot;.
        &quot;type&quot;: &quot;A String&quot;, # The type of replica.
      },
    ],
    &quot;reconciling&quot;: True or False, # Output only. If true, the instance config is being created or updated. If false, there are no ongoing operations for the instance config.
    &quot;replicas&quot;: [ # The geographic placement of nodes in this instance configuration and their replication properties.
      {
        &quot;defaultLeaderLocation&quot;: True or False, # If true, this location is designated as the default leader location where leader replicas are placed. See the [region types documentation](https://cloud.google.com/spanner/docs/instances#region_types) for more details.
        &quot;location&quot;: &quot;A String&quot;, # The location of the serving resources, e.g. &quot;us-central1&quot;.
        &quot;type&quot;: &quot;A String&quot;, # The type of replica.
      },
    ],
    &quot;state&quot;: &quot;A String&quot;, # Output only. The current instance config state. Applicable only for USER_MANAGED configs.
  },
  &quot;updateMask&quot;: &quot;A String&quot;, # Required. A mask specifying which fields in InstanceConfig should be updated. The field mask must always be specified; this prevents any future fields in InstanceConfig from being erased accidentally by clients that do not know about them. Only display_name and labels can be updated.
  &quot;validateOnly&quot;: True or False, # An option to validate, but not actually execute, a request, and provide the same response.
}

  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # This resource represents a long-running operation that is the result of a network API call.
  &quot;done&quot;: True or False, # If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.
  &quot;error&quot;: { # The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors). # The error result of the operation in case of failure or cancellation.
    &quot;code&quot;: 42, # The status code, which should be an enum value of google.rpc.Code.
    &quot;details&quot;: [ # A list of messages that carry the error details. There is a common set of message types for APIs to use.
      {
        &quot;a_key&quot;: &quot;&quot;, # Properties of the object. Contains field @type with type URL.
      },
    ],
    &quot;message&quot;: &quot;A String&quot;, # A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.
  },
  &quot;metadata&quot;: { # Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.
    &quot;a_key&quot;: &quot;&quot;, # Properties of the object. Contains field @type with type URL.
  },
  &quot;name&quot;: &quot;A String&quot;, # The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.
  &quot;response&quot;: { # The normal, successful response of the operation. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
    &quot;a_key&quot;: &quot;&quot;, # Properties of the object. Contains field @type with type URL.
  },
}</pre>
</div>

</body></html>