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 contain 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 not allowed
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?

Gets an app profile in the instance.

See AppProfile#delete and 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:



756
757
758
759
760
761
762
 
# File 'lib/google/cloud/bigtable/instance.rb', line 756

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>

Lists all app profiles in the instance.

See AppProfile#delete and 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:



784
785
786
787
788
 
# File 'lib/google/cloud/bigtable/instance.rb', line 784

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 a cluster in the instance.

See Cluster#delete and 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:



374
375
376
377
378
379
380
 
# File 'lib/google/cloud/bigtable/instance.rb', line 374

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 the clusters in the instance.

See Cluster#delete and 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:



349
350
351
352
353
 
# File 'lib/google/cloud/bigtable/instance.rb', line 349

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

Creates an app profile for the instance with a routing policy. Only one routing policy can applied to the 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:



709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
 
# File 'lib/google/cloud/bigtable/instance.rb', line 709

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 in the 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.

  • 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:



426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/google/cloud/bigtable/instance.rb', line 426

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 in the instance.

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.

  • 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:



609
610
611
612
613
614
615
616
617
618
619
620
 
# File 'lib/google/cloud/bigtable/instance.rb', line 609

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 the 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.



320
321
322
323
324
 
# File 'lib/google/cloud/bigtable/instance.rb', line 320

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, nodes on the cluster must not be set. (See #create_cluster.)

Returns:

  • (Boolean) 


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

def development?
  type == :DEVELOPMENT
end

#display_name ⇒ String

The descriptive name for the 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 the 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 the 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}

Gets the Cloud Labels for the instance.

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.



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

def labels
  @grpc.labels
end

#labels=(labels) ⇒ Object

Sets the Cloud Labels for the instance.

Parameters:

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

    The Cloud Labels.



244
245
246
247
248
249
250
 
# File 'lib/google/cloud/bigtable/instance.rb', line 244

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 the 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 the instance.

See Also:



823
824
825
826
827
828
829
830
 
# File 'lib/google/cloud/bigtable/instance.rb', line 823

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. Requires that nodes must be set on the cluster. (See #create_cluster.)

Returns:

  • (Boolean) 


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

def production?
  type == :PRODUCTION
end

#project_id ⇒ String

The unique identifier for the project to which the instance belongs.

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

Reloads instance data.

Returns:



302
303
304
305
 
# File 'lib/google/cloud/bigtable/instance.rb', line 302

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

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

Updates the instance.

Updatable attributes are:

  • display_name - The descriptive name for the 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:



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

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

Gets metadata information of a table in the instance.

Examples:

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

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

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:



520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
 
# File 'lib/google/cloud/bigtable/instance.rb', line 520

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>

Lists all tables in the instance.

See Table#delete and 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:



460
461
462
463
464
 
# File 'lib/google/cloud/bigtable/instance.rb', line 460

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

#test_iam_permissions(*permissions) ⇒ Array<String>

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 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<String>) —

    The permissions that are configured for the policy.

See Also:



903
904
905
906
907
 
# File 'lib/google/cloud/bigtable/instance.rb', line 903

def test_iam_permissions *permissions
  ensure_service!
  grpc = service.test_instance_permissions instance_id, permissions.flatten
  grpc.permissions.to_a
end

#type ⇒ Symbol

Instance type. Possible values include :DEVELOPMENT and :PRODUCTION.

Returns:

  • (Symbol) 


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

def type
  @grpc.type
end

#type=(instance_type) ⇒ Object

Sets the instance type.

Valid values are :DEVELOPMENT and :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.

Examples:

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new

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

instance.development? # true
instance.type = :PRODUCTION
instance.development? # false
instance.production? # true

Parameters:

  • instance_type (Symbol) 


213
214
215
 
# File 'lib/google/cloud/bigtable/instance.rb', line 213

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 the 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 updated_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.



859
860
861
862
863
 
# File 'lib/google/cloud/bigtable/instance.rb', line 859

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