Class: Google::Cloud::Bigtable::Instance

Inherits:
Object
  • Object
show all
Defined in:
lib/google/cloud/bigtable/instance.rb,
lib/google/cloud/bigtable/instance/job.rb,
lib/google/cloud/bigtable/instance/list.rb,
lib/google/cloud/bigtable/instance/cluster_map.rb

Overview

Instance

Represents a Bigtable instance. Instances are dedicated Bigtable storage resources that Bigtable tables.

See Project#instances, Project#instance, and Project#create_instance.

Examples:

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

job = bigtable.create_instance(
  "my-instance",
  display_name: "Instance for user data",
  type: :DEVELOPMENT,
  labels: { "env" => "dev"}
) do |clusters|
  clusters.add("test-cluster", "us-east1-b", nodes: 1)
end

job.done? #=> false

# To block until the operation completes.
job.wait_until_done!
job.done? #=> true

if job.error?
  status = job.error
else
  instance = job.instance
end

Defined Under Namespace

Classes: ClusterMap, Job, List

Instance Method Summary collapse

Instance Method Details

#app_profile(app_profile_id) ⇒ Google::Cloud::Bigtable::AppProfile?

Get app profile.

See to delete app_profile AppProfile#delete and update app_profile AppProfile#save.

Examples:

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")

app_profile = instance.app_profile("my-app-profile")

if app_profile
  puts app_profile.name
end

Parameters:

  • app_profile_id (String) —

    The unique name of the requested app profile.

Returns:



746
747
748
749
750
751
752
 
# File 'lib/google/cloud/bigtable/instance.rb', line 746

def app_profile app_profile_id
  ensure_service!
  grpc = service.get_app_profile instance_id, app_profile_id
  AppProfile.from_grpc grpc, service
rescue Google::Cloud::NotFoundError
  nil
end

#app_profiles ⇒ Array<Google::Cloud::Bigtable::AppProfile>

List all app profiles

See to delete app_profile AppProfile#delete and update app_profile AppProfile#save.

Examples:

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")

instance.app_profiles.all do |app_profile|
  puts app_profile.name
end

Returns:



774
775
776
777
778
 
# File 'lib/google/cloud/bigtable/instance.rb', line 774

def app_profiles
  ensure_service!
  grpc = service.list_app_profiles instance_id
  AppProfile::List.from_grpc grpc, service
end

#cluster(cluster_id) ⇒ Google::Cloud::Bigtable::Cluster?

Gets cluster information.

See to delete Cluster#delete and update cluster Cluster#save.

Examples:

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")

cluster = instance.cluster("my-instance-cluster")
puts cluster.cluster_id

Parameters:

  • cluster_id (String) —

    The unique ID of the requested cluster.

Returns:



362
363
364
365
366
367
368
 
# File 'lib/google/cloud/bigtable/instance.rb', line 362

def cluster cluster_id
  ensure_service!
  grpc = service.get_cluster instance_id, cluster_id
  Cluster.from_grpc grpc, service
rescue Google::Cloud::NotFoundError
  nil
end

#clusters(token: nil) ⇒ Array<Google::Cloud::Bigtable::Cluster>

Lists information about clusters in an instance.

See to delete Cluster#delete and update cluster Cluster#save.

Examples:

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")

instance.clusters.all do |cluster|
  puts cluster.cluster_id
end

Parameters:

  • token (String) (defaults to: nil) —

    The token value returned by the last call to clusters; indicates that this is a continuation of a call and that the system should return the next page of data.

Returns:



337
338
339
340
341
 
# File 'lib/google/cloud/bigtable/instance.rb', line 337

def clusters token: nil
  ensure_service!
  grpc = service.list_clusters instance_id, token: token
  Cluster::List.from_grpc grpc, service, instance_id: instance_id
end

#create_app_profile(name, routing_policy, description: nil, etag: nil, ignore_warnings: false) ⇒ Google::Cloud::Bigtable::AppProfile

Create app profile for an instance with a routing policy. Only one routing policy can applied to app profile. The policy can be multi-cluster routing or single cluster routing.

