Class: Aws::EC2::NatGateway

Inherits:
Object
  • Object
show all
Extended by:
Deprecations
Defined in:
sig/nat_gateway.rbs,
lib/aws-sdk-ec2/nat_gateway.rb

Overview

https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/EC2/NatGateway.html

Defined Under Namespace

Classes: Collection

Read-Only Attributes collapse

Actions collapse

Associations collapse

Instance Method Summary collapse

Constructor Details

#initialize(id, options = {}) ⇒ NatGateway #initialize(options = {}) ⇒ NatGateway

Returns a new instance of NatGateway.

Overloads:

  • #initialize(id, options = {}) ⇒ NatGateway

    Parameters:

    • id (String)

    Options Hash (options):

  • #initialize(options = {}) ⇒ NatGateway

    Options Hash (options):

    • :id (required, String)
    • :client (Client) 


13
14
15
 
# File 'sig/nat_gateway.rbs', line 13

def initialize: (String id, Hash[Symbol, untyped] options) -> void
| (id: String, ?client: Client) -> void
| (Hash[Symbol, untyped] args) -> void

Instance Method Details

#address ⇒ VpcAddress?

Returns:



113
 
# File 'sig/nat_gateway.rbs', line 113

def address: () -> VpcAddress?

#attached_appliances ⇒ Array<Types::NatGatewayAttachedAppliance>

The proxy appliances attached to the NAT Gateway for filtering and inspecting traffic to prevent data exfiltration.

Returns:



64
 
# File 'sig/nat_gateway.rbs', line 64

def attached_appliances: () -> ::Array[Types::NatGatewayAttachedAppliance]

#auto_provision_zones ⇒ String

For regional NAT gateways only: Indicates whether Amazon Web Services automatically manages AZ coverage. When enabled, the NAT gateway associates EIPs in all AZs where your VPC has subnets to handle outbound NAT traffic, expands to new AZs when you create subnets there, and retracts from AZs where you've removed all subnets. When disabled, you must manually manage which AZs the NAT gateway supports and their corresponding EIPs.

A regional NAT gateway is a single NAT Gateway that works across multiple availability zones (AZs) in your VPC, providing redundancy, scalability and availability across all the AZs in a Region.

For more information, see Regional NAT gateways for automatic multi-AZ expansion in the Amazon VPC User Guide.

Returns:

  • (String) 


61
 
# File 'sig/nat_gateway.rbs', line 61

def auto_provision_zones: () -> ("enabled" | "disabled")

#auto_scaling_ips ⇒ String

For regional NAT gateways only: Indicates whether Amazon Web Services automatically allocates additional Elastic IP addresses (EIPs) in an AZ when the NAT gateway needs more ports due to increased concurrent connections to a single destination from that AZ.

For more information, see Regional NAT gateways for automatic multi-AZ expansion in the Amazon VPC User Guide.

Returns:

  • (String) 


58
 
# File 'sig/nat_gateway.rbs', line 58

def auto_scaling_ips: () -> ("enabled" | "disabled")

#availability_mode ⇒ String

Indicates whether this is a zonal (single-AZ) or regional (multi-AZ) NAT gateway.

A zonal NAT gateway is a NAT Gateway that provides redundancy and scalability within a single availability zone. A regional NAT gateway is a single NAT Gateway that works across multiple availability zones (AZs) in your VPC, providing redundancy, scalability and availability across all the AZs in a Region.

For more information, see Regional NAT gateways for automatic multi-AZ expansion in the Amazon VPC User Guide.

Returns:

  • (String) 


55
 
# File 'sig/nat_gateway.rbs', line 55

def availability_mode: () -> ("zonal" | "regional")

#client ⇒ Client

Returns:



226
 
# File 'lib/aws-sdk-ec2/nat_gateway.rb', line 226

def client: () -> Client

#connectivity_type ⇒ String

Indicates whether the NAT gateway supports public or private connectivity.

Returns:

  • (String) 


52
 
# File 'sig/nat_gateway.rbs', line 52

def connectivity_type: () -> ("private" | "public")

#create_tags(options = {}) ⇒ Tag::Collection

Examples:

Request syntax with placeholder values


tag = nat_gateway.create_tags({
  dry_run: false,
  tags: [ # required
    {
      key: "String",
      value: "String",
    },
  ],
})

Parameters:

  • options (Hash) (defaults to: {}) —

    ({})

Options Hash (options):

  • :dry_run (Boolean) —

    Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is DryRunOperation. Otherwise, it is UnauthorizedOperation.

  • :tags (required, Array<Types::Tag>) —

    The tags. The value parameter is required, but if you don't want the tag to have a value, specify the parameter with no value, and we set the value to an empty string.

Returns:



83
 
# File 'sig/nat_gateway.rbs', line 83