Examples:

Create an app profile with a single cluster routing policy

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")

routing_policy = Google::Cloud::Bigtable::AppProfile.single_cluster_routing(
  "my-instance-cluster-1",
  allow_transactional_writes: true
)

app_profile = instance.create_app_profile(
  "my-app-profile",
  routing_policy,
  description: "App profile for user data instance"
)
puts app_profile.name

Create an app profile with multi-cluster routing policy

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")

routing_policy = Google::Cloud::Bigtable::AppProfile.multi_cluster_routing

app_profile = instance.create_app_profile(
  "my-app-profile",
  routing_policy,
  description: "App profile for user data instance"
)
puts app_profile.name

Create app profile and ignore warnings.

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")

routing_policy = Google::Cloud::Bigtable::AppProfile.multi_cluster_routing

app_profile = instance.create_app_profile(
  "my-app-profile",
  routing_policy,
  description: "App profile for user data instance",
  ignore_warnings: true
)
puts app_profile.name

Parameters:

  • name (String) —

    Unique Id of the app profile

  • routing_policy (Google::Cloud::Bigtable::RoutingPolicy) —

    The routing policy for all read/write requests that use this app profile. A value must be explicitly set.

    Routing Policies:

    • MultiClusterRoutingUseAny - Read/write requests may be routed to any cluster in the instance and will fail over to another cluster in the event of transient errors or delays. Choosing this option sacrifices read-your-writes consistency to improve availability.
    • SingleClusterRouting - Unconditionally routes all read/write requests to a specific cluster. This option preserves read-your-writes consistency but does not improve availability. Value contains cluster_id and optional field allow_transactional_writes.
  • description (String) (defaults to: nil) —

    Description of the use case for this app profile

  • etag (String) (defaults to: nil) —

    Strongly validated etag for optimistic concurrency control. Preserve the value returned from GetAppProfile when calling UpdateAppProfile to fail the request if there has been a modification in the meantime. The update_mask of the request need not include etag for this protection to apply. See Wikipedia and RFC 7232 for more details.

  • ignore_warnings (Boolean) (defaults to: false) —

    If true, ignore safety checks when creating the app profile. Default value is false

Returns:



699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
 
# File 'lib/google/cloud/bigtable/instance.rb', line 699

def create_app_profile name, routing_policy, description: nil, etag: nil, ignore_warnings: false
  ensure_service!
  routing_policy_grpc = routing_policy.to_grpc
  if routing_policy_grpc.is_a? Google::Bigtable::Admin::V2::AppProfile::MultiClusterRoutingUseAny
    multi_cluster_routing = routing_policy_grpc
  else
    single_cluster_routing = routing_policy_grpc
  end

  app_profile_attrs = {
    multi_cluster_routing_use_any: multi_cluster_routing,
    single_cluster_routing:        single_cluster_routing,
    description:                   description,
    etag:                          etag
  }.delete_if { |_, v| v.nil? }

  grpc = service.create_app_profile(
    instance_id,
    name,
    Google::Bigtable::Admin::V2::AppProfile.new(app_profile_attrs),
    ignore_warnings: ignore_warnings
  )
  AppProfile.from_grpc grpc, service
end

#create_cluster(cluster_id, location, nodes: nil, storage_type: nil) ⇒ Google::Cloud::Bigtable::Cluster::Job

Creates a cluster within an instance.

Examples:

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")
job = instance.create_cluster(
  "my-new-cluster",
  "us-east-1b",
  nodes: 3,
  storage_type: :SSD
)

job.done? #=> false

# To block until the operation completes.
job.wait_until_done!
job.done? #=> true

if job.error?
  status = job.error
else
  cluster = job.cluster
end

Parameters:

  • cluster_id (String) —

    The ID to be used when referring to the new cluster within its instance, e.g., just mycluster

  • location (String) —

    The location where this cluster's nodes and storage reside. For best performance, clients should be located as close as possible to this cluster. Example: "us-east-1b"

  • nodes (Integer) (defaults to: nil) —

    The number of nodes allocated to this cluster. More nodes enable higher throughput and more consistent performance.

  • storage_type (Symbol) (defaults to: nil) —

    Storage type. The type of storage used by this cluster to serve its parent instance's tables. Valid types are:

    • :SSD - Flash (SSD) storage.
    • :HDD - Magnetic drive (HDD).