def create_tags: (

#create_time ⇒ Time

The date and time the NAT gateway was created.

Returns:

  • (Time) 


22
 
# File 'sig/nat_gateway.rbs', line 22

def create_time: () -> ::Time

#data ⇒ Types::NatGateway

Returns the data for this Aws::EC2::NatGateway. Calls Client#describe_nat_gateways if #data_loaded? is false.

Returns:



76
 
# File 'sig/nat_gateway.rbs', line 76

def data: () -> Types::NatGateway

#data_loaded? ⇒ Boolean

Returns true if this resource is loaded. Accessing attributes or #data on an unloaded resource will trigger a call to #load.

Returns:

  • (Boolean) —

    Returns true if this resource is loaded. Accessing attributes or #data on an unloaded resource will trigger a call to #load.



79
 
# File 'sig/nat_gateway.rbs', line 79

def data_loaded?: () -> bool

#delete(options = {}) ⇒ Types::DeleteNatGatewayResult

Examples:

Request syntax with placeholder values


nat_gateway.delete({
  dry_run: false,
})

Parameters:

  • options (Hash) (defaults to: {}) —

    ({})

Options Hash (options):

  • :dry_run (Boolean) —

    Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is DryRunOperation. Otherwise, it is UnauthorizedOperation.

Returns:



107
 
# File 'sig/nat_gateway.rbs', line 107

def delete: (

#delete_tags(options = {}) ⇒ Tag::Collection

Examples:

Request syntax with placeholder values


tag = nat_gateway.delete_tags({
  dry_run: false,
  tags: [
    {
      key: "String",
      value: "String",
    },
  ],
})

Parameters:

  • options (Hash) (defaults to: {}) —

    ({})

Options Hash (options):

  • :dry_run (Boolean) —

    Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is DryRunOperation. Otherwise, it is UnauthorizedOperation.

  • :tags (Array<Types::Tag>) —

    The tags to delete. Specify a tag key and an optional tag value to delete specific tags. If you specify a tag key without a tag value, we delete any tag with this key regardless of its value. If you specify a tag key with an empty string as the tag value, we delete the tag only if its value is an empty string.

    If you omit this parameter, we delete all user-defined tags for the specified resources. We do not delete Amazon Web Services-generated tags (tags that have the aws: prefix).

    Constraints: Up to 1000 tags.

Returns:



95
 
# File 'sig/nat_gateway.rbs', line 95

def delete_tags: (

#delete_time ⇒ Time

The date and time the NAT gateway was deleted, if applicable.

Returns:

  • (Time) 


25
 
# File 'sig/nat_gateway.rbs', line 25

def delete_time: () -> ::Time

#failure_code ⇒ String

If the NAT gateway could not be created, specifies the error code for the failure. (InsufficientFreeAddressesInSubnet | Gateway.NotAttached | InvalidAllocationID.NotFound | Resource.AlreadyAssociated | InternalError | InvalidSubnetID.NotFound)

Returns:

  • (String) 


28
 
# File 'sig/nat_gateway.rbs', line 28

def failure_code: () -> ::String

#failure_message ⇒ String

If the NAT gateway could not be created, specifies the error message for the failure, that corresponds to the error code.

  • For InsufficientFreeAddressesInSubnet: "Subnet has insufficient free addresses to create this NAT gateway"

  • For Gateway.NotAttached: "Network vpc-xxxxxxxx has no Internet gateway attached"

  • For InvalidAllocationID.NotFound: "Elastic IP address eipalloc-xxxxxxxx could not be associated with this NAT gateway"

  • For Resource.AlreadyAssociated: "Elastic IP address eipalloc-xxxxxxxx is already associated"

  • For InternalError: "Network interface eni-xxxxxxxx, created and used internally by this NAT gateway is in an invalid state. Please try again."

  • For InvalidSubnetID.NotFound: "The specified subnet subnet-xxxxxxxx does not exist or could not be found."

Returns:

  • (String) 


31
 
# File 'sig/nat_gateway.rbs', line 31

def failure_message: () -> ::String

#id ⇒ String Also known as: nat_gateway_id

Returns:

  • (String) 


18
 
# File 'sig/nat_gateway.rbs', line 18

def id: () -> String

#identifiers ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Deprecated. 


495
496
497
 
# File 'lib/aws-sdk-ec2/nat_gateway.rb', line 495

def identifiers
  { id: @id }
end

#load ⇒ self Also known as: reload

Loads, or reloads #data for the current Aws::EC2::NatGateway. Returns self making it possible to chain methods.

nat_gateway.reload.data

Returns:

  • (self) 


72
 
# File 'sig/nat_gateway.rbs', line 72

def load: () -> self

#nat_gateway_addresses ⇒ Array<Types::NatGatewayAddress>

Information about the IP addresses and network interface associated with the NAT gateway.

Returns:



34
 
# File 'sig/nat_gateway.rbs', line 34

def nat_gateway_addresses: () -> ::Array[Types::NatGatewayAddress]

#provisioned_bandwidth ⇒ Types::ProvisionedBandwidth

Reserved. If you need to sustain traffic greater than the documented limits, contact Amazon Web Services Support.

Returns:



37
 
# File 'sig/nat_gateway.rbs', line 37

def provisioned_bandwidth: () -> Types::ProvisionedBandwidth

#route_table_id ⇒ String

For regional NAT gateways only, this is the ID of the NAT gateway.

Returns:

  • (String) 


67
 
# File 'sig/nat_gateway.rbs', line 67

def route_table_id: () -> ::String

#state ⇒ String

The state of the NAT gateway.

  • pending: The NAT gateway is being created and is not ready to process traffic.

  • failed: The NAT gateway could not be created. Check the failureCode and failureMessage fields for the reason.

  • available: The NAT gateway is able to process traffic. This status remains until you delete the NAT gateway, and does not indicate the health of the NAT gateway.

  • deleting: The NAT gateway is in the process of being terminated and may still be processing traffic.

  • deleted: The NAT gateway has been terminated and is no longer processing traffic.

Returns:

  • (String) 


40
 
# File 'sig/nat_gateway.rbs', line 40

def state: () -> ("pending" | "failed" | "available" | "deleting" | "deleted")

#subnet ⇒ Subnet?

Returns:



116
 
# File 'sig/nat_gateway.rbs', line 116

def subnet: () -> Subnet?

#subnet_id ⇒ String

The ID of the subnet in which the NAT gateway is located.

Returns:

  • (String) 


43
 
# File 'sig/nat_gateway.rbs', line 43

def subnet_id: () -> ::String

#tags ⇒ Array<Types::Tag>

The tags for the NAT gateway.

Returns:



49
 
# File 'sig/nat_gateway.rbs', line 49

def tags: () -> ::Array[Types::Tag]

#vpc_id ⇒ String

The ID of the VPC in which the NAT gateway is located.

Returns:

  • (String) 


46
 
# File 'sig/nat_gateway.rbs', line 46

def vpc_id: () -> ::String

#wait_until(options = {}) {|resource| ... } ⇒ Resource

Deprecated.

Use [Aws::EC2::Client] #wait_until instead

Note:

The waiting operation is performed on a copy. The original resource remains unchanged.

Waiter polls an API operation until a resource enters a desired state.

Basic Usage

Waiter will polls until it is successful, it fails by entering a terminal state, or until a maximum number of attempts are made.

# polls in a loop until condition is true
resource.wait_until(options) {|resource| condition}

Example

instance.wait_until(max_attempts:10, delay:5) do |instance|
  instance.state.name == 'running'
end

Configuration

You can configure the maximum number of polling attempts, and the delay (in seconds) between each polling attempt. The waiting condition is set by passing a block to #wait_until:

# poll for ~25 seconds
resource.wait_until(max_attempts:5,delay:5) {|resource|...}

Callbacks

You can be notified before each polling attempt and before each delay. If you throw :success or :failure from these callbacks, it will terminate the waiter.

started_at = Time.now
# poll for 1 hour, instead of a number of attempts
proc = Proc.new do |attempts, response|
  throw :failure if Time.now - started_at > 3600
end

  # disable max attempts
instance.wait_until(before_wait:proc, max_attempts:nil) {...}

Handling Errors

When a waiter is successful, it returns the Resource. When a waiter fails, it raises an error.

begin
  resource.wait_until(...)
rescue Aws::Waiters::Errors::WaiterFailed
  # resource did not enter the desired state in time
end

attempts attempt in seconds invoked before each attempt invoked before each wait

Parameters:

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :max_attempts (Integer) — default: 10 —

    Maximum number of

  • :delay (Integer) — default: 10 —

    Delay between each

  • :before_attempt (Proc) — default: nil —

    Callback

  • :before_wait (Proc) — default: nil —

    Callback

Yield Parameters:

  • resource (Resource) —

    to be used in the waiting condition.

Returns:

  • (Resource) —

    if the waiter was successful

Raises:

  • (Aws::Waiters::Errors::FailureStateError) —

    Raised when the waiter terminates because the waiter has entered a state that it will not transition out of, preventing success.

    yet successful.

  • (Aws::Waiters::Errors::UnexpectedError) —

    Raised when an error is encountered while polling for a resource that is not expected.

  • (NotImplementedError) —

    Raised when the resource does not



340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
 
# File 'lib/aws-sdk-ec2/nat_gateway.rb', line 340

def wait_until(options = {}, &block)
  self_copy = self.dup
  attempts = 0
  options[:max_attempts] = 10 unless options.key?(:max_attempts)
  options[:delay] ||= 10
  options[:poller] = Proc.new do
    attempts += 1
    if block.call(self_copy)
      [:success, self_copy]
    else
      self_copy.reload unless attempts == options[:max_attempts]
      :retry
    end
  end
  Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
    Aws::Waiters::Waiter.new(options).wait({})
  end
end