Returns:



415
416
417
418
419
420
421
422
423
424
425
426
 
# File 'lib/google/cloud/bigtable/instance.rb', line 415

def create_cluster cluster_id, location, nodes: nil, storage_type: nil
  ensure_service!
  attrs = {
    serve_nodes:          nodes,
    default_storage_type: storage_type,
    location:             location
  }.delete_if { |_, v| v.nil? }

  cluster = Google::Bigtable::Admin::V2::Cluster.new attrs
  grpc = service.create_cluster instance_id, cluster_id, cluster
  Cluster::Job.from_grpc grpc, service
end

#create_table(name, column_families: nil, granularity: nil, initial_splits: nil) {|column_families| ... } ⇒ Google::Cloud::Bigtable::Table

Creates a new table.

The table can be created with a full set of initial column families, specified in the request.

Examples:

Create a table without column families.

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")

table = instance.create_table("my-table")
puts table.name

Create a table with initial splits and column families.

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")

initial_splits = ["user-00001", "user-100000", "others"]
table = instance.create_table("my-table", initial_splits: initial_splits) do |cfm|
  cfm.add('cf1', gc_rule: Google::Cloud::Bigtable::GcRule.max_versions(5))
  cfm.add('cf2', gc_rule: Google::Cloud::Bigtable::GcRule.max_age(600))

  gc_rule = Google::Cloud::Bigtable::GcRule.union(
     Google::Cloud::Bigtable::GcRule.max_age(1800),
    Google::Cloud::Bigtable::GcRule.max_versions(3)
  )
  cfm.add('cf3', gc_rule: gc_rule)
end

puts table

Parameters:

  • name (String) —

    The name by which the new table should be referred to within the parent instance, e.g., foobar

  • column_families (Google::Cloud::Bigtable::ColumnFamilyMap) (defaults to: nil) —

    An object containing the column families for the table, mapped by column family name.

  • granularity (Symbol) (defaults to: nil) —

    The granularity at which timestamps are stored in this table. Timestamps not matching the granularity will be rejected. Valid value is :MILLIS. If unspecified, the value will be set to :MILLIS.

  • initial_splits (Array<String>) (defaults to: nil) —

    The optional list of row keys that will be used to initially split the table into several tablets (tablets are similar to HBase regions). Given two split keys, s1 and s2, three tablets will be created, spanning the key ranges: [, s1), [s1, s2), [s2, ).

    Example:

    • Row keys := ["a", "apple", "custom", "customer_1", "customer_2", "other", "zz"]
    • initial_split_keys := ["apple", "customer_1", "customer_2", "other"]
    • Key assignment:
      • Tablet 1 : [, apple) => {"a"}
      • Tablet 2 : [apple, customer_1) => {"apple", "custom"}
      • Tablet 3 : [customer_1, customer_2) => {"customer_1"}
      • Tablet 4 : [customer_2, other) => {"customer_2"}
      • Tablet 5 : [other, ) => {"other", "zz"} A hash in the form of Google::Bigtable::Admin::V2::CreateTableRequest::Split can also be provided.

Yields:

  • (column_families) —

    A block for adding column families.

Yield Parameters:

Returns:



599
600
601
602
603
604
605
606
607
608
609
610
 
# File 'lib/google/cloud/bigtable/instance.rb', line 599

def create_table name, column_families: nil, granularity: nil, initial_splits: nil, &block
  ensure_service!
  Table.create(
    service,
    instance_id,
    name,
    column_families: column_families,
    granularity:     granularity,
    initial_splits:  initial_splits,
    &block
  )
end

#creating? ⇒ Boolean

The instance is currently being created and may be destroyed if the creation process encounters an error.

Returns:

  • (Boolean) 


152
153
154
 
# File 'lib/google/cloud/bigtable/instance.rb', line 152

def creating?
  state == :CREATING
end

#delete ⇒ Boolean

Permanently deletes the instance from a project.

Examples:

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")
instance.delete

Returns:

  • (Boolean) —

    Returns true if the instance was deleted.



308
309
310
311
312
 
# File 'lib/google/cloud/bigtable/instance.rb', line 308

def delete
  ensure_service!
  service.delete_instance instance_id
  true
end

#development? ⇒ Boolean

The instance is meant for development and testing purposes only; it has no performance or uptime guarantees and is not covered by SLA. After a development instance is created, it can be upgraded by updating the instance to type PRODUCTION. An instance created as a production instance cannot be changed to a development instance. When creating a development instance, serve_nodes on the cluster must not be set.

Returns:

  • (Boolean) 


177
178
179
 
# File 'lib/google/cloud/bigtable/instance.rb', line 177

def development?
  type == :DEVELOPMENT
end

#display_name ⇒ String

The descriptive name for this instance as it appears in UIs. Must be unique per project and between 4 and 30 characters long.

Returns:

  • (String) 


101
102
103
 
# File 'lib/google/cloud/bigtable/instance.rb', line 101

def display_name
  @grpc.display_name
end

#display_name=(value) ⇒ Object

Updates the descriptive name for this instance as it appears in UIs. Can be changed at any time, but should be kept globally unique to avoid confusion.

Parameters:

  • value (String) —

    The descriptive name for this instance.



112
113
114
 
# File 'lib/google/cloud/bigtable/instance.rb', line 112

def display_name= value
  @grpc.display_name = value
end

#instance_id ⇒ String

The unique identifier for the instance.

Returns:

  • (String) 


91
92
93
 
# File 'lib/google/cloud/bigtable/instance.rb', line 91

def instance_id
  @grpc.name.split("/")[3]
end

#labels ⇒ Hash{String=>String}

Get instance labels.

Cloud Labels are a flexible and lightweight mechanism for organizing cloud resources into groups that reflect a customer's organizational needs and deployment strategies. Cloud Labels can be used to filter collections of resources, to control how resource metrics are aggregated, and 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]([-a-z0-9]*[a-z0-9])?.
  • Label values must be between 0 and 63 characters long and must conform to the regular expression ([a-z]([-a-z0-9]*[a-z0-9])?)?.
  • No more than 64 labels can be associated with a given resource.

Returns:

  • (Hash{String=>String}) —

    The label keys and values in a hash.



224
225
226
 
# File 'lib/google/cloud/bigtable/instance.rb', line 224

def labels
  @grpc.labels
end

#labels=(labels) ⇒ Object

Set the Cloud Labels.

Parameters:

  • labels (Hash{String=>String}) —

    The Cloud Labels.



233
234
235
236
237
238
239
 
# File 'lib/google/cloud/bigtable/instance.rb', line 233

def labels= labels
  labels ||= {}
  @grpc.labels = Google::Protobuf::Map.new(
    :string, :string,
    Hash[labels.map { |k, v| [String(k), String(v)] }]
  )
end

#path ⇒ String

The full path for the instance resource. Values are of the form projects/<project_id>/instances/<instance_id>.

Returns:

  • (String) 


122
123
124
 
# File 'lib/google/cloud/bigtable/instance.rb', line 122

def path
  @grpc.name
end

#policy {|policy| ... } ⇒ Policy

Gets the Cloud IAM access control policy for this instance.

Examples:

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")
policy = instance.policy

Update the policy by passing a block:

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new
instance = bigtable.instance("my-instance")

instance.policy do |p|
  p.add("roles/owner", "user:[email protected]")
end # 2 API calls

Yields:

  • (policy) —

    A block for updating the policy. The latest policy will be read from the Bigtable service and passed to the block. After the block completes, the modified policy will be written to the service.

Yield Parameters:

  • policy (Policy) —

    the current Cloud IAM Policy for this instance

Returns:

  • (Policy) —

    The current Cloud IAM Policy for this instance.

See Also:



813
814
815
816
817
818
819
820
 
# File 'lib/google/cloud/bigtable/instance.rb', line 813

def policy
  ensure_service!
  grpc = service.get_instance_policy instance_id
  policy = Policy.from_grpc grpc
  return policy unless block_given?
  yield policy
  update_policy policy
end

#production? ⇒ Boolean

An instance meant for production use. serve_nodes must be set on the cluster.

Returns:

  • (Boolean) 


187
188
189
 
# File 'lib/google/cloud/bigtable/instance.rb', line 187

def production?
  type == :PRODUCTION
end

#project_id ⇒ String

The unique identifier for the project.

Returns:

  • (String) 


82
83
84
 
# File 'lib/google/cloud/bigtable/instance.rb', line 82

def project_id
  @grpc.name.split("/")[1]
end

#ready? ⇒ Boolean

The instance has been successfully created and can serve requests to its tables.

Returns:

  • (Boolean) 


142
143
144
 
# File 'lib/google/cloud/bigtable/instance.rb', line 142

def ready?
  state == :READY
end

#reload! ⇒ Google::Cloud::Bigtable::Instance

Reload instance information.

Returns:



290
291
292
293
 
# File 'lib/google/cloud/bigtable/instance.rb', line 290

def reload!
  @grpc = service.get_instance instance_id
  self
end

#save ⇒ Google::Cloud::Bigtable::Instance::Job Also known as: update

Update instance.

Updatable attributes are :

  • display_name - The descriptive name for this instance.
  • type - :DEVELOPMENT type instance can be upgraded to :PRODUCTION instance. An instance created as a production instance cannot be changed to a development instance.
  • labels - Cloud Labels are a flexible and lightweight mechanism for organizing cloud resources.

Examples:

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")
instance.display_name = "My app dev instance"  # Set display name
instance.labels = { env: "dev", data: "users" }
job = instance.save

job.done? #=> false

# Reload job until completion.
job.wait_until_done!
job.done? #=> true

if job.error?
  puts job.error
else
  instance = job.instance
  puts instance.name
  puts instance.labels
end

Returns:



277
278
279
280
281
282
 
# File 'lib/google/cloud/bigtable/instance.rb', line 277

def save
  ensure_service!
  update_mask = Google::Protobuf::FieldMask.new paths: ["labels", "display_name", "type"]
  grpc = service.partial_update_instance @grpc, update_mask
  Instance::Job.from_grpc grpc, service
end

#state ⇒ Symbol

The current instance state. Possible values are :CREATING, :READY, :STATE_NOT_KNOWN.

Returns:

  • (Symbol) 


132
133
134
 
# File 'lib/google/cloud/bigtable/instance.rb', line 132

def state
  @grpc.state
end

#table(table_id, view: nil, perform_lookup: nil, app_profile_id: nil) ⇒ Google::Cloud::Bigtable::Table

Get metadata information of table.

Examples:

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")

# Default view is full view
table = instance.table("my-table", perform_lookup: true)
puts table.name
puts table.column_families

# Name-only view
table = instance.table("my-table", view: :NAME_ONLY, perform_lookup: true)
puts table.name

Mutate rows

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

table = bigtable.table("my-instance", "my-table")

entry = table.new_mutation_entry("user-1")
entry.set_cell(
  "cf-1",
  "field-1",
  "XYZ",
  timestamp: (Time.now.to_f * 1000000).round(-3) # microseconds
).delete_cells("cf2", "field02")

table.mutate_row(entry)

Parameters:

  • view (Symbol) (defaults to: nil) —

    The view to be applied to the returned tables' fields Defaults to SCHEMA_VIEW if unspecified. Valid view types are.

    • :NAME_ONLY - Only populates name
    • :SCHEMA_VIEW - Only populates name and fields related to the table's schema
    • :REPLICATION_VIEW - Only populates name and fields related to the table's replication state.
    • :FULL - Populates all fields
  • perform_lookup (Boolean) (defaults to: nil) —

    Creates table object without verifying that the table resource exists. Calls made on this object will raise errors if the table does not exist. Default value is false. Optional. Helps to reduce admin API calls.

  • app_profile_id (String) (defaults to: nil) —

    The unique identifier for the app profile. Optional. Used only in data operations. This value specifies routing for replication. If not specified, the "default" application profile will be used.

Returns:



510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
 
# File 'lib/google/cloud/bigtable/instance.rb', line 510

def table table_id, view: nil, perform_lookup: nil, app_profile_id: nil
  ensure_service!

  table = if perform_lookup
            grpc = service.get_table instance_id, table_id, view: view
            Table.from_grpc grpc, service, view: view
          else
            Table.from_path service.table_path(instance_id, table_id), service
          end

  table.app_profile_id = app_profile_id
  table
rescue Google::Cloud::NotFoundError
  nil
end

#tables ⇒ Array<Google::Cloud::Bigtable::Table>

List all tables.

See to delete table Table#delete and update table Table#save.

Examples:

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")

# Default name-only view
instance.tables.all do |table|
  puts table.name
end

Returns:



449
450
451
452
453
 
# File 'lib/google/cloud/bigtable/instance.rb', line 449

def tables
  ensure_service!
  grpc = service.list_tables instance_id
  Table::List.from_grpc grpc, service
end

#test_iam_permissions(*permissions) ⇒ Array<Strings>

Tests the specified permissions against the Cloud IAM access control policy.

Examples:

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")

permissions = instance.test_iam_permissions(
  "bigtable.instances.get",
  "bigtable.instances.update"
)
permissions.include? "bigtable.instances.get" #=> true
permissions.include? "bigtable.instances.update" #=> false

Parameters:

  • permissions (String, Array<String>) —

    permissions The set of permissions to check access for. Permissions with wildcards (such as * or bigtable.*) are not allowed. See (https://cloud.google.com/bigtable/docs/access-control)

    Some of the permissions that can be checked on a instance are:

    • bigtable.instances.create
    • bigtable.instances.list
    • bigtable.instances.get
    • bigtable.tables.create
    • bigtable.tables.delete
    • bigtable.tables.get
    • bigtable.tables.list

Returns:

  • (Array<Strings>) —

    The permissions that have access.

See Also:



893
894
895
896
897
898
899
900
 
# File 'lib/google/cloud/bigtable/instance.rb', line 893

def test_iam_permissions *permissions
  ensure_service!
  grpc = service.test_instance_permissions(
    instance_id,
    Array(permissions).flatten
  )
  grpc.permissions
end

#type ⇒ Symbol

Instance type. Possible values are :DEVELOPMENT, :PRODUCTION, :TYPE_UNSPECIFIED

Returns:

  • (Symbol) 


162
163
164
 
# File 'lib/google/cloud/bigtable/instance.rb', line 162

def type
  @grpc.type
end

#type=(instance_type) ⇒ Object

Set instance type.

Valid values are :DEVELOPMENT, :PRODUCTION. After a development instance is created, it can be upgraded by updating the instance to type PRODUCTION. An instance created as a production instance cannot be changed to a development instance.

Parameters:

  • instance_type (Symbol) 


202
203
204
 
# File 'lib/google/cloud/bigtable/instance.rb', line 202

def type= instance_type
  @grpc.type = instance_type
end

#update_policy(new_policy) ⇒ Policy Also known as: policy=

Updates the Cloud IAM access control policy for this instance. The policy should be read from #policy. See Policy for an explanation of the policy etag property and how to modify policies.

You can also update the policy by passing a block to #policy, which will call this method internally after the block completes.

Examples:

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

instance = bigtable.instance("my-instance")

policy = instance.policy
policy.add("roles/owner", "user:[email protected]")
updated_policy = instance.update_policy(policy)

puts update_policy.roles

Parameters:

  • new_policy (Policy) —

    a new or modified Cloud IAM Policy for this instance

Returns:

  • (Policy) —

    The policy returned by the API update operation.



849
850
851
852
853
 
# File 'lib/google/cloud/bigtable/instance.rb', line 849

def update_policy new_policy
  ensure_service!
  grpc = service.set_instance_policy instance_id, new_policy.to_grpc
  Policy.from_grpc grpc
end