Há mais exemplos de AWS SDK disponíveis no repositório [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) GitHub .
As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Exemplos do Amazon EC2 usando AWS CLI
Os exemplos de código a seguir mostram como realizar ações e implementar cenários comuns usando o AWS Command Line Interface com o Amazon EC2.
*Ações* são trechos de código de programas maiores e devem ser executadas em contexto. Embora as ações mostrem como chamar perfis de serviço individuais, você pode ver as ações no contexto em seus cenários relacionados.
Cada exemplo inclui um link para o código-fonte completo, em que você pode encontrar instruções sobre como configurar e executar o código.
**Topics**
+ [Ações](#actions)
## Ações
### `accept-address-transfer`
O código de exemplo a seguir mostra como usar `accept-address-transfer`.
**AWS CLI**
**Aceitar um endereço IP elástico transferido para sua conta**
O exemplo `accept-address-transfer` a seguir aceita a transferência do endereço IP elástico especificado para sua conta.
```
aws ec2 accept-address-transfer \
--address 100.21.184.216
```
Saída:
```
{
"AddressTransfer": {
"PublicIp": "100.21.184.216",
"AllocationId": "eipalloc-09ad461b0d03f6aaf",
"TransferAccountId": "123456789012",
"TransferOfferExpirationTimestamp": "2023-02-22T20:51:10.000Z",
"TransferOfferAcceptedTimestamp": "2023-02-22T22:52:54.000Z",
"AddressTransferStatus": "accepted"
}
}
```
Para obter mais informações, consulte [Transferir endereços IP elásticos](https://docs.aws.amazon.com/vpc/latest/userguide/WorkWithEIPs.html#transfer-EIPs-intro) no *Guia do usuário do Amazon VPC*.
+ Para obter detalhes da API, consulte [AcceptAddressTransfer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/accept-address-transfer.html)em *Referência de AWS CLI Comandos*.
### `accept-reserved-instances-exchange-quote`
O código de exemplo a seguir mostra como usar `accept-reserved-instances-exchange-quote`.
**AWS CLI**
**Para realizar uma troca de Instância Reservada Conversível**
Este exemplo realiza uma troca das Instâncias Reservadas Conversíveis especificadas.
Comando:
```
aws ec2 accept-reserved-instances-exchange-quote --reserved-instance-ids 7b8750c3-397e-4da4-bbcb-a45ebexample --target-configurations OfferingId=b747b472-423c-48f3-8cee-679bcexample
```
Saída:
```
{
"ExchangeId": "riex-e68ed3c1-8bc8-4c17-af77-811afexample"
}
```
+ Para obter detalhes da API, consulte [AcceptReservedInstancesExchangeQuote](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/accept-reserved-instances-exchange-quote.html)em *Referência de AWS CLI Comandos*.
### `accept-transit-gateway-peering-attachment`
O código de exemplo a seguir mostra como usar `accept-transit-gateway-peering-attachment`.
**AWS CLI**
**Aceitar um anexo de emparelhamento do gateway de trânsito**
O exemplo `accept-transit-gateway-peering-attachment` a seguia aceite o anexo de emparelhamento do gateway de trânsito especificado. O parâmetro `--region` especifica a região na qual o gateway de trânsito do aceitante está localizado.
```
aws ec2 accept-transit-gateway-peering-attachment \
--transit-gateway-attachment-id tgw-attach-4455667788aabbccd \
--region us-east-2
```
Saída:
```
{
"TransitGatewayPeeringAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-4455667788aabbccd",
"RequesterTgwInfo": {
"TransitGatewayId": "tgw-123abc05e04123abc",
"OwnerId": "123456789012",
"Region": "us-west-2"
},
"AccepterTgwInfo": {
"TransitGatewayId": "tgw-11223344aabbcc112",
"OwnerId": "123456789012",
"Region": "us-east-2"
},
"State": "pending",
"CreationTime": "2019-12-09T11:38:31.000Z"
}
}
```
Para obter mais informações, consulte [Anexos de pareamento do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-peering.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [AcceptTransitGatewayPeeringAttachment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/accept-transit-gateway-peering-attachment.html)em *Referência de AWS CLI Comandos*.
### `accept-transit-gateway-vpc-attachment`
O código de exemplo a seguir mostra como usar `accept-transit-gateway-vpc-attachment`.
**AWS CLI**
**Aceitar uma solicitação para anexar uma VPC a um gateway de trânsito.**
O exemplo `accept-transit-gateway-vpc-attachment` a seguir aceita a solicitação para um anexo especificado.
```
aws ec2 accept-transit-gateway-vpc-attachment \
--transit-gateway-attachment-id tgw-attach-0a34fe6b4fEXAMPLE
```
Saída:
```
{
"TransitGatewayVpcAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-0a34fe6b4fEXAMPLE",
"TransitGatewayId": "tgw-0262a0e521EXAMPLE",
"VpcId": "vpc-07e8ffd50fEXAMPLE",
"VpcOwnerId": "123456789012",
"State": "pending",
"SubnetIds": [
"subnet-0752213d59EXAMPLE"
],
"CreationTime": "2019-07-10T17:33:46.000Z",
"Options": {
"DnsSupport": "enable",
"Ipv6Support": "disable"
}
}
}
```
Para obter mais informações, consulte [Anexos do gateway de trânsito para uma VPC](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [AcceptTransitGatewayVpcAttachment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/accept-transit-gateway-vpc-attachment.html)em *Referência de AWS CLI Comandos*.
### `accept-vpc-endpoint-connections`
O código de exemplo a seguir mostra como usar `accept-vpc-endpoint-connections`.
**AWS CLI**
**Aceitar uma solicitação de conexão de interface de endpoint**
Este exemplo aceita a solicitação de conexão de endpoint especificada para o serviço de endpoint especificado.
Comando:
```
aws ec2 accept-vpc-endpoint-connections --service-id vpce-svc-03d5ebb7d9579a2b3 --vpc-endpoint-ids vpce-0c1308d7312217abc
```
Saída:
```
{
"Unsuccessful": []
}
```
+ Para obter detalhes da API, consulte [AcceptVpcEndpointConnections](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/accept-vpc-endpoint-connections.html)em *Referência de AWS CLI Comandos*.
### `accept-vpc-peering-connection`
O código de exemplo a seguir mostra como usar `accept-vpc-peering-connection`.
**AWS CLI**
**Aceitar uma conexão de emparelhamento da VPC**
Este exemplo aceita a solicitação de conexão de emparelhamento da VPC especificada.
Comando:
```
aws ec2 accept-vpc-peering-connection --vpc-peering-connection-id pcx-1a2b3c4d
```
Saída:
```
{
"VpcPeeringConnection": {
"Status": {
"Message": "Provisioning",
"Code": "provisioning"
},
"Tags": [],
"AccepterVpcInfo": {
"OwnerId": "444455556666",
"VpcId": "vpc-44455566",
"CidrBlock": "10.0.1.0/28"
},
"VpcPeeringConnectionId": "pcx-1a2b3c4d",
"RequesterVpcInfo": {
"OwnerId": "444455556666",
"VpcId": "vpc-111abc45",
"CidrBlock": "10.0.0.0/28"
}
}
}
```
+ Para obter detalhes da API, consulte [AcceptVpcPeeringConnection](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/accept-vpc-peering-connection.html)em *Referência de AWS CLI Comandos*.
### `advertise-byoip-cidr`
O código de exemplo a seguir mostra como usar `advertise-byoip-cidr`.
**AWS CLI**
**Anunciar um intervalo de endereços**
O `advertise-byoip-cidr` exemplo a seguir anuncia o intervalo de IPv4 endereços públicos especificado.
```
aws ec2 advertise-byoip-cidr \
--cidr 203.0.113.25/24
```
Saída:
```
{
"ByoipCidr": {
"Cidr": "203.0.113.25/24",
"StatusMessage": "ipv4pool-ec2-1234567890abcdef0",
"State": "provisioned"
}
}
```
+ Para obter detalhes da API, consulte [AdvertiseByoipCidr](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/advertise-byoip-cidr.html)em *Referência de AWS CLI Comandos*.
### `allocate-address`
O código de exemplo a seguir mostra como usar `allocate-address`.
**AWS CLI**
**Exemplo 1: alocar um endereço IP elástico do conjunto de endereços da Amazon**
O exemplo `allocate-address` a seguir aloca um endereço IP elástico. O Amazon EC2 seleciona o endereço do conjunto de endereços da Amazon.
```
aws ec2 allocate-address
```
Saída:
```
{
"PublicIp": "70.224.234.241",
"AllocationId": "eipalloc-01435ba59eEXAMPLE",
"PublicIpv4Pool": "amazon",
"NetworkBorderGroup": "us-west-2",
"Domain": "vpc"
}
```
Para obter mais informações, consulte [Endereços IP elásticos](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) no *Guia do usuário do Amazon EC2*.
**Exemplo 2: alocar um endereço IP elástico e associá-lo a um grupo de borda de rede**
O exemplo `allocate-address` a seguir aloca um endereço IP elástico e o associa ao grupo de borda de rede especificado.
```
aws ec2 allocate-address \
--network-border-group us-west-2-lax-1
```
Saída:
```
{
"PublicIp": "70.224.234.241",
"AllocationId": "eipalloc-e03dd489ceEXAMPLE",
"PublicIpv4Pool": "amazon",
"NetworkBorderGroup": "us-west-2-lax-1",
"Domain": "vpc"
}
```
Para obter mais informações, consulte [Endereços IP elásticos](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) no *Guia do usuário do Amazon EC2*.
**Exemplo 3: alocar um endereço IP elástico de um conjunto de endereços de sua propriedade**
O exemplo `allocate-address` a seguir aloca um endereço IP elástico de um conjunto de endereços que você trouxe para a conta da Amazon Web Services. O Amazon EC2 seleciona o endereço do conjunto de endereços.
```
aws ec2 allocate-address \
--public-ipv4-pool ipv4pool-ec2-1234567890abcdef0
```
Saída:
```
{
"AllocationId": "eipalloc-02463d08ceEXAMPLE",
"NetworkBorderGroup": "us-west-2",
"CustomerOwnedIp": "18.218.95.81",
"CustomerOwnedIpv4Pool": "ipv4pool-ec2-1234567890abcdef0",
"Domain": "vpc"
"NetworkBorderGroup": "us-west-2",
}
```
Para obter mais informações, consulte [Endereços IP elásticos](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) no *Guia do usuário do Amazon EC2*.
**Exemplo 4: alocar um endereço IP elástico de um grupo de IPAM**
O exemplo de `allocate-address` a seguir aloca um endereço IP elástico /32 específico de um grupo do Gerenciador de endereços IP (IPAM) da Amazon VPC.
```
aws ec2 allocate-address \
--region us-east-1 \
--ipam-pool-id ipam-pool-1234567890abcdef0 \
--address 192.0.2.0
```
Saída:
```
{
"PublicIp": "192.0.2.0",
"AllocationId": "eipalloc-abcdef01234567890",
"PublicIpv4Pool": "ipam-pool-1234567890abcdef0",
"NetworkBorderGroup": "us-east-1",
"Domain": "vpc"
}
```
Para obter mais informações, consulte [Allocate sequential Elastic IP addresses from an IPAM pool](https://docs.aws.amazon.com/vpc/latest/ipam/tutorials-eip-pool.html) no *Guia do usuário do IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [AllocateAddress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/allocate-address.html)em *Referência de AWS CLI Comandos*.
### `allocate-hosts`
O código de exemplo a seguir mostra como usar `allocate-hosts`.
**AWS CLI**
**Exemplo 1: alocar um Host Dedicado**
O exemplo `allocate-hosts` a seguir aloca um único Host Dedicado na Zona de Disponibilidade `eu-west-1a`, no qual você pode executar instâncias `m5.large`. Por padrão, o Host Dedicado aceita somente a execução da instância de destino e não oferece suporte à recuperação do host.
```
aws ec2 allocate-hosts \
--instance-type m5.large \
--availability-zone eu-west-1a \
--quantity 1
```
Saída:
```
{
"HostIds": [
"h-07879acf49EXAMPLE"
]
}
```
**Exemplo 2: alocar um Host Dedicado com posicionamento automático e recuperação de host ativados**
O exemplo `allocate-hosts` a seguir aloca um único Host Dedicado na Zona de Disponibilidade `eu-west-1a` com posicionamento automático e recuperação de host ativados.
```
aws ec2 allocate-hosts \
--instance-type m5.large \
--availability-zone eu-west-1a \
--auto-placement on \
--host-recovery on \
--quantity 1
```
Saída:
```
{
"HostIds": [
"h-07879acf49EXAMPLE"
]
}
```
**Exemplo 3: alocar um Host Dedicado com tags**
O exemplo `allocate-hosts` a seguir aloca um único Host Dedicado e aplica uma tag com uma chave chamada `purpose` e um valor de `production`.
```
aws ec2 allocate-hosts \
--instance-type m5.large \
--availability-zone eu-west-1a \
--quantity 1 \
--tag-specifications 'ResourceType=dedicated-host,Tags={Key=purpose,Value=production}'
```
Saída:
```
{
"HostIds": [
"h-07879acf49EXAMPLE"
]
}
```
Para obter mais informações, consulte [Alocar um host dedicado](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-hosts-allocating.html) no *Manual do Usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [AllocateHosts](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/allocate-hosts.html)em *Referência de AWS CLI Comandos*.
### `allocate-ipam-pool-cidr`
O código de exemplo a seguir mostra como usar `allocate-ipam-pool-cidr`.
**AWS CLI**
**Alocar um CIDR de um pool IPAM**
O exemplo `allocate-ipam-pool-cidr` a seguir aloca um CIDR de um pool do IPAM.
(Linux):
```
aws ec2 allocate-ipam-pool-cidr \
--ipam-pool-id ipam-pool-0533048da7d823723 \
--netmask-length 24
```
(Windows):
```
aws ec2 allocate-ipam-pool-cidr ^
--ipam-pool-id ipam-pool-0533048da7d823723 ^
--netmask-length 24
```
Saída:
```
{
"IpamPoolAllocation": {
"Cidr": "10.0.0.0/24",
"IpamPoolAllocationId": "ipam-pool-alloc-018ecc28043b54ba38e2cd99943cebfbd",
"ResourceType": "custom",
"ResourceOwner": "123456789012"
}
}
```
Para obter mais informações, consulte [Alocar manualmente um CIDR a um pool para reservar espaço de endereço IP](https://docs.aws.amazon.com/vpc/latest/ipam/manually-allocate-ipam.html) no *Guia do usuário IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [AllocateIpamPoolCidr](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/allocate-ipam-pool-cidr.html)em *Referência de AWS CLI Comandos*.
### `apply-security-groups-to-client-vpn-target-network`
O código de exemplo a seguir mostra como usar `apply-security-groups-to-client-vpn-target-network`.
**AWS CLI**
**Aplicar grupos de segurança a uma rede de destino para um endpoint de Cliente VPN**
O exemplo `apply-security-groups-to-client-vpn-target-network` a seguir aplica um grupo de segurança `sg-01f6e627a89f4db32` à associação entre a rede de destino e o endpoint do Cliente VPN.
```
aws ec2 apply-security-groups-to-client-vpn-target-network \
--security-group-ids sg-01f6e627a89f4db32 \
--vpc-id vpc-0e2110c2f324332e0 \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde
```
Saída:
```
{
"SecurityGroupIds": [
"sg-01f6e627a89f4db32"
]
}
```
Para obter mais informações, consulte [Redes de destino](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-target.html) no *Guia do administrador da AWS *.
+ Para obter detalhes da API, consulte [ApplySecurityGroupsToClientVpnTargetNetwork](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/apply-security-groups-to-client-vpn-target-network.html)em *Referência de AWS CLI Comandos*.
### `assign-ipv6-addresses`
O código de exemplo a seguir mostra como usar `assign-ipv6-addresses`.
**AWS CLI**
**Para atribuir IPv6 endereços específicos a uma interface de rede**
Este exemplo atribui os IPv6 endereços especificados à interface de rede especificada.
Comando:
```
aws ec2 assign-ipv6-addresses --network-interface-id eni-38664473 --ipv6-addresses 2001:db8:1234:1a00:3304:8879:34cf:4071 2001:db8:1234:1a00:9691:9503:25ad:1761
```
Saída:
```
{
"AssignedIpv6Addresses": [
"2001:db8:1234:1a00:3304:8879:34cf:4071",
"2001:db8:1234:1a00:9691:9503:25ad:1761"
],
"NetworkInterfaceId": "eni-38664473"
}
```
**Para atribuir IPv6 endereços que a Amazon seleciona a uma interface de rede**
Este exemplo atribui dois IPv6 endereços à interface de rede especificada. A Amazon atribui automaticamente esses IPv6 endereços a partir dos IPv6 endereços disponíveis no intervalo de blocos IPv6 CIDR da sub-rede.
Comando:
```
aws ec2 assign-ipv6-addresses --network-interface-id eni-38664473 --ipv6-address-count 2
```
Saída:
```
{
"AssignedIpv6Addresses": [
"2001:db8:1234:1a00:3304:8879:34cf:4071",
"2001:db8:1234:1a00:9691:9503:25ad:1761"
],
"NetworkInterfaceId": "eni-38664473"
}
```
+ Para obter detalhes da API, consulte [AssignIpv6Addresses](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/assign-ipv6-addresses.html) in *AWS CLI Command Reference*.
### `assign-private-ip-addresses`
O código de exemplo a seguir mostra como usar `assign-private-ip-addresses`.
**AWS CLI**
**Atribuir um endereço IP privado secundário a uma interface de rede**
Este exemplo atribui os endereços IP privados secundários especificados à interface de rede especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 assign-private-ip-addresses --network-interface-id eni-e5aa89a3 --private-ip-addresses 10.0.0.82
```
**Atribuir endereços IP privados secundários que o Amazon EC2 seleciona a uma interface de rede**
Este exemplo atribui dois endereços IP privados secundários à interface de rede especificada. O Amazon EC2 atribui automaticamente esses endereços IP a partir dos endereços IP disponíveis no intervalo de blocos CIDR da sub-rede à qual a interface de rede está associada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 assign-private-ip-addresses --network-interface-id eni-e5aa89a3 --secondary-private-ip-address-count 2
```
+ Para obter detalhes da API, consulte [AssignPrivateIpAddresses](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/assign-private-ip-addresses.html)em *Referência de AWS CLI Comandos*.
### `assign-private-nat-gateway-address`
O código de exemplo a seguir mostra como usar `assign-private-nat-gateway-address`.
**AWS CLI**
**Atribuir endereços IP privados ao seu gateway NAT privado**
O exemplo `assign-private-nat-gateway-address` a seguir atribui dois endereços IP privados ao gateway NAT privado especificado.
```
aws ec2 assign-private-nat-gateway-address \
--nat-gateway-id nat-1234567890abcdef0 \
--private-ip-address-count 2
```
Saída:
```
{
"NatGatewayId": "nat-1234567890abcdef0",
"NatGatewayAddresses": [
{
"NetworkInterfaceId": "eni-0065a61b324d1897a",
"IsPrimary": false,
"Status": "assigning"
},
{
"NetworkInterfaceId": "eni-0065a61b324d1897a",
"IsPrimary": false,
"Status": "assigning"
}
]
}
```
Para obter mais informações, consulte [Gateways NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [AssignPrivateNatGatewayAddress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/assign-private-nat-gateway-address.html)em *Referência de AWS CLI Comandos*.
### `associate-address`
O código de exemplo a seguir mostra como usar `associate-address`.
**AWS CLI**
**Exemplo 1: associar um endereço IP elástico a uma instância**
O exemplo de `associate-address` a seguir associa um endereço IP elástico à instância do EC2 especificada.
```
aws ec2 associate-address \
--instance-id i-0b263919b6498b123 \
--allocation-id eipalloc-64d5890a
```
Saída:
```
{
"AssociationId": "eipassoc-2bebb745"
}
```
**Exemplo 2: associar um endereço IP elástico a uma interface de rede**
O exemplo de `associate-address` a seguir associa o endereço IP elástico especificado à interface de rede determinada.
```
aws ec2 associate-address
--allocation-id eipalloc-64d5890a \
--network-interface-id eni-1a2b3c4d
```
Saída:
```
{
"AssociationId": "eipassoc-2bebb745"
}
```
**Exemplo 3: associar um endereço IP elástico a um endereço IP privado**
O exemplo de `associate-address` a seguir associa o endereço IP elástico especificado ao endereço IP privado determinado na interface de rede indicada.
```
aws ec2 associate-address \
--allocation-id eipalloc-64d5890a \
--network-interface-id eni-1a2b3c4d \
--private-ip-address 10.0.0.85
```
Saída:
```
{
"AssociationId": "eipassoc-2bebb745"
}
```
Para obter mais informações, consulte [Endereços IP elásticos](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [AssociateAddress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-address.html)em *Referência de AWS CLI Comandos*.
### `associate-client-vpn-target-network`
O código de exemplo a seguir mostra como usar `associate-client-vpn-target-network`.
**AWS CLI**
**Associar uma rede de destino a um endpoint do Cliente VPN**
O exemplo `associate-client-vpn-target-network` a seguir associa uma sub-rede a um endpoint especificado do Cliente VPN.
```
aws ec2 associate-client-vpn-target-network \
--subnet-id subnet-0123456789abcabca \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde
```
Saída:
```
{
"AssociationId": "cvpn-assoc-12312312312312312",
"Status": {
"Code": "associating"
}
}
```
Para obter mais informações, consulte [Redes de destino](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-target.html) no *Guia do administrador da AWS *.
+ Para obter detalhes da API, consulte [AssociateClientVpnTargetNetwork](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-client-vpn-target-network.html)em *Referência de AWS CLI Comandos*.
### `associate-dhcp-options`
O código de exemplo a seguir mostra como usar `associate-dhcp-options`.
**AWS CLI**
**Associar um conjunto de opções DHCP a uma VPC**
Este exemplo associa o conjunto de opções de DHCP especificado à VPC especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 associate-dhcp-options --dhcp-options-id dopt-d9070ebb --vpc-id vpc-a01106c2
```
**Associar o conjunto de opções DHCP padrão associado a uma VPC**
Este exemplo associa o conjunto padrão de opções de DHCP à VPC especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 associate-dhcp-options --dhcp-options-id default --vpc-id vpc-a01106c2
```
+ Para obter detalhes da API, consulte [AssociateDhcpOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-dhcp-options.html)em *Referência de AWS CLI Comandos*.
### `associate-iam-instance-profile`
O código de exemplo a seguir mostra como usar `associate-iam-instance-profile`.
**AWS CLI**
**Associar um perfil de instância do IAM a uma instância**
Este exemplo associa um perfil de instância do IAM chamado `admin-role` à instância `i-123456789abcde123`.
Comando:
```
aws ec2 associate-iam-instance-profile --instance-id i-123456789abcde123 --iam-instance-profile Name=admin-role
```
Saída:
```
{
"IamInstanceProfileAssociation": {
"InstanceId": "i-123456789abcde123",
"State": "associating",
"AssociationId": "iip-assoc-0e7736511a163c209",
"IamInstanceProfile": {
"Id": "AIPAJBLK7RKJKWDXVHIEC",
"Arn": "arn:aws:iam::123456789012:instance-profile/admin-role"
}
}
}
```
+ Para obter detalhes da API, consulte [AssociateIamInstanceProfile](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-iam-instance-profile.html)em *Referência de AWS CLI Comandos*.
### `associate-instance-event-window`
O código de exemplo a seguir mostra como usar `associate-instance-event-window`.
**AWS CLI**
**Exemplo 1: associar uma ou mais instâncias a uma janela de eventos**
O exemplo `associate-instance-event-window` a seguir associa uma ou mais instâncias a uma janela de eventos.
```
aws ec2 associate-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890 \
--association-target "InstanceIds=i-1234567890abcdef0,i-0598c7d356eba48d7"
```
Saída:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"AssociationTarget": {
"InstanceIds": [
"i-1234567890abcdef0",
"i-0598c7d356eba48d7"
],
"Tags": [],
"DedicatedHostIds": []
},
"State": "creating"
}
}
```
Para restrições da janela de eventos, consulte [Considerações](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) na seção Eventos Programados do *Guia do usuário do Amazon EC2*.
**Exemplo 2: associar tags de instância a uma janela de eventos**
O exemplo `associate-instance-event-window` a seguir associa tags de instância a uma janela de eventos. Insira um parâmetro `instance-event-window-id` para especificar a janela do evento. Para associar tags de instância, especifique o parâmetro `association-target` e, para os valores de parâmetro, especifique uma ou mais tags.
```
aws ec2 associate-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890 \
--association-target "InstanceTags=[{Key=k2,Value=v2},{Key=k1,Value=v1}]"
```
Saída:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"AssociationTarget": {
"InstanceIds": [],
"Tags": [
{
"Key": "k2",
"Value": "v2"
},
{
"Key": "k1",
"Value": "v1"
}
],
"DedicatedHostIds": []
},
"State": "creating"
}
}
```
Para restrições da janela de eventos, consulte [Considerações](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) na seção Eventos Programados do *Guia do usuário do Amazon EC2*.
**Exemplo 3: associar um Host Dedicado a uma janela de eventos**
O exemplo `associate-instance-event-window` a seguir associa um Host Dedicado a uma janela de eventos. Insira um parâmetro `instance-event-window-id` para especificar a janela do evento. Para associar um host dedicado, especifique o `--association-target` parâmetro e, para os valores dos parâmetros, especifique um ou mais hosts dedicados IDs.
```
aws ec2 associate-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890 \
--association-target "DedicatedHostIds=h-029fa35a02b99801d"
```
Saída:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"AssociationTarget": {
"InstanceIds": [],
"Tags": [],
"DedicatedHostIds": [
"h-029fa35a02b99801d"
]
},
"State": "creating"
}
}
```
Para restrições da janela de eventos, consulte [Considerações](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) na seção Eventos Programados do *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [AssociateInstanceEventWindow](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-instance-event-window.html)em *Referência de AWS CLI Comandos*.
### `associate-ipam-resource-discovery`
O código de exemplo a seguir mostra como usar `associate-ipam-resource-discovery`.
**AWS CLI**
**Associar uma descoberta de recursos a um IPAM**
Neste exemplo, você é um administrador delegado do IPAM e uma descoberta de recursos foi criada e compartilhada com você por outra AWS conta para que você possa usar o IPAM para gerenciar e monitorar recursos CIDRs pertencentes à outra conta.
Observação
Para concluir essa solicitação, você precisará da ID de descoberta de recursos, que pode ser obtida com, [describe-ipam-resource-discoveries](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-ipam-resource-discoveries.html)e da ID IPAM, que pode ser obtida com [describe-ipams](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-ipams.html). A descoberta de recursos que você está associando deve ter sido compartilhada primeiro com sua conta usando RAM. A informação inserida deve corresponder à região de origem AWS do IPAM à `--region` qual você a está associando.
O exemplo `associate-ipam-resource-discovery` a seguir associa uma descoberta de recurso a um IPAM.
```
aws ec2 associate-ipam-resource-discovery \
--ipam-id ipam-005f921c17ebd5107 \
--ipam-resource-discovery-id ipam-res-disco-03e0406de76a044ee \
--tag-specifications 'ResourceType=ipam-resource-discovery,Tags=[{Key=cost-center,Value=cc123}]' \
--region us-east-1
```
Saída:
```
{
{
"IpamResourceDiscoveryAssociation": {
"OwnerId": "320805250157",
"IpamResourceDiscoveryAssociationId": "ipam-res-disco-assoc-04382a6346357cf82",
"IpamResourceDiscoveryAssociationArn": "arn:aws:ec2::320805250157:ipam-resource-discovery-association/ipam-res-disco-assoc-04382a6346357cf82",
"IpamResourceDiscoveryId": "ipam-res-disco-0365d2977fc1672fe",
"IpamId": "ipam-005f921c17ebd5107",
"IpamArn": "arn:aws:ec2::320805250157:ipam/ipam-005f921c17ebd5107",
"IpamRegion": "us-east-1",
"IsDefault": false,
"ResourceDiscoveryStatus": "active",
"State": "associate-in-progress",
"Tags": []
}
}
}
```
Depois de associar uma descoberta de recursos, você pode monitorar and/or e gerenciar os endereços IP dos recursos criados pelas outras contas. Para obter mais informações, consulte [Integrar o IPAM com contas fora da sua organização](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam-outside-org.html) no *Guia do usuário do IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [AssociateIpamResourceDiscovery](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-ipam-resource-discovery.html)em *Referência de AWS CLI Comandos*.
### `associate-nat-gateway-address`
O código de exemplo a seguir mostra como usar `associate-nat-gateway-address`.
**AWS CLI**
**Associar um endereço IP elástico a um gateway NAT público**
O `associate-nat-gateway-address` exemplo a seguir associa o endereço IP elástico especificado ao gateway NAT público especificado. AWS atribui automaticamente um IPv4 endereço privado secundário.
```
aws ec2 associate-nat-gateway-address \
--nat-gateway-id nat-1234567890abcdef0 \
--allocation-ids eipalloc-0be6ecac95EXAMPLE
```
Saída:
```
{
"NatGatewayId": "nat-1234567890abcdef0",
"NatGatewayAddresses": [
{
"AllocationId": "eipalloc-0be6ecac95EXAMPLE",
"NetworkInterfaceId": "eni-09cc4b2558794f7f9",
"IsPrimary": false,
"Status": "associating"
}
]
}
```
Para obter mais informações, consulte [Gateways NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [AssociateNatGatewayAddress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-nat-gateway-address.html)em *Referência de AWS CLI Comandos*.
### `associate-route-table`
O código de exemplo a seguir mostra como usar `associate-route-table`.
**AWS CLI**
**Associar uma tabela de rotas a uma sub-rede**
Este exemplo associa a tabela de rotas especificada à sub-rede especificada.
Comando:
```
aws ec2 associate-route-table --route-table-id rtb-22574640 --subnet-id subnet-9d4a7b6c
```
Saída:
```
{
"AssociationId": "rtbassoc-781d0d1a"
}
```
+ Para obter detalhes da API, consulte [AssociateRouteTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-route-table.html)em *Referência de AWS CLI Comandos*.
### `associate-security-group-vpc`
O código de exemplo a seguir mostra como usar `associate-security-group-vpc`.
**AWS CLI**
**Como associar um grupo de segurança a outra VPC**
O exemplo de `associate-security-group-vpc` a seguir associa o grupo de segurança especificado à VPC especificada.
```
aws ec2 associate-security-group-vpc \
--group-id sg-04dbb43907d3f8a78 \
--vpc-id vpc-0bf4c2739bc05a694
```
Saída:
```
{
"State": "associating"
}
```
Para obter mais informações, consulte [Associar grupos de segurança a vários VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-assoc.html) no Guia do *usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [AssociateSecurityGroupVpc](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-security-group-vpc.html)em *Referência de AWS CLI Comandos*.
### `associate-subnet-cidr-block`
O código de exemplo a seguir mostra como usar `associate-subnet-cidr-block`.
**AWS CLI**
**Para associar um bloco IPv6 CIDR a uma sub-rede**
Este exemplo associa um bloco IPv6 CIDR à sub-rede especificada.
Comando:
```
aws ec2 associate-subnet-cidr-block --subnet-id subnet-5f46ec3b --ipv6-cidr-block 2001:db8:1234:1a00::/64
```
Saída:
```
{
"SubnetId": "subnet-5f46ec3b",
"Ipv6CidrBlockAssociation": {
"Ipv6CidrBlock": "2001:db8:1234:1a00::/64",
"AssociationId": "subnet-cidr-assoc-3aa54053",
"Ipv6CidrBlockState": {
"State": "associating"
}
}
}
```
+ Para obter detalhes da API, consulte [AssociateSubnetCidrBlock](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-subnet-cidr-block.html)em *Referência de AWS CLI Comandos*.
### `associate-transit-gateway-multicast-domain`
O código de exemplo a seguir mostra como usar `associate-transit-gateway-multicast-domain`.
**AWS CLI**
**Associar um gateway de trânsito a um domínio multicast**
O exemplo `associate-transit-gateway-multicast-domain` a seguir associa a sub-rede e o anexo especificados ao domínio multicast especificado.
```
aws ec2 associate-transit-gateway-multicast-domain \
--transit-gateway-multicast-domain-id tgw-mcast-domain-0c4905cef79d6e597 \
--transit-gateway-attachment-id tgw-attach-028c1dd0f8f5cbe8e \
--subnet-ids subnet-000de86e3b49c932a \
--transit-gateway-multicast-domain-id tgw-mcast-domain-0c4905cef7EXAMPLE
```
Saída:
```
{
"Associations": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-0c4905cef79d6e597",
"TransitGatewayAttachmentId": "tgw-attach-028c1dd0f8f5cbe8e",
"ResourceId": "vpc-01128d2c240c09bd5",
"ResourceType": "vpc",
"Subnets": [
{
"SubnetId": "subnet-000de86e3b49c932a",
"State": "associating"
}
]
}
}
```
Consulte mais informações em [Multicast domains](https://docs.aws.amazon.com/vpc/latest/tgw/multicast-domains-about.html) no *Guia do Transit Gateway*.
+ Para obter detalhes da API, consulte [AssociateTransitGatewayMulticastDomain](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-transit-gateway-multicast-domain.html)em *Referência de AWS CLI Comandos*.
### `associate-transit-gateway-route-table`
O código de exemplo a seguir mostra como usar `associate-transit-gateway-route-table`.
**AWS CLI**
**Associar uma tabela de rotas do gateway de trânsito a um anexo do gateway de trânsito**
O exemplo a seguir associa a tabela de rotas do gateway de trânsito especificado ao anexo VPC especificado.
```
aws ec2 associate-transit-gateway-route-table \
--transit-gateway-route-table-id tgw-rtb-002573ed1eEXAMPLE \
--transit-gateway-attachment-id tgw-attach-0b5968d3b6EXAMPLE
```
Saída:
```
{
"Association": {
"TransitGatewayRouteTableId": "tgw-rtb-002573ed1eEXAMPLE",
"TransitGatewayAttachmentId": "tgw-attach-0b5968d3b6EXAMPLE",
"ResourceId": "vpc-0065acced4EXAMPLE",
"ResourceType": "vpc",
"State": "associating"
}
}
```
Para obter mais informações, consulte [Associar uma tabelas de rota de gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html#associate-tgw-route-table) no *Guia de gateway de trânsito AWS *.
+ Para obter detalhes da API, consulte [AssociateTransitGatewayRouteTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-transit-gateway-route-table.html)em *Referência de AWS CLI Comandos*.
### `associate-vpc-cidr-block`
O código de exemplo a seguir mostra como usar `associate-vpc-cidr-block`.
**AWS CLI**
**Exemplo 1: Para associar um bloco IPv6 CIDR fornecido pela Amazon a uma VPC**
O `associate-vpc-cidr-block` exemplo a seguir associa um bloco IPv6 CIDR à VPC especificada. :
```
aws ec2 associate-vpc-cidr-block \
--amazon-provided-ipv6-cidr-block \
--ipv6-cidr-block-network-border-group us-west-2-lax-1 \
--vpc-id vpc-8EXAMPLE
```
Saída:
```
{
"Ipv6CidrBlockAssociation": {
"AssociationId": "vpc-cidr-assoc-0838ce7d9dEXAMPLE",
"Ipv6CidrBlockState": {
"State": "associating"
},
"NetworkBorderGroup": "us-west-2-lax-1"
},
"VpcId": "vpc-8EXAMPLE"
}
```
**Exemplo 2:Para associar um bloco IPv4 CIDR adicional a uma VPC**
O `associate-vpc-cidr-block` exemplo a seguir associa o bloco IPv4 CIDR `10.2.0.0/16` à VPC especificada.
```
aws ec2 associate-vpc-cidr-block \
--vpc-id vpc-1EXAMPLE \
--cidr-block 10.2.0.0/16
```
Saída:
```
{
"CidrBlockAssociation": {
"AssociationId": "vpc-cidr-assoc-2EXAMPLE",
"CidrBlock": "10.2.0.0/16",
"CidrBlockState": {
"State": "associating"
}
},
"VpcId": "vpc-1EXAMPLE"
}
```
+ Para obter detalhes da API, consulte [AssociateVpcCidrBlock](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-vpc-cidr-block.html)em *Referência de AWS CLI Comandos*.
### `attach-classic-link-vpc`
O código de exemplo a seguir mostra como usar `attach-classic-link-vpc`.
**AWS CLI**
**Vincular (anexar) uma instância do EC2-Classic a uma VPC**
Este exemplo vincula a instância i-1234567890abcdef0 à VPC vpc-88888888 por meio do grupo de segurança da VPC sg-12312312.
Comando:
```
aws ec2 attach-classic-link-vpc --instance-id i-1234567890abcdef0 --vpc-id vpc-88888888 --groups sg-12312312
```
Saída:
```
{
"Return": true
}
```
+ Para obter detalhes da API, consulte [AttachClassicLinkVpc](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/attach-classic-link-vpc.html)em *Referência de AWS CLI Comandos*.
### `attach-internet-gateway`
O código de exemplo a seguir mostra como usar `attach-internet-gateway`.
**AWS CLI**
**Anexar um gateway da internet à VPC**
O exemplo `attach-internet-gateway` a seguir anexa o gateway da internet especificado à VPC específica.
```
aws ec2 attach-internet-gateway \
--internet-gateway-id igw-0d0fb496b3EXAMPLE \
--vpc-id vpc-0a60eb65b4EXAMPLE
```
Este comando não produz saída.
Para obter mais informações, consulte [Gateways da Internet](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [AttachInternetGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/attach-internet-gateway.html)em *Referência de AWS CLI Comandos*.
### `attach-network-interface`
O código de exemplo a seguir mostra como usar `attach-network-interface`.
**AWS CLI**
**Exemplo 1: anexar uma interface de rede a uma instância**
O exemplo `attach-network-interface` a seguir anexa a interface de rede especificada à instância especificada.
```
aws ec2 attach-network-interface \
--network-interface-id eni-0dc56a8d4640ad10a \
--instance-id i-1234567890abcdef0 \
--device-index 1
```
Saída:
```
{
"AttachmentId": "eni-attach-01a8fc87363f07cf9"
}
```
Para obter mais informações, consulte [Interfaces de rede elástica](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) no *Guia do usuário do Amazon EC2*.
**Exemplo 2: associar uma interface de rede a uma instância com vários cartões de rede**
O exemplo `attach-network-interface` a seguir anexa a interface de rede especificada à instância e ao cartão de rede especificados.
```
aws ec2 attach-network-interface \
--network-interface-id eni-07483b1897541ad83 \
--instance-id i-01234567890abcdef \
--network-card-index 1 \
--device-index 1
```
Saída:
```
{
"AttachmentId": "eni-attach-0fbd7ee87a88cd06c"
}
```
Para obter mais informações, consulte [Interfaces de rede elástica](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [AttachNetworkInterface](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/attach-network-interface.html)em *Referência de AWS CLI Comandos*.
### `attach-verified-access-trust-provider`
O código de exemplo a seguir mostra como usar `attach-verified-access-trust-provider`.
**AWS CLI**
**Anexar um provedor de confiança a uma instância**
O exemplo `attach-verified-access-trust-provider` a seguir anexa o provedor confiável de acesso verificado especificado à instância de acesso verificado especificada.
```
aws ec2 attach-verified-access-trust-provider \
--verified-access-instance-id vai-0ce000c0b7643abea \
--verified-access-trust-provider-id vatp-0bb32de759a3e19e7
```
Saída:
```
{
"VerifiedAccessTrustProvider": {
"VerifiedAccessTrustProviderId": "vatp-0bb32de759a3e19e7",
"Description": "",
"TrustProviderType": "user",
"UserTrustProviderType": "iam-identity-center",
"PolicyReferenceName": "idc",
"CreationTime": "2023-08-25T19:00:38",
"LastUpdatedTime": "2023-08-25T19:00:38"
},
"VerifiedAccessInstance": {
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"Description": "",
"VerifiedAccessTrustProviders": [
{
"VerifiedAccessTrustProviderId": "vatp-0bb32de759a3e19e7",
"TrustProviderType": "user",
"UserTrustProviderType": "iam-identity-center"
}
],
"CreationTime": "2023-08-25T18:27:56",
"LastUpdatedTime": "2023-08-25T18:27:56"
}
}
```
Para obter mais informações, consulte [Instâncias de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-instances.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [AttachVerifiedAccessTrustProvider](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/attach-verified-access-trust-provider.html)em *Referência de AWS CLI Comandos*.
### `attach-volume`
O código de exemplo a seguir mostra como usar `attach-volume`.
**AWS CLI**
**Anexar um volume a uma instância**
Este exemplo de comando anexa um volume (`vol-1234567890abcdef0`) a uma instância (`i-01474ef662b89480`) como `/dev/sdf`.
Comando:
```
aws ec2 attach-volume --volume-id vol-1234567890abcdef0 --instance-id i-01474ef662b89480 --device /dev/sdf
```
Saída:
```
{
"AttachTime": "YYYY-MM-DDTHH:MM:SS.000Z",
"InstanceId": "i-01474ef662b89480",
"VolumeId": "vol-1234567890abcdef0",
"State": "attaching",
"Device": "/dev/sdf"
}
```
+ Para obter detalhes da API, consulte [AttachVolume](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/attach-volume.html)em *Referência de AWS CLI Comandos*.
### `attach-vpn-gateway`
O código de exemplo a seguir mostra como usar `attach-vpn-gateway`.
**AWS CLI**
**Anexar um gateway privado virtual à VPC**
O exemplo `attach-vpn-gateway` a seguir anexa o gateway privado virtual especificado à VPC especificada.
```
aws ec2 attach-vpn-gateway \
--vpn-gateway-id vgw-9a4cacf3 \
--vpc-id vpc-a01106c2
```
Saída:
```
{
"VpcAttachment": {
"State": "attaching",
"VpcId": "vpc-a01106c2"
}
}
```
+ Para obter detalhes da API, consulte [AttachVpnGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/attach-vpn-gateway.html)em *Referência de AWS CLI Comandos*.
### `authorize-client-vpn-ingress`
O código de exemplo a seguir mostra como usar `authorize-client-vpn-ingress`.
**AWS CLI**
**Adicionar uma regra de autorização a um endpoint do Cliente VPN**
O exemplo `authorize-client-vpn-ingress` a seguir adiciona uma regra de autorização de entrada que permite que todos os clientes acessem a internet (`0.0.0.0/0`).
```
aws ec2 authorize-client-vpn-ingress \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde \
--target-network-cidr 0.0.0.0/0 \
--authorize-all-groups
```
Saída:
```
{
"Status": {
"Code": "authorizing"
}
}
```
Para obter mais informações, consulte [Regras de autorização](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-rules.html) no *Guia do administrador do Cliente VPN da AWS *.
+ Para obter detalhes da API, consulte [AuthorizeClientVpnIngress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/authorize-client-vpn-ingress.html)em *Referência de AWS CLI Comandos*.
### `authorize-security-group-egress`
O código de exemplo a seguir mostra como usar `authorize-security-group-egress`.
**AWS CLI**
**Exemplo 1: adicionar uma regra que permita tráfego de saída para um intervalo de endereços específico**
O exemplo de `authorize-security-group-egress` a seguir adiciona uma regra que concede acesso aos intervalos de endereços especificados na porta TCP 80.
```
aws ec2 authorize-security-group-egress \
--group-id sg-1234567890abcdef0 \
--ip-permissions 'IpProtocol=tcp,FromPort=80,ToPort=80,IpRanges=[{CidrIp=10.0.0.0/16}]'
```
Saída:
```
{
"Return": true,
"SecurityGroupRules": [
{
"SecurityGroupRuleId": "sgr-0b15794cdb17bf29c",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "123456789012",
"IsEgress": true,
"IpProtocol": "tcp",
"FromPort": 80,
"ToPort": 80,
"CidrIpv4": "10.0.0.0/16"
}
]
}
```
**Exemplo 2: adicionar uma regra que permita tráfego de saída a um grupo de segurança específico**
O exemplo de `authorize-security-group-egress` a seguir adiciona uma regra que concede acesso ao grupo de segurança especificado na porta TCP 80.
```
aws ec2 authorize-security-group-egress \
--group-id sg-1234567890abcdef0 \
--ip-permissions 'IpProtocol=tcp,FromPort=80,ToPort=80,UserIdGroupPairs=[{GroupId=sg-0aad1c26bbeec5c22}]'
```
Saída:
```
{
"Return": true,
"SecurityGroupRules": [
{
"SecurityGroupRuleId": "sgr-0b5dd815afcea9cc3",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "123456789012",
"IsEgress": true,
"IpProtocol": "tcp",
"FromPort": 80,
"ToPort": 80,
"ReferencedGroupInfo": {
"GroupId": "sg-0aad1c26bbeec5c22",
"UserId": "123456789012"
}
}
]
}
```
Para obter mais informações, consulte [Grupos de segurança](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-security-groups.html) no *Manual do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [AuthorizeSecurityGroupEgress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/authorize-security-group-egress.html)em *Referência de AWS CLI Comandos*.
### `authorize-security-group-ingress`
O código de exemplo a seguir mostra como usar `authorize-security-group-ingress`.
**AWS CLI**
**Exemplo 1: adicionar uma regra que permita tráfego SSH de entrada**
O exemplo `authorize-security-group-ingress` a seguir adiciona uma regra que permite o tráfego de entrada na porta TCP 22 (SSH).
```
aws ec2 authorize-security-group-ingress \
--group-id sg-1234567890abcdef0 \
--protocol tcp \
--port 22 \
--cidr 203.0.113.0/24
```
Saída:
```
{
"Return": true,
"SecurityGroupRules": [
{
"SecurityGroupRuleId": "sgr-01afa97ef3e1bedfc",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "123456789012",
"IsEgress": false,
"IpProtocol": "tcp",
"FromPort": 22,
"ToPort": 22,
"CidrIpv4": "203.0.113.0/24"
}
]
}
```
**Exemplo 2: adicionar uma regra que permita tráfego HTTP de entrada de outro grupo de segurança**
O exemplo `authorize-security-group-ingress` a seguir adiciona uma regra que permite o acesso de entrada na porta TCP 80 do grupo de segurança de origem `sg-1a2b3c4d`. O grupo de origem deve estar na mesma VPC ou em uma VPC de par (requer uma conexão de emparelhamento da VPC). O tráfego de entrada é permitido com base nos endereços IP privados das instâncias associadas ao grupo de segurança de origem (e não ao endereço IP público ou ao endereço IP elástico).
```
aws ec2 authorize-security-group-ingress \
--group-id sg-1234567890abcdef0 \
--protocol tcp \
--port 80 \
--source-group sg-1a2b3c4d
```
Saída:
```
{
"Return": true,
"SecurityGroupRules": [
{
"SecurityGroupRuleId": "sgr-01f4be99110f638a7",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "123456789012",
"IsEgress": false,
"IpProtocol": "tcp",
"FromPort": 80,
"ToPort": 80,
"ReferencedGroupInfo": {
"GroupId": "sg-1a2b3c4d",
"UserId": "123456789012"
}
}
]
}
```
**Exemplo 3: adicionar várias regras na mesma chamada**
O exemplo `authorize-security-group-ingress` a seguir usa o parâmetro `ip-permissions` para adicionar duas regras de entrada, uma que habilita o acesso de entrada na porta TCP 3389 (RDP) e a outra que habilita o ping e ICMP.
```
aws ec2 authorize-security-group-ingress \
--group-id sg-1234567890abcdef0 \
--ip-permissions 'IpProtocol=tcp,FromPort=3389,ToPort=3389,IpRanges=[{CidrIp=172.31.0.0/16}]' 'IpProtocol=icmp,FromPort=-1,ToPort=-1,IpRanges=[{CidrIp=172.31.0.0/16}]'
```
Saída:
```
{
"Return": true,
"SecurityGroupRules": [
{
"SecurityGroupRuleId": "sgr-00e06e5d3690f29f3",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "123456789012",
"IsEgress": false,
"IpProtocol": "tcp",
"FromPort": 3389,
"ToPort": 3389,
"CidrIpv4": "172.31.0.0/16"
},
{
"SecurityGroupRuleId": "sgr-0a133dd4493944b87",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "123456789012",
"IsEgress": false,
"IpProtocol": "tcp",
"FromPort": -1,
"ToPort": -1,
"CidrIpv4": "172.31.0.0/16"
}
]
}
```
**Exemplo 4: adicionar uma regra para o tráfego ICMP**
O exemplo `authorize-security-group-ingress` a seguir usa o parâmetro `ip-permissions` para adicionar uma regra de entrada que permite a mensagem do ICMP `Destination Unreachable: Fragmentation Needed and Don't Fragment was Set` (Tipo 3, Código 4) de qualquer lugar.
```
aws ec2 authorize-security-group-ingress \
--group-id sg-1234567890abcdef0 \
--ip-permissions 'IpProtocol=icmp,FromPort=3,ToPort=4,IpRanges=[{CidrIp=0.0.0.0/0}]'
```
Saída:
```
{
"Return": true,
"SecurityGroupRules": [
{
"SecurityGroupRuleId": "sgr-0de3811019069b787",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "123456789012",
"IsEgress": false,
"IpProtocol": "icmp",
"FromPort": 3,
"ToPort": 4,
"CidrIpv4": "0.0.0.0/0"
}
]
}
```
**Exemplo 5: Para adicionar uma regra para IPv6 tráfego**
O `authorize-security-group-ingress` exemplo a seguir usa o `ip-permissions` parâmetro para adicionar uma regra de entrada que permite acesso SSH (porta 22) a IPv6 partir do intervalo. `2001:db8:1234:1a00::/64`
```
aws ec2 authorize-security-group-ingress \
--group-id sg-1234567890abcdef0 \
--ip-permissions 'IpProtocol=tcp,FromPort=22,ToPort=22,Ipv6Ranges=[{CidrIpv6=2001:db8:1234:1a00::/64}]'
```
Saída:
```
{
"Return": true,
"SecurityGroupRules": [
{
"SecurityGroupRuleId": "sgr-0455bc68b60805563",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "123456789012",
"IsEgress": false,
"IpProtocol": "tcp",
"FromPort": 22,
"ToPort": 22,
"CidrIpv6": "2001:db8:1234:1a00::/64"
}
]
}
```
**Exemplo 6: Para adicionar uma regra para ICMPv6 tráfego**
O `authorize-security-group-ingress` exemplo a seguir usa o `ip-permissions` parâmetro para adicionar uma regra de entrada que permite ICMPv6 tráfego de qualquer lugar.
```
aws ec2 authorize-security-group-ingress \
--group-id sg-1234567890abcdef0 \
--ip-permissions 'IpProtocol=icmpv6,Ipv6Ranges=[{CidrIpv6=::/0}]'
```
Saída:
```
{
"Return": true,
"SecurityGroupRules": [
{
"SecurityGroupRuleId": "sgr-04b612d9363ab6327",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "123456789012",
"IsEgress": false,
"IpProtocol": "icmpv6",
"FromPort": -1,
"ToPort": -1,
"CidrIpv6": "::/0"
}
]
}
```
**Exemplo 7: adicionar uma regra com uma descrição**
O `authorize-security-group-ingress` exemplo a seguir usa o `ip-permissions` parâmetro para adicionar uma regra de entrada que permite tráfego RDP do intervalo de IPv4 endereços especificado. A regra inclui uma descrição para ajudar a identificá-lo posteriormente.
```
aws ec2 authorize-security-group-ingress \
--group-id sg-1234567890abcdef0 \
--ip-permissions 'IpProtocol=tcp,FromPort=3389,ToPort=3389,IpRanges=[{CidrIp=203.0.113.0/24,Description='RDP access from NY office'}]'
```
Saída:
```
{
"Return": true,
"SecurityGroupRules": [
{
"SecurityGroupRuleId": "sgr-0397bbcc01e974db3",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "123456789012",
"IsEgress": false,
"IpProtocol": "tcp",
"FromPort": 3389,
"ToPort": 3389,
"CidrIpv4": "203.0.113.0/24",
"Description": "RDP access from NY office"
}
]
}
```
**Exemplo 8: adicionar uma regra de entrada que use uma lista de prefixos**
O exemplo `authorize-security-group-ingress` a seguir usa o parâmetro `ip-permissions` para adicionar uma regra de entrada que permite todo o tráfego para os intervalos CIDR na lista de prefixos especificada.
```
aws ec2 authorize-security-group-ingress \
--group-id sg-04a351bfe432d4e71 \
--ip-permissions 'IpProtocol=all,PrefixListIds=[{PrefixListId=pl-002dc3ec097de1514}]'
```
Saída:
```
{
"Return": true,
"SecurityGroupRules": [
{
"SecurityGroupRuleId": "sgr-09c74b32f677c6c7c",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "123456789012",
"IsEgress": false,
"IpProtocol": "-1",
"FromPort": -1,
"ToPort": -1,
"PrefixListId": "pl-0721453c7ac4ec009"
}
]
}
```
Para obter mais informações, consulte [Grupos de segurança](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-security-groups.html) no *Manual do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [AuthorizeSecurityGroupIngress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/authorize-security-group-ingress.html)em *Referência de AWS CLI Comandos*.
### `bundle-instance`
O código de exemplo a seguir mostra como usar `bundle-instance`.
**AWS CLI**
**Empacotar uma instância**
Este exemplo empacota a instância `i-1234567890abcdef0` em um bucket chamado `bundletasks`. Antes de especificar valores para sua chave de acesso IDs, revise e siga as orientações em Melhores práticas para gerenciar chaves de AWS acesso.
Comando:
```
aws ec2 bundle-instance --instance-id i-1234567890abcdef0 --bucket bundletasks --prefix winami --owner-akid AK12AJEXAMPLE --owner-sak example123example
```
Saída:
```
{
"BundleTask": {
"UpdateTime": "2015-09-15T13:30:35.000Z",
"InstanceId": "i-1234567890abcdef0",
"Storage": {
"S3": {
"Prefix": "winami",
"Bucket": "bundletasks"
}
},
"State": "pending",
"StartTime": "2015-09-15T13:30:35.000Z",
"BundleId": "bun-294e041f"
}
}
```
+ Para obter detalhes da API, consulte [BundleInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/bundle-instance.html)em *Referência de AWS CLI Comandos*.
### `cancel-bundle-task`
O código de exemplo a seguir mostra como usar `cancel-bundle-task`.
**AWS CLI**
**Cancelar uma tarefa de empacotamento**
Este exemplo cancela a tarefa de empacotamento `bun-2a4e041c`.
Comando:
```
aws ec2 cancel-bundle-task --bundle-id bun-2a4e041c
```
Saída:
```
{
"BundleTask": {
"UpdateTime": "2015-09-15T13:27:40.000Z",
"InstanceId": "i-1234567890abcdef0",
"Storage": {
"S3": {
"Prefix": "winami",
"Bucket": "bundletasks"
}
},
"State": "cancelling",
"StartTime": "2015-09-15T13:24:35.000Z",
"BundleId": "bun-2a4e041c"
}
}
```
+ Para obter detalhes da API, consulte [CancelBundleTask](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-bundle-task.html)em *Referência de AWS CLI Comandos*.
### `cancel-capacity-reservation-fleets`
O código de exemplo a seguir mostra como usar `cancel-capacity-reservation-fleets`.
**AWS CLI**
**Cancelar uma frota de reserva de capacidade**
O exemplo `cancel-capacity-reservation-fleets` a seguir cancela a frota de reserva de capacidade especificada e a capacidade que ela reserva. Quando você cancela uma frota, o status muda para `cancelled` e ela não poderá mais criar novas reservas de capacidade. Além disso, todas as reservas de capacidade individuais na frota são canceladas e as instâncias que estavam em execução anteriormente na capacidade reservada continuam a ser executadas normalmente com capacidade compartilhada.
```
aws ec2 cancel-capacity-reservation-fleets \
--capacity-reservation-fleet-ids crf-abcdef01234567890
```
Saída:
```
{
"SuccessfulFleetCancellations": [
{
"CurrentFleetState": "cancelling",
"PreviousFleetState": "active",
"CapacityReservationFleetId": "crf-abcdef01234567890"
}
],
"FailedFleetCancellations": []
}
```
Para obter mais informações sobre as Frotas de Reserva de Capacidade, consulte [Frotas de reserva de capacidade](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cr-fleets.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [CancelCapacityReservationFleets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-capacity-reservation-fleets.html)em *Referência de AWS CLI Comandos*.
### `cancel-capacity-reservation`
O código de exemplo a seguir mostra como usar `cancel-capacity-reservation`.
**AWS CLI**
**Cancelar uma reserva de capacidade**
O exemplo `cancel-capacity-reservation` a seguir cancela a reserva de capacidade especificada.
```
aws ec2 cancel-capacity-reservation \
--capacity-reservation-id cr-1234abcd56EXAMPLE
```
Saída:
```
{
"Return": true
}
```
Consulte mais informações em [Cancelar uma Reserva de capacidade](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservations-release.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [CancelCapacityReservation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-capacity-reservation.html)em *Referência de AWS CLI Comandos*.
### `cancel-conversion-task`
O código de exemplo a seguir mostra como usar `cancel-conversion-task`.
**AWS CLI**
**Cancelar uma conversão ativa de uma instância ou volume**
Este exemplo cancela o upload associado à ID da tarefa import-i-fh 95npoc. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 cancel-conversion-task --conversion-task-id import-i-fh95npoc
```
+ Para obter detalhes da API, consulte [CancelConversionTask](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-conversion-task.html)em *Referência de AWS CLI Comandos*.
### `cancel-export-task`
O código de exemplo a seguir mostra como usar `cancel-export-task`.
**AWS CLI**
**Cancelar uma tarefa de exportação ativa**
Este exemplo cancela uma tarefa de exportação ativa com o ID de tarefa export-i-fgelt 0i7. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 cancel-export-task --export-task-id export-i-fgelt0i7
```
+ Para obter detalhes da API, consulte [CancelExportTask](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-export-task.html)em *Referência de AWS CLI Comandos*.
### `cancel-image-launch-permission`
O código de exemplo a seguir mostra como usar `cancel-image-launch-permission`.
**AWS CLI**
**Cancelar o compartilhamento de uma AMI com sua conta da Amazon Web Services**
O exemplo `cancel-image-launch-permission` a seguir remove sua conta das permissões de execução para a AMI especificada.
```
aws ec2 cancel-image-launch-permission \
--image-id ami-0123456789example \
--region us-east-1
```
Saída:
```
{
"Return": true
}
```
Para obter mais informações, consulte [Cancelar o compartilhamento de uma AMI com sua conta da Amazon Web Services](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cancel-sharing-an-AMI.html#cancel-image-launch-permission) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [CancelImageLaunchPermission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-image-launch-permission.html)em *Referência de AWS CLI Comandos*.
### `cancel-import-task`
O código de exemplo a seguir mostra como usar `cancel-import-task`.
**AWS CLI**
**Cancelar uma tarefa de importação**
O exemplo `cancel-import-task` a seguir cancela a tarefa de importação de imagem especificada.
```
aws ec2 cancel-import-task \
--import-task-id import-ami-1234567890abcdef0
```
Saída:
```
{
"ImportTaskId": "import-ami-1234567890abcdef0",
"PreviousState": "active",
"State": "deleting"
}
```
+ Para obter detalhes da API, consulte [CancelImportTask](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-import-task.html)em *Referência de AWS CLI Comandos*.
### `cancel-reserved-instances-listing`
O código de exemplo a seguir mostra como usar `cancel-reserved-instances-listing`.
**AWS CLI**
**Cancelar uma listagem de Instâncias Reservadas**
O exemplo `cancel-reserved-instances-listing` a seguir cancela a listagem de instâncias reservadas especificada.
```
aws ec2 cancel-reserved-instances-listing \
--reserved-instances-listing-id 5ec28771-05ff-4b9b-aa31-9e57dexample
```
+ Para obter detalhes da API, consulte [CancelReservedInstancesListing](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-reserved-instances-listing.html)em *Referência de AWS CLI Comandos*.
### `cancel-spot-fleet-requests`
O código de exemplo a seguir mostra como usar `cancel-spot-fleet-requests`.
**AWS CLI**
**Exemplo 1: cancelar uma solicitação de frota Spot e encerrar as instâncias associadas**
O exemplo `cancel-spot-fleet-requests` a seguir cancela uma solicitação de Frota Spot e encerra as Instâncias Sob Demanda e Instâncias Spot associadas.
```
aws ec2 cancel-spot-fleet-requests \
--spot-fleet-request-ids sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE \
--terminate-instances
```
Saída:
```
{
"SuccessfulFleetRequests": [
{
"SpotFleetRequestId": "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE",
"CurrentSpotFleetRequestState": "cancelled_terminating",
"PreviousSpotFleetRequestState": "active"
}
],
"UnsuccessfulFleetRequests": []
}
```
**Exemplo 2: cancelar uma solicitação de frota Spot sem encerrar as instâncias associadas**
O exemplo `cancel-spot-fleet-requests` a seguir cancela uma solicitação de Frota Spot sem encerrar as Instâncias Sob Demanda e Instâncias Spot associadas.
```
aws ec2 cancel-spot-fleet-requests \
--spot-fleet-request-ids sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE \
--no-terminate-instances
```
Saída:
```
{
"SuccessfulFleetRequests": [
{
"SpotFleetRequestId": "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE",
"CurrentSpotFleetRequestState": "cancelled_running",
"PreviousSpotFleetRequestState": "active"
}
],
"UnsuccessfulFleetRequests": []
}
```
Consulte mais informações em [Cancelar uma solicitação de frota spot](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cancel-spot-fleet.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [CancelSpotFleetRequests](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-spot-fleet-requests.html)em *Referência de AWS CLI Comandos*.
### `cancel-spot-instance-requests`
O código de exemplo a seguir mostra como usar `cancel-spot-instance-requests`.
**AWS CLI**
**Cancelar solicitações de Instância Spot**
Este exemplo de comando cancela uma solicitação de Instância Spot.
Comando:
```
aws ec2 cancel-spot-instance-requests --spot-instance-request-ids sir-08b93456
```
Saída:
```
{
"CancelledSpotInstanceRequests": [
{
"State": "cancelled",
"SpotInstanceRequestId": "sir-08b93456"
}
]
}
```
+ Para obter detalhes da API, consulte [CancelSpotInstanceRequests](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-spot-instance-requests.html)em *Referência de AWS CLI Comandos*.
### `confirm-product-instance`
O código de exemplo a seguir mostra como usar `confirm-product-instance`.
**AWS CLI**
**Confirmar a instância do produto**
Esse exemplo determina se o código do produto especificado está associado à instância especificada.
Comando:
```
aws ec2 confirm-product-instance --product-code 774F4FF8 --instance-id i-1234567890abcdef0
```
Saída:
```
{
"OwnerId": "123456789012"
}
```
+ Para obter detalhes da API, consulte [ConfirmProductInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/confirm-product-instance.html)em *Referência de AWS CLI Comandos*.
### `copy-fpga-image`
O código de exemplo a seguir mostra como usar `copy-fpga-image`.
**AWS CLI**
**Copiar uma imagem FPGA da Amazon**
Este exemplo copia o AFI especificado da região `us-east-1` para a região atual (`eu-west-1`).
Comando:
```
aws ec2 copy-fpga-image --name copy-afi --source-fpga-image-id afi-0d123e123bfc85abc --source-region us-east-1 --region eu-west-1
```
Saída:
```
{
"FpgaImageId": "afi-06b12350a123fbabc"
}
```
+ Para obter detalhes da API, consulte [CopyFpgaImage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/copy-fpga-image.html)em *Referência de AWS CLI Comandos*.
### `copy-image`
O código de exemplo a seguir mostra como usar `copy-image`.
**AWS CLI**
**Exemplo 1: copiar uma AMI para outra região**
O comando de exemplo `copy-image` a seguir copia a AMI especificada da região `us-west-2` para a região `us-east-1` e adiciona uma breve descrição.
```
aws ec2 copy-image \
--region us-east-1 \
--name ami-name \
--source-region us-west-2 \
--source-image-id ami-066877671789bd71b \
--description "This is my copied image."
```
Saída:
```
{
"ImageId": "ami-0123456789abcdefg"
}
```
Para obter mais informações, consulte [Copiar uma AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/CopyingAMIs.html) no *Guia do usuário do Amazon EC2*.
**Exemplo 2: copiar uma AMI para outra região e criptografar o snapshot de apoio**
O comando `copy-image` a seguir copia a AMI especificada da região `us-west-2` para a região atual e criptografa o snapshot de backup usando a chave KMS especificada.
```
aws ec2 copy-image \
--source-region us-west-2 \
--name ami-name \
--source-image-id ami-066877671789bd71b \
--encrypted \
--kms-key-id alias/my-kms-key
```
Saída:
```
{
"ImageId": "ami-0123456789abcdefg"
}
```
Para obter mais informações, consulte [Copiar uma AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/CopyingAMIs.html) no *Guia do usuário do Amazon EC2*.
**Exemplo 3: incluir as tags de AMI definidas pelo usuário ao copiar uma AMI**
O comando `copy-image` a seguir usa o parâmetro `--copy-image-tags` para copiar as tags de AMI definidas pelo usuário ao copiar a AMI.
```
aws ec2 copy-image \
--region us-east-1 \
--name ami-name \
--source-region us-west-2 \
--source-image-id ami-066877671789bd71b \
--description "This is my copied image."
--copy-image-tags
```
Saída:
```
{
"ImageId": "ami-0123456789abcdefg"
}
```
Para obter mais informações, consulte [Copiar uma AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/CopyingAMIs.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [CopyImage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/copy-image.html)em *Referência de AWS CLI Comandos*.
### `copy-snapshot`
O código de exemplo a seguir mostra como usar `copy-snapshot`.
**AWS CLI**
**Exemplo 1: copiar um snapshot para outra região**
O comando de exemplo `copy-snapshot` a seguir copia o snapshot especificado da região `us-west-2` para a região `us-east-1` e adiciona uma breve descrição.
```
aws ec2 copy-snapshot \
--region us-east-1 \
--source-region us-west-2 \
--source-snapshot-id snap-066877671789bd71b \
--description 'This is my copied snapshot.'
```
Saída:
```
{
"SnapshotId": "snap-066877671789bd71b"
}
```
**Exemplo 2: copiar um snapshot não criptografado e criptografar o novo snapshot**
O comando `copy-snapshot` a seguir copia o snapshot não criptografado especificado da região `us-west-2` para a região atual e criptografa o novo snapshot usando a chave KMS especificada.
```
aws ec2 copy-snapshot \
--source-region us-west-2 \
--source-snapshot-id snap-066877671789bd71b \
--encrypted \
--kms-key-id alias/my-kms-key
```
Saída:
```
{
"SnapshotId": "snap-066877671789bd71b"
}
```
Consulte mais informações em [Copy an Amazon EBS snapshot](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-copy-snapshot.html) no *Guia do usuário do Amazon EBS*.
+ Para obter detalhes da API, consulte [CopySnapshot](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/copy-snapshot.html)em *Referência de AWS CLI Comandos*.
### `create-capacity-reservation-fleet`
O código de exemplo a seguir mostra como usar `create-capacity-reservation-fleet`.
**AWS CLI**
**Criar uma Frota de Reserva de Capacidade**
O exemplo `create-capacity-reservation-fleet` a seguir cria uma frota de reserva de capacidade para o tipo de instância especificado na solicitação, até a capacidade total de destino especificada. O número de instâncias para as quais a frota de reserva de capacidade reserva capacidade depende da capacidade total de destino e dos pesos de tipo de instância que você especifica na solicitação. Especifique os tipos de instância a serem usados e uma prioridade para cada um dos tipos de instância designados.
```
aws ec2 create-capacity-reservation-fleet \
--total-target-capacity 24 \
--allocation-strategy prioritized \
--instance-match-criteria open \
--tenancy default \
--end-date 2022-12-31T23:59:59.000Z \
--instance-type-specifications file://instanceTypeSpecification.json
```
Conteúdo de `instanceTypeSpecification.json`:
```
[
{
"InstanceType": "m5.xlarge",
"InstancePlatform": "Linux/UNIX",
"Weight": 3.0,
"AvailabilityZone":"us-east-1a",
"EbsOptimized": true,
"Priority" : 1
}
]
```
Saída:
```
{
"Status": "submitted",
"TotalFulfilledCapacity": 0.0,
"CapacityReservationFleetId": "crf-abcdef01234567890",
"TotalTargetCapacity": 24
}
```
Para obter mais informações sobre as Frotas de Reserva de Capacidade, consulte [Frotas de reserva de capacidade](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cr-fleets.html) no *Guia do usuário do Amazon EC2*.
Para obter mais informações sobre o peso do tipo de instância e a capacidade total alvo, consulte [Peso do tipo de instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#instance-weight) e [Capacidade total alvo](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#target-capacity) no *Guia do usuário do Amazon EC2*.
Para obter mais informações sobre a designação de prioridade para tipos de instância específicos, consulte [Estratégia de alocação](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#allocation-strategy) e [Prioridade do tipo de instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#instance-priority) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [CreateCapacityReservationFleet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-capacity-reservation-fleet.html)em *Referência de AWS CLI Comandos*.
### `create-capacity-reservation`
O código de exemplo a seguir mostra como usar `create-capacity-reservation`.
**AWS CLI**
**Exemplo 1: criar uma reserva de capacidade**
O `create-capacity-reservation` exemplo a seguir cria uma reserva de capacidade na zona de `eu-west-1a` disponibilidade, na qual você pode executar três `t2.medium` instâncias executando um sistema Linux/Unix operacional. Por padrão, a reserva de capacidade é criada com critérios de correspondência de instâncias abertas e sem suporte para armazenamento temporário, e permanece ativa até que você a cancele manualmente.
```
aws ec2 create-capacity-reservation \
--availability-zone eu-west-1a \
--instance-type t2.medium \
--instance-platform Linux/UNIX \
--instance-count 3
```
Saída:
```
{
"CapacityReservation": {
"CapacityReservationId": "cr-1234abcd56EXAMPLE ",
"EndDateType": "unlimited",
"AvailabilityZone": "eu-west-1a",
"InstanceMatchCriteria": "open",
"EphemeralStorage": false,
"CreateDate": "2019-08-16T09:27:35.000Z",
"AvailableInstanceCount": 3,
"InstancePlatform": "Linux/UNIX",
"TotalInstanceCount": 3,
"State": "active",
"Tenancy": "default",
"EbsOptimized": false,
"InstanceType": "t2.medium"
}
}
```
**Exemplo 2: criar uma reserva de capacidade que termine automaticamente em uma data/hora especificada**
O `create-capacity-reservation` exemplo a seguir cria uma reserva de capacidade na zona de `eu-west-1a` disponibilidade, na qual você pode executar três `m5.large` instâncias executando um sistema Linux/Unix operacional. Essa reserva de capacidade termina automaticamente em 31/08/2019 às 23:59:59.
```
aws ec2 create-capacity-reservation \
--availability-zone eu-west-1a \
--instance-type m5.large \
--instance-platform Linux/UNIX \
--instance-count 3 \
--end-date-type limited \
--end-date 2019-08-31T23:59:59Z
```
Saída:
```
{
"CapacityReservation": {
"CapacityReservationId": "cr-1234abcd56EXAMPLE ",
"EndDateType": "limited",
"AvailabilityZone": "eu-west-1a",
"EndDate": "2019-08-31T23:59:59.000Z",
"InstanceMatchCriteria": "open",
"EphemeralStorage": false,
"CreateDate": "2019-08-16T10:15:53.000Z",
"AvailableInstanceCount": 3,
"InstancePlatform": "Linux/UNIX",
"TotalInstanceCount": 3,
"State": "active",
"Tenancy": "default",
"EbsOptimized": false,
"InstanceType": "m5.large"
}
}
```
**Exemplo 3: criar uma reserva de capacidade que aceite somente execuções direcionadas de instância**
O exemplo `create-capacity-reservation` a seguir cria uma reserva de capacidade que aceita somente lançamentos de instâncias direcionadas.
```
aws ec2 create-capacity-reservation \
--availability-zone eu-west-1a \
--instance-type m5.large \
--instance-platform Linux/UNIX \
--instance-count 3 \
--instance-match-criteria targeted
```
Saída:
```
{
"CapacityReservation": {
"CapacityReservationId": "cr-1234abcd56EXAMPLE ",
"EndDateType": "unlimited",
"AvailabilityZone": "eu-west-1a",
"InstanceMatchCriteria": "targeted",
"EphemeralStorage": false,
"CreateDate": "2019-08-16T10:21:57.000Z",
"AvailableInstanceCount": 3,
"InstancePlatform": "Linux/UNIX",
"TotalInstanceCount": 3,
"State": "active",
"Tenancy": "default",
"EbsOptimized": false,
"InstanceType": "m5.large"
}
}
```
Consulte mais informações em [Criar uma Reserva de capacidade](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservations-using.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [CreateCapacityReservation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-capacity-reservation.html)em *Referência de AWS CLI Comandos*.
### `create-carrier-gateway`
O código de exemplo a seguir mostra como usar `create-carrier-gateway`.
**AWS CLI**
**Criar um gateway de operadora**
O exemplo `create-carrier-gateway` a seguir cria um gateway de operadora para a VPC especificada.
```
aws ec2 create-carrier-gateway \
--vpc-id vpc-0c529aEXAMPLE1111
```
Saída:
```
{
"CarrierGateway": {
"CarrierGatewayId": "cagw-0465cdEXAMPLE1111",
"VpcId": "vpc-0c529aEXAMPLE1111",
"State": "pending",
"OwnerId": "123456789012"
}
}
```
Para obter mais informações, consulte [Gateways de operadoras](https://docs.aws.amazon.com/wavelength/latest/developerguide/carrier-gateways.html) no *Guia do usuário do AWS Wavelength*.
+ Para obter detalhes da API, consulte [CreateCarrierGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-carrier-gateway.html)em *Referência de AWS CLI Comandos*.
### `create-client-vpn-endpoint`
O código de exemplo a seguir mostra como usar `create-client-vpn-endpoint`.
**AWS CLI**
**Criar um endpoint da cliente VPN**
O exemplo `create-client-vpn-endpoint` a seguir cria um endpoint do Cliente VPN usando autenticação mútua e especificando um valor para o bloco do CIDR do cliente.
```
aws ec2 create-client-vpn-endpoint \
--client-cidr-block "172.31.0.0/16" \
--server-certificate-arn arn:aws:acm:ap-south-1:123456789012:certificate/a1b2c3d4-5678-90ab-cdef-11111EXAMPLE \
--authentication-options Type=certificate-authentication,MutualAuthentication={ClientRootCertificateChainArn=arn:aws:acm:ap-south-1:123456789012:certificate/a1b2c3d4-5678-90ab-cdef-22222EXAMPLE} \
--connection-log-options Enabled=false
```
Saída:
```
{
"ClientVpnEndpointId": "cvpn-endpoint-123456789123abcde",
"Status": {
"Code": "pending-associate"
},
"DnsName": "cvpn-endpoint-123456789123abcde.prod.clientvpn.ap-south-1.amazonaws.com"
}
```
Para obter mais informações, consulte [Endpoints de Client VPN](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-endpoints.html) no *Guia do administrador do Cliente VPN da AWS *.
+ Para obter detalhes da API, consulte [CreateClientVpnEndpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-client-vpn-endpoint.html)em *Referência de AWS CLI Comandos*.
### `create-client-vpn-route`
O código de exemplo a seguir mostra como usar `create-client-vpn-route`.
**AWS CLI**
**Criar uma rota para um endpoint do Cliente VPN**
O exemplo `create-client-vpn-route` a seguir adiciona uma rota à internet (`0.0.0.0/0`) para a sub-rede especificada do endpoint de Cliente VPN.
```
aws ec2 create-client-vpn-route \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde \
--destination-cidr-block 0.0.0.0/0 \
--target-vpc-subnet-id subnet-0123456789abcabca
```
Saída:
```
{
"Status": {
"Code": "creating"
}
}
```
Para obter mais informações, consulte [Rotas](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-routes.html) no *Guia do administrador de cliente VPN da AWS *.
+ Para obter detalhes da API, consulte [CreateClientVpnRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-client-vpn-route.html)em *Referência de AWS CLI Comandos*.
### `create-coip-cidr`
O código de exemplo a seguir mostra como usar `create-coip-cidr`.
**AWS CLI**
**Criar um intervalo de endereços IP de propriedade do cliente (CoIP)**
O exemplo `create-coip-cidr` a seguir cria o intervalo especificado de endereços de CoIP no pool de CoIP especificado.
```
aws ec2 create-coip-cidr \
--cidr 15.0.0.0/24 \
--coip-pool-id ipv4pool-coip-1234567890abcdefg
```
Saída:
```
{
"CoipCidr": {
"Cidr": "15.0.0.0/24",
"CoipPoolId": "ipv4pool-coip-1234567890abcdefg",
"LocalGatewayRouteTableId": "lgw-rtb-abcdefg1234567890"
}
}
```
Para obter mais informações, consulte [Endereços IP pertencentes ao cliente](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#ip-addressing) no *Guia do usuário do AWS Outposts*.
+ Para obter detalhes da API, consulte [CreateCoipCidr](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-coip-cidr.html)em *Referência de AWS CLI Comandos*.
### `create-coip-pool`
O código de exemplo a seguir mostra como usar `create-coip-pool`.
**AWS CLI**
**Criar um pool de endereços IP de propriedade do cliente (CoIP)**
O exemplo `create-coip-pool` a seguir cria um pool de CoIP para endereços de CoIP na tabela de rotas do gateway local especificada.
```
aws ec2 create-coip-pool \
--local-gateway-route-table-id lgw-rtb-abcdefg1234567890
```
Saída:
```
{
"CoipPool": {
"PoolId": "ipv4pool-coip-1234567890abcdefg",
"LocalGatewayRouteTableId": "lgw-rtb-abcdefg1234567890",
"PoolArn": "arn:aws:ec2:us-west-2:123456789012:coip-pool/ipv4pool-coip-1234567890abcdefg"
}
}
```
Para obter mais informações, consulte [Endereços IP pertencentes ao cliente](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#ip-addressing) no *Guia do usuário do AWS Outposts*.
+ Para obter detalhes da API, consulte [CreateCoipPool](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-coip-pool.html)em *Referência de AWS CLI Comandos*.
### `create-customer-gateway`
O código de exemplo a seguir mostra como usar `create-customer-gateway`.
**AWS CLI**
**Criar um gateway do cliente**
Este exemplo cria um gateway do cliente com o endereço IP especificado para sua interface externa.
Comando:
```
aws ec2 create-customer-gateway --type ipsec.1 --public-ip 12.1.2.3 --bgp-asn 65534
```
Saída:
```
{
"CustomerGateway": {
"CustomerGatewayId": "cgw-0e11f167",
"IpAddress": "12.1.2.3",
"State": "available",
"Type": "ipsec.1",
"BgpAsn": "65534"
}
}
```
+ Para obter detalhes da API, consulte [CreateCustomerGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-customer-gateway.html)em *Referência de AWS CLI Comandos*.
### `create-default-subnet`
O código de exemplo a seguir mostra como usar `create-default-subnet`.
**AWS CLI**
**Criar uma sub-rede padrão**
Este exemplo cria uma sub-rede padrão na Zona de Disponibilidade `us-east-2a`.
Comando:
```
aws ec2 create-default-subnet --availability-zone us-east-2a
{
"Subnet": {
"AvailabilityZone": "us-east-2a",
"Tags": [],
"AvailableIpAddressCount": 4091,
"DefaultForAz": true,
"Ipv6CidrBlockAssociationSet": [],
"VpcId": "vpc-1a2b3c4d",
"State": "available",
"MapPublicIpOnLaunch": true,
"SubnetId": "subnet-1122aabb",
"CidrBlock": "172.31.32.0/20",
"AssignIpv6AddressOnCreation": false
}
}
```
+ Para obter detalhes da API, consulte [CreateDefaultSubnet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-default-subnet.html)em *Referência de AWS CLI Comandos*.
### `create-default-vpc`
O código de exemplo a seguir mostra como usar `create-default-vpc`.
**AWS CLI**
**Criar uma VPC padrão**
Este exemplo cria uma VPC padrão.
Comando:
```
aws ec2 create-default-vpc
```
Saída:
```
{
"Vpc": {
"VpcId": "vpc-8eaae5ea",
"InstanceTenancy": "default",
"Tags": [],
"Ipv6CidrBlockAssociationSet": [],
"State": "pending",
"DhcpOptionsId": "dopt-af0c32c6",
"CidrBlock": "172.31.0.0/16",
"IsDefault": true
}
}
```
+ Para obter detalhes da API, consulte [CreateDefaultVpc](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-default-vpc.html)em *Referência de AWS CLI Comandos*.
### `create-dhcp-options`
O código de exemplo a seguir mostra como usar `create-dhcp-options`.
**AWS CLI**
**Criar um conjunto de opções DHCP**
O exemplo `create-dhcp-options` a seguir cria um conjunto de opções DHCP que especifica o nome do domínio, os servidores de nomes de domínio e o tipo de nó NetBIOS.
```
aws ec2 create-dhcp-options \
--dhcp-configuration \
"Key=domain-name-servers,Values=10.2.5.1,10.2.5.2" \
"Key=domain-name,Values=example.com" \
"Key=netbios-node-type,Values=2"
```
Saída:
```
{
"DhcpOptions": {
"DhcpConfigurations": [
{
"Key": "domain-name",
"Values": [
{
"Value": "example.com"
}
]
},
{
"Key": "domain-name-servers",
"Values": [
{
"Value": "10.2.5.1"
},
{
"Value": "10.2.5.2"
}
]
},
{
"Key": "netbios-node-type",
"Values": [
{
"Value": "2"
}
]
}
],
"DhcpOptionsId": "dopt-06d52773eff4c55f3"
}
}
```
+ Para obter detalhes da API, consulte [CreateDhcpOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-dhcp-options.html)em *Referência de AWS CLI Comandos*.
### `create-egress-only-internet-gateway`
O código de exemplo a seguir mostra como usar `create-egress-only-internet-gateway`.
**AWS CLI**
**Criar um gateway da Internet somente de saída**
Este exemplo cria um gateway da Internet somente de saída para a VPC especificada.
Comando:
```
aws ec2 create-egress-only-internet-gateway --vpc-id vpc-0c62a468
```
Saída:
```
{
"EgressOnlyInternetGateway": {
"EgressOnlyInternetGatewayId": "eigw-015e0e244e24dfe8a",
"Attachments": [
{
"State": "attached",
"VpcId": "vpc-0c62a468"
}
]
}
}
```
+ Para obter detalhes da API, consulte [CreateEgressOnlyInternetGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-egress-only-internet-gateway.html)em *Referência de AWS CLI Comandos*.
### `create-fleet`
O código de exemplo a seguir mostra como usar `create-fleet`.
**AWS CLI**
**Exemplo 1: criar uma frota EC2 que lança instâncias spot como modelo de compra padrão**
O exemplo `create-fleet` a seguir cria uma Frota EC2 usando os parâmetros mínimos necessários para lançar uma frota: um modelo de execução, a capacidade de destino e o modelo de compra padrão. O modelo de execução é identificado pelo ID do seu modelo de execução e o número da versão. A capacidade de destino da frota é de 2 instâncias, e o modelo de compra padrão é `spot`. Isso faz com que a frota execute duas Instâncias spot.
Quando você cria um Frota do EC2, use um arquivo JSON para especificar informações sobre as instâncias a serem executadas.
```
aws ec2 create-fleet \
--cli-input-json file://file_name.json
```
Conteúdo do file\$1name.json:
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-0e8c754449b27161c",
"Version": "1"
}
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 2,
"DefaultTargetCapacityType": "spot"
}
}
```
Saída:
```
{
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE"
}
```
**Exemplo 2: criar uma Frota EC2 que lança instâncias sob demanda como modelo de compra padrão**
O exemplo `create-fleet` a seguir cria uma Frota EC2 usando os parâmetros mínimos necessários para lançar uma frota: um modelo de execução, a capacidade de destino e o modelo de compra padrão. O modelo de execução é identificado pelo ID do seu modelo de execução e o número da versão. A capacidade de destino da frota é de duas instâncias, e o modelo de compra padrão é `on-demand`. Isso faz com que a frota execute duas Instâncias sob demanda.
Quando você cria um Frota do EC2, use um arquivo JSON para especificar informações sobre as instâncias a serem executadas.
```
aws ec2 create-fleet \
--cli-input-json file://file_name.json
```
Conteúdo do file\$1name.json:
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-0e8c754449b27161c",
"Version": "1"
}
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 2,
"DefaultTargetCapacityType": "on-demand"
}
}
```
Saída:
```
{
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE"
}
```
**Exemplo 3: criar uma Frota EC2 que lança Instâncias sob demanda como a capacidade principal**
O exemplo `create-fleet` a seguir cria uma Frota EC2 que especifica a capacidade total de destino de duas instâncias para a frota e uma capacidade de destino de uma instância sob demanda. O modelo de compra padrão é `spot`. A frota executa uma instância sob demanda, conforme especificado, mas precisa executar mais uma instância para atender à capacidade total desejada. O modelo de compra para a diferença é calculado como `TotalTargetCapacity` - `OnDemandTargetCapacity` = `DefaultTargetCapacityType`, o que resulta na frota executando uma instância spot.
Quando você cria um Frota do EC2, use um arquivo JSON para especificar informações sobre as instâncias a serem executadas.
```
aws ec2 create-fleet \
--cli-input-json file://file_name.json
```
Conteúdo do file\$1name.json:
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-0e8c754449b27161c",
"Version": "1"
}
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 2,
"OnDemandTargetCapacity":1,
"DefaultTargetCapacityType": "spot"
}
}
```
Saída:
```
{
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE"
}
```
**Exemplo 4: criar uma frota EC2 que lança instâncias spot usando a estratégia de alocação de menor preço**
Se a estratégia de alocação para Instâncias spot não for especificada, a estratégia de alocação padrão, `lowest-price`, será usada. O exemplo `create-fleet` a seguir cria uma frota EC2 usando a estratégia de alocação `lowest-price`. As três especificações de execução, que substituem o modelo de execução, têm tipos de instância diferentes, mas a mesma capacidade ponderada e sub-rede. A capacidade de destino total é de duas instâncias, e o modelo de compra padrão é `spot`. A Frota do EC2 executa duas Instâncias spot usando o tipo de instância da especificação de execução com o menor preço.
Quando você cria um Frota do EC2, use um arquivo JSON para especificar informações sobre as instâncias a serem executadas.
```
aws ec2 create-fleet \
--cli-input-json file://file_name.jsonContents of file_name.json::
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-0e8c754449b27161c",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "c4.large",
"WeightedCapacity": 1,
"SubnetId": "subnet-a4f6c5d3"
},
{
"InstanceType": "c3.large",
"WeightedCapacity": 1,
"SubnetId": "subnet-a4f6c5d3"
},
{
"InstanceType": "c5.large",
"WeightedCapacity": 1,
"SubnetId": "subnet-a4f6c5d3"
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 2,
"DefaultTargetCapacityType": "spot"
}
}
```
Saída:
```
{
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE"
}
```
+ Para obter detalhes da API, consulte [CreateFleet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-fleet.html)em *Referência de AWS CLI Comandos*.
### `create-flow-logs`
O código de exemplo a seguir mostra como usar `create-flow-logs`.
**AWS CLI**
**Exemplo 1: criar um log de fluxo**
O exemplo `create-flow-logs` a seguir cria um log de fluxo que captura todo o tráfego rejeitado para a interface de rede especificada. Os registros de fluxo são entregues a um grupo de CloudWatch registros em Logs usando as permissões na função do IAM especificada.
```
aws ec2 create-flow-logs \
--resource-type NetworkInterface \
--resource-ids eni-11223344556677889 \
--traffic-type REJECT \
--log-group-name my-flow-logs \
--deliver-logs-permission-arn arn:aws:iam::123456789101:role/publishFlowLogs
```
Saída:
```
{
"ClientToken": "so0eNA2uSHUNlHI0S2cJ305GuIX1CezaRdGtexample",
"FlowLogIds": [
"fl-12345678901234567"
],
"Unsuccessful": []
}
```
Para obter mais informações, consulte [Logs de fluxo da VPC](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html) no *Guia do usuário do Amazon Virtual Private Cloud*.
**Exemplo 2: criar um log de fluxo com um formato personalizado**
O exemplo `create-flow-logs` a seguir cria um log de fluxo que captura todo o tráfego da VPC especificada e fornece os logs de fluxo a um bucket do Amazon S3. O parâmetro `--log-format` especifica um formato personalizado para os registros de log de fluxo. Para executar esse comando no Windows, altere as aspas simples (') para aspas duplas (").
```
aws ec2 create-flow-logs \
--resource-type VPC \
--resource-ids vpc-00112233344556677 \
--traffic-type ALL \
--log-destination-type s3 \
--log-destination arn:aws:s3:::flow-log-bucket/my-custom-flow-logs/ \
--log-format '${version} ${vpc-id} ${subnet-id} ${instance-id} ${srcaddr} ${dstaddr} ${srcport} ${dstport} ${protocol} ${tcp-flags} ${type} ${pkt-srcaddr} ${pkt-dstaddr}'
```
Para obter mais informações, consulte [Logs de fluxo da VPC](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html) no *Guia do usuário do Amazon Virtual Private Cloud*.
**Exemplo 3: criar um log de fluxo com um intervalo máximo de agregação de um minuto**
O exemplo `create-flow-logs` a seguir cria um log de fluxo que captura todo o tráfego da VPC especificada e fornece os logs de fluxo a um bucket do Amazon S3. O parâmetro `--max-aggregation-interval` especifica um intervalo de agregação máximo de 60 segundos (um minuto).
```
aws ec2 create-flow-logs \
--resource-type VPC \
--resource-ids vpc-00112233344556677 \
--traffic-type ALL \
--log-destination-type s3 \
--log-destination arn:aws:s3:::flow-log-bucket/my-custom-flow-logs/ \
--max-aggregation-interval 60
```
Para obter mais informações, consulte [Logs de fluxo da VPC](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html) no *Guia do usuário do Amazon Virtual Private Cloud*.
+ Para obter detalhes da API, consulte [CreateFlowLogs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-flow-logs.html)em *Referência de AWS CLI Comandos*.
### `create-fpga-image`
O código de exemplo a seguir mostra como usar `create-fpga-image`.
**AWS CLI**
**Criar uma imagem Amazon FPGA**
Este exemplo cria uma AFI do tarball especificado no bucket especificado.
Comando:
```
aws ec2 create-fpga-image --name my-afi --description test-afi --input-storage-location Bucket=my-fpga-bucket,Key=dcp/17_12_22-103226.Developer_CL.tar --logs-storage-location Bucket=my-fpga-bucket,Key=logs
```
Saída:
```
{
"FpgaImageId": "afi-0d123e123bfc85abc",
"FpgaImageGlobalId": "agfi-123cb27b5e84a0abc"
}
```
+ Para obter detalhes da API, consulte [CreateFpgaImage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-fpga-image.html)em *Referência de AWS CLI Comandos*.
### `create-image`
O código de exemplo a seguir mostra como usar `create-image`.
**AWS CLI**
**Exemplo 1: criar uma AMI de uma instância com Amazon EBS**
O exemplo `create-image` a seguir cria uma AMI da instância especificada.
```
aws ec2 create-image \
--instance-id i-1234567890abcdef0 \
--name "My server" \
--description "An AMI for my server"
```
Saída:
```
{
"ImageId": "ami-abcdef01234567890"
}
```
Para obter mais informações sobre especificar um mapeamento de dispositivos de blocos para sua AMI, consulte [Especificar um mapeamento de dispositivos de blocos para AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html#create-ami-bdm) no *Guia do usuário do Amazon EC2*.
**Exemplo 2: criar uma AMI de uma instância baseada no Amazon EBS sem reinicializar**
O exemplo `create-image` a seguir cria uma AMI e define o parâmetro --no-reboot, para que a instância não seja reinicializada antes da criação da imagem.
```
aws ec2 create-image \
--instance-id i-1234567890abcdef0 \
--name "My server" \
--no-reboot
```
Saída:
```
{
"ImageId": "ami-abcdef01234567890"
}
```
Para obter mais informações sobre especificar um mapeamento de dispositivos de blocos para sua AMI, consulte [Especificar um mapeamento de dispositivos de blocos para AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html#create-ami-bdm) no *Guia do usuário do Amazon EC2*.
**Exemplo 3: aplicar tag em uma AMI e snapshots na criação**
O exemplo `create-image` a seguir cria uma AMI e aplica uma tag na AMI e nos snapshots com a mesma tag `cost-center=cc123`
```
aws ec2 create-image \
--instance-id i-1234567890abcdef0 \
--name "My server" \
--tag-specifications "ResourceType=image,Tags=[{Key=cost-center,Value=cc123}]" "ResourceType=snapshot,Tags=[{Key=cost-center,Value=cc123}]"
```
Saída:
```
{
"ImageId": "ami-abcdef01234567890"
}
```
Para obter mais informações sobre como aplicar tags em seus recursos na criação, consulte [Adicionar tags na criação de recursos](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-on-create-examples) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [CreateImage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-image.html)em *Referência de AWS CLI Comandos*.
### `create-instance-connect-endpoint`
O código de exemplo a seguir mostra como usar `create-instance-connect-endpoint`.
**AWS CLI**
**Criar um endpoint de conexão da instância EC2**
O exemplo `create-instance-connect-endpoint` a seguir cria um Endpoint de Conexão da Instância EC2 na sub-rede especificada.
```
aws ec2 create-instance-connect-endpoint \
--region us-east-1 \
--subnet-id subnet-0123456789example
```
Saída:
```
{
"VpcId": "vpc-0123abcd",
"InstanceConnectEndpointArn": "arn:aws:ec2:us-east-1:111111111111:instance-connect-endpoint/eice-0123456789example",
"AvailabilityZone": "us-east-1a",
"NetworkInterfaceIds": [
"eni-0123abcd"
],
"PreserveClientIp": true,
"Tags": [],
"FipsDnsName": "eice-0123456789example.0123abcd.fips.ec2-instance-connect-endpoint.us-east-1.amazonaws.com",
"StateMessage": "",
"State": "create-complete",
"DnsName": "eice-0123456789example.0123abcd.ec2-instance-connect-endpoint.us-east-1.amazonaws.com",
"SubnetId": "subnet-0123abcd",
"OwnerId": "111111111111",
"SecurityGroupIds": [
"sg-0123abcd"
],
"InstanceConnectEndpointId": "eice-0123456789example",
"CreatedAt": "2023-04-07T15:43:53.000Z"
}
```
Para obter mais informações, consulte [Criar um endpoint de conexão de instância EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-ec2-instance-connect-endpoints.html) no *Guiado usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [CreateInstanceConnectEndpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-instance-connect-endpoint.html)em *Referência de AWS CLI Comandos*.
### `create-instance-event-window`
O código de exemplo a seguir mostra como usar `create-instance-event-window`.
**AWS CLI**
**Exemplo 1: criar uma janela de eventos com um intervalo de tempo**
O exemplo `create-instance-event-window` a seguir cria uma janela de eventos com um intervalo de tempo. Você também deve especificar o parâmetro `cron-expression`.
```
aws ec2 create-instance-event-window \
--region us-east-1 \
--time-range StartWeekDay=monday,StartHour=2,EndWeekDay=wednesday,EndHour=8 \
--tag-specifications "ResourceType=instance-event-window,Tags=[{Key=K1,Value=V1}]" \
--name myEventWindowName
```
Saída:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"TimeRanges": [
{
"StartWeekDay": "monday",
"StartHour": 2,
"EndWeekDay": "wednesday",
"EndHour": 8
}
],
"Name": "myEventWindowName",
"State": "creating",
"Tags": [
{
"Key": "K1",
"Value": "V1"
}
]
}
}
```
Para restrições da janela de eventos, consulte [Considerações](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) na seção Eventos Programados do *Guia do usuário do Amazon EC2*.
**Exemplo 2: criar uma janela de eventos com uma expressão cron**
O exemplo `create-instance-event-window` a seguir cria uma janela de eventos com uma expressão cron. Você também deve especificar o parâmetro `time-range`.
```
aws ec2 create-instance-event-window \
--region us-east-1 \
--cron-expression "* 21-23 * * 2,3" \
--tag-specifications "ResourceType=instance-event-window,Tags=[{Key=K1,Value=V1}]" \
--name myEventWindowName
```
Saída:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"State": "creating",
"Tags": [
{
"Key": "K1",
"Value": "V1"
}
]
}
}
```
Para restrições da janela de eventos, consulte [Considerações](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) na seção Eventos Programados do *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [CreateInstanceEventWindow](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-instance-event-window.html)em *Referência de AWS CLI Comandos*.
### `create-instance-export-task`
O código de exemplo a seguir mostra como usar `create-instance-export-task`.
**AWS CLI**
**Exportar uma instância**
Esse comando de exemplo cria uma tarefa para exportar a instância i-1234567890abcdef0 para o bucket myexportbucket do Amazon S3.
Comando:
```
aws ec2 create-instance-export-task --description "RHEL5 instance" --instance-id i-1234567890abcdef0 --target-environment vmware --export-to-s3-task DiskImageFormat=vmdk,ContainerFormat=ova,S3Bucket=myexportbucket,S3Prefix=RHEL5
```
Saída:
```
{
"ExportTask": {
"State": "active",
"InstanceExportDetails": {
"InstanceId": "i-1234567890abcdef0",
"TargetEnvironment": "vmware"
},
"ExportToS3Task": {
"S3Bucket": "myexportbucket",
"S3Key": "RHEL5export-i-fh8sjjsq.ova",
"DiskImageFormat": "vmdk",
"ContainerFormat": "ova"
},
"Description": "RHEL5 instance",
"ExportTaskId": "export-i-fh8sjjsq"
}
}
```
+ Para obter detalhes da API, consulte [CreateInstanceExportTask](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-instance-export-task.html)em *Referência de AWS CLI Comandos*.
### `create-internet-gateway`
O código de exemplo a seguir mostra como usar `create-internet-gateway`.
**AWS CLI**
**Criar um gateway da Internet**
O exemplo `create-internet-gateway` a seguir cria um gateway da Internet com a tag `Name=my-igw`.
```
aws ec2 create-internet-gateway \
--tag-specifications ResourceType=internet-gateway,Tags=[{Key=Name,Value=my-igw}]
```
Saída:
```
{
"InternetGateway": {
"Attachments": [],
"InternetGatewayId": "igw-0d0fb496b3994d755",
"OwnerId": "123456789012",
"Tags": [
{
"Key": "Name",
"Value": "my-igw"
}
]
}
}
```
Para obter mais informações, consulte [Gateways da Internet](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [CreateInternetGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-internet-gateway.html)em *Referência de AWS CLI Comandos*.
### `create-ipam-pool`
O código de exemplo a seguir mostra como usar `create-ipam-pool`.
**AWS CLI**
**Criar um pool IPAM**
O exemplo `create-ipam-pool` a seguir cria um pool IPAM.
(Linux):
```
aws ec2 create-ipam-pool \
--ipam-scope-id ipam-scope-02fc38cd4c48e7d38 \
--address-family ipv4 \
--auto-import \
--allocation-min-netmask-length 16 \
--allocation-max-netmask-length 26 \
--allocation-default-netmask-length 24 \
--allocation-resource-tags "Key=Environment,Value=Preprod" \
--tag-specifications 'ResourceType=ipam-pool,Tags=[{Key=Name,Value="Preprod pool"}]'
```
(Windows):
```
aws ec2 create-ipam-pool ^
--ipam-scope-id ipam-scope-02fc38cd4c48e7d38 ^
--address-family ipv4 ^
--auto-import ^
--allocation-min-netmask-length 16 ^
--allocation-max-netmask-length 26 ^
--allocation-default-netmask-length 24 ^
--allocation-resource-tags "Key=Environment,Value=Preprod" ^
--tag-specifications ResourceType=ipam-pool,Tags=[{Key=Name,Value="Preprod pool"}]
```
Saída:
```
{
"IpamPool": {
"OwnerId": "123456789012",
"IpamPoolId": "ipam-pool-0533048da7d823723",
"IpamPoolArn": "arn:aws:ec2::123456789012:ipam-pool/ipam-pool-0533048da7d823723",
"IpamScopeArn": "arn:aws:ec2::123456789012:ipam-scope/ipam-scope-02fc38cd4c48e7d38",
"IpamScopeType": "private",
"IpamArn": "arn:aws:ec2::123456789012:ipam/ipam-08440e7a3acde3908",
"IpamRegion": "us-east-1",
"Locale": "None",
"PoolDepth": 1,
"State": "create-in-progress",
"AutoImport": true,
"AddressFamily": "ipv4",
"AllocationMinNetmaskLength": 16,
"AllocationMaxNetmaskLength": 26,
"AllocationDefaultNetmaskLength": 24,
"AllocationResourceTags": [
{
"Key": "Environment",
"Value": "Preprod"
}
],
"Tags": [
{
"Key": "Name",
"Value": "Preprod pool"
}
]
}
}
```
Para obter mais informações, consulte [Planos para provisionamento de endereços IP](https://docs.aws.amazon.com/vpc/latest/ipam/planning-ipam.html), no *Guia do usuário da Amazon VPC IPAM*.
+ Para obter detalhes da API, consulte [CreateIpamPool](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-ipam-pool.html)em *Referência de AWS CLI Comandos*.
### `create-ipam-resource-discovery`
O código de exemplo a seguir mostra como usar `create-ipam-resource-discovery`.
**AWS CLI**
**Criar uma descoberta de recursos**
Neste exemplo, você é um administrador delegado do IPAM que deseja criar e compartilhar uma descoberta de recursos com o administrador do IPAM em outra AWS organização para que o administrador da outra organização possa gerenciar e monitorar os endereços IP dos recursos em sua organização.
Importante
Este exemplo inclui as opções `--region` e `--operating-regions` porque, embora sejam opcionais, elas devem ser configuradas de uma maneira específica para integrar com êxito uma descoberta de recursos a um IPAM. \$1 `--operating-regions` deve corresponder às regiões em que você tem recursos que deseja que o IPAM descubra. Se houver regiões nas quais você não deseja que o IPAM gerencie os endereços IP (por exemplo, por motivos de conformidade), não as inclua. \$1 `--region` deve corresponder à região de origem do IPAM ao qual você deseja associá-lo. Você deve criar a descoberta de recurso na mesma região em que o IPAM foi criado. Por exemplo, se o IPAM ao qual você está se associando foi criado em us-east-1, inclua `--region us-east-1` na solicitação. As opções `--region` e `--operating-regions` assumem como padrão a região em que você está executando o comando, caso você não as especifique.
Neste exemplo, as regiões operacionais do IPAM com as quais estamos integrando incluem `us-west-1`, `us-west-2` e `ap-south-1`. Quando criamos a descoberta de recursos, queremos que o IPAM descubra os endereços IP dos recursos em `us-west-1` e `us-west-2`, mas não em `ap-south-1`. Portanto, estamos incluindo apenas `--operating-regions RegionName='us-west-1' RegionName='us-west-2'` na solicitação.
O exemplo `create-ipam-resource-discovery` a seguir cria uma descoberta de recurso IPAM.
```
aws ec2 create-ipam-resource-discovery \
--description 'Example-resource-discovery' \
--tag-specifications 'ResourceType=ipam-resource-discovery,Tags=[{Key=cost-center,Value=cc123}]' \
--operating-regions RegionName='us-west-1' RegionName='us-west-2' \
--region us-east-1
```
Saída:
```
{
"IpamResourceDiscovery":{
"OwnerId": "149977607591",
"IpamResourceDiscoveryId": "ipam-res-disco-0257046d8aa78b8bc",
"IpamResourceDiscoveryArn": "arn:aws:ec2::149977607591:ipam-resource-discovery/ipam-res-disco-0257046d8aa78b8bc",
"IpamResourceDiscoveryRegion": "us-east-1",
"Description": "'Example-resource-discovery'",
"OperatingRegions":[
{"RegionName": "us-west-1"},
{"RegionName": "us-west-2"},
{"RegionName": "us-east-1"}
],
"IsDefault": false,
"State": "create-in-progress",
"Tags": [
{
"Key": "cost-center",
"Value": "cc123"
}
]
}
```
Depois de criar uma descoberta de recursos, talvez você queira compartilhá-la com outro administrador delegado do IPAM, com o qual você pode fazer isso. [create-resource-share](https://docs.aws.amazon.com/cli/latest/reference/ram/create-resource-share.html) Para obter mais informações, consulte [Integrar o IPAM com contas fora da sua organização](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam-outside-org.html) no *Guia do usuário do IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [CreateIpamResourceDiscovery](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-ipam-resource-discovery.html)em *Referência de AWS CLI Comandos*.
### `create-ipam-scope`
O código de exemplo a seguir mostra como usar `create-ipam-scope`.
**AWS CLI**
**Criar um escopo IPAM**
O exemplo `create-ipam-scope` a seguir cria um escopo IPAM.
(Linux):
```
aws ec2 create-ipam-scope \
--ipam-id ipam-08440e7a3acde3908 \
--description "Example description" \
--tag-specifications 'ResourceType=ipam-scope,Tags=[{Key=Name,Value="Example name value"}]'
```
(Windows):
```
aws ec2 create-ipam-scope ^
--ipam-id ipam-08440e7a3acde3908 ^
--description "Example description" ^
--tag-specifications ResourceType=ipam-scope,Tags=[{Key=Name,Value="Example name value"}]
```
Saída:
```
{
"IpamScope": {
"OwnerId": "123456789012",
"IpamScopeId": "ipam-scope-01c1ebab2b63bd7e4",
"IpamScopeArn": "arn:aws:ec2::123456789012:ipam-scope/ipam-scope-01c1ebab2b63bd7e4",
"IpamArn": "arn:aws:ec2::123456789012:ipam/ipam-08440e7a3acde3908",
"IpamRegion": "us-east-1",
"IpamScopeType": "private",
"IsDefault": false,
"Description": "Example description",
"PoolCount": 0,
"State": "create-in-progress",
"Tags": [
{
"Key": "Name",
"Value": "Example name value"
}
]
}
}
```
Para obter mais informações, consulte [Criar escopos adicionais](https://docs.aws.amazon.com/vpc/latest/ipam/add-scope-ipam.html) no *Guia do usuário do IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [CreateIpamScope](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-ipam-scope.html)em *Referência de AWS CLI Comandos*.
### `create-ipam`
O código de exemplo a seguir mostra como usar `create-ipam`.
**AWS CLI**
**Criar um IPAM**
O exemplo `create-ipam` a seguir cria um IPAM.
(Linux):
```
aws ec2 create-ipam \
--description "Example description" \
--operating-regions "RegionName=us-east-2" "RegionName=us-west-1" \
--tag-specifications 'ResourceType=ipam,Tags=[{Key=Name,Value=ExampleIPAM}]'
```
(Windows):
```
aws ec2 create-ipam ^
--description "Example description" ^
--operating-regions "RegionName=us-east-2" "RegionName=us-west-1" ^
--tag-specifications ResourceType=ipam,Tags=[{Key=Name,Value=ExampleIPAM}]
```
Saída:
```
{
"Ipam": {
"OwnerId": "123456789012",
"IpamId": "ipam-036486dfa6af58ee0",
"IpamArn": "arn:aws:ec2::123456789012:ipam/ipam-036486dfa6af58ee0",
"IpamRegion": "us-east-1",
"PublicDefaultScopeId": "ipam-scope-071b8042b0195c183",
"PrivateDefaultScopeId": "ipam-scope-0807405dece705a30",
"ScopeCount": 2,
"OperatingRegions": [
{
"RegionName": "us-east-2"
},
{
"RegionName": "us-west-1"
},
{
"RegionName": "us-east-1"
}
],
"State": "create-in-progress",
"Tags": [
{
"Key": "Name",
"Value": "ExampleIPAM"
}
]
}
}
```
Para obter mais informações, consulte [Criar um IPAM](https://docs.aws.amazon.com/vpc/latest/ipam/create-ipam.html) no *Guia do usuário do IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [CreateIpam](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-ipam.html)em *Referência de AWS CLI Comandos*.
### `create-key-pair`
O código de exemplo a seguir mostra como usar `create-key-pair`.
**AWS CLI**
**Para criar um par de chaves**
Este exemplo cria um par de chaves denominado `MyKeyPair`.
Comando:
```
aws ec2 create-key-pair --key-name MyKeyPair
```
A saída é uma versão ASCII da chave privada e da impressão digital da chave. Você precisa salvar a chave em um arquivo.
Para obter mais informações, consulte Using Key Pairs no *Guia do usuário da AWS Command Line Interface*.
+ Para obter detalhes da API, consulte [CreateKeyPair](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-key-pair.html)em *Referência de AWS CLI Comandos*.
### `create-launch-template-version`
O código de exemplo a seguir mostra como usar `create-launch-template-version`.
**AWS CLI**
**Criar uma versão de modelo de inicialização**
Este exemplo cria uma nova versão do modelo de lançamento com base na versão 1 do modelo de execução e especifica um ID de AMI diferente.
Comando:
```
aws ec2 create-launch-template-version --launch-template-id lt-0abcd290751193123 --version-description WebVersion2 --source-version 1 --launch-template-data '{"ImageId":"ami-c998b6b2"}'
```
Saída:
```
{
"LaunchTemplateVersion": {
"VersionDescription": "WebVersion2",
"LaunchTemplateId": "lt-0abcd290751193123",
"LaunchTemplateName": "WebServers",
"VersionNumber": 2,
"CreatedBy": "arn:aws:iam::123456789012:root",
"LaunchTemplateData": {
"ImageId": "ami-c998b6b2",
"InstanceType": "t2.micro",
"NetworkInterfaces": [
{
"Ipv6Addresses": [
{
"Ipv6Address": "2001:db8:1234:1a00::123"
}
],
"DeviceIndex": 0,
"SubnetId": "subnet-7b16de0c",
"AssociatePublicIpAddress": true
}
]
},
"DefaultVersion": false,
"CreateTime": "2017-12-01T13:35:46.000Z"
}
}
```
+ Para obter detalhes da API, consulte [CreateLaunchTemplateVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-launch-template-version.html)em *Referência de AWS CLI Comandos*.
### `create-launch-template`
O código de exemplo a seguir mostra como usar `create-launch-template`.
**AWS CLI**
**Exemplo 1: criar um modelo de lançamento**
O `create-launch-template` exemplo a seguir cria um modelo de execução que especifica a sub-rede na qual iniciar a instância, atribui um endereço IP público e um IPv6 endereço à instância e cria uma tag para a instância.
```
aws ec2 create-launch-template \
--launch-template-name TemplateForWebServer \
--version-description WebVersion1 \
--launch-template-data '{"NetworkInterfaces":[{"AssociatePublicIpAddress":true,"DeviceIndex":0,"Ipv6AddressCount":1,"SubnetId":"subnet-7b16de0c"}],"ImageId":"ami-8c1be5f6","InstanceType":"t2.small","TagSpecifications":[{"ResourceType":"instance","Tags":[{"Key":"purpose","Value":"webserver"}]}]}'
```
Saída:
```
{
"LaunchTemplate": {
"LatestVersionNumber": 1,
"LaunchTemplateId": "lt-01238c059e3466abc",
"LaunchTemplateName": "TemplateForWebServer",
"DefaultVersionNumber": 1,
"CreatedBy": "arn:aws:iam::123456789012:user/Bob",
"CreateTime": "2019-01-27T09:13:24.000Z"
}
}
```
Para obter mais informações, consulte Execução de uma instância em um modelo de execução no *Guia do usuário do Amazon Elastic Compute Cloud*. Para obter informações sobre como citar parâmetros formatados em JSON, consulte Uso de aspas com strings no *Guia do usuário da AWS Command Line Interface*.
**Exemplo 2: para criar um modelo de execução para o Amazon EC2 Auto Scaling**
O exemplo `create-launch-template` a seguir cria um modelo de execução com várias tags e um mapeamento de dispositivos de blocos para especificar um volume adicional do EBS quando uma instância é executada. Especifique um valor para `Groups` que corresponda aos grupos de segurança da VPC na qual o seu grupo do Auto Scaling executará as instâncias. Especifique a VPC e as sub-redes como propriedades do grupo do Auto Scaling.
```
aws ec2 create-launch-template \
--launch-template-name TemplateForAutoScaling \
--version-description AutoScalingVersion1 \
--launch-template-data '{"NetworkInterfaces":[{"DeviceIndex":0,"AssociatePublicIpAddress":true,"Groups":["sg-7c227019,sg-903004f8"],"DeleteOnTermination":true}],"ImageId":"ami-b42209de","InstanceType":"m4.large","TagSpecifications":[{"ResourceType":"instance","Tags":[{"Key":"environment","Value":"production"},{"Key":"purpose","Value":"webserver"}]},{"ResourceType":"volume","Tags":[{"Key":"environment","Value":"production"},{"Key":"cost-center","Value":"cc123"}]}],"BlockDeviceMappings":[{"DeviceName":"/dev/sda1","Ebs":{"VolumeSize":100}}]}' --region us-east-1
```
Saída:
```
{
"LaunchTemplate": {
"LatestVersionNumber": 1,
"LaunchTemplateId": "lt-0123c79c33a54e0abc",
"LaunchTemplateName": "TemplateForAutoScaling",
"DefaultVersionNumber": 1,
"CreatedBy": "arn:aws:iam::123456789012:user/Bob",
"CreateTime": "2019-04-30T18:16:06.000Z"
}
}
```
Para obter mais informações, consulte Como criar um modelo de execução para um grupo do Auto Scaling no *Guia do usuário do Amazon EC2 Auto Scaling*. Para obter informações sobre como citar parâmetros formatados em JSON, consulte Uso de aspas com strings no *Guia do usuário da AWS Command Line Interface*.
**Exemplo 3: criar um modelo de execução que especifique a criptografia dos volumes do EBS**
O exemplo `create-launch-template` a seguir cria um modelo de execução que inclui volumes criptografados do EBS criados de um snapshot não criptografado. Ele também coloca tags nos volumes durante a criação. Se a criptografia por padrão estiver desabilitada, você deve especificar a opção `"Encrypted"` conforme mostrado no exemplo a seguir. Se você usar a opção `"KmsKeyId"` para especificar uma CMK gerenciada pelo cliente, também deverá especificar a opção `"Encrypted"` mesmo que a criptografia por padrão esteja habilitada.
```
aws ec2 create-launch-template \
--launch-template-name TemplateForEncryption \
--launch-template-data file://config.json
```
Conteúdo de `config.json`:
```
{
"BlockDeviceMappings":[
{
"DeviceName":"/dev/sda1",
"Ebs":{
"VolumeType":"gp2",
"DeleteOnTermination":true,
"SnapshotId":"snap-066877671789bd71b",
"Encrypted":true,
"KmsKeyId":"arn:aws:kms:us-east-1:012345678910:key/abcd1234-a123-456a-a12b-a123b4cd56ef"
}
}
],
"ImageId":"ami-00068cd7555f543d5",
"InstanceType":"c5.large",
"TagSpecifications":[
{
"ResourceType":"volume",
"Tags":[
{
"Key":"encrypted",
"Value":"yes"
}
]
}
]
}
```
Saída:
```
{
"LaunchTemplate": {
"LatestVersionNumber": 1,
"LaunchTemplateId": "lt-0d5bd51bcf8530abc",
"LaunchTemplateName": "TemplateForEncryption",
"DefaultVersionNumber": 1,
"CreatedBy": "arn:aws:iam::123456789012:user/Bob",
"CreateTime": "2020-01-07T19:08:36.000Z"
}
}
```
Para obter mais informações, consulte Restoring an Amazon EBS Volume from a Snapshot and Encryption by Default no *Guia do usuário do Amazon Elastic Compute Cloud*.
+ Para obter detalhes da API, consulte [CreateLaunchTemplate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-launch-template.html)em *Referência de AWS CLI Comandos*.
### `create-local-gateway-route-table-virtual-interface-group-association`
O código de exemplo a seguir mostra como usar `create-local-gateway-route-table-virtual-interface-group-association`.
**AWS CLI**
**Para associar uma tabela de rotas de gateway local a um grupo de interfaces virtuais (VIFs)**
O exemplo `create-local-gateway-route-table-virtual-interface-group-association` a seguir cria uma associação entre a tabela de rotas do gateway local especificada e o grupo VIF.
```
aws ec2 create-local-gateway-route-table-virtual-interface-group-association \
--local-gateway-route-table-id lgw-rtb-exampleidabcd1234 \
--local-gateway-virtual-interface-group-id lgw-vif-grp-exampleid0123abcd
```
Saída:
```
{
"LocalGatewayRouteTableVirtualInterfaceGroupAssociation": {
"LocalGatewayRouteTableVirtualInterfaceGroupAssociationId": "lgw-vif-grp-assoc-exampleid12345678",
"LocalGatewayVirtualInterfaceGroupId": "lgw-vif-grp-exampleid0123abcd",
"LocalGatewayId": "lgw-exampleid11223344",
"LocalGatewayRouteTableId": "lgw-rtb-exampleidabcd1234",
"LocalGatewayRouteTableArn": "arn:aws:ec2:us-west-2:111122223333:local-gateway-route-table/lgw-rtb-exampleidabcd1234",
"OwnerId": "111122223333",
"State": "pending",
"Tags": []
}
}
```
Para obter mais informações, consulte [Associações de grupo VIF](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#vif-group-associations) no *Guia do usuário do AWS Outposts*.
+ Para obter detalhes da API, consulte [CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-local-gateway-route-table-virtual-interface-group-association.html)em *Referência de AWS CLI Comandos*.
### `create-local-gateway-route-table-vpc-association`
O código de exemplo a seguir mostra como usar `create-local-gateway-route-table-vpc-association`.
**AWS CLI**
**Associar uma VPC a uma tabela de rotas**
O exemplo `create-local-gateway-route-table-vpc-association` a seguir associa a VPC especificada à tabela de rotas do gateway local especificada.
```
aws ec2 create-local-gateway-route-table-vpc-association \
--local-gateway-route-table-id lgw-rtb-059615ef7dEXAMPLE \
--vpc-id vpc-07ef66ac71EXAMPLE
```
Saída:
```
{
"LocalGatewayRouteTableVpcAssociation": {
"LocalGatewayRouteTableVpcAssociationId": "lgw-vpc-assoc-0ee765bcc8EXAMPLE",
"LocalGatewayRouteTableId": "lgw-rtb-059615ef7dEXAMPLE",
"LocalGatewayId": "lgw-09b493aa7cEXAMPLE",
"VpcId": "vpc-07ef66ac71EXAMPLE",
"State": "associated"
}
}
```
+ Para obter detalhes da API, consulte [CreateLocalGatewayRouteTableVpcAssociation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-local-gateway-route-table-vpc-association.html)em *Referência de AWS CLI Comandos*.
### `create-local-gateway-route-table`
O código de exemplo a seguir mostra como usar `create-local-gateway-route-table`.
**AWS CLI**
**Criar uma rota da tabela de rotas de gateway local**
O exemplo `create-local-gateway-route-table` a seguir cria uma tabela de rotas de gateway local com o modo de roteamento VPC direto com o modo de roteamento direto da VPC.
```
aws ec2 create-local-gateway-route-table \
--local-gateway-id lgw-1a2b3c4d5e6f7g8h9 \
--mode direct-vpc-routing
```
Saída:
```
{
"LocalGatewayRouteTable": {
"LocalGatewayRouteTableId": "lgw-rtb-abcdefg1234567890",
"LocalGatewayRouteTableArn": "arn:aws:ec2:us-west-2:111122223333:local-gateway-route-table/lgw-rtb-abcdefg1234567890",
"LocalGatewayId": "lgw-1a2b3c4d5e6f7g8h9",
"OutpostArn": "arn:aws:outposts:us-west-2:111122223333:outpost/op-021345abcdef67890",
"OwnerId": "111122223333",
"State": "pending",
"Tags": [],
"Mode": "direct-vpc-routing"
}
}
```
Para ter mais informações, consulte [Tabelas de rotas do gateway local](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html) no *AWS Guia do usuário do Outposts*.
+ Para obter detalhes da API, consulte [CreateLocalGatewayRouteTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-local-gateway-route-table.html)em *Referência de AWS CLI Comandos*.
### `create-local-gateway-route`
O código de exemplo a seguir mostra como usar `create-local-gateway-route`.
**AWS CLI**
**Criar uma rota estática para uma tabela de rotas do gateway local**
O exemplo `create-local-gateway-route` a seguir cria a rota especificada na tabela de rotas do gateway local especificada.
```
aws ec2 create-local-gateway-route \
--destination-cidr-block 0.0.0.0/0 \
--local-gateway-route-table-id lgw-rtb-059615ef7dEXAMPLE
```
Saída:
```
{
"Route": {
"DestinationCidrBlock": "0.0.0.0/0",
"LocalGatewayVirtualInterfaceGroupId": "lgw-vif-grp-07145b276bEXAMPLE",
"Type": "static",
"State": "deleted",
"LocalGatewayRouteTableId": "lgw-rtb-059615ef7dEXAMPLE"
}
}
```
+ Para obter detalhes da API, consulte [CreateLocalGatewayRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-local-gateway-route.html)em *Referência de AWS CLI Comandos*.
### `create-managed-prefix-list`
O código de exemplo a seguir mostra como usar `create-managed-prefix-list`.
**AWS CLI**
**Criar uma lista de prefixos**
O `create-managed-prefix-list` exemplo a seguir cria uma lista de IPv4 prefixos com no máximo 10 entradas e cria 2 entradas na lista de prefixos.
```
aws ec2 create-managed-prefix-list \
--address-family IPv4 \
--max-entries 10 \
--entries Cidr=10.0.0.0/16,Description=vpc-a Cidr=10.2.0.0/16,Description=vpc-b \
--prefix-list-name vpc-cidrs
```
Saída:
```
{
"PrefixList": {
"PrefixListId": "pl-0123456abcabcabc1",
"AddressFamily": "IPv4",
"State": "create-in-progress",
"PrefixListArn": "arn:aws:ec2:us-west-2:123456789012:prefix-list/pl-0123456abcabcabc1",
"PrefixListName": "vpc-cidrs",
"MaxEntries": 10,
"Version": 1,
"Tags": [],
"OwnerId": "123456789012"
}
}
```
Para obter mais informações, consulte [Listas de prefixos gerenciados](https://docs.aws.amazon.com/vpc/latest/userguide/managed-prefix-lists.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [CreateManagedPrefixList](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-managed-prefix-list.html)em *Referência de AWS CLI Comandos*.
### `create-nat-gateway`
O código de exemplo a seguir mostra como usar `create-nat-gateway`.
**AWS CLI**
**Exemplo 1: criar um gateway NAT público**
O exemplo `create-nat-gateway` a seguir cria um gateway NAT público na sub-rede especificada e associa o endereço IP elástico ao ID de alocação especificado. Ao criar um gateway de NAT público, será necessário associar um endereço IP elástico.
```
aws ec2 create-nat-gateway \
--subnet-id subnet-0250c25a1fEXAMPLE \
--allocation-id eipalloc-09ad461b0dEXAMPLE
```
Saída:
```
{
"NatGateway": {
"CreateTime": "2021-12-01T22:22:38.000Z",
"NatGatewayAddresses": [
{
"AllocationId": "eipalloc-09ad461b0dEXAMPLE"
}
],
"NatGatewayId": "nat-0c61bf8a12EXAMPLE",
"State": "pending",
"SubnetId": "subnet-0250c25a1fEXAMPLE",
"VpcId": "vpc-0a60eb65b4EXAMPLE",
"ConnectivityType": "public"
}
}
```
Para obter mais informações, consulte [Gateways NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) no *Guia do usuário da Amazon VPC*.
**Exemplo 2: criar um gateway NAT privado**
O exemplo `create-nat-gateway` a seguir cria um gateway NAT privado na sub-rede especificada. Um gateway NAT privado não tem um endereço IP elástico associado.
```
aws ec2 create-nat-gateway \
--subnet-id subnet-0250c25a1fEXAMPLE \
--connectivity-type private
```
Saída:
```
{
"NatGateway": {
"CreateTime": "2021-12-01T22:26:00.000Z",
"NatGatewayAddresses": [
{}
],
"NatGatewayId": "nat-011b568379EXAMPLE",
"State": "pending",
"SubnetId": "subnet-0250c25a1fEXAMPLE",
"VpcId": "vpc-0a60eb65b4EXAMPLE",
"ConnectivityType": "private"
}
}
```
Para obter mais informações, consulte [Gateways NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [CreateNatGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-nat-gateway.html)em *Referência de AWS CLI Comandos*.
### `create-network-acl-entry`
O código de exemplo a seguir mostra como usar `create-network-acl-entry`.
**AWS CLI**
**Criar uma entrada de ACL de rede**
Este exemplo cria uma entrada para a rede ACL especificada. A regra permite o tráfego de entrada de qualquer IPv4 endereço (0.0.0.0/0) na porta UDP 53 (DNS) em qualquer sub-rede associada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 create-network-acl-entry --network-acl-id acl-5fb85d36 --ingress --rule-number 100 --protocol udp --port-range From=53,To=53 --cidr-block 0.0.0.0/0 --rule-action allow
```
Este exemplo cria uma regra para a rede ACL especificada que permite o tráfego de entrada de qualquer IPv6 endereço (:: /0) na porta TCP 80 (HTTP).
Comando:
```
aws ec2 create-network-acl-entry --network-acl-id acl-5fb85d36 --ingress --rule-number 120 --protocol tcp --port-range From=80,To=80 --ipv6-cidr-block ::/0 --rule-action allow
```
+ Para obter detalhes da API, consulte [CreateNetworkAclEntry](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-network-acl-entry.html)em *Referência de AWS CLI Comandos*.
### `create-network-acl`
O código de exemplo a seguir mostra como usar `create-network-acl`.
**AWS CLI**
**Criar uma ACL de rede**
Este exemplo cria uma rede ACL para a VPC especificada.
Comando:
```
aws ec2 create-network-acl --vpc-id vpc-a01106c2
```
Saída:
```
{
"NetworkAcl": {
"Associations": [],
"NetworkAclId": "acl-5fb85d36",
"VpcId": "vpc-a01106c2",
"Tags": [],
"Entries": [
{
"CidrBlock": "0.0.0.0/0",
"RuleNumber": 32767,
"Protocol": "-1",
"Egress": true,
"RuleAction": "deny"
},
{
"CidrBlock": "0.0.0.0/0",
"RuleNumber": 32767,
"Protocol": "-1",
"Egress": false,
"RuleAction": "deny"
}
],
"IsDefault": false
}
}
```
+ Para obter detalhes da API, consulte [CreateNetworkAcl](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-network-acl.html)em *Referência de AWS CLI Comandos*.
### `create-network-insights-access-scope`
O código de exemplo a seguir mostra como usar `create-network-insights-access-scope`.
**AWS CLI**
**Criar um escopo de acesso à rede**
O exemplo `create-network-insights-access-scope` a seguir cria um Escopo de Acesso à Rede.
```
aws ec2 create-network-insights-access-scope \
--cli-input-json file://access-scope-file.json
```
Conteúdo de `access-scope-file.json`:
```
{
"MatchPaths": [
{
"Source": {
"ResourceStatement": {
"Resources": [
"vpc-abcd12e3"
]
}
}
}
],
"ExcludePaths": [
{
"Source": {
"ResourceStatement": {
"ResourceTypes": [
"AWS::EC2::InternetGateway"
]
}
}
}
]
}
```
Saída:
```
{
"NetworkInsightsAccessScope": {
"NetworkInsightsAccessScopeId": "nis-123456789abc01234",
"NetworkInsightsAccessScopeArn": "arn:aws:ec2:us-east-1:123456789012:network-insights-access-scope/nis-123456789abc01234",
"CreatedDate": "2022-01-25T19:20:28.796000+00:00",
"UpdatedDate": "2022-01-25T19:20:28.797000+00:00"
},
"NetworkInsightsAccessScopeContent": {
"NetworkInsightsAccessScopeId": "nis-123456789abc01234",
"MatchPaths": [
{
"Source": {
"ResourceStatement": {
"Resources": [
"vpc-abcd12e3"
]
}
}
}
],
"ExcludePaths": [
{
"Source": {
"ResourceStatement": {
"ResourceTypes": [
"AWS::EC2::InternetGateway"
]
}
}
}
]
}
}
```
Para obter mais informações, consulte [Introdução ao Network Access Analyzer usando a AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli.html) no Guia *do Network Access* Analyzer.
+ Para obter detalhes da API, consulte [CreateNetworkInsightsAccessScope](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-network-insights-access-scope.html)em *Referência de AWS CLI Comandos*.
### `create-network-insights-path`
O código de exemplo a seguir mostra como usar `create-network-insights-path`.
**AWS CLI**
**Criar um caminho**
O exemplo `create-network-insights-path` a seguir cria um caminho. A origem é o gateway da internet especificado e o destino é a instância EC2 especificada. Para determinar se o destino pode ser acessado usando o protocolo e a porta especificados, analise o caminho usando o comando `start-network-insights-analysis`.
```
aws ec2 create-network-insights-path \
--source igw-0797cccdc9d73b0e5 \
--destination i-0495d385ad28331c7 \
--destination-port 22 \
--protocol TCP
```
Saída:
```
{
"NetworkInsightsPaths": {
"NetworkInsightsPathId": "nip-0b26f224f1d131fa8",
"NetworkInsightsPathArn": "arn:aws:ec2:us-east-1:123456789012:network-insights-path/nip-0b26f224f1d131fa8",
"CreatedDate": "2021-01-20T22:43:46.933Z",
"Source": "igw-0797cccdc9d73b0e5",
"Destination": "i-0495d385ad28331c7",
"Protocol": "tcp"
}
}
```
Para obter mais informações, consulte [Introdução ao uso da AWS CLI](https://docs.aws.amazon.com/vpc/latest/reachability/getting-started-cli.html) no Guia do *Reachability Analyzer*.
+ Para obter detalhes da API, consulte [CreateNetworkInsightsPath](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-network-insights-path.html)em *Referência de AWS CLI Comandos*.
### `create-network-interface-permission`
O código de exemplo a seguir mostra como usar `create-network-interface-permission`.
**AWS CLI**
**Criar permissão de interface de rede**
Este exemplo concede permissão à conta `123456789012` para anexar uma interface de rede `eni-1a2b3c4d` a uma instância.
Comando:
```
aws ec2 create-network-interface-permission --network-interface-id eni-1a2b3c4d --aws-account-id 123456789012 --permission INSTANCE-ATTACH
```
Saída:
```
{
"InterfacePermission": {
"PermissionState": {
"State": "GRANTED"
},
"NetworkInterfacePermissionId": "eni-perm-06fd19020ede149ea",
"NetworkInterfaceId": "eni-1a2b3c4d",
"Permission": "INSTANCE-ATTACH",
"AwsAccountId": "123456789012"
}
}
```
+ Para obter detalhes da API, consulte [CreateNetworkInterfacePermission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-network-interface-permission.html)em *Referência de AWS CLI Comandos*.
### `create-network-interface`
O código de exemplo a seguir mostra como usar `create-network-interface`.
**AWS CLI**
**Exemplo 1: Para especificar um IPv4 endereço para uma interface de rede**
O `create-network-interface` exemplo a seguir cria uma interface de rede para a sub-rede especificada com o IPv4 endereço primário especificado.
```
aws ec2 create-network-interface \
--subnet-id subnet-00a24d0d67acf6333 \
--description "my network interface" \
--groups sg-09dfba7ed20cda78b \
--private-ip-address 10.0.8.17
```
Saída:
```
{
"NetworkInterface": {
"AvailabilityZone": "us-west-2a",
"Description": "my network interface",
"Groups": [
{
"GroupName": "my-security-group",
"GroupId": "sg-09dfba7ed20cda78b"
}
],
"InterfaceType": "interface",
"Ipv6Addresses": [],
"MacAddress": "06:6a:0f:9a:49:37",
"NetworkInterfaceId": "eni-0492b355f0cf3b3f8",
"OwnerId": "123456789012",
"PrivateDnsName": "ip-10-0-8-18.us-west-2.compute.internal",
"PrivateIpAddress": "10.0.8.17",
"PrivateIpAddresses": [
{
"Primary": true,
"PrivateDnsName": "ip-10-0-8-17.us-west-2.compute.internal",
"PrivateIpAddress": "10.0.8.17"
}
],
"RequesterId": "AIDA4Z3Y7GSXTMEXAMPLE",
"RequesterManaged": false,
"SourceDestCheck": true,
"Status": "pending",
"SubnetId": "subnet-00a24d0d67acf6333",
"TagSet": [],
"VpcId": "vpc-02723a0feeeb9d57b"
}
}
```
**Exemplo 2: Para criar uma interface de rede com um IPv4 endereço e um IPv6 endereço**
O exemplo `create-network-interface` a seguir cria uma interface de rede para a sub-rede especificada com um endereço IPv4 e um endereço IPv6 selecionados pelo Amazon EC2.
```
aws ec2 create-network-interface \
--subnet-id subnet-00a24d0d67acf6333 \
--description "my dual stack network interface" \
--ipv6-address-count 1 \
--groups sg-09dfba7ed20cda78b
```
Saída:
```
{
"NetworkInterface": {
"AvailabilityZone": "us-west-2a",
"Description": "my dual stack network interface",
"Groups": [
{
"GroupName": "my-security-group",
"GroupId": "sg-09dfba7ed20cda78b"
}
],
"InterfaceType": "interface",
"Ipv6Addresses": [
{
"Ipv6Address": "2600:1f13:cfe:3650:a1dc:237c:393a:4ba7",
"IsPrimaryIpv6": false
}
],
"MacAddress": "06:b8:68:d2:b2:2d",
"NetworkInterfaceId": "eni-05da417453f9a84bf",
"OwnerId": "123456789012",
"PrivateDnsName": "ip-10-0-8-18.us-west-2.compute.internal",
"PrivateIpAddress": "10.0.8.18",
"PrivateIpAddresses": [
{
"Primary": true,
"PrivateDnsName": "ip-10-0-8-18.us-west-2.compute.internal",
"PrivateIpAddress": "10.0.8.18"
}
],
"RequesterId": "AIDA4Z3Y7GSXTMEXAMPLE",
"RequesterManaged": false,
"SourceDestCheck": true,
"Status": "pending",
"SubnetId": "subnet-00a24d0d67acf6333",
"TagSet": [],
"VpcId": "vpc-02723a0feeeb9d57b",
"Ipv6Address": "2600:1f13:cfe:3650:a1dc:237c:393a:4ba7"
}
}
```
**Exemplo 3: criar uma interface de rede com opções de configuração de rastreamento de conexão**
O exemplo `create-network-interface` a seguir cria uma interface de rede e configura os tempos limite de rastreamento de conexão ociosa.
```
aws ec2 create-network-interface \
--subnet-id subnet-00a24d0d67acf6333 \
--groups sg-02e57dbcfe0331c1b \
--connection-tracking-specification TcpEstablishedTimeout=86400,UdpTimeout=60
```
Saída:
```
{
"NetworkInterface": {
"AvailabilityZone": "us-west-2a",
"ConnectionTrackingConfiguration": {
"TcpEstablishedTimeout": 86400,
"UdpTimeout": 60
},
"Description": "",
"Groups": [
{
"GroupName": "my-security-group",
"GroupId": "sg-02e57dbcfe0331c1b"
}
],
"InterfaceType": "interface",
"Ipv6Addresses": [],
"MacAddress": "06:4c:53:de:6d:91",
"NetworkInterfaceId": "eni-0c133586e08903d0b",
"OwnerId": "123456789012",
"PrivateDnsName": "ip-10-0-8-94.us-west-2.compute.internal",
"PrivateIpAddress": "10.0.8.94",
"PrivateIpAddresses": [
{
"Primary": true,
"PrivateDnsName": "ip-10-0-8-94.us-west-2.compute.internal",
"PrivateIpAddress": "10.0.8.94"
}
],
"RequesterId": "AIDA4Z3Y7GSXTMEXAMPLE",
"RequesterManaged": false,
"SourceDestCheck": true,
"Status": "pending",
"SubnetId": "subnet-00a24d0d67acf6333",
"TagSet": [],
"VpcId": "vpc-02723a0feeeb9d57b"
}
}
```
**Exemplo 4: criar um adaptador Fabric elástico**
O exemplo `create-network-interface` a seguir cria um EFA:
```
aws ec2 create-network-interface \
--interface-type efa \
--subnet-id subnet-00a24d0d67acf6333 \
--description "my efa" \
--groups sg-02e57dbcfe0331c1b
```
Saída:
```
{
"NetworkInterface": {
"AvailabilityZone": "us-west-2a",
"Description": "my efa",
"Groups": [
{
"GroupName": "my-efa-sg",
"GroupId": "sg-02e57dbcfe0331c1b"
}
],
"InterfaceType": "efa",
"Ipv6Addresses": [],
"MacAddress": "06:d7:a4:f7:4d:57",
"NetworkInterfaceId": "eni-034acc2885e862b65",
"OwnerId": "123456789012",
"PrivateDnsName": "ip-10-0-8-180.us-west-2.compute.internal",
"PrivateIpAddress": "10.0.8.180",
"PrivateIpAddresses": [
{
"Primary": true,
"PrivateDnsName": "ip-10-0-8-180.us-west-2.compute.internal",
"PrivateIpAddress": "10.0.8.180"
}
],
"RequesterId": "AIDA4Z3Y7GSXTMEXAMPLE",
"RequesterManaged": false,
"SourceDestCheck": true,
"Status": "pending",
"SubnetId": "subnet-00a24d0d67acf6333",
"TagSet": [],
"VpcId": "vpc-02723a0feeeb9d57b"
}
}
```
Para obter mais informações, consulte [Interfaces de rede elástica](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [CreateNetworkInterface](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-network-interface.html)em *Referência de AWS CLI Comandos*.
### `create-placement-group`
O código de exemplo a seguir mostra como usar `create-placement-group`.
**AWS CLI**
**Criar um grupo de posicionamento**
Esse exemplo de comando cria um grupo de posicionamento com o nome especificado.
Comando:
```
aws ec2 create-placement-group --group-name my-cluster --strategy cluster
```
**Criar um grupo com posicionamento em partições**
Esse exemplo de comando cria um grupo com posicionamento em partições chamado `HDFS-Group-A` com cinco partições.
Comando:
```
aws ec2 create-placement-group --group-name HDFS-Group-A --strategy partition --partition-count 5
```
+ Para obter detalhes da API, consulte [CreatePlacementGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-placement-group.html)em *Referência de AWS CLI Comandos*.
### `create-replace-root-volume-task`
O código de exemplo a seguir mostra como usar `create-replace-root-volume-task`.
**AWS CLI**
**Exemplo 1: restaurar um volume raiz ao estado inicial de inicialização**
O exemplo `create-replace-root-volume-task` a seguir restaura o volume raiz da instância i-0123456789abcdefa para seu estado inicial de inicialização.
```
aws ec2 create-replace-root-volume-task \
--instance-id i-0123456789abcdefa
```
Saída:
```
{
"ReplaceRootVolumeTask":
{
"InstanceId": "i-0123456789abcdefa",
"ReplaceRootVolumeTaskId": "replacevol-0111122223333abcd",
"TaskState": "pending",
"StartTime": "2022-03-14T15:06:38Z",
"Tags": []
}
}
```
**Exemplo 2: restaurar um volume raiz para um snapshot específico**
O exemplo `create-replace-root-volume-task` a seguir restaura o volume raiz da instância i-0123456789abcdefa para o snapshot snap-0abcdef1234567890.
```
aws ec2 create-replace-root-volume-task \
--instance-id i-0123456789abcdefa \
--snapshot-id snap-0abcdef1234567890
```
Saída:
```
{
"ReplaceRootVolumeTask":
{
"InstanceId": "i-0123456789abcdefa",
"ReplaceRootVolumeTaskId": "replacevol-0555566667777abcd",
"TaskState": "pending",
"StartTime": "2022-03-14T15:16:28Z",
"Tags": []
}
}
```
Consulte mais informações em [Substituir um volume raiz](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/replace-root.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [CreateReplaceRootVolumeTask](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-replace-root-volume-task.html)em *Referência de AWS CLI Comandos*.
### `create-reserved-instances-listing`
O código de exemplo a seguir mostra como usar `create-reserved-instances-listing`.
**AWS CLI**
**Listar uma instância reservada no Marketplace de instâncias reservadas usando**
O exemplo `create-reserved-instances-listing` a seguir cria uma listagem da Instância Reservada especificada no Marketplace de Instâncias Reservadas.
```
aws ec2 create-reserved-instances-listing \
--reserved-instances-id 5ec28771-05ff-4b9b-aa31-9e57dexample \
--instance-count 3 \
--price-schedules CurrencyCode=USD,Price=25.50 \
--client-token 550e8400-e29b-41d4-a716-446655440000
```
+ Para obter detalhes da API, consulte [CreateReservedInstancesListing](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-reserved-instances-listing.html)em *Referência de AWS CLI Comandos*.
### `create-restore-image-task`
O código de exemplo a seguir mostra como usar `create-restore-image-task`.
**AWS CLI**
**Restaurar uma AMI de um bucket do S3**
O exemplo `create-restore-image-task` a seguir restaura uma AMI de um bucket do S3. Use os valores de `S3ObjectKey `` and ``Bucket` da saída `describe-store-image-tasks`, especifique a chave de objeto da AMI e o nome do bucket do S3 para o qual a AMI foi copiada e especifique o nome da AMI restaurada. O nome dessa conta deve ser exclusivo AMIs na região. A AMI restaurada receberá uma nova ID AMI.
```
aws ec2 create-restore-image-task \
--object-key ami-1234567890abcdef0.bin \
--bucket my-ami-bucket \
--name 'New AMI Name'
```
Saída:
```
{
"ImageId": "ami-0eab20fe36f83e1a8"
}
```
Para obter mais informações, consulte [Armazenar e restaurar uma AMI usando o S3](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html) no *Guia de usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [CreateRestoreImageTask](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-restore-image-task.html)em *Referência de AWS CLI Comandos*.
### `create-route-table`
O código de exemplo a seguir mostra como usar `create-route-table`.
**AWS CLI**
**Para criar uma tabela de rotas**
Este exemplo cria uma tabela de rotas para a VPC especificada.
Comando:
```
aws ec2 create-route-table --vpc-id vpc-a01106c2
```
Saída:
```
{
"RouteTable": {
"Associations": [],
"RouteTableId": "rtb-22574640",
"VpcId": "vpc-a01106c2",
"PropagatingVgws": [],
"Tags": [],
"Routes": [
{
"GatewayId": "local",
"DestinationCidrBlock": "10.0.0.0/16",
"State": "active"
}
]
}
}
```
+ Para obter detalhes da API, consulte [CreateRouteTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-route-table.html)em *Referência de AWS CLI Comandos*.
### `create-route`
O código de exemplo a seguir mostra como usar `create-route`.
**AWS CLI**
**Criar uma rota**
Este exemplo cria uma rota para a tabela de rotas especificada. A rota corresponde a todo o IPv4 tráfego (`0.0.0.0/0`) e o encaminha para o gateway de Internet especificado. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 create-route --route-table-id rtb-22574640 --destination-cidr-block 0.0.0.0/0 --gateway-id igw-c0a643a9
```
Este exemplo de comando cria uma rota na tabela de rotas rtb-g8ff4ea2. A rota corresponde ao tráfego do bloco IPv4 CIDR 10.0.0.0/16 e o encaminha para a conexão de emparelhamento de VPC, pcx-111aaa22. Essa rota permite que o tráfego seja direcionado para a VPC de mesmo nível na conexão de emparelhamento da VPC. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 create-route --route-table-id rtb-g8ff4ea2 --destination-cidr-block 10.0.0.0/16 --vpc-peering-connection-id pcx-1a2b3c4d
```
Este exemplo cria uma rota na tabela de rotas especificada que corresponde a todo o IPv6 tráfego (`::/0`) e a encaminha para o gateway de Internet somente de saída especificado.
Comando:
```
aws ec2 create-route --route-table-id rtb-dce620b8 --destination-ipv6-cidr-block ::/0 --egress-only-internet-gateway-id eigw-01eadbd45ecd7943f
```
+ Para obter detalhes da API, consulte [CreateRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-route.html)em *Referência de AWS CLI Comandos*.
### `create-security-group`
O código de exemplo a seguir mostra como usar `create-security-group`.
**AWS CLI**
**Para criar um grupo de segurança do EC2-Classic**
Este exemplo cria um grupo de segurança chamado `MySecurityGroup`.
Comando:
```
aws ec2 create-security-group --group-name MySecurityGroup --description "My security group"
```
Saída:
```
{
"GroupId": "sg-903004f8"
}
```
**Para criar um grupo de segurança do EC2-VPC**
Este exemplo cria um grupo de segurança chamado `MySecurityGroup` para a VPC especificada.
Comando:
```
aws ec2 create-security-group --group-name MySecurityGroup --description "My security group" --vpc-id vpc-1a2b3c4d
```
Saída:
```
{
"GroupId": "sg-903004f8"
}
```
Para obter mais informações, consulte Using Security Groups no *Guia do usuário da AWS Command Line Interface*.
+ Para obter detalhes da API, consulte [CreateSecurityGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-security-group.html)em *Referência de AWS CLI Comandos*.
### `create-snapshot`
O código de exemplo a seguir mostra como usar `create-snapshot`.
**AWS CLI**
**Para criar um snapshot**
Esse exemplo de comando cria um snapshot do volume com um ID do volume `vol-1234567890abcdef0` e uma breve descrição para identificar o snapshot.
Comando:
```
aws ec2 create-snapshot --volume-id vol-1234567890abcdef0 --description "This is my root volume snapshot"
```
Saída:
```
{
"Description": "This is my root volume snapshot",
"Tags": [],
"Encrypted": false,
"VolumeId": "vol-1234567890abcdef0",
"State": "pending",
"VolumeSize": 8,
"StartTime": "2018-02-28T21:06:01.000Z",
"Progress": "",
"OwnerId": "012345678910",
"SnapshotId": "snap-066877671789bd71b"
}
```
**Para criar um snapshot com tags**
Esse exemplo de comando cria um snapshot e aplica duas tags: purpose=prod e costcenter=123.
Comando:
```
aws ec2 create-snapshot --volume-id vol-1234567890abcdef0 --description 'Prod backup' --tag-specifications 'ResourceType=snapshot,Tags=[{Key=purpose,Value=prod},{Key=costcenter,Value=123}]'
```
Saída:
```
{
"Description": "Prod backup",
"Tags": [
{
"Value": "prod",
"Key": "purpose"
},
{
"Value": "123",
"Key": "costcenter"
}
],
"Encrypted": false,
"VolumeId": "vol-1234567890abcdef0",
"State": "pending",
"VolumeSize": 8,
"StartTime": "2018-02-28T21:06:06.000Z",
"Progress": "",
"OwnerId": "012345678910",
"SnapshotId": "snap-09ed24a70bc19bbe4"
}
```
+ Para obter detalhes da API, consulte [CreateSnapshot](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-snapshot.html)em *Referência de AWS CLI Comandos*.
### `create-snapshots`
O código de exemplo a seguir mostra como usar `create-snapshots`.
**AWS CLI**
**Exemplo 1: criar um snapshot de vários volumes**
O exemplo `create-snapshots` a seguir cria snapshots de todos os volumes anexados à instância especificada.
```
aws ec2 create-snapshots \
--instance-specification InstanceId=i-1234567890abcdef0 \
--description "This is snapshot of a volume from my-instance"
```
Saída:
```
{
"Snapshots": [
{
"Description": "This is a snapshot of a volume from my-instance",
"Tags": [],
"Encrypted": false,
"VolumeId": "vol-0a01d2d5a34697479",
"State": "pending",
"VolumeSize": 16,
"StartTime": "2019-08-05T16:58:19.000Z",
"Progress": "",
"OwnerId": "123456789012",
"SnapshotId": "snap-07f30e3909aa0045e"
},
{
"Description": "This is a snapshot of a volume from my-instance",
"Tags": [],
"Encrypted": false,
"VolumeId": "vol-02d0d4947008cb1a2",
"State": "pending",
"VolumeSize": 20,
"StartTime": "2019-08-05T16:58:19.000Z",
"Progress": "",
"OwnerId": "123456789012",
"SnapshotId": "snap-0ec20b602264aad48"
},
...
]
}
```
**Exemplo 2: criar um snapshot de vários volumes com tags do volume de origem**
O exemplo `create-snapshots` a seguir cria snapshots de todos os volumes anexados à instância especificada e copia as tags de cada volume para o snapshot correspondente.
```
aws ec2 create-snapshots \
--instance-specification InstanceId=i-1234567890abcdef0 \
--copy-tags-from-source volume \
--description "This is snapshot of a volume from my-instance"
```
Saída:
```
{
"Snapshots": [
{
"Description": "This is a snapshot of a volume from my-instance",
"Tags": [
{
"Key": "Name",
"Value": "my-volume"
}
],
"Encrypted": false,
"VolumeId": "vol-02d0d4947008cb1a2",
"State": "pending",
"VolumeSize": 20,
"StartTime": "2019-08-05T16:53:04.000Z",
"Progress": "",
"OwnerId": "123456789012",
"SnapshotId": "snap-053bfaeb821a458dd"
}
...
]
}
```
**Exemplo 3: criar um snapshot de vários volumes que não inclua o volume raiz**
O exemplo `create-snapshots` a seguir cria um snapshot de todos os volumes anexados à instância especificada, exceto o volume raiz.
```
aws ec2 create-snapshots \
--instance-specification InstanceId=i-1234567890abcdef0,ExcludeBootVolume=true
```
Consulte a amostra de saída no exemplo 1.
**Exemplo 4: criar um snapshot de vários volumes e adicionar tags**
O exemplo `create-snapshots` a seguir cria snapshots de todos os volumes anexados à instância especificada e adiciona duas tags a cada snapshot.
```
aws ec2 create-snapshots \
--instance-specification InstanceId=i-1234567890abcdef0 \
--tag-specifications 'ResourceType=snapshot,Tags=[{Key=Name,Value=backup},{Key=costcenter,Value=123}]'
```
Consulte uma amostra de saída no exemplo 1.
+ Para obter detalhes da API, consulte [CreateSnapshots](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-snapshots.html)em *Referência de AWS CLI Comandos*.
### `create-spot-datafeed-subscription`
O código de exemplo a seguir mostra como usar `create-spot-datafeed-subscription`.
**AWS CLI**
**Criar um feed de dados da instância spot**
O exemplo `create-spot-datafeed-subscription` a seguir cria um feed de dados da Instância Spot.
```
aws ec2 create-spot-datafeed-subscription \
--bucket amzn-s3-demo-bucket \
--prefix spot-data-feed
```
Saída:
```
{
"SpotDatafeedSubscription": {
"Bucket": "amzn-s3-demo-bucket",
"OwnerId": "123456789012",
"Prefix": "spot-data-feed",
"State": "Active"
}
}
```
O feed de dados é armazenado no bucket do Amazon S3 que você especificar. Os nomes de arquivo desse feed de dados têm o formato a seguir.
```
amzn-s3-demo-bucket.s3.amazonaws.com/spot-data-feed/123456789012.YYYY-MM-DD-HH.n.abcd1234.gz
```
Consulte mais informações em [Feed de dados da instância spot](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-data-feeds.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [CreateSpotDatafeedSubscription](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-spot-datafeed-subscription.html)em *Referência de AWS CLI Comandos*.
### `create-store-image-task`
O código de exemplo a seguir mostra como usar `create-store-image-task`.
**AWS CLI**
**Armazenar uma AMI em um bucket do S3**
O exemplo `create-store-image-task` a seguir armazena uma AMI em um bucket do S3. Especifique o ID da AMI e o nome do bucket do S3 no qual a AMI será armazenada.
```
aws ec2 create-store-image-task \
--image-id ami-1234567890abcdef0 \
--bucket my-ami-bucket
```
Saída:
```
{
"ObjectKey": "ami-1234567890abcdef0.bin"
}
```
Para obter mais informações, consulte [Armazenar e restaurar uma AMI usando o S3](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html) no *Guia de usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [CreateStoreImageTask](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-store-image-task.html)em *Referência de AWS CLI Comandos*.
### `create-subnet-cidr-reservation`
O código de exemplo a seguir mostra como usar `create-subnet-cidr-reservation`.
**AWS CLI**
**Criar uma reserva CIDR de sub-rede**
O exemplo `create-subnet-cidr-reservation` a seguir cria uma reserva CIDR de sub-rede para a sub-rede e o intervalo CIDR especificados.
```
aws ec2 create-subnet-cidr-reservation \
--subnet-id subnet-03c51e2eEXAMPLE \
--reservation-type prefix \
--cidr 10.1.0.20/26
```
Saída:
```
{
"SubnetCidrReservation": {
"SubnetCidrReservationId": "scr-044f977c4eEXAMPLE",
"SubnetId": "subnet-03c51e2e6cEXAMPLE",
"Cidr": "10.1.0.16/28",
"ReservationType": "prefix",
"OwnerId": "123456789012"
}
}
```
Para obter mais informações, consulte [Comportamento do endereçamento IP para sua sub-rede](https://docs.aws.amazon.com/vpc/latest/userguide/subnet-cidr-reservation.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [CreateSubnetCidrReservation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-subnet-cidr-reservation.html)em *Referência de AWS CLI Comandos*.
### `create-subnet`
O código de exemplo a seguir mostra como usar `create-subnet`.
**AWS CLI**
**Exemplo 1: Para criar uma sub-rede somente com um bloco IPv4 CIDR**
O `create-subnet` exemplo a seguir cria uma sub-rede na VPC especificada com o bloco CIDR IPv4 especificado.
```
aws ec2 create-subnet \
--vpc-id vpc-081ec835f3EXAMPLE \
--cidr-block 10.0.0.0/24 \
--tag-specifications ResourceType=subnet,Tags=[{Key=Name,Value=my-ipv4-only-subnet}]
```
Saída:
```
{
"Subnet": {
"AvailabilityZone": "us-west-2a",
"AvailabilityZoneId": "usw2-az2",
"AvailableIpAddressCount": 251,
"CidrBlock": "10.0.0.0/24",
"DefaultForAz": false,
"MapPublicIpOnLaunch": false,
"State": "available",
"SubnetId": "subnet-0e99b93155EXAMPLE",
"VpcId": "vpc-081ec835f3EXAMPLE",
"OwnerId": "123456789012",
"AssignIpv6AddressOnCreation": false,
"Ipv6CidrBlockAssociationSet": [],
"Tags": [
{
"Key": "Name",
"Value": "my-ipv4-only-subnet"
}
],
"SubnetArn": "arn:aws:ec2:us-west-2:123456789012:subnet/subnet-0e99b93155EXAMPLE"
}
}
```
**Exemplo 2: Para criar uma sub-rede com blocos ambos IPv4 e IPv6 CIDR**
O `create-subnet` exemplo a seguir cria uma sub-rede na VPC especificada com os blocos IPv4 especificados IPv6 e CIDR.
```
aws ec2 create-subnet \
--vpc-id vpc-081ec835f3EXAMPLE \
--cidr-block 10.0.0.0/24 \
--ipv6-cidr-block 2600:1f16:cfe:3660::/64 \
--tag-specifications ResourceType=subnet,Tags=[{Key=Name,Value=my-ipv4-ipv6-subnet}]
```
Saída:
```
{
"Subnet": {
"AvailabilityZone": "us-west-2a",
"AvailabilityZoneId": "usw2-az2",
"AvailableIpAddressCount": 251,
"CidrBlock": "10.0.0.0/24",
"DefaultForAz": false,
"MapPublicIpOnLaunch": false,
"State": "available",
"SubnetId": "subnet-0736441d38EXAMPLE",
"VpcId": "vpc-081ec835f3EXAMPLE",
"OwnerId": "123456789012",
"AssignIpv6AddressOnCreation": false,
"Ipv6CidrBlockAssociationSet": [
{
"AssociationId": "subnet-cidr-assoc-06c5f904499fcc623",
"Ipv6CidrBlock": "2600:1f13:cfe:3660::/64",
"Ipv6CidrBlockState": {
"State": "associating"
}
}
],
"Tags": [
{
"Key": "Name",
"Value": "my-ipv4-ipv6-subnet"
}
],
"SubnetArn": "arn:aws:ec2:us-west-2:123456789012:subnet/subnet-0736441d38EXAMPLE"
}
}
```
**Exemplo 3: Para criar uma sub-rede somente com um bloco IPv6 CIDR**
O `create-subnet` exemplo a seguir cria uma sub-rede na VPC especificada com o bloco CIDR IPv6 especificado.
```
aws ec2 create-subnet \
--vpc-id vpc-081ec835f3EXAMPLE \
--ipv6-native \
--ipv6-cidr-block 2600:1f16:115:200::/64 \
--tag-specifications ResourceType=subnet,Tags=[{Key=Name,Value=my-ipv6-only-subnet}]
```
Saída:
```
{
"Subnet": {
"AvailabilityZone": "us-west-2a",
"AvailabilityZoneId": "usw2-az2",
"AvailableIpAddressCount": 0,
"DefaultForAz": false,
"MapPublicIpOnLaunch": false,
"State": "available",
"SubnetId": "subnet-03f720e7deEXAMPLE",
"VpcId": "vpc-081ec835f3EXAMPLE",
"OwnerId": "123456789012",
"AssignIpv6AddressOnCreation": true,
"Ipv6CidrBlockAssociationSet": [
{
"AssociationId": "subnet-cidr-assoc-01ef639edde556709",
"Ipv6CidrBlock": "2600:1f13:cfe:3660::/64",
"Ipv6CidrBlockState": {
"State": "associating"
}
}
],
"Tags": [
{
"Key": "Name",
"Value": "my-ipv6-only-subnet"
}
],
"SubnetArn": "arn:aws:ec2:us-west-2:123456789012:subnet/subnet-03f720e7deEXAMPLE"
}
}
```
Para obter mais informações, consulte [VPCs e sub-redes no Guia](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html) do usuário da Amazon *VPC*.
+ Para obter detalhes da API, consulte [CreateSubnet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-subnet.html)em *Referência de AWS CLI Comandos*.
### `create-tags`
O código de exemplo a seguir mostra como usar `create-tags`.
**AWS CLI**
**Exemplo 1: adicionar uma tag a um recurso**
O exemplo `create-tags` a seguir adiciona a tag `Stack=production` à imagem especificada ou substitui uma tag existente para a AMI na qual a chave de tag é `Stack`.
```
aws ec2 create-tags \
--resources ami-1234567890abcdef0 \
--tags Key=Stack,Value=production
```
Este comando não produz saída
**Exemplo 2: adicionar tags a vários recursos**
O exemplo `create-tags` a seguir adiciona (ou substitui) duas tags para uma AMI e uma instância. Uma das tags tem uma chave (`webserver`), mas nenhum valor (o valor é definido como uma string vazia). A outra tag tem uma chave (`stack`) e um valor (`Production`).
```
aws ec2 create-tags \
--resources ami-1a2b3c4d i-1234567890abcdef0 \
--tags Key=webserver,Value= Key=stack,Value=Production
```
Este comando não produz saída
**Exemplo 3: adicionar tags contendo caracteres especiais**
Os exemplos de `create-tags` a seguir adicionam a tag `[Group]=test` a uma instância. Os colchetes ([ e ]) são caracteres especiais e devem ser recuados. Os exemplos a seguir também usam o caractere de continuação de linha apropriado para cada ambiente.
Se você estiver usando o Windows, coloque o elemento com caracteres especiais entre aspas duplas (“) e preceda cada caractere de aspas duplas com uma barra invertida (\$1) da maneira a seguir.
```
aws ec2 create-tags ^
--resources i-1234567890abcdef0 ^
--tags Key=\"[Group]\",Value=test
```
Se você estiver usando o Windows PowerShell, coloque o elemento no valor que tem caracteres especiais com aspas duplas (“), preceda cada caractere de aspas duplas com uma barra invertida (\$1) e, em seguida, coloque toda a estrutura de chave e valor entre aspas simples (') da seguinte maneira.
```
aws ec2 create-tags `
--resources i-1234567890abcdef0 `
--tags 'Key=\"[Group]\",Value=test'
```
Se você estiver usando Linux ou OS X, coloque o elemento com caracteres especiais entre aspas duplas (“) e toda a estrutura de chave e valor entre aspas simples (‘) da maneira a seguir.
```
aws ec2 create-tags \
--resources i-1234567890abcdef0 \
--tags 'Key="[Group]",Value=test'
```
Para ter mais informações, consulte [Marcar com tag os recursos do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [CreateTags](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-tags.html)em *Referência de AWS CLI Comandos*.
### `create-traffic-mirror-filter-rule`
O código de exemplo a seguir mostra como usar `create-traffic-mirror-filter-rule`.
**AWS CLI**
**Criar uma regra de filtro para o tráfego TCP de entrada**
O exemplo `create-traffic-mirror-filter-rule` a seguir cria uma regra que você pode usar para espelhar todo o tráfego TCP de entrada. Antes de executar esse comando, use `create-traffic-mirror-filter` para criar o filtro de espelhamento de tráfego.
```
aws ec2 create-traffic-mirror-filter-rule \
--description 'TCP Rule' \
--destination-cidr-block 0.0.0.0/0 \
--protocol 6 \
--rule-action accept \
--rule-number 1 \
--source-cidr-block 0.0.0.0/0 \
--traffic-direction ingress \
--traffic-mirror-filter-id tmf-04812ff784b25ae67
```
Saída:
```
{
"TrafficMirrorFilterRule": {
"DestinationCidrBlock": "0.0.0.0/0",
"TrafficMirrorFilterId": "tmf-04812ff784b25ae67",
"TrafficMirrorFilterRuleId": "tmfr-02d20d996673f3732",
"SourceCidrBlock": "0.0.0.0/0",
"TrafficDirection": "ingress",
"Description": "TCP Rule",
"RuleNumber": 1,
"RuleAction": "accept",
"Protocol": 6
},
"ClientToken": "4752b573-40a6-4eac-a8a4-a72058761219"
}
```
Consulte mais informações em [Create a traffic mirror filter](https://docs.aws.amazon.com/vpc/latest/mirroring/create-traffic-mirroring-filter.html) no *Guia de espelhamento de tráfego*.
+ Para obter detalhes da API, consulte [CreateTrafficMirrorFilterRule](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-traffic-mirror-filter-rule.html)em *Referência de AWS CLI Comandos*.
### `create-traffic-mirror-filter`
O código de exemplo a seguir mostra como usar `create-traffic-mirror-filter`.
**AWS CLI**
**Como criar um filtro de espelhamento de tráfego**
O exemplo de `create-traffic-mirror-filter` a seguir cria um filtro de espelhamento de tráfego. Depois de criar o filtro, use `create-traffic-mirror-filter-rule` para adicionar regras.
```
aws ec2 create-traffic-mirror-filter \
--description 'TCP Filter'
```
Saída:
```
{
"ClientToken": "28908518-100b-4987-8233-8c744EXAMPLE",
"TrafficMirrorFilter": {
"TrafficMirrorFilterId": "tmf-04812ff784EXAMPLE",
"Description": "TCP Filter",
"EgressFilterRules": [],
"IngressFilterRules": [],
"Tags": [],
"NetworkServices": []
}
}
```
Consulte mais informações em [Create a traffic mirror filter](https://docs.aws.amazon.com/vpc/latest/mirroring/create-traffic-mirroring-filter.html) no *Guia de espelhamento de tráfego*.
+ Para obter detalhes da API, consulte [CreateTrafficMirrorFilter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-traffic-mirror-filter.html)em *Referência de AWS CLI Comandos*.
### `create-traffic-mirror-session`
O código de exemplo a seguir mostra como usar `create-traffic-mirror-session`.
**AWS CLI**
**Como criar uma sessão de espelhamento de tráfego**
O comando de `create-traffic-mirror-session` a seguir cria uma sessão de espelhamento de tráfego de 25 bytes do pacote para a origem e o destino especificados.
```
aws ec2 create-traffic-mirror-session \
--description 'example session' \
--traffic-mirror-target-id tmt-07f75d8feeEXAMPLE \
--network-interface-id eni-070203f901EXAMPLE \
--session-number 1 \
--packet-length 25 \
--traffic-mirror-filter-id tmf-04812ff784EXAMPLE
```
Saída:
```
{
"TrafficMirrorSession": {
"TrafficMirrorSessionId": "tms-08a33b1214EXAMPLE",
"TrafficMirrorTargetId": "tmt-07f75d8feeEXAMPLE",
"TrafficMirrorFilterId": "tmf-04812ff784EXAMPLE",
"NetworkInterfaceId": "eni-070203f901EXAMPLE",
"OwnerId": "111122223333",
"PacketLength": 25,
"SessionNumber": 1,
"VirtualNetworkId": 7159709,
"Description": "example session",
"Tags": []
},
"ClientToken": "5236cffc-ee13-4a32-bb5b-388d9da09d96"
}
```
Consulte mais informações em [Create a traffic mirror session](https://docs.aws.amazon.com/vpc/latest/mirroring/create-traffic-mirroring-session.html) no *Guia de espelhamento de tráfego*.
+ Para obter detalhes da API, consulte [CreateTrafficMirrorSession](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-traffic-mirror-session.html)em *Referência de AWS CLI Comandos*.
### `create-traffic-mirror-target`
O código de exemplo a seguir mostra como usar `create-traffic-mirror-target`.
**AWS CLI**
**Como criar um destino de espelho de tráfego no Network Load Balancer**
O exemplo de `create-traffic-mirror-target` a seguir cria um destino de espelho de tráfego no Network Load Balancer.
```
aws ec2 create-traffic-mirror-target \
--description 'Example Network Load Balancer Target' \
--network-load-balancer-arn arn:aws:elasticloadbalancing:us-east-1:111122223333:loadbalancer/net/NLB/7cdec873EXAMPLE
```
Saída:
```
{
"TrafficMirrorTarget": {
"Type": "network-load-balancer",
"Tags": [],
"Description": "Example Network Load Balancer Target",
"OwnerId": "111122223333",
"NetworkLoadBalancerArn": "arn:aws:elasticloadbalancing:us-east-1:724145273726:loadbalancer/net/NLB/7cdec873EXAMPLE",
"TrafficMirrorTargetId": "tmt-0dabe9b0a6EXAMPLE"
},
"ClientToken": "d5c090f5-8a0f-49c7-8281-72c796a21f72"
}
```
**Como criar um destino de espelhamento de tráfego de rede**
O exemplo `create-traffic-mirror-target` a seguir cria um destino de espelho de tráfego na interface de rede.
```
aws ec2 create-traffic-mirror-target \
--description 'Network interface target' \
--network-interface-id eni-eni-01f6f631eEXAMPLE
```
Saída:
```
{
"ClientToken": "5289a345-0358-4e62-93d5-47ef3061d65e",
"TrafficMirrorTarget": {
"Description": "Network interface target",
"NetworkInterfaceId": "eni-01f6f631eEXAMPLE",
"TrafficMirrorTargetId": "tmt-02dcdbe2abEXAMPLE",
"OwnerId": "111122223333",
"Type": "network-interface",
"Tags": []
}
}
```
Consulte mais informações em [Create a traffic mirror target](https://docs.aws.amazon.com/vpc/latest/mirroring/create-traffic-mirroring-target.html) no *Guia de espelhamento de tráfego*.
+ Para obter detalhes da API, consulte [CreateTrafficMirrorTarget](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-traffic-mirror-target.html)em *Referência de AWS CLI Comandos*.
### `create-transit-gateway-connect-peer`
O código de exemplo a seguir mostra como usar `create-transit-gateway-connect-peer`.
**AWS CLI**
**Criar um par de conexão de gateway de trânsito**
O exemplo `create-transit-gateway-connect-peer` a seguir cria um par de conexão.
```
aws ec2 create-transit-gateway-connect-peer \
--transit-gateway-attachment-id tgw-attach-0f0927767cEXAMPLE \
--peer-address 172.31.1.11 \
--inside-cidr-blocks 169.254.6.0/29
```
Saída:
```
{
"TransitGatewayConnectPeer": {
"TransitGatewayAttachmentId": "tgw-attach-0f0927767cEXAMPLE",
"TransitGatewayConnectPeerId": "tgw-connect-peer-0666adbac4EXAMPLE",
"State": "pending",
"CreationTime": "2021-10-13T03:35:17.000Z",
"ConnectPeerConfiguration": {
"TransitGatewayAddress": "10.0.0.234",
"PeerAddress": "172.31.1.11",
"InsideCidrBlocks": [
"169.254.6.0/29"
],
"Protocol": "gre",
"BgpConfigurations": [
{
"TransitGatewayAsn": 64512,
"PeerAsn": 64512,
"TransitGatewayAddress": "169.254.6.2",
"PeerAddress": "169.254.6.1",
"BgpStatus": "down"
},
{
"TransitGatewayAsn": 64512,
"PeerAsn": 64512,
"TransitGatewayAddress": "169.254.6.3",
"PeerAddress": "169.254.6.1",
"BgpStatus": "down"
}
]
}
}
}
```
Para obter mais informações, consulte [Anexos de conexão do gateway de trânsito e pares de conexão do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [CreateTransitGatewayConnectPeer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-connect-peer.html)em *Referência de AWS CLI Comandos*.
### `create-transit-gateway-connect`
O código de exemplo a seguir mostra como usar `create-transit-gateway-connect`.
**AWS CLI**
**Criar um anexo de conexão do gateway de trânsito**
O exemplo `create-transit-gateway-connect` a seguir cria um anexo de conexão, com o protocolo “gre”, para o anexo especificado.
```
aws ec2 create-transit-gateway-connect \
--transport-transit-gateway-attachment-id tgw-attach-0a89069f57EXAMPLE \
--options "Protocol=gre"
```
Saída:
```
{
"TransitGatewayConnect": {
"TransitGatewayAttachmentId": "tgw-attach-037012e5dcEXAMPLE",
"TransportTransitGatewayAttachmentId": "tgw-attach-0a89069f57EXAMPLE",
"TransitGatewayId": "tgw-02f776b1a7EXAMPLE",
"State": "pending",
"CreationTime": "2021-03-09T19:59:17+00:00",
"Options": {
"Protocol": "gre"
}
}
}
```
Para obter mais informações, consulte [Anexos de conexão do gateway de trânsito e pares de conexão do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [CreateTransitGatewayConnect](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-connect.html)em *Referência de AWS CLI Comandos*.
### `create-transit-gateway-multicast-domain`
O código de exemplo a seguir mostra como usar `create-transit-gateway-multicast-domain`.
**AWS CLI**
**Exemplo 1: um domínio multicast do IGMP**
O exemplo `create-transit-gateway-multicast-domain` a seguir cria um domínio multicast para o gateway de trânsito especificado. Com as fontes estáticas desabilitadas, todas as instâncias nas sub-redes associadas ao domínio multicast podem enviar tráfego multicast. Se pelo menos um membro usar o protocolo IGMP, você deverá ativar o IGMPv2 suporte.
```
aws ec2 create-transit-gateway-multicast-domain \
--transit-gateway-id tgw-0bf0bffefaEXAMPLE \
--options StaticSourcesSupport=disable,Igmpv2Support=enable
```
Saída:
```
{
"TransitGatewayMulticastDomain": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-0c9e29e2a7EXAMPLE",
"TransitGatewayId": "tgw-0bf0bffefaEXAMPLE",
"TransitGatewayMulticastDomainArn": "arn:aws:ec2:us-west-2:123456789012:transit-gateway-multicast-domain/tgw-mcast-domain-0c9e29e2a7EXAMPLE",
"OwnerId": "123456789012",
"Options": {
"Igmpv2Support": "enable",
"StaticSourcesSupport": "disable",
"AutoAcceptSharedAssociations": "disable"
},
"State": "pending",
"CreationTime": "2021-09-29T22:17:13.000Z"
}
}
```
**Exemplo 2: criar um domínio multicast estático**
O exemplo `create-transit-gateway-multicast-domain` a seguir cria um domínio multicast para o gateway de trânsito especificado. Com as fontes estáticas ativadas, você deve adicionar fontes estaticamente.
```
aws ec2 create-transit-gateway-multicast-domain \
--transit-gateway-id tgw-0bf0bffefaEXAMPLE \
--options StaticSourcesSupport=enable,Igmpv2Support=disable
```
Saída:
```
{
"TransitGatewayMulticastDomain": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-000fb24d04EXAMPLE",
"TransitGatewayId": "tgw-0bf0bffefaEXAMPLE",
"TransitGatewayMulticastDomainArn": "arn:aws:ec2:us-west-2:123456789012:transit-gateway-multicast-domain/tgw-mcast-domain-000fb24d04EXAMPLE",
"OwnerId": "123456789012",
"Options": {
"Igmpv2Support": "disable",
"StaticSourcesSupport": "enable",
"AutoAcceptSharedAssociations": "disable"
},
"State": "pending",
"CreationTime": "2021-09-29T22:20:19.000Z"
}
}
```
Para obter mais informações, consulte [Como gerenciar domínios multicast](https://docs.aws.amazon.com/vpc/latest/tgw/manage-domain.html) no *Guia de gateway de trânsito*.
+ Para obter detalhes da API, consulte [CreateTransitGatewayMulticastDomain](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-multicast-domain.html)em *Referência de AWS CLI Comandos*.
### `create-transit-gateway-peering-attachment`
O código de exemplo a seguir mostra como usar `create-transit-gateway-peering-attachment`.
**AWS CLI**
**Criar um anexo de emparelhamento do gateway de trânsito**
O exemplo `create-transit-gateway-peering-attachment` a seguir cria uma solicitação de anexo de emparelhamento entre os dois gateways de trânsito especificados.
```
aws ec2 create-transit-gateway-peering-attachment \
--transit-gateway-id tgw-123abc05e04123abc \
--peer-transit-gateway-id tgw-11223344aabbcc112 \
--peer-account-id 123456789012 \
--peer-region us-east-2
```
Saída:
```
{
"TransitGatewayPeeringAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-4455667788aabbccd",
"RequesterTgwInfo": {
"TransitGatewayId": "tgw-123abc05e04123abc",
"OwnerId": "123456789012",
"Region": "us-west-2"
},
"AccepterTgwInfo": {
"TransitGatewayId": "tgw-11223344aabbcc112",
"OwnerId": "123456789012",
"Region": "us-east-2"
},
"State": "initiatingRequest",
"CreationTime": "2019-12-09T11:38:05.000Z"
}
}
```
Para obter mais informações, consulte [Anexos de pareamento do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-peering.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [CreateTransitGatewayPeeringAttachment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-peering-attachment.html)em *Referência de AWS CLI Comandos*.
### `create-transit-gateway-policy-table`
O código de exemplo a seguir mostra como usar `create-transit-gateway-policy-table`.
**AWS CLI**
**Criar uma tabela de políticas de gateway de trânsito**
O exemplo `create-transit-gateway-policy-table` a seguir cria uma tabela de políticas de gateway de trânsito para o gateway de trânsito especificado.
```
aws ec2 create-transit-gateway-policy-table \
--transit-gateway-id tgw-067f8505c18f0bd6e
```
Saída:
```
{
"TransitGatewayPolicyTable": {
"TransitGatewayPolicyTableId": "tgw-ptb-0a16f134b78668a81",
"TransitGatewayId": "tgw-067f8505c18f0bd6e",
"State": "pending",
"CreationTime": "2023-11-28T16:36:43+00:00"
}
}
```
Para obter mais informações, consulte [Tabelas de política do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-policy-tables.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [CreateTransitGatewayPolicyTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-policy-table.html)em *Referência de AWS CLI Comandos*.
### `create-transit-gateway-prefix-list-reference`
O código de exemplo a seguir mostra como usar `create-transit-gateway-prefix-list-reference`.
**AWS CLI**
**Criar uma referência de lista de prefixos**
O exemplo `create-transit-gateway-prefix-list-reference` a seguir cria uma referência à lista de prefixos especificada na tabela de rotas do gateway de trânsito especificada.
```
aws ec2 create-transit-gateway-prefix-list-reference \
--transit-gateway-route-table-id tgw-rtb-0123456789abcd123 \
--prefix-list-id pl-11111122222222333 \
--transit-gateway-attachment-id tgw-attach-aaaaaabbbbbb11111
```
Saída:
```
{
"TransitGatewayPrefixListReference": {
"TransitGatewayRouteTableId": "tgw-rtb-0123456789abcd123",
"PrefixListId": "pl-11111122222222333",
"PrefixListOwnerId": "123456789012",
"State": "pending",
"Blackhole": false,
"TransitGatewayAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-aaaaaabbbbbb11111",
"ResourceType": "vpc",
"ResourceId": "vpc-112233445566aabbc"
}
}
}
```
Consulte mais informações em [Create a prefix list reference](https://docs.aws.amazon.com/vpc/latest/tgw/create-prefix-list-reference.html) no *Guia do Transit Gateway*.
+ Para obter detalhes da API, consulte [CreateTransitGatewayPrefixListReference](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-prefix-list-reference.html)em *Referência de AWS CLI Comandos*.
### `create-transit-gateway-route-table`
O código de exemplo a seguir mostra como usar `create-transit-gateway-route-table`.
**AWS CLI**
**Criar uma tabela de rotas do gateway de trânsito**
O exemplo `create-transit-gateway-route-table` a seguir cria uma tabela de rotas para o gateway de trânsito especificado.
```
aws ec2 create-transit-gateway-route-table \
--transit-gateway-id tgw-0262a0e521EXAMPLE
```
Saída:
```
{
"TransitGatewayRouteTable": {
"TransitGatewayRouteTableId": "tgw-rtb-0960981be7EXAMPLE",
"TransitGatewayId": "tgw-0262a0e521EXAMPLE",
"State": "pending",
"DefaultAssociationRouteTable": false,
"DefaultPropagationRouteTable": false,
"CreationTime": "2019-07-10T19:01:46.000Z"
}
}
```
Para obter mais informações, consulte [Criar uma tabelas de rotas do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html#create-tgw-route-table) no *Guia de gateway de trânsito*.
+ Para obter detalhes da API, consulte [CreateTransitGatewayRouteTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-route-table.html)em *Referência de AWS CLI Comandos*.
### `create-transit-gateway-route`
O código de exemplo a seguir mostra como usar `create-transit-gateway-route`.
**AWS CLI**
**Criar uma rota do gateway de trânsito**
O exemplo `create-transit-gateway-route` a seguir cria uma rota, com o destino especificado, para a tabela de rotas especificada.
```
aws ec2 create-transit-gateway-route \
--destination-cidr-block 10.0.2.0/24 \
--transit-gateway-route-table-id tgw-rtb-0b6f6aaa01EXAMPLE \
--transit-gateway-attachment-id tgw-attach-0b5968d3b6EXAMPLE
```
Saída:
```
{
"Route": {
"DestinationCidrBlock": "10.0.2.0/24",
"TransitGatewayAttachments": [
{
"ResourceId": "vpc-0065acced4EXAMPLE",
"TransitGatewayAttachmentId": "tgw-attach-0b5968d3b6EXAMPLE",
"ResourceType": "vpc"
}
],
"Type": "static",
"State": "active"
}
}
```
Para obter mais informações, consulte [Tabelas de rota do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [CreateTransitGatewayRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-route.html)em *Referência de AWS CLI Comandos*.
### `create-transit-gateway-vpc-attachment`
O código de exemplo a seguir mostra como usar `create-transit-gateway-vpc-attachment`.
**AWS CLI**
**Exemplo 1: associar um gateway de trânsito a uma VPC**
O exemplo `create-transit-gateway-vpc-attachment` a seguir cria um anexo do gateway de trânsito à VPC especificada.
```
aws ec2 create-transit-gateway-vpc-attachment \
--transit-gateway-id tgw-0262a0e521EXAMPLE \
--vpc-id vpc-07e8ffd50f49335df \
--subnet-id subnet-0752213d59EXAMPLE
```
Saída:
```
{
"TransitGatewayVpcAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-0a34fe6b4fEXAMPLE",
"TransitGatewayId": "tgw-0262a0e521EXAMPLE",
"VpcId": "vpc-07e8ffd50fEXAMPLE",
"VpcOwnerId": "111122223333",
"State": "pending",
"SubnetIds": [
"subnet-0752213d59EXAMPLE"
],
"CreationTime": "2019-07-10T17:33:46.000Z",
"Options": {
"DnsSupport": "enable",
"Ipv6Support": "disable"
}
}
}
```
Para obter mais informações, consulte [Criar um anexo do gateway de trânsito para uma VPC](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html#create-vpc-attachment) no *Guia do gateway de trânsito*.
**Exemplo 2: associar um gateway de trânsito a várias sub-redes em uma VPC**
O exemplo `create-transit-gateway-vpc-attachment` a seguir cria um anexo do gateway de trânsito à VPC e às sub-redes especificadas.
```
aws ec2 create-transit-gateway-vpc-attachment \
--transit-gateway-id tgw-02f776b1a7EXAMPLE \
--vpc-id vpc-3EXAMPLE \
--subnet-ids "subnet-dEXAMPLE" "subnet-6EXAMPLE"
```
Saída:
```
{
"TransitGatewayVpcAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-0e141e0bebEXAMPLE",
"TransitGatewayId": "tgw-02f776b1a7EXAMPLE",
"VpcId": "vpc-3EXAMPLE",
"VpcOwnerId": "111122223333",
"State": "pending",
"SubnetIds": [
"subnet-6EXAMPLE",
"subnet-dEXAMPLE"
],
"CreationTime": "2019-12-17T20:07:52.000Z",
"Options": {
"DnsSupport": "enable",
"Ipv6Support": "disable"
}
}
}
```
Para obter mais informações, consulte [Criar um anexo do gateway de trânsito para uma VPC](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html#create-vpc-attachment) no *Guia do gateway de trânsito*.
+ Para obter detalhes da API, consulte [CreateTransitGatewayVpcAttachment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-vpc-attachment.html)em *Referência de AWS CLI Comandos*.
### `create-transit-gateway`
O código de exemplo a seguir mostra como usar `create-transit-gateway`.
**AWS CLI**
**Criar um gateway de trânsito**
O exemplo `create-transit-gateway` a seguir cria um gateway de trânsito.
```
aws ec2 create-transit-gateway \
--description MyTGW \
--options AmazonSideAsn=64516,AutoAcceptSharedAttachments=enable,DefaultRouteTableAssociation=enable,DefaultRouteTablePropagation=enable,VpnEcmpSupport=enable,DnsSupport=enable
```
Saída:
```
{
"TransitGateway": {
"TransitGatewayId": "tgw-0262a0e521EXAMPLE",
"TransitGatewayArn": "arn:aws:ec2:us-east-2:111122223333:transit-gateway/tgw-0262a0e521EXAMPLE",
"State": "pending",
"OwnerId": "111122223333",
"Description": "MyTGW",
"CreationTime": "2019-07-10T14:02:12.000Z",
"Options": {
"AmazonSideAsn": 64516,
"AutoAcceptSharedAttachments": "enable",
"DefaultRouteTableAssociation": "enable",
"AssociationDefaultRouteTableId": "tgw-rtb-018774adf3EXAMPLE",
"DefaultRouteTablePropagation": "enable",
"PropagationDefaultRouteTableId": "tgw-rtb-018774adf3EXAMPLE",
"VpnEcmpSupport": "enable",
"DnsSupport": "enable"
}
}
}
```
Para obter mais informações, consulte [Criar um gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-transit-gateways.html#create-tgw) no *Guia de gateway de trânsito*.
+ Para obter detalhes da API, consulte [CreateTransitGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway.html)em *Referência de AWS CLI Comandos*.
### `create-verified-access-endpoint`
O código de exemplo a seguir mostra como usar `create-verified-access-endpoint`.
**AWS CLI**
**Criar um endpoint do acesso verificado**
O exemplo `create-verified-access-endpoint` a seguir cria um endpoint de acesso verificado para o grupo de acesso verificado especificado. A interface de rede e o grupo de segurança especificados devem pertencem à mesma VPC.
```
aws ec2 create-verified-access-endpoint \
--verified-access-group-id vagr-0dbe967baf14b7235 \
--endpoint-type network-interface \
--attachment-type vpc \
--domain-certificate-arn arn:aws:acm:us-east-2:123456789012:certificate/eb065ea0-26f9-4e75-a6ce-0a1a7EXAMPLE \
--application-domain example.com \
--endpoint-domain-prefix my-ava-app \
--security-group-ids sg-004915970c4c8f13a \
--network-interface-options NetworkInterfaceId=eni-0aec70418c8d87a0f,Protocol=https,Port=443 \
--tag-specifications ResourceType=verified-access-endpoint,Tags=[{Key=Name,Value=my-va-endpoint}]
```
Saída:
```
{
"VerifiedAccessEndpoint": {
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"VerifiedAccessGroupId": "vagr-0dbe967baf14b7235",
"VerifiedAccessEndpointId": "vae-066fac616d4d546f2",
"ApplicationDomain": "example.com",
"EndpointType": "network-interface",
"AttachmentType": "vpc",
"DomainCertificateArn": "arn:aws:acm:us-east-2:123456789012:certificate/eb065ea0-26f9-4e75-a6ce-0a1a7EXAMPLE",
"EndpointDomain": "my-ava-app.edge-00c3372d53b1540bb.vai-0ce000c0b7643abea.prod.verified-access.us-east-2.amazonaws.com",
"SecurityGroupIds": [
"sg-004915970c4c8f13a"
],
"NetworkInterfaceOptions": {
"NetworkInterfaceId": "eni-0aec70418c8d87a0f",
"Protocol": "https",
"Port": 443
},
"Status": {
"Code": "pending"
},
"Description": "",
"CreationTime": "2023-08-25T20:54:43",
"LastUpdatedTime": "2023-08-25T20:54:43",
"Tags": [
{
"Key": "Name",
"Value": "my-va-endpoint"
}
]
}
}
```
Para obter mais informações, consulte [Endpoints de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-endpoints.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [CreateVerifiedAccessEndpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-verified-access-endpoint.html)em *Referência de AWS CLI Comandos*.
### `create-verified-access-group`
O código de exemplo a seguir mostra como usar `create-verified-access-group`.
**AWS CLI**
**Criar um grupo do acesso verificado**
O exemplo `create-verified-access-group` a seguir cria um grupo de acesso verificado para a instância especificada do acesso verificado.
```
aws ec2 create-verified-access-group \
--verified-access-instance-id vai-0ce000c0b7643abea \
--tag-specifications ResourceType=verified-access-group,Tags=[{Key=Name,Value=my-va-group}]
```
Saída:
```
{
"VerifiedAccessGroup": {
"VerifiedAccessGroupId": "vagr-0dbe967baf14b7235",
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"Description": "",
"Owner": "123456789012",
"VerifiedAccessGroupArn": "arn:aws:ec2:us-east-2:123456789012:verified-access-group/vagr-0dbe967baf14b7235",
"CreationTime": "2023-08-25T19:55:19",
"LastUpdatedTime": "2023-08-25T19:55:19",
"Tags": [
{
"Key": "Name",
"Value": "my-va-group"
}
]
}
}
```
Para obter mais informações, consulte [Grupos de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-groups.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [CreateVerifiedAccessGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-verified-access-group.html)em *Referência de AWS CLI Comandos*.
### `create-verified-access-instance`
O código de exemplo a seguir mostra como usar `create-verified-access-instance`.
**AWS CLI**
**Criar uma instância do acesso verificado**
O exemplo `create-verified-access-instance` a seguir cria uma instância de acesso verificado com uma tag de Nome.
```
aws ec2 create-verified-access-instance \
--tag-specifications ResourceType=verified-access-instance,Tags=[{Key=Name,Value=my-va-instance}]
```
Saída:
```
{
"VerifiedAccessInstance": {
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"Description": "",
"VerifiedAccessTrustProviders": [],
"CreationTime": "2023-08-25T18:27:56",
"LastUpdatedTime": "2023-08-25T18:27:56",
"Tags": [
{
"Key": "Name",
"Value": "my-va-instance"
}
]
}
}
```
Para obter mais informações, consulte [Instâncias de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-instances.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [CreateVerifiedAccessInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-verified-access-instance.html)em *Referência de AWS CLI Comandos*.
### `create-verified-access-trust-provider`
O código de exemplo a seguir mostra como usar `create-verified-access-trust-provider`.
**AWS CLI**
**Criar um provedor confiável de acesso verificado**
O `create-verified-access-trust-provider` exemplo a seguir configura um provedor confiável de acesso verificado usando o AWS Identity Center.
```
aws ec2 create-verified-access-trust-provider \
--trust-provider-type user \
--user-trust-provider-type iam-identity-center \
--policy-reference-name idc \
--tag-specifications ResourceType=verified-access-trust-provider,Tags=[{Key=Name,Value=my-va-trust-provider}]
```
Saída:
```
{
"VerifiedAccessTrustProvider": {
"VerifiedAccessTrustProviderId": "vatp-0bb32de759a3e19e7",
"Description": "",
"TrustProviderType": "user",
"UserTrustProviderType": "iam-identity-center",
"PolicyReferenceName": "idc",
"CreationTime": "2023-08-25T18:40:36",
"LastUpdatedTime": "2023-08-25T18:40:36",
"Tags": [
{
"Key": "Name",
"Value": "my-va-trust-provider"
}
]
}
}
```
Para obter mais informações, consulte [Provedores confiáveis para acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/trust-providers.html) no *Guia do usuário de acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [CreateVerifiedAccessTrustProvider](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-verified-access-trust-provider.html)em *Referência de AWS CLI Comandos*.
### `create-volume`
O código de exemplo a seguir mostra como usar `create-volume`.
**AWS CLI**
**Criar um volume SSD de uso geral (gp2) vazio**
O exemplo `create-volume` a seguir cria um volume SSD de uso geral (gp2) de 80 GiB na zona de disponibilidade especificada. Observe que a região atual deve ser `us-east-1`, ou você pode adicionar o parâmetro `--region` para especificar a região para o comando.
```
aws ec2 create-volume \
--volume-type gp2 \
--size 80 \
--availability-zone us-east-1a
```
Saída:
```
{
"AvailabilityZone": "us-east-1a",
"Tags": [],
"Encrypted": false,
"VolumeType": "gp2",
"VolumeId": "vol-1234567890abcdef0",
"State": "creating",
"Iops": 240,
"SnapshotId": "",
"CreateTime": "YYYY-MM-DDTHH:MM:SS.000Z",
"Size": 80
}
```
Se você não especificar um tipo de volume, o tipo de volume padrão será `gp2`.
```
aws ec2 create-volume \
--size 80 \
--availability-zone us-east-1a
```
**Exemplo 2: criar um volume SSD (io1) de IOPS provisionadas de um snapshot**
O exemplo `create-volume` a seguir cria um volume SSD de IOPS provisionadas (io1) com 1.000 IOPS provisionadas na Zona de Disponibilidade especificada usando o snapshot especificado.
```
aws ec2 create-volume \
--volume-type io1 \
--iops 1000 \
--snapshot-id snap-066877671789bd71b \
--availability-zone us-east-1a
```
Saída:
```
{
"AvailabilityZone": "us-east-1a",
"Tags": [],
"Encrypted": false,
"VolumeType": "io1",
"VolumeId": "vol-1234567890abcdef0",
"State": "creating",
"Iops": 1000,
"SnapshotId": "snap-066877671789bd71b",
"CreateTime": "YYYY-MM-DDTHH:MM:SS.000Z",
"Size": 500
}
```
**Exemplo 3: criar um volume criptografado**
O exemplo `create-volume` a seguir cria um volume criptografado usando a CMK padrão para criptografia do EBS. Se a criptografia por padrão estiver desabilitada, você deve especificar o parâmetro `--encrypted` da seguinte maneira.
```
aws ec2 create-volume \
--size 80 \
--encrypted \
--availability-zone us-east-1a
```
Saída:
```
{
"AvailabilityZone": "us-east-1a",
"Tags": [],
"Encrypted": true,
"VolumeType": "gp2",
"VolumeId": "vol-1234567890abcdef0",
"State": "creating",
"Iops": 240,
"SnapshotId": "",
"CreateTime": "YYYY-MM-DDTHH:MM:SS.000Z",
"Size": 80
}
```
Se a criptografia estiver habilitada por padrão, o comando de exemplo a seguir criará um volume criptografado, mesmo sem o parâmetro `--encrypted`.
```
aws ec2 create-volume \
--size 80 \
--availability-zone us-east-1a
```
Se você usar o parâmetro `--kms-key-id` para especificar uma CMK gerenciada pelo cliente, você deverá especificar o parâmetro `--encrypted` mesmo que a criptografia por padrão esteja habilitada.
```
aws ec2 create-volume \
--volume-type gp2 \
--size 80 \
--encrypted \
--kms-key-id 0ea3fef3-80a7-4778-9d8c-1c0c6EXAMPLE \
--availability-zone us-east-1a
```
**Exemplo 4: criar um volume com tags**
O exemplo `create-volume` a seguir cria um volume e adiciona duas tags.
```
aws ec2 create-volume \
--availability-zone us-east-1a \
--volume-type gp2 \
--size 80 \
--tag-specifications 'ResourceType=volume,Tags=[{Key=purpose,Value=production},{Key=cost-center,Value=cc123}]'
```
+ Para obter detalhes da API, consulte [CreateVolume](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-volume.html)em *Referência de AWS CLI Comandos*.
### `create-vpc-endpoint-connection-notification`
O código de exemplo a seguir mostra como usar `create-vpc-endpoint-connection-notification`.
**AWS CLI**
**Criar uma notificação de conexão endpoint**
Este exemplo cria uma notificação para um serviço de endpoint específico que alerta você quando os endpoints da interface se conectam ao seu serviço e quando os endpoints são aceitos para o seu serviço.
Comando:
```
aws ec2 create-vpc-endpoint-connection-notification --connection-notification-arn arn:aws:sns:us-east-2:123456789012:VpceNotification --connection-events Connect Accept --service-id vpce-svc-1237881c0d25a3abc
```
Saída:
```
{
"ConnectionNotification": {
"ConnectionNotificationState": "Enabled",
"ConnectionNotificationType": "Topic",
"ServiceId": "vpce-svc-1237881c0d25a3abc",
"ConnectionEvents": [
"Accept",
"Connect"
],
"ConnectionNotificationId": "vpce-nfn-008776de7e03f5abc",
"ConnectionNotificationArn": "arn:aws:sns:us-east-2:123456789012:VpceNotification"
}
}
```
+ Para obter detalhes da API, consulte [CreateVpcEndpointConnectionNotification](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint-connection-notification.html)em *Referência de AWS CLI Comandos*.
### `create-vpc-endpoint-service-configuration`
O código de exemplo a seguir mostra como usar `create-vpc-endpoint-service-configuration`.
**AWS CLI**
**Exemplo 1: criar uma configuração de serviço de endpoint para um endpoint de interface**
O exemplo `create-vpc-endpoint-service-configuration` a seguir cria uma configuração de serviço de endpoint da VPC usando o Network Load Balancer `nlb-vpce`. Esse exemplo também especifica que as solicitações para se conectar ao serviço por meio de um endpoint de interface devem ser aceitas.
```
aws ec2 create-vpc-endpoint-service-configuration \
--network-load-balancer-arns arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/net/nlb-vpce/e94221227f1ba532 \
--acceptance-required
```
Saída:
```
{
"ServiceConfiguration": {
"ServiceType": [
{
"ServiceType": "Interface"
}
],
"NetworkLoadBalancerArns": [
"arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/net/nlb-vpce/e94221227f1ba532"
],
"ServiceName": "com.amazonaws.vpce.us-east-1.vpce-svc-03d5ebb7d9579a2b3",
"ServiceState": "Available",
"ServiceId": "vpce-svc-03d5ebb7d9579a2b3",
"AcceptanceRequired": true,
"AvailabilityZones": [
"us-east-1d"
],
"BaseEndpointDnsNames": [
"vpce-svc-03d5ebb7d9579a2b3.us-east-1.vpce.amazonaws.com"
]
}
}
```
Para obter mais informações, consulte [Criar um serviço de endpoint](https://docs.aws.amazon.com/vpc/latest/privatelink/create-endpoint-service.html) no *Guia do AWS PrivateLink usuário*.
**Exemplo 2: criar uma configuração de serviço de endpoint para endpoints do balanceador de carga de gateway**
O exemplo `create-vpc-endpoint-service-configuration` a seguir cria uma configuração de serviço de endpoint da VPC usando o Balanceador de Carga de Gateway `GWLBService`. Solicitações para se conectar ao serviço por meio de um endpoint do Balanceador de Carga de Gateway são aceitas automaticamente.
```
aws ec2 create-vpc-endpoint-service-configuration \
--gateway-load-balancer-arns arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/gwy/GWLBService/123123123123abcc \
--no-acceptance-required
```
Saída:
```
{
"ServiceConfiguration": {
"ServiceType": [
{
"ServiceType": "GatewayLoadBalancer"
}
],
"ServiceId": "vpce-svc-123123a1c43abc123",
"ServiceName": "com.amazonaws.vpce.us-east-1.vpce-svc-123123a1c43abc123",
"ServiceState": "Available",
"AvailabilityZones": [
"us-east-1d"
],
"AcceptanceRequired": false,
"ManagesVpcEndpoints": false,
"GatewayLoadBalancerArns": [
"arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/gwy/GWLBService/123123123123abcc"
]
}
}
```
*Para obter mais informações, consulte [Criar um serviço de endpoint do Gateway Load Balancer no Guia](https://docs.aws.amazon.com/vpc/latest/privatelink/create-gateway-load-balancer-endpoint-service.html) do AWS PrivateLink usuário.*
+ Para obter detalhes da API, consulte [CreateVpcEndpointServiceConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint-service-configuration.html)em *Referência de AWS CLI Comandos*.
### `create-vpc-endpoint`
O código de exemplo a seguir mostra como usar `create-vpc-endpoint`.
**AWS CLI**
**Exemplo 1: criar um endpoint de gateway**
O exemplo `create-vpc-endpoint` a seguir cria um endpoint da VPC de gateway entre a VPC `vpc-1a2b3c4d` e o Amazon S3 na região `us-east-1` e associa a tabela de rotas `rtb-11aa22bb` ao endpoint.
```
aws ec2 create-vpc-endpoint \
--vpc-id vpc-1a2b3c4d \
--service-name com.amazonaws.us-east-1.s3 \
--route-table-ids rtb-11aa22bb
```
Saída:
```
{
"VpcEndpoint": {
"PolicyDocument": "{\"Version\":\"2008-10-17\",\"Statement\":[{\"Sid\":\"\",\"Effect\":\"Allow\",\"Principal\":\"\*\",\"Action\":\"\*\",\"Resource\":\"\*\"}]}",
"VpcId": "vpc-1a2b3c4d",
"State": "available",
"ServiceName": "com.amazonaws.us-east-1.s3",
"RouteTableIds": [
"rtb-11aa22bb"
],
"VpcEndpointId": "vpc-1a2b3c4d",
"CreationTimestamp": "2015-05-15T09:40:50Z"
}
}
```
Para obter mais informações, consulte [Criar um endpoint de gateway](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-s3.html#create-gateway-endpoint-s3) no *Guia do AWS PrivateLink usuário*.
**Exemplo 2: criar um endpoint de interface**
O exemplo `create-vpc-endpoint` a seguir cria uma interface de endpoint da VPC entre a VPC `vpc-1a2b3c4d` e o Amazon S3 na região `us-east-1`. O comando cria o endpoint na sub-rede `subnet-1a2b3c4d`, o associa ao grupo de segurança `sg-1a2b3c4d` e adiciona uma tag com uma chave de “Serviço” e um valor de “S3".
```
aws ec2 create-vpc-endpoint \
--vpc-id vpc-1a2b3c4d \
--vpc-endpoint-type Interface \
--service-name com.amazonaws.us-east-1.s3 \
--subnet-ids subnet-7b16de0c \
--security-group-id sg-1a2b3c4d \
--tag-specifications ResourceType=vpc-endpoint,Tags=[{Key=service,Value=S3}]
```
Saída:
```
{
"VpcEndpoint": {
"VpcEndpointId": "vpce-1a2b3c4d5e6f1a2b3",
"VpcEndpointType": "Interface",
"VpcId": "vpc-1a2b3c4d",
"ServiceName": "com.amazonaws.us-east-1.s3",
"State": "pending",
"RouteTableIds": [],
"SubnetIds": [
"subnet-1a2b3c4d"
],
"Groups": [
{
"GroupId": "sg-1a2b3c4d",
"GroupName": "default"
}
],
"PrivateDnsEnabled": false,
"RequesterManaged": false,
"NetworkInterfaceIds": [
"eni-0b16f0581c8ac6877"
],
"DnsEntries": [
{
"DnsName": "*.vpce-1a2b3c4d5e6f1a2b3-9hnenorg.s3.us-east-1.vpce.amazonaws.com",
"HostedZoneId": "Z7HUB22UULQXV"
},
{
"DnsName": "*.vpce-1a2b3c4d5e6f1a2b3-9hnenorg-us-east-1c.s3.us-east-1.vpce.amazonaws.com",
"HostedZoneId": "Z7HUB22UULQXV"
}
],
"CreationTimestamp": "2021-03-05T14:46:16.030000+00:00",
"Tags": [
{
"Key": "service",
"Value": "S3"
}
],
"OwnerId": "123456789012"
}
}
```
*Para obter mais informações, consulte [Criar uma interface VPC endpoint](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html) no Guia do AWS PrivateLink usuário.*
**Exemplo 3: criar um endpoint do balanceador de carga de gateway**
O exemplo `create-vpc-endpoint` a seguir cria um endpoint do balanceador de carga de Gateway entre a VPC `vpc-111122223333aabbc` e um serviço configurado usando o balanceador de carga de Gateway.
```
aws ec2 create-vpc-endpoint \
--service-name com.amazonaws.vpce.us-east-1.vpce-svc-123123a1c43abc123 \
--vpc-endpoint-type GatewayLoadBalancer \
--vpc-id vpc-111122223333aabbc \
--subnet-ids subnet-0011aabbcc2233445
```
Saída:
```
{
"VpcEndpoint": {
"VpcEndpointId": "vpce-aabbaabbaabbaabba",
"VpcEndpointType": "GatewayLoadBalancer",
"VpcId": "vpc-111122223333aabbc",
"ServiceName": "com.amazonaws.vpce.us-east-1.vpce-svc-123123a1c43abc123",
"State": "pending",
"SubnetIds": [
"subnet-0011aabbcc2233445"
],
"RequesterManaged": false,
"NetworkInterfaceIds": [
"eni-01010120203030405"
],
"CreationTimestamp": "2020-11-11T08:06:03.522Z",
"OwnerId": "123456789012"
}
}
```
*Para obter mais informações, consulte os [endpoints do Gateway Load Balancer no Guia](https://docs.aws.amazon.com/vpc/latest/privatelink/gateway-load-balancer-endpoints.html) do AWS PrivateLink usuário.*
**Exemplo 4: como criar um endpoint de recurso**
O exemplo de `create-vpc-endpoint` a seguir cria um endpoint de recurso.
```
aws ec2 create-vpc-endpoint \
--vpc-endpoint-type Resource \
--vpc-id vpc-111122223333aabbc \
--subnet-ids subnet-0011aabbcc2233445 \
--resource-configuration-arn arn:aws:vpc-lattice-us-east-1:123456789012:resourceconfiguration/rcfg-0123abcde98765432
```
Saída:
```
{
"VpcEndpoint": {
"VpcEndpointId": "vpce-00939a7ed9EXAMPLE",
"VpcEndpointType": "Resource",
"VpcId": "vpc-111122223333aabbc",
"State": "Pending",
"SubnetIds": [
"subnet-0011aabbcc2233445"
],
"Groups": [
{
"GroupId": "sg-03e2f15fbfc09b000",
"GroupName": "default"
}
],
"IpAddressType": "IPV4",
"PrivateDnsEnabled": false,
"CreationTimestamp": "2025-02-06T23:38:49.525000+00:00",
"Tags": [],
"OwnerId": "123456789012",
"ResourceConfigurationArn": "arn:aws:vpc-lattice:us-east-1:123456789012:resourceconfiguration/rcfg-0123abcde98765432"
}
}
```
Para obter mais informações, consulte [Endpoints de recursos](https://docs.aws.amazon.com/vpc/latest/privatelink/privatelink-access-resources.html) no *Guia do AWS PrivateLink usuário*.
**Exemplo 5: como criar um endpoint de rede de serviço**
O exemplo de `create-vpc-endpoint` a seguir cria um endpoint de rede de serviço.
```
aws ec2 create-vpc-endpoint \
--vpc-endpoint-type ServiceNetwork \
--vpc-id vpc-111122223333aabbc \
--subnet-ids subnet-0011aabbcc2233445 \
--service-network-arn arn:aws:vpc-lattice:us-east-1:123456789012:servicenetwork/sn-0101abcd5432abcd0 \
--security-group-ids sg-0123456789012abcd
```
Saída:
```
{
"VpcEndpoint": {
"VpcEndpointId": "vpce-0f00567fa8EXAMPLE",
"VpcEndpointType": "ServiceNetwork",
"VpcId": "vpc-111122223333aabbc",
"State": "Pending",
"SubnetIds": [
"subnet-0011aabbcc2233445"
],
"Groups": [
{
"GroupId": "sg-0123456789012abcd",
"GroupName": "my-security-group"
}
],
"IpAddressType": "IPV4",
"PrivateDnsEnabled": false,
"CreationTimestamp": "2025-02-06T23:44:20.449000+00:00",
"Tags": [],
"OwnerId": "123456789012",
"ServiceNetworkArn": "arn:aws:vpc-lattice:us-east-1:123456789012:servicenetwork/sn-0101abcd5432abcd0"
}
}
```
Para obter mais informações, consulte [Endpoints da rede de serviços](https://docs.aws.amazon.com/vpc/latest/privatelink/privatelink-access-service-networks.html) no *Guia do AWS PrivateLink usuário*.
+ Para obter detalhes da API, consulte [CreateVpcEndpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html)em *Referência de AWS CLI Comandos*.
### `create-vpc-peering-connection`
O código de exemplo a seguir mostra como usar `create-vpc-peering-connection`.
**AWS CLI**
**Para criar uma conexão de emparelhamento de VPC entre seus VPCs**
Este exemplo solicita uma conexão de emparelhamento entre seu VPCs vpc-1a2b3c4d e o vpc-11122233.
Comando:
```
aws ec2 create-vpc-peering-connection --vpc-id vpc-1a2b3c4d --peer-vpc-id vpc-11122233
```
Saída:
```
{
"VpcPeeringConnection": {
"Status": {
"Message": "Initiating Request to 444455556666",
"Code": "initiating-request"
},
"Tags": [],
"RequesterVpcInfo": {
"OwnerId": "444455556666",
"VpcId": "vpc-1a2b3c4d",
"CidrBlock": "10.0.0.0/28"
},
"VpcPeeringConnectionId": "pcx-111aaa111",
"ExpirationTime": "2014-04-02T16:13:36.000Z",
"AccepterVpcInfo": {
"OwnerId": "444455556666",
"VpcId": "vpc-11122233"
}
}
}
```
**Criar uma conexão de emparelhamento da VPC com uma VPC em outra conta**
Este exemplo solicita uma conexão de emparelhamento entre sua VPC (vpc-1a2b3c4d) e uma VPC (vpc-11122233) que pertence à conta 123456789012. AWS
Comando:
```
aws ec2 create-vpc-peering-connection --vpc-id vpc-1a2b3c4d --peer-vpc-id vpc-11122233 --peer-owner-id 123456789012
```
**Criar uma conexão de emparelhamento da VPC com uma VPC em uma região diferente**
Este exemplo solicita uma conexão de emparelhamento entre sua VPC na região atual (vpc-1a2b3c4d) e uma VPC (vpc-11122233) em sua conta na região `us-west-2`.
Comando:
```
aws ec2 create-vpc-peering-connection --vpc-id vpc-1a2b3c4d --peer-vpc-id vpc-11122233 --peer-region us-west-2
```
Este exemplo solicita uma conexão de emparelhamento entre sua VPC na região atual (vpc-1a2b3c4d) e uma VPC (vpc-11122233) que pertence à conta 123456789012 que está na região. AWS `us-west-2`
Comando:
```
aws ec2 create-vpc-peering-connection --vpc-id vpc-1a2b3c4d --peer-vpc-id vpc-11122233 --peer-owner-id 123456789012 --peer-region us-west-2
```
+ Para obter detalhes da API, consulte [CreateVpcPeeringConnection](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-peering-connection.html)em *Referência de AWS CLI Comandos*.
### `create-vpc`
O código de exemplo a seguir mostra como usar `create-vpc`.
**AWS CLI**
**Exemplo 1: criar uma VPC**
O `create-vpc` exemplo a seguir cria uma VPC com o bloco IPv4 CIDR especificado e uma tag Name.
```
aws ec2 create-vpc \
--cidr-block 10.0.0.0/16 \
--tag-specifications ResourceType=vpc,Tags=[{Key=Name,Value=MyVpc}]
```
Saída:
```
{
"Vpc": {
"CidrBlock": "10.0.0.0/16",
"DhcpOptionsId": "dopt-5EXAMPLE",
"State": "pending",
"VpcId": "vpc-0a60eb65b4EXAMPLE",
"OwnerId": "123456789012",
"InstanceTenancy": "default",
"Ipv6CidrBlockAssociationSet": [],
"CidrBlockAssociationSet": [
{
"AssociationId": "vpc-cidr-assoc-07501b79ecEXAMPLE",
"CidrBlock": "10.0.0.0/16",
"CidrBlockState": {
"State": "associated"
}
}
],
"IsDefault": false,
"Tags": [
{
"Key": "Name",
"Value": MyVpc"
}
]
}
}
```
**Exemplo 2: para criar uma VPC com locação dedicada**
O `create-vpc` exemplo a seguir cria uma VPC com o bloco IPv4 CIDR especificado e locação dedicada.
```
aws ec2 create-vpc \
--cidr-block 10.0.0.0/16 \
--instance-tenancy dedicated
```
Saída:
```
{
"Vpc": {
"CidrBlock": "10.0.0.0/16",
"DhcpOptionsId": "dopt-19edf471",
"State": "pending",
"VpcId": "vpc-0a53287fa4EXAMPLE",
"OwnerId": "111122223333",
"InstanceTenancy": "dedicated",
"Ipv6CidrBlockAssociationSet": [],
"CidrBlockAssociationSet": [
{
"AssociationId": "vpc-cidr-assoc-00b24cc1c2EXAMPLE",
"CidrBlock": "10.0.0.0/16",
"CidrBlockState": {
"State": "associated"
}
}
],
"IsDefault": false
}
}
```
**Exemplo 3: Para criar uma VPC com um IPv6 bloco CIDR**
O `create-vpc` exemplo a seguir cria uma VPC com um bloco CIDR fornecido pela Amazon IPv6 .
```
aws ec2 create-vpc \
--cidr-block 10.0.0.0/16 \
--amazon-provided-ipv6-cidr-block
```
Saída:
```
{
"Vpc": {
"CidrBlock": "10.0.0.0/16",
"DhcpOptionsId": "dopt-dEXAMPLE",
"State": "pending",
"VpcId": "vpc-0fc5e3406bEXAMPLE",
"OwnerId": "123456789012",
"InstanceTenancy": "default",
"Ipv6CidrBlockAssociationSet": [
{
"AssociationId": "vpc-cidr-assoc-068432c60bEXAMPLE",
"Ipv6CidrBlock": "",
"Ipv6CidrBlockState": {
"State": "associating"
},
"Ipv6Pool": "Amazon",
"NetworkBorderGroup": "us-west-2"
}
],
"CidrBlockAssociationSet": [
{
"AssociationId": "vpc-cidr-assoc-0669f8f9f5EXAMPLE",
"CidrBlock": "10.0.0.0/16",
"CidrBlockState": {
"State": "associated"
}
}
],
"IsDefault": false
}
}
```
**Exemplo 4: criar uma VPC com um CIDR de um grupo do IPAM**
O exemplo `create-vpc` a seguir cria uma VPC com um CIDR de um conjunto do gerenciador de endereços IP (IPAM) da Amazon VPC.
Linux e macOS:
```
aws ec2 create-vpc \
--ipv4-ipam-pool-id ipam-pool-0533048da7d823723 \
--tag-specifications ResourceType=vpc,Tags='[{Key=Environment,Value="Preprod"},{Key=Owner,Value="Build Team"}]'
```
Windows:
```
aws ec2 create-vpc ^
--ipv4-ipam-pool-id ipam-pool-0533048da7d823723 ^
--tag-specifications ResourceType=vpc,Tags=[{Key=Environment,Value="Preprod"},{Key=Owner,Value="Build Team"}]
```
Saída:
```
{
"Vpc": {
"CidrBlock": "10.0.1.0/24",
"DhcpOptionsId": "dopt-2afccf50",
"State": "pending",
"VpcId": "vpc-010e1791024eb0af9",
"OwnerId": "123456789012",
"InstanceTenancy": "default",
"Ipv6CidrBlockAssociationSet": [],
"CidrBlockAssociationSet": [
{
"AssociationId": "vpc-cidr-assoc-0a77de1d803226d4b",
"CidrBlock": "10.0.1.0/24",
"CidrBlockState": {
"State": "associated"
}
}
],
"IsDefault": false,
"Tags": [
{
"Key": "Environment",
"Value": "Preprod"
},
{
"Key": "Owner",
"Value": "Build Team"
}
]
}
}
```
Para obter mais informações, consulte [Criar uma VPC que usa um CIDR de um conjunto do IPAM](https://docs.aws.amazon.com/vpc/latest/ipam/create-vpc-ipam.html) no *Guia do usuário do IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [CreateVpc](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc.html)em *Referência de AWS CLI Comandos*.
### `create-vpn-connection-route`
O código de exemplo a seguir mostra como usar `create-vpn-connection-route`.
**AWS CLI**
**Criar uma rota estática para uma conexão VPN**
Este exemplo cria uma rota estática para a VPN especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 create-vpn-connection-route --vpn-connection-id vpn-40f41529 --destination-cidr-block 11.12.0.0/16
```
+ Para obter detalhes da API, consulte [CreateVpnConnectionRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpn-connection-route.html)em *Referência de AWS CLI Comandos*.
### `create-vpn-connection`
O código de exemplo a seguir mostra como usar `create-vpn-connection`.
**AWS CLI**
**Exemplo 1: criar uma conexão VPN com roteamento dinâmico**
O exemplo `create-vpn-connection` a seguir cria uma conexão VPN entre o gateway privado virtual especificado e o gateway do cliente especificado e aplica tags à conexão VPN. A saída inclui as informações de configuração do dispositivo de gateway do cliente, no formato XML.
```
aws ec2 create-vpn-connection \
--type ipsec.1 \
--customer-gateway-id cgw-001122334455aabbc \
--vpn-gateway-id vgw-1a1a1a1a1a1a2b2b2 \
--tag-specification 'ResourceType=vpn-connection,Tags=[{Key=Name,Value=BGP-VPN}]'
```
Saída:
```
{
"VpnConnection": {
"CustomerGatewayConfiguration": "...configuration information...",
"CustomerGatewayId": "cgw-001122334455aabbc",
"Category": "VPN",
"State": "pending",
"VpnConnectionId": "vpn-123123123123abcab",
"VpnGatewayId": "vgw-1a1a1a1a1a1a2b2b2",
"Options": {
"EnableAcceleration": false,
"StaticRoutesOnly": false,
"LocalIpv4NetworkCidr": "0.0.0.0/0",
"RemoteIpv4NetworkCidr": "0.0.0.0/0",
"TunnelInsideIpVersion": "ipv4",
"TunnelOptions": [
{},
{}
]
},
"Routes": [],
"Tags": [
{
"Key": "Name",
"Value": "BGP-VPN"
}
]
}
}
```
Para obter mais informações, consulte [Como a AWS Site-to-Site VPN funciona](https://docs.aws.amazon.com/vpn/latest/s2svpn/how_it_works.html) no *Guia do usuário da AWS Site-to-Site VPN*.
**Exemplo 2: criar uma conexão VPN com roteamento estático**
O exemplo `create-vpn-connection` a seguir cria uma conexão VPN entre o gateway privado virtual especificado e o gateway do cliente especificado. As opções especificam o roteamento estático. A saída inclui as informações de configuração do dispositivo de gateway do cliente, no formato XML.
```
aws ec2 create-vpn-connection \
--type ipsec.1 \
--customer-gateway-id cgw-001122334455aabbc \
--vpn-gateway-id vgw-1a1a1a1a1a1a2b2b2 \
--options "{\"StaticRoutesOnly\":true}"
```
Saída:
```
{
"VpnConnection": {
"CustomerGatewayConfiguration": "..configuration information...",
"CustomerGatewayId": "cgw-001122334455aabbc",
"Category": "VPN",
"State": "pending",
"VpnConnectionId": "vpn-123123123123abcab",
"VpnGatewayId": "vgw-1a1a1a1a1a1a2b2b2",
"Options": {
"EnableAcceleration": false,
"StaticRoutesOnly": true,
"LocalIpv4NetworkCidr": "0.0.0.0/0",
"RemoteIpv4NetworkCidr": "0.0.0.0/0",
"TunnelInsideIpVersion": "ipv4",
"TunnelOptions": [
{},
{}
]
},
"Routes": [],
"Tags": []
}
}
```
Para obter mais informações, consulte [Como a AWS Site-to-Site VPN funciona](https://docs.aws.amazon.com/vpn/latest/s2svpn/how_it_works.html) no *Guia do usuário da AWS Site-to-Site VPN*.
**Exemplo 3: criar uma conexão VPN e especificar sua própria chave interna CIDR e pré-compartilhada**
O exemplo `create-vpn-connection` a seguir cria uma conexão VPN e especifica o bloco CIDR do endereço IP interno e uma chave personalizada pré-compartilhada para cada túnel. Os valores especificados são retornados nas informações `CustomerGatewayConfiguration`.
```
aws ec2 create-vpn-connection \
--type ipsec.1 \
--customer-gateway-id cgw-001122334455aabbc \
--vpn-gateway-id vgw-1a1a1a1a1a1a2b2b2 \
--options TunnelOptions='[{TunnelInsideCidr=169.254.12.0/30,PreSharedKey=ExamplePreSharedKey1},{TunnelInsideCidr=169.254.13.0/30,PreSharedKey=ExamplePreSharedKey2}]'
```
Saída:
```
{
"VpnConnection": {
"CustomerGatewayConfiguration": "..configuration information...",
"CustomerGatewayId": "cgw-001122334455aabbc",
"Category": "VPN",
"State": "pending",
"VpnConnectionId": "vpn-123123123123abcab",
"VpnGatewayId": "vgw-1a1a1a1a1a1a2b2b2",
"Options": {
"EnableAcceleration": false,
"StaticRoutesOnly": false,
"LocalIpv4NetworkCidr": "0.0.0.0/0",
"RemoteIpv4NetworkCidr": "0.0.0.0/0",
"TunnelInsideIpVersion": "ipv4",
"TunnelOptions": [
{
"OutsideIpAddress": "203.0.113.3",
"TunnelInsideCidr": "169.254.12.0/30",
"PreSharedKey": "ExamplePreSharedKey1"
},
{
"OutsideIpAddress": "203.0.113.5",
"TunnelInsideCidr": "169.254.13.0/30",
"PreSharedKey": "ExamplePreSharedKey2"
}
]
},
"Routes": [],
"Tags": []
}
}
```
Para obter mais informações, consulte [Como a AWS Site-to-Site VPN funciona](https://docs.aws.amazon.com/vpn/latest/s2svpn/how_it_works.html) no *Guia do usuário da AWS Site-to-Site VPN*.
**Exemplo 4: Para criar uma conexão VPN que ofereça suporte ao IPv6 tráfego**
O `create-vpn-connection` exemplo a seguir cria uma conexão VPN que oferece suporte ao IPv6 tráfego entre o gateway de trânsito especificado e o gateway do cliente especificado. As opções de túnel para ambos os túneis especificam que AWS deve iniciar a negociação IKE.
```
aws ec2 create-vpn-connection \
--type ipsec.1 \
--transit-gateway-id tgw-12312312312312312 \
--customer-gateway-id cgw-001122334455aabbc \
--options TunnelInsideIpVersion=ipv6,TunnelOptions=[{StartupAction=start},{StartupAction=start}]
```
Saída:
```
{
"VpnConnection": {
"CustomerGatewayConfiguration": "..configuration information...",
"CustomerGatewayId": "cgw-001122334455aabbc",
"Category": "VPN",
"State": "pending",
"VpnConnectionId": "vpn-11111111122222222",
"TransitGatewayId": "tgw-12312312312312312",
"Options": {
"EnableAcceleration": false,
"StaticRoutesOnly": false,
"LocalIpv6NetworkCidr": "::/0",
"RemoteIpv6NetworkCidr": "::/0",
"TunnelInsideIpVersion": "ipv6",
"TunnelOptions": [
{
"OutsideIpAddress": "203.0.113.3",
"StartupAction": "start"
},
{
"OutsideIpAddress": "203.0.113.5",
"StartupAction": "start"
}
]
},
"Routes": [],
"Tags": []
}
}
```
Para obter mais informações, consulte [Como a AWS Site-to-Site VPN funciona](https://docs.aws.amazon.com/vpn/latest/s2svpn/how_it_works.html) no *Guia do usuário da AWS Site-to-Site VPN*.
+ Para obter detalhes da API, consulte [CreateVpnConnection](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpn-connection.html)em *Referência de AWS CLI Comandos*.
### `create-vpn-gateway`
O código de exemplo a seguir mostra como usar `create-vpn-gateway`.
**AWS CLI**
**Criar um gateway privado virtual**
Este exemplo cria um gateway privado virtual.
Comando:
```
aws ec2 create-vpn-gateway --type ipsec.1
```
Saída:
```
{
"VpnGateway": {
"AmazonSideAsn": 64512,
"State": "available",
"Type": "ipsec.1",
"VpnGatewayId": "vgw-9a4cacf3",
"VpcAttachments": []
}
}
```
**Criar um gateway privado virtual com um ASN específico do lado da Amazon**
Esse exemplo cria um gateway privado virtual e especifica o Número de sistema autônomo (ASN) para o lado da Amazon da sessão BGP.
Comando:
```
aws ec2 create-vpn-gateway --type ipsec.1 --amazon-side-asn 65001
```
Saída:
```
{
"VpnGateway": {
"AmazonSideAsn": 65001,
"State": "available",
"Type": "ipsec.1",
"VpnGatewayId": "vgw-9a4cacf3",
"VpcAttachments": []
}
}
```
+ Para obter detalhes da API, consulte [CreateVpnGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpn-gateway.html)em *Referência de AWS CLI Comandos*.
### `delete-carrier-gateway`
O código de exemplo a seguir mostra como usar `delete-carrier-gateway`.
**AWS CLI**
**Excluir o gateway de operadora**
O exemplo `delete-carrier-gateway` a seguir exclui o gateway de operadora especificado.
```
aws ec2 delete-carrier-gateway \
--carrier-gateway-id cagw-0465cdEXAMPLE1111
```
Saída:
```
{
"CarrierGateway": {
"CarrierGatewayId": "cagw-0465cdEXAMPLE1111",
"VpcId": "vpc-0c529aEXAMPLE1111",
"State": "deleting",
"OwnerId": "123456789012"
}
}
```
Para obter mais informações, consulte [Gateways de operadoras](https://docs.aws.amazon.com/vpc/latest/userguide/Carrier_Gateway.html) no *Guia do usuário da Amazon Virtual Private Cloud*.
+ Para obter detalhes da API, consulte [DeleteCarrierGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-carrier-gateway.html)em *Referência de AWS CLI Comandos*.
### `delete-client-vpn-endpoint`
O código de exemplo a seguir mostra como usar `delete-client-vpn-endpoint`.
**AWS CLI**
**Excluir um endpoint do Client VPN**
O exemplo `delete-client-vpn-endpoint` a seguir exclui o endpoint de Client VPN especificado.
```
aws ec2 delete-client-vpn-endpoint \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde
```
Saída:
```
{
"Status": {
"Code": "deleting"
}
}
```
Para obter mais informações, consulte [Endpoints de Client VPN](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-endpoints.html) no *Guia do administrador do Cliente VPN da AWS *.
+ Para obter detalhes da API, consulte [DeleteClientVpnEndpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-client-vpn-endpoint.html)em *Referência de AWS CLI Comandos*.
### `delete-client-vpn-route`
O código de exemplo a seguir mostra como usar `delete-client-vpn-route`.
**AWS CLI**
**Excluir uma rota para o endpoint do Client VPN**
O exemplo `delete-client-vpn-route` a seguir exclui a rota `0.0.0.0/0` para a sub-rede especificada de um endpoint Client VPN.
```
aws ec2 delete-client-vpn-route \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde \
--destination-cidr-block 0.0.0.0/0 \
--target-vpc-subnet-id subnet-0123456789abcabca
```
Saída:
```
{
"Status": {
"Code": "deleting"
}
}
```
Para obter mais informações, consulte [Rotas](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-routes.html) no *Guia do administrador de cliente VPN da AWS *.
+ Para obter detalhes da API, consulte [DeleteClientVpnRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-client-vpn-route.html)em *Referência de AWS CLI Comandos*.
### `delete-coip-cidr`
O código de exemplo a seguir mostra como usar `delete-coip-cidr`.
**AWS CLI**
**Excluir um intervalo de endereços IP de propriedade do cliente (CoIP)**
O exemplo `delete-coip-cidr` a seguir exclui o intervalo especificado de endereços de CoIP no pool de CoIP especificado.
```
aws ec2 delete-coip-cidr \
--cidr 14.0.0.0/24 \
--coip-pool-id ipv4pool-coip-1234567890abcdefg
```
Saída:
```
{
"CoipCidr": {
"Cidr": "14.0.0.0/24",
"CoipPoolId": "ipv4pool-coip-1234567890abcdefg",
"LocalGatewayRouteTableId": "lgw-rtb-abcdefg1234567890"
}
}
```
Para obter mais informações, consulte [Endereços IP pertencentes ao cliente](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#ip-addressing) no *Guia do usuário do AWS Outposts*.
+ Para obter detalhes da API, consulte [DeleteCoipCidr](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-coip-cidr.html)em *Referência de AWS CLI Comandos*.
### `delete-coip-pool`
O código de exemplo a seguir mostra como usar `delete-coip-pool`.
**AWS CLI**
**Excluir um pool de endereços IP de propriedade do cliente (CoIP)**
O exemplo `delete-coip-pool` a seguir exclui um pool CoIP de endereços CoIP.
```
aws ec2 delete-coip-pool \
--coip-pool-id ipv4pool-coip-1234567890abcdefg
```
Saída:
```
{
"CoipPool": {
"PoolId": "ipv4pool-coip-1234567890abcdefg",
"LocalGatewayRouteTableId": "lgw-rtb-abcdefg1234567890",
"PoolArn": "arn:aws:ec2:us-west-2:123456789012:coip-pool/ipv4pool-coip-1234567890abcdefg"
}
}
```
Para obter mais informações, consulte [Endereços IP pertencentes ao cliente](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#ip-addressing) no *Guia do usuário do AWS Outposts*.
+ Para obter detalhes da API, consulte [DeleteCoipPool](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-coip-pool.html)em *Referência de AWS CLI Comandos*.
### `delete-customer-gateway`
O código de exemplo a seguir mostra como usar `delete-customer-gateway`.
**AWS CLI**
**Excluir um gateway do cliente**
Este exemplo exclui o gateway do cliente especificado. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-customer-gateway --customer-gateway-id cgw-0e11f167
```
+ Para obter detalhes da API, consulte [DeleteCustomerGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-customer-gateway.html)em *Referência de AWS CLI Comandos*.
### `delete-dhcp-options`
O código de exemplo a seguir mostra como usar `delete-dhcp-options`.
**AWS CLI**
**Excluir um conjunto de opções DHCP**
Este exemplo exclui o conjunto de opções DHCP especificado. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-dhcp-options --dhcp-options-id dopt-d9070ebb
```
+ Para obter detalhes da API, consulte [DeleteDhcpOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-dhcp-options.html)em *Referência de AWS CLI Comandos*.
### `delete-egress-only-internet-gateway`
O código de exemplo a seguir mostra como usar `delete-egress-only-internet-gateway`.
**AWS CLI**
**Excluir um Gateway da Internet somente de saída**
Este exemplo exclui o gateway da Internet de somente saída especificado.
Comando:
```
aws ec2 delete-egress-only-internet-gateway --egress-only-internet-gateway-id eigw-01eadbd45ecd7943f
```
Saída:
```
{
"ReturnCode": true
}
```
+ Para obter detalhes da API, consulte [DeleteEgressOnlyInternetGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-egress-only-internet-gateway.html)em *Referência de AWS CLI Comandos*.
### `delete-fleets`
O código de exemplo a seguir mostra como usar `delete-fleets`.
**AWS CLI**
**Exemplo 1: excluir uma frota do EC2 e encerrar as instâncias associadas**
O exemplo `delete-fleets` a seguir cancela a Frota EC2 especificada e encerra as Instâncias Sob Demanda e Instâncias Spot associadas.
```
aws ec2 delete-fleets \
--fleet-ids fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE \
--terminate-instances
```
Saída:
```
{
"SuccessfulFleetDeletions": [
{
"CurrentFleetState": "deleted_terminating",
"PreviousFleetState": "active",
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE"
}
],
"UnsuccessfulFleetDeletions": []
}
```
Para obter mais informações, consulte [Excluir uma Frota EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html#delete-fleet) no *Guia do usuário do Amazon Elastic Compute Cloud para instâncias Linux*.
**Exemplo 2: excluir uma frota EC2 sem encerrar as instâncias associadas**
O exemplo `delete-fleets` a seguir cancela a Frota EC2 especificada sem encerrar as Instâncias Sob Demanda e Instâncias Spot associadas.
```
aws ec2 delete-fleets \
--fleet-ids fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE \
--no-terminate-instances
```
Saída:
```
{
"SuccessfulFleetDeletions": [
{
"CurrentFleetState": "deleted_running",
"PreviousFleetState": "active",
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE"
}
],
"UnsuccessfulFleetDeletions": []
}
```
Para obter mais informações, consulte [Excluir uma Frota EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html#delete-fleet) no *Guia do usuário do Amazon Elastic Compute Cloud para instâncias Linux*.
+ Para obter detalhes da API, consulte [DeleteFleets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-fleets.html)em *Referência de AWS CLI Comandos*.
### `delete-flow-logs`
O código de exemplo a seguir mostra como usar `delete-flow-logs`.
**AWS CLI**
**Excluir um log de fluxo**
O exemplo `delete-flow-logs` a seguir exclui o log de fluxo especificado.
```
aws ec2 delete-flow-logs --flow-log-id fl-11223344556677889
```
Saída:
```
{
"Unsuccessful": []
}
```
+ Para obter detalhes da API, consulte [DeleteFlowLogs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-flow-logs.html)em *Referência de AWS CLI Comandos*.
### `delete-fpga-image`
O código de exemplo a seguir mostra como usar `delete-fpga-image`.
**AWS CLI**
**Excluir uma imagem FPGA da Amazon**
Este exemplo exclui a AFI especificada.
Comando:
```
aws ec2 delete-fpga-image --fpga-image-id afi-06b12350a123fbabc
```
Saída:
```
{
"Return": true
}
```
+ Para obter detalhes da API, consulte [DeleteFpgaImage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-fpga-image.html)em *Referência de AWS CLI Comandos*.
### `delete-instance-connect-endpoint`
O código de exemplo a seguir mostra como usar `delete-instance-connect-endpoint`.
**AWS CLI**
**Excluir um endpoint de conexão de instância EC2**
O exemplo `delete-instance-connect-endpoint` a seguir exclui o endpoint de conexão de instância EC2 especificado.
```
aws ec2 delete-instance-connect-endpoint \
--instance-connect-endpoint-id eice-03f5e49b83924bbc7
```
Saída:
```
{
"InstanceConnectEndpoint": {
"OwnerId": "111111111111",
"InstanceConnectEndpointId": "eice-0123456789example",
"InstanceConnectEndpointArn": "arn:aws:ec2:us-east-1:111111111111:instance-connect-endpoint/eice-0123456789example",
"State": "delete-in-progress",
"StateMessage": "",
"NetworkInterfaceIds": [],
"VpcId": "vpc-0123abcd",
"AvailabilityZone": "us-east-1d",
"CreatedAt": "2023-02-07T12:05:37+00:00",
"SubnetId": "subnet-0123abcd"
}
}
```
Para obter mais informações, consulte [Remover um endpoint de conexão de instância EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/delete-ec2-instance-connect-endpoint.html) no *Guiado usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DeleteInstanceConnectEndpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-instance-connect-endpoint.html)em *Referência de AWS CLI Comandos*.
### `delete-instance-event-window`
O código de exemplo a seguir mostra como usar `delete-instance-event-window`.
**AWS CLI**
**Exemplo 1: excluir uma janela de eventos**
O exemplo `delete-instance-event-window` a seguir exclui uma janela de evento.
```
aws ec2 delete-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890
```
Saída:
```
{
"InstanceEventWindowState": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"State": "deleting"
}
}
```
Para restrições da janela de eventos, consulte [Considerações](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) na seção Eventos Programados do *Guia do usuário do Amazon EC2*.
**Exemplo 2: forçar a exclusão de uma janela de eventos**
O exemplo `delete-instance-event-window` a seguir força a exclusão de uma janela de evento se a janela de evento estiver atualmente associada a destinos.
```
aws ec2 delete-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890 \
--force-delete
```
Saída:
```
{
"InstanceEventWindowState": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"State": "deleting"
}
}
```
Para restrições da janela de eventos, consulte [Considerações](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) na seção Eventos Programados do *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DeleteInstanceEventWindow](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-instance-event-window.html)em *Referência de AWS CLI Comandos*.
### `delete-internet-gateway`
O código de exemplo a seguir mostra como usar `delete-internet-gateway`.
**AWS CLI**
**Excluir um gateway da internet**
O exemplo `delete-internet-gateway` a seguir exclui o gateway da internet especificado.
```
aws ec2 delete-internet-gateway \
--internet-gateway-id igw-0d0fb496b3EXAMPLE
```
Este comando não produz saída.
Para obter mais informações, consulte [Gateways da Internet](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [DeleteInternetGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-internet-gateway.html)em *Referência de AWS CLI Comandos*.
### `delete-ipam-pool`
O código de exemplo a seguir mostra como usar `delete-ipam-pool`.
**AWS CLI**
**Excluir um pool IPAM**
Neste exemplo, você é um administrador delegado de IPAM que deseja excluir um pool de IPAM que não é mais necessário, mas o pool tem um CIDR provisionado para ele. Você não pode excluir um pool se ele tiver sido CIDRs provisionado a ele, a menos que use a `--cascade` opção, então você usará. `--cascade`
Para concluir essa solicitação:
Você precisará do ID do pool IPAM, com o qual você pode obter [describe-ipam-pools](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-ipam-pools.html). `--region` Deve ser a região de origem do IPAM.
O `delete-ipam-pool` exemplo a seguir exclui um pool IPAM em sua AWS conta.
```
aws ec2 delete-ipam-pool \
--ipam-pool-id ipam-pool-050c886a3ca41cd5b \
--cascade \
--region us-east-1
```
Saída:
```
{
"IpamPool": {
"OwnerId": "320805250157",
"IpamPoolId": "ipam-pool-050c886a3ca41cd5b",
"IpamPoolArn": "arn:aws:ec2::320805250157:ipam-pool/ipam-pool-050c886a3ca41cd5b",
"IpamScopeArn": "arn:aws:ec2::320805250157:ipam-scope/ipam-scope-0a158dde35c51107b",
"IpamScopeType": "private",
"IpamArn": "arn:aws:ec2::320805250157:ipam/ipam-005f921c17ebd5107",
"IpamRegion": "us-east-1",
"Locale": "None",
"PoolDepth": 1,
"State": "delete-in-progress",
"Description": "example",
"AutoImport": false,
"AddressFamily": "ipv4",
"AllocationMinNetmaskLength": 0,
"AllocationMaxNetmaskLength": 32
}
}
```
Para obter mais informações, consulte [Excluir um pool](https://docs.aws.amazon.com/vpc/latest/ipam/delete-pool-ipam.html) no *Guia do usuário do IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [DeleteIpamPool](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-ipam-pool.html)em *Referência de AWS CLI Comandos*.
### `delete-ipam-resource-discovery`
O código de exemplo a seguir mostra como usar `delete-ipam-resource-discovery`.
**AWS CLI**
**Excluir uma descoberta de recursos**
Neste exemplo, você é um administrador delegado do IPAM que deseja excluir uma descoberta de recursos não padrão que você criou para compartilhar com outro administrador do IPAM durante o processo de integração do IPAM com contas fora da sua organização.
Para concluir essa solicitação:
`--region` deve ser a região em que você criou a descoberta do recurso. Você não pode excluir uma descoberta de recurso padrão se `"IsDefault": true`. Uma descoberta de recursos padrão é aquela criada automaticamente na conta que cria um IPAM. Para excluir uma descoberta de recursos padrão, você precisa excluir o IPAM.
O exemplo `delete-ipam-resource-discovery` a seguir exclui uma descoberta de recursos.
```
aws ec2 delete-ipam-resource-discovery \
--ipam-resource-discovery-id ipam-res-disco-0e39761475298ee0f \
--region us-east-1
```
Saída:
```
{
"IpamResourceDiscovery": {
"OwnerId": "149977607591",
"IpamResourceDiscoveryId": "ipam-res-disco-0e39761475298ee0f",
"IpamResourceDiscoveryArn": "arn:aws:ec2::149977607591:ipam-resource-discovery/ipam-res-disco-0e39761475298ee0f",
"IpamResourceDiscoveryRegion": "us-east-1",
"OperatingRegions": [
{
"RegionName": "us-east-1"
}
],
"IsDefault": false,
"State": "delete-in-progress"
}
}
```
Para obter mais informações sobre as descobertas de recursos, consulte [Trabalhar com descobertas de recurso](https://docs.aws.amazon.com/vpc/latest/ipam/res-disc-work-with.html) no *Guia do usuário da Amazon VPC IPAM*.
+ Para obter detalhes da API, consulte [DeleteIpamResourceDiscovery](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-ipam-resource-discovery.html)em *Referência de AWS CLI Comandos*.
### `delete-ipam-scope`
O código de exemplo a seguir mostra como usar `delete-ipam-scope`.
**AWS CLI**
**Excluir um escopo do IPAM**
O exemplo `delete-ipam-scope` a seguir exclui um IPAM.
```
aws ec2 delete-ipam-scope \
--ipam-scope-id ipam-scope-01c1ebab2b63bd7e4
```
Saída:
```
{
"IpamScope": {
"OwnerId": "123456789012",
"IpamScopeId": "ipam-scope-01c1ebab2b63bd7e4",
"IpamScopeArn": "arn:aws:ec2::123456789012:ipam-scope/ipam-scope-01c1ebab2b63bd7e4",
"IpamArn": "arn:aws:ec2::123456789012:ipam/ipam-08440e7a3acde3908",
"IpamRegion": "us-east-1",
"IpamScopeType": "private",
"IsDefault": false,
"Description": "Example description",
"PoolCount": 0,
"State": "delete-in-progress"
}
}
```
Para obter mais informações, consulte [Excluir um escopo](https://docs.aws.amazon.com/vpc/latest/ipam/delete-scope-ipam.html) no *Guia do usuário do IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [DeleteIpamScope](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-ipam-scope.html)em *Referência de AWS CLI Comandos*.
### `delete-ipam`
O código de exemplo a seguir mostra como usar `delete-ipam`.
**AWS CLI**
**Excluir um IPAM**
O exemplo `delete-ipam` a seguir exclui um IPAM.
```
aws ec2 delete-ipam \
--ipam-id ipam-036486dfa6af58ee0
```
Saída:
```
{
"Ipam": {
"OwnerId": "123456789012",
"IpamId": "ipam-036486dfa6af58ee0",
"IpamArn": "arn:aws:ec2::123456789012:ipam/ipam-036486dfa6af58ee0",
"IpamRegion": "us-east-1",
"PublicDefaultScopeId": "ipam-scope-071b8042b0195c183",
"PrivateDefaultScopeId": "ipam-scope-0807405dece705a30",
"ScopeCount": 2,
"OperatingRegions": [
{
"RegionName": "us-east-1"
},
{
"RegionName": "us-east-2"
},
{
"RegionName": "us-west-1"
}
],
"State": "delete-in-progress"
}
}
```
Para obter mais informações, consulte [Excluir um IPAM](https://docs.aws.amazon.com/vpc/latest/ipam/delete-ipam.html) no *Guia do usuário do IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [DeleteIpam](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-ipam.html)em *Referência de AWS CLI Comandos*.
### `delete-key-pair`
O código de exemplo a seguir mostra como usar `delete-key-pair`.
**AWS CLI**
**Para excluir um par de chaves**
O exemplo `delete-key-pair` a seguir exclui o par de chaves especificado.
```
aws ec2 delete-key-pair \
--key-name my-key-pair
```
Saída:
```
{
"Return": true,
"KeyPairId": "key-03c8d3aceb53b507"
}
```
Para obter mais informações, consulte [Criar e excluir pares de chaves](https://docs.aws.amazon.com/cli/latest/userguide/cli-ec2-keypairs.html) no *Guia do usuário da interface da linha de comando AWS *.
+ Para obter detalhes da API, consulte [DeleteKeyPair](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-key-pair.html)em *Referência de AWS CLI Comandos*.
### `delete-launch-template-versions`
O código de exemplo a seguir mostra como usar `delete-launch-template-versions`.
**AWS CLI**
**Excluir uma versão de modelo de inicialização**
Este exemplo exclui a versão do modelo de lançamento especificado.
Comando:
```
aws ec2 delete-launch-template-versions --launch-template-id lt-0abcd290751193123 --versions 1
```
Saída:
```
{
"UnsuccessfullyDeletedLaunchTemplateVersions": [],
"SuccessfullyDeletedLaunchTemplateVersions": [
{
"LaunchTemplateName": "TestVersion",
"VersionNumber": 1,
"LaunchTemplateId": "lt-0abcd290751193123"
}
]
}
```
+ Para obter detalhes da API, consulte [DeleteLaunchTemplateVersions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-launch-template-versions.html)em *Referência de AWS CLI Comandos*.
### `delete-launch-template`
O código de exemplo a seguir mostra como usar `delete-launch-template`.
**AWS CLI**
**Para excluir um modelo de execução**
Este exemplo exclui o modelo de execução especificado.
Comando:
```
aws ec2 delete-launch-template --launch-template-id lt-0abcd290751193123
```
Saída:
```
{
"LaunchTemplate": {
"LatestVersionNumber": 2,
"LaunchTemplateId": "lt-0abcd290751193123",
"LaunchTemplateName": "TestTemplate",
"DefaultVersionNumber": 2,
"CreatedBy": "arn:aws:iam::123456789012:root",
"CreateTime": "2017-11-23T16:46:25.000Z"
}
}
```
+ Para obter detalhes da API, consulte [DeleteLaunchTemplate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-launch-template.html)em *Referência de AWS CLI Comandos*.
### `delete-local-gateway-route-table-virtual-interface-group-association`
O código de exemplo a seguir mostra como usar `delete-local-gateway-route-table-virtual-interface-group-association`.
**AWS CLI**
**Para desassociar uma tabela de rotas de gateway local de um grupo de interfaces virtuais (VIFs)**
O exemplo `delete-local-gateway-route-table-virtual-interface-group-association` a seguir exclui a associação entre a tabela de rotas do gateway local especificada e o grupo VIF.
```
aws ec2 delete-local-gateway-route-table-virtual-interface-group-association \
--local-gateway-route-table-virtual-interface-group-association-id lgw-vif-grp-assoc-exampleid12345678
```
Saída:
```
{
"LocalGatewayRouteTableVirtualInterfaceGroupAssociation": {
"LocalGatewayRouteTableVirtualInterfaceGroupAssociationId": "lgw-vif-grp-assoc-exampleid12345678",
"LocalGatewayVirtualInterfaceGroupId": "lgw-vif-grp-exampleid0123abcd",
"LocalGatewayId": "lgw-exampleid11223344",
"LocalGatewayRouteTableId": "lgw-rtb-exampleidabcd1234",
"LocalGatewayRouteTableArn": "arn:aws:ec2:us-west-2:111122223333:local-gateway-route-table/lgw-rtb-exampleidabcd1234",
"OwnerId": "111122223333",
"State": "disassociating",
"Tags": []
}
}
```
Para obter mais informações, consulte [Associações de grupo VIF](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#vif-group-associations) no *Guia do usuário do AWS Outposts*.
+ Para obter detalhes da API, consulte [DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-local-gateway-route-table-virtual-interface-group-association.html)em *Referência de AWS CLI Comandos*.
### `delete-local-gateway-route-table-vpc-association`
O código de exemplo a seguir mostra como usar `delete-local-gateway-route-table-vpc-association`.
**AWS CLI**
**Desassociar a tabela de rotas de um gateway local de uma VPC**
O exemplo `delete-local-gateway-route-table-vpc-association` a seguir exclui a associação entre a tabela de rotas do gateway local especificada e a VPC.
```
aws ec2 delete-local-gateway-route-table-vpc-association \
--local-gateway-route-table-vpc-association-id vpc-example0123456789
```
Saída:
```
{
"LocalGatewayRouteTableVpcAssociation": {
"LocalGatewayRouteTableVpcAssociationId": "lgw-vpc-assoc-abcd1234wxyz56789",
"LocalGatewayRouteTableId": "lgw-rtb-abcdefg1234567890",
"LocalGatewayRouteTableArn": "arn:aws:ec2:us-west-2:555555555555:local-gateway-route-table/lgw-rtb-abcdefg1234567890",
"LocalGatewayId": "lgw-exampleid01234567",
"VpcId": "vpc-example0123456789",
"OwnerId": "555555555555",
"State": "disassociating"
}
}
```
Para obter mais informações, consulte [Associações de VPC](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#vpc-associations) no *Guia do usuário do AWS Outposts*.
+ Para obter detalhes da API, consulte [DeleteLocalGatewayRouteTableVpcAssociation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-local-gateway-route-table-vpc-association.html)em *Referência de AWS CLI Comandos*.
### `delete-local-gateway-route-table`
O código de exemplo a seguir mostra como usar `delete-local-gateway-route-table`.
**AWS CLI**
**Excluir uma rota da tabela de rotas de gateway local**
O exemplo `delete-local-gateway-route-table` a seguir cria uma tabela de rotas de gateway local com o modo de roteamento VPC direto com o modo de roteamento direto da VPC.
```
aws ec2 delete-local-gateway-route-table \
--local-gateway-route-table-id lgw-rtb-abcdefg1234567890
```
Saída:
```
{
"LocalGatewayRouteTable": {
"LocalGatewayRouteTableId": "lgw-rtb-abcdefg1234567890",
"LocalGatewayRouteTableArn": "arn:aws:ec2:us-west-2:111122223333:local-gateway-route-table/lgw-rtb-abcdefg1234567890",
"LocalGatewayId": "lgw-1a2b3c4d5e6f7g8h9",
"OutpostArn": "arn:aws:outposts:us-west-2:111122223333:outpost/op-021345abcdef67890",
"OwnerId": "111122223333",
"State": "deleting",
"Tags": [],
"Mode": "direct-vpc-routing"
}
}
```
Para ter mais informações, consulte [Tabelas de rotas do gateway local](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html) no *AWS Guia do usuário do Outposts*.
+ Para obter detalhes da API, consulte [DeleteLocalGatewayRouteTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-local-gateway-route-table.html)em *Referência de AWS CLI Comandos*.
### `delete-local-gateway-route`
O código de exemplo a seguir mostra como usar `delete-local-gateway-route`.
**AWS CLI**
**Excluir uma rota de uma tabela de rotas de gateway local**
O exemplo `delete-local-gateway-route` a seguir exclui a rota especificada da tabela de rotas do gateway local especificado.
```
aws ec2 delete-local-gateway-route \
--destination-cidr-block 0.0.0.0/0 \
--local-gateway-route-table-id lgw-rtb-059615ef7dEXAMPLE
```
Saída:
```
{
"Route": {
"DestinationCidrBlock": "0.0.0.0/0",
"LocalGatewayVirtualInterfaceGroupId": "lgw-vif-grp-07145b276bEXAMPLE",
"Type": "static",
"State": "deleted",
"LocalGatewayRouteTableId": "lgw-rtb-059615ef7EXAMPLE"
}
}
```
+ Para obter detalhes da API, consulte [DeleteLocalGatewayRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-local-gateway-route.html)em *Referência de AWS CLI Comandos*.
### `delete-managed-prefix-list`
O código de exemplo a seguir mostra como usar `delete-managed-prefix-list`.
**AWS CLI**
**Excluir uma lista de prefixos**
O exemplo `delete-managed-prefix-list` a seguir exclui a lista de prefixos especificada.
```
aws ec2 delete-managed-prefix-list \
--prefix-list-id pl-0123456abcabcabc1
```
Saída:
```
{
"PrefixList": {
"PrefixListId": "pl-0123456abcabcabc1",
"AddressFamily": "IPv4",
"State": "delete-in-progress",
"PrefixListArn": "arn:aws:ec2:us-west-2:123456789012:prefix-list/pl-0123456abcabcabc1",
"PrefixListName": "test",
"MaxEntries": 10,
"Version": 1,
"OwnerId": "123456789012"
}
}
```
Para obter mais informações, consulte [Listas de prefixos gerenciados](https://docs.aws.amazon.com/vpc/latest/userguide/managed-prefix-lists.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [DeleteManagedPrefixList](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-managed-prefix-list.html)em *Referência de AWS CLI Comandos*.
### `delete-nat-gateway`
O código de exemplo a seguir mostra como usar `delete-nat-gateway`.
**AWS CLI**
**Excluir um gateway NAT**
Este exemplo exclui o gateway NAT `nat-04ae55e711cec5680`.
Comando:
```
aws ec2 delete-nat-gateway --nat-gateway-id nat-04ae55e711cec5680
```
Saída:
```
{
"NatGatewayId": "nat-04ae55e711cec5680"
}
```
+ Para obter detalhes da API, consulte [DeleteNatGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-nat-gateway.html)em *Referência de AWS CLI Comandos*.
### `delete-network-acl-entry`
O código de exemplo a seguir mostra como usar `delete-network-acl-entry`.
**AWS CLI**
**Excluir uma entrada de ACL de rede**
Este exemplo exclui a regra de entrada número 100 da ACL de rede especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-network-acl-entry --network-acl-id acl-5fb85d36 --ingress --rule-number 100
```
+ Para obter detalhes da API, consulte [DeleteNetworkAclEntry](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-network-acl-entry.html)em *Referência de AWS CLI Comandos*.
### `delete-network-acl`
O código de exemplo a seguir mostra como usar `delete-network-acl`.
**AWS CLI**
**Excluir uma ACL de rede**
Este exemplo exclui a rede ACL especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-network-acl --network-acl-id acl-5fb85d36
```
+ Para obter detalhes da API, consulte [DeleteNetworkAcl](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-network-acl.html)em *Referência de AWS CLI Comandos*.
### `delete-network-insights-access-scope-analysis`
O código de exemplo a seguir mostra como usar `delete-network-insights-access-scope-analysis`.
**AWS CLI**
**Excluir uma análise do Escopo de Acesso à Rede**
O exemplo `delete-network-insights-access-scope-analysis` a seguir exclui a análise de Escopo de Acesso à Rede especificada.
```
aws ec2 delete-network-insights-access-scope-analysis \
--network-insights-access-scope-analysis-id nisa-01234567891abcdef
```
Saída:
```
{
"NetworkInsightsAccessScopeAnalysisId": "nisa-01234567891abcdef
}
```
Para obter mais informações, consulte [Introdução ao Network Access Analyzer usando a AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli.html) no Guia *do Network Access* Analyzer.
+ Para obter detalhes da API, consulte [DeleteNetworkInsightsAccessScopeAnalysis](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-network-insights-access-scope-analysis.html)em *Referência de AWS CLI Comandos*.
### `delete-network-insights-access-scope`
O código de exemplo a seguir mostra como usar `delete-network-insights-access-scope`.
**AWS CLI**
**Excluir um Escopo de Acesso à Rede**
O exemplo `delete-network-insights-access-scope` a seguir exclui p Escopo de Acesso à Rede especificado.
```
aws ec2 delete-network-insights-access-scope \
--network-insights-access-scope-id nis-123456789abc01234
```
Saída:
```
{
"NetworkInsightsAccessScopeId": "nis-123456789abc01234"
}
```
Para obter mais informações, consulte [Introdução ao Network Access Analyzer usando a AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli.html) no Guia *do Network Access* Analyzer.
+ Para obter detalhes da API, consulte [DeleteNetworkInsightsAccessScope](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-network-insights-access-scope.html)em *Referência de AWS CLI Comandos*.
### `delete-network-insights-analysis`
O código de exemplo a seguir mostra como usar `delete-network-insights-analysis`.
**AWS CLI**
**Excluir uma análise de caminho**
O exemplo `delete-network-insights-analysis` a seguir exclui a análise especificada.
```
aws ec2 delete-network-insights-analysis \
--network-insights-analysis-id nia-02207aa13eb480c7a
```
Saída:
```
{
"NetworkInsightsAnalysisId": "nia-02207aa13eb480c7a"
}
```
Para obter mais informações, consulte [Introdução ao uso da AWS CLI](https://docs.aws.amazon.com/vpc/latest/reachability/getting-started-cli.html) no Guia do *Reachability Analyzer*.
+ Para obter detalhes da API, consulte [DeleteNetworkInsightsAnalysis](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-network-insights-analysis.html)em *Referência de AWS CLI Comandos*.
### `delete-network-insights-path`
O código de exemplo a seguir mostra como usar `delete-network-insights-path`.
**AWS CLI**
**Excluir um caminho**
O exemplo `delete-network-insights-path` a seguir exclui o caminho especificado. Para poder excluir um caminho, primeiro é necessário excluir todas as análises usando o comando `delete-network-insights-analysis`.
```
aws ec2 delete-network-insights-path \
--network-insights-path-id nip-0b26f224f1d131fa8
```
Saída:
```
{
"NetworkInsightsPathId": "nip-0b26f224f1d131fa8"
}
```
Para obter mais informações, consulte [Introdução ao uso da AWS CLI](https://docs.aws.amazon.com/vpc/latest/reachability/getting-started-cli.html) no Guia do *Reachability Analyzer*.
+ Para obter detalhes da API, consulte [DeleteNetworkInsightsPath](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-network-insights-path.html)em *Referência de AWS CLI Comandos*.
### `delete-network-interface-permission`
O código de exemplo a seguir mostra como usar `delete-network-interface-permission`.
**AWS CLI**
**Excluir uma permissão de interface de rede**
Este exemplo exclui a permissão de interface de rede especificada.
Comando:
```
aws ec2 delete-network-interface-permission --network-interface-permission-id eni-perm-06fd19020ede149ea
```
Saída:
```
{
"Return": true
}
```
+ Para obter detalhes da API, consulte [DeleteNetworkInterfacePermission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-network-interface-permission.html)em *Referência de AWS CLI Comandos*.
### `delete-network-interface`
O código de exemplo a seguir mostra como usar `delete-network-interface`.
**AWS CLI**
**Excluir uma interface de rede**
Este exemplo exclui a interface de rede especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-network-interface --network-interface-id eni-e5aa89a3
```
+ Para obter detalhes da API, consulte [DeleteNetworkInterface](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-network-interface.html)em *Referência de AWS CLI Comandos*.
### `delete-placement-group`
O código de exemplo a seguir mostra como usar `delete-placement-group`.
**AWS CLI**
**Excluir um grupo de posicionamento**
Esse exemplo de comando exclui o grupo de posicionamento especificado.
Comando:
```
aws ec2 delete-placement-group --group-name my-cluster
```
+ Para obter detalhes da API, consulte [DeletePlacementGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-placement-group.html)em *Referência de AWS CLI Comandos*.
### `delete-queued-reserved-instances`
O código de exemplo a seguir mostra como usar `delete-queued-reserved-instances`.
**AWS CLI**
**Excluir uma compra colocada na fila**
O exemplo `delete-queued-reserved-instances` a seguir exclui a instância reservada especificada, que estava na fila para compra.
```
aws ec2 delete-queued-reserved-instances \
--reserved-instances-ids af9f760e-6f91-4559-85f7-4980eexample
```
Saída:
```
{
"SuccessfulQueuedPurchaseDeletions": [
{
"ReservedInstancesId": "af9f760e-6f91-4559-85f7-4980eexample"
}
],
"FailedQueuedPurchaseDeletions": []
}
```
+ Para obter detalhes da API, consulte [DeleteQueuedReservedInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-queued-reserved-instances.html)em *Referência de AWS CLI Comandos*.
### `delete-route-table`
O código de exemplo a seguir mostra como usar `delete-route-table`.
**AWS CLI**
**Excluir uma tabela de rotas**
Este exemplo exclui a tabela de rotas especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-route-table --route-table-id rtb-22574640
```
+ Para obter detalhes da API, consulte [DeleteRouteTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-route-table.html)em *Referência de AWS CLI Comandos*.
### `delete-route`
O código de exemplo a seguir mostra como usar `delete-route`.
**AWS CLI**
**Para excluir uma rota**
Este exemplo exclui a rota especificada da tabela de rotas especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-route --route-table-id rtb-22574640 --destination-cidr-block 0.0.0.0/0
```
+ Para obter detalhes da API, consulte [DeleteRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-route.html)em *Referência de AWS CLI Comandos*.
### `delete-security-group`
O código de exemplo a seguir mostra como usar `delete-security-group`.
**AWS CLI**
**[EC2-Classic] Para excluir um grupo de segurança**
Este exemplo exclui o grupo de segurança chamado `MySecurityGroup`. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-security-group --group-name MySecurityGroup
```
**[EC2-VPC] Para excluir um grupo de segurança**
Este exemplo exclui o grupo de segurança com o ID `sg-903004f8`. Não é possível fazer referência a um grupo de segurança do EC2-VPC por nome. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-security-group --group-id sg-903004f8
```
Para obter mais informações, consulte Using Security Groups no *Guia do usuário da AWS Command Line Interface*.
+ Para obter detalhes da API, consulte [DeleteSecurityGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-security-group.html)em *Referência de AWS CLI Comandos*.
### `delete-snapshot`
O código de exemplo a seguir mostra como usar `delete-snapshot`.
**AWS CLI**
**Para excluir um snapshot**
Este exemplo de comando exclui um snapshot com o ID de snapshot de `snap-1234567890abcdef0`. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-snapshot --snapshot-id snap-1234567890abcdef0
```
+ Para obter detalhes da API, consulte [DeleteSnapshot](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-snapshot.html)em *Referência de AWS CLI Comandos*.
### `delete-spot-datafeed-subscription`
O código de exemplo a seguir mostra como usar `delete-spot-datafeed-subscription`.
**AWS CLI**
**Cancelar uma assinatura de feed de dados da Instância Spot**
Este exemplo de comando exclui uma assinatura de feed de dados Spot para a conta. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-spot-datafeed-subscription
```
+ Para obter detalhes da API, consulte [DeleteSpotDatafeedSubscription](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-spot-datafeed-subscription.html)em *Referência de AWS CLI Comandos*.
### `delete-subnet-cidr-reservation`
O código de exemplo a seguir mostra como usar `delete-subnet-cidr-reservation`.
**AWS CLI**
**Excluir uma reserva CIDR de sub-rede**
O exemplo `delete-subnet-cidr-reservation` a seguir exclui a reserva CIDR de sub-rede especificada.
```
aws ec2 delete-subnet-cidr-reservation \
--subnet-cidr-reservation-id scr-044f977c4eEXAMPLE
```
Saída:
```
{
"DeletedSubnetCidrReservation": {
"SubnetCidrReservationId": "scr-044f977c4eEXAMPLE",
"SubnetId": "subnet-03c51e2e6cEXAMPLE",
"Cidr": "10.1.0.16/28",
"ReservationType": "prefix",
"OwnerId": "123456789012"
}
}
```
Para obter mais informações, consulte [Comportamento do endereçamento IP para sua sub-rede](https://docs.aws.amazon.com/vpc/latest/userguide/subnet-cidr-reservation.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [DeleteSubnetCidrReservation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-subnet-cidr-reservation.html)em *Referência de AWS CLI Comandos*.
### `delete-subnet`
O código de exemplo a seguir mostra como usar `delete-subnet`.
**AWS CLI**
**Excluir uma sub-rede**
Este exemplo exclui a sub-rede especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-subnet --subnet-id subnet-9d4a7b6c
```
+ Para obter detalhes da API, consulte [DeleteSubnet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-subnet.html)em *Referência de AWS CLI Comandos*.
### `delete-tags`
O código de exemplo a seguir mostra como usar `delete-tags`.
**AWS CLI**
**Exemplo 1: excluir uma tag de um recurso**
O exemplo `delete-tags` a seguir exclui a tag `Stack=Test` da imagem especificada. Quando você especifica um valor e um nome de chave, a tag é excluída somente se o valor da tag corresponder ao valor especificado.
```
aws ec2 delete-tags \
--resources ami-1234567890abcdef0 \
--tags Key=Stack,Value=Test
```
É opcional especificar o valor de uma tag. O exemplo `delete-tags` a seguir exclui a tag com o nome de chave `purpose` da instância especificada, independentemente do valor da tag.
```
aws ec2 delete-tags \
--resources i-1234567890abcdef0 \
--tags Key=purpose
```
Se você especificar a string vazia como o valor da tag, a tag será excluída somente se o valor da tag for a string vazia. O exemplo `delete-tags` a seguir especifica a string vazia como o valor da tag a ser excluída.
```
aws ec2 delete-tags \
--resources i-1234567890abcdef0 \
--tags Key=Name,Value=
```
**Exemplo 2: excluir uma tag de vários recursos**
O exemplo `delete-tags` a seguir exclui a tag ``Purpose=Test`` de uma instância e de uma AMI. Conforme mostrado no exemplo anterior, você pode omitir o valor da tag do comando.
```
aws ec2 delete-tags \
--resources i-1234567890abcdef0 ami-1234567890abcdef0 \
--tags Key=Purpose
```
+ Para obter detalhes da API, consulte [DeleteTags](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-tags.html)em *Referência de AWS CLI Comandos*.
### `delete-traffic-mirror-filter-rule`
O código de exemplo a seguir mostra como usar `delete-traffic-mirror-filter-rule`.
**AWS CLI**
**Excluir uma regra de filtro de espelhamento de tráfego**
O exemplo `delete-traffic-mirror-filter-rule` a seguir exclui a regra de filtro de espelhos de tráfego especificada.
```
aws ec2 delete-traffic-mirror-filter-rule \
--traffic-mirror-filter-rule-id tmfr-081f71283bEXAMPLE
```
Saída:
```
{
"TrafficMirrorFilterRuleId": "tmfr-081f71283bEXAMPLE"
}
```
Para obter mais informações, consulte [Modificar suas regras de filtro de espelhamento de tráfego](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-filter.html#modify-traffic-mirroring-filter-rules) no *Guia de espelhamento de tráfego da AWS *.
+ Para obter detalhes da API, consulte [DeleteTrafficMirrorFilterRule](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-traffic-mirror-filter-rule.html)em *Referência de AWS CLI Comandos*.
### `delete-traffic-mirror-filter`
O código de exemplo a seguir mostra como usar `delete-traffic-mirror-filter`.
**AWS CLI**
**Excluir um filtro de espelhamento de tráfego**
O exemplo `delete-traffic-mirror-filter` a seguir exclui o filtro de espelhamento de tráfego especificado.
```
aws ec2 delete-traffic-mirror-filter \
--traffic-mirror-filter-id tmf-0be0b25fcdEXAMPLE
```
Saída:
```
{
"TrafficMirrorFilterId": "tmf-0be0b25fcdEXAMPLE"
}
```
Para obter mais informações, consulte [Excluir um filtro de espelhamento de tráfego](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-filter.html#delete-traffic-mirroring-filter) no *Guia de espelhamento de tráfego da AWS *.
+ Para obter detalhes da API, consulte [DeleteTrafficMirrorFilter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-traffic-mirror-filter.html)em *Referência de AWS CLI Comandos*.
### `delete-traffic-mirror-session`
O código de exemplo a seguir mostra como usar `delete-traffic-mirror-session`.
**AWS CLI**
**Excluir uma sessão de espelhamento de tráfego**
O exemplo `delete-traffic-mirror-session` a seguir exclui a sessão de espelhamento de tráfego especificada.
```
aws ec2 delete-traffic-mirror-session \
--traffic-mirror-session-id tms-0af3141ce5EXAMPLE
```
Saída:
```
{
"TrafficMirrorSessionId": "tms-0af3141ce5EXAMPLE"
}
```
Para obter mais informações, consulte [Excluir uma sessão de espelhamento de tráfego](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-session.html#delete-traffic-mirroring-session) no *Guia de espelhamento de tráfego da AWS *.
+ Para obter detalhes da API, consulte [DeleteTrafficMirrorSession](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-traffic-mirror-session.html)em *Referência de AWS CLI Comandos*.
### `delete-traffic-mirror-target`
O código de exemplo a seguir mostra como usar `delete-traffic-mirror-target`.
**AWS CLI**
**Excluir um destino de espelhamento de tráfego**
O exemplo `delete-traffic-mirror-target` a seguir exclui o destino de espelhamento de tráfego especificado.
```
aws ec2 delete-traffic-mirror-target \
--traffic-mirror-target-id tmt-060f48ce9EXAMPLE
```
Saída:
```
{
"TrafficMirrorTargetId": "tmt-060f48ce9EXAMPLE"
}
```
Para obter mais informações, consulte [Excluir um destino de espelhamento de tráfego](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-target.html#delete-traffic-mirroring-target) no *Guia de espelhamento de tráfego da AWS *.
+ Para obter detalhes da API, consulte [DeleteTrafficMirrorTarget](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-traffic-mirror-target.html)em *Referência de AWS CLI Comandos*.
### `delete-transit-gateway-connect-peer`
O código de exemplo a seguir mostra como usar `delete-transit-gateway-connect-peer`.
**AWS CLI**
**Excluir um par da conexão de Gateway de trânsito**
O exemplo `delete-transit-gateway-connect-peer` a seguir exclui o par de conexão especificado.
```
aws ec2 delete-transit-gateway-connect-peer \
--transit-gateway-connect-peer-id tgw-connect-peer-0666adbac4EXAMPLE
```
Saída:
```
{
"TransitGatewayConnectPeer": {
"TransitGatewayAttachmentId": "tgw-attach-0f0927767cEXAMPLE",
"TransitGatewayConnectPeerId": "tgw-connect-peer-0666adbac4EXAMPLE",
"State": "deleting",
"CreationTime": "2021-10-13T03:35:17.000Z",
"ConnectPeerConfiguration": {
"TransitGatewayAddress": "10.0.0.234",
"PeerAddress": "172.31.1.11",
"InsideCidrBlocks": [
"169.254.6.0/29"
],
"Protocol": "gre",
"BgpConfigurations": [
{
"TransitGatewayAsn": 64512,
"PeerAsn": 64512,
"TransitGatewayAddress": "169.254.6.2",
"PeerAddress": "169.254.6.1",
"BgpStatus": "down"
},
{
"TransitGatewayAsn": 64512,
"PeerAsn": 64512,
"TransitGatewayAddress": "169.254.6.3",
"PeerAddress": "169.254.6.1",
"BgpStatus": "down"
}
]
}
}
}
```
Para obter mais informações, consulte [Anexos de conexão do gateway de trânsito e pares de conexão do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [DeleteTransitGatewayConnectPeer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-connect-peer.html)em *Referência de AWS CLI Comandos*.
### `delete-transit-gateway-connect`
O código de exemplo a seguir mostra como usar `delete-transit-gateway-connect`.
**AWS CLI**
**Excluir um anexo da conexão do gateway de trânsito**
O exemplo `delete-transit-gateway-connect` a seguir exclui o anexo de conexão especificado.
```
aws ec2 delete-transit-gateway-connect \
--transit-gateway-attachment-id tgw-attach-037012e5dcEXAMPLE
```
Saída:
```
{
"TransitGatewayConnect": {
"TransitGatewayAttachmentId": "tgw-attach-037012e5dcEXAMPLE",
"TransportTransitGatewayAttachmentId": "tgw-attach-0a89069f57EXAMPLE",
"TransitGatewayId": "tgw-02f776b1a7EXAMPLE",
"State": "deleting",
"CreationTime": "2021-03-09T19:59:17+00:00",
"Options": {
"Protocol": "gre"
}
}
}
```
Para obter mais informações, consulte [Anexos de conexão do gateway de trânsito e pares de conexão do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [DeleteTransitGatewayConnect](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-connect.html)em *Referência de AWS CLI Comandos*.
### `delete-transit-gateway-multicast-domain`
O código de exemplo a seguir mostra como usar `delete-transit-gateway-multicast-domain`.
**AWS CLI**
**Excluir um domínio de multicast do gateway de trânsito**
O exemplo `delete-transit-gateway-multicast-domain` a seguir exclui o domínio multicast especificado.
```
aws ec2 delete-transit-gateway-multicast-domain \
--transit-gateway-multicast-domain-id tgw-mcast-domain-0c4905cef7EXAMPLE
```
Saída:
```
{
"TransitGatewayMulticastDomain": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-02bb79002bEXAMPLE",
"TransitGatewayId": "tgw-0d88d2d0d5EXAMPLE",
"State": "deleting",
"CreationTime": "2019-11-20T22:02:03.000Z"
}
}
```
Para obter mais informações, consulte [Como gerenciar domínios multicast](https://docs.aws.amazon.com/vpc/latest/tgw/manage-domain.html) no *Guia de gateway de trânsito*.
+ Para obter detalhes da API, consulte [DeleteTransitGatewayMulticastDomain](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-multicast-domain.html)em *Referência de AWS CLI Comandos*.
### `delete-transit-gateway-peering-attachment`
O código de exemplo a seguir mostra como usar `delete-transit-gateway-peering-attachment`.
**AWS CLI**
**Excluir um anexo de emparelhamento do gateway de trânsito**
O exemplo `delete-transit-gateway-peering-attachment` a seguir exclui o anexo de emparelhamento do gateway de trânsito especificado.
```
aws ec2 delete-transit-gateway-peering-attachment \
--transit-gateway-attachment-id tgw-attach-4455667788aabbccd
```
Saída:
```
{
"TransitGatewayPeeringAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-4455667788aabbccd",
"RequesterTgwInfo": {
"TransitGatewayId": "tgw-123abc05e04123abc",
"OwnerId": "123456789012",
"Region": "us-west-2"
},
"AccepterTgwInfo": {
"TransitGatewayId": "tgw-11223344aabbcc112",
"OwnerId": "123456789012",
"Region": "us-east-2"
},
"State": "deleting",
"CreationTime": "2019-12-09T11:38:31.000Z"
}
}
```
Para obter mais informações, consulte [Anexos de pareamento do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-peering.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [DeleteTransitGatewayPeeringAttachment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-peering-attachment.html)em *Referência de AWS CLI Comandos*.
### `delete-transit-gateway-policy-table`
O código de exemplo a seguir mostra como usar `delete-transit-gateway-policy-table`.
**AWS CLI**
**Excluir uma tabela de políticas de gateway de trânsito**
O exemplo `delete-transit-gateway-policy-table` a seguir exclui a tabela de política de gateway de trânsito especificada.
```
aws ec2 delete-transit-gateway-policy-table \
--transit-gateway-policy-table-id tgw-ptb-0a16f134b78668a81
```
Saída:
```
{
"TransitGatewayPolicyTables": [
{
"TransitGatewayPolicyTableId": "tgw-ptb-0a16f134b78668a81",
"TransitGatewayId": "tgw-067f8505c18f0bd6e",
"State": "deleting",
"CreationTime": "2023-11-28T16:36:43+00:00",
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Tabelas de política do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-policy-tables.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [DeleteTransitGatewayPolicyTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-policy-table.html)em *Referência de AWS CLI Comandos*.
### `delete-transit-gateway-prefix-list-reference`
O código de exemplo a seguir mostra como usar `delete-transit-gateway-prefix-list-reference`.
**AWS CLI**
**Excluir uma referência da lista de prefixos**
O exemplo `delete-transit-gateway-prefix-list-reference` a seguir exclui a referência da lista de prefixos especificada.
```
aws ec2 delete-transit-gateway-prefix-list-reference \
--transit-gateway-route-table-id tgw-rtb-0123456789abcd123 \
--prefix-list-id pl-11111122222222333
```
Saída:
```
{
"TransitGatewayPrefixListReference": {
"TransitGatewayRouteTableId": "tgw-rtb-0123456789abcd123",
"PrefixListId": "pl-11111122222222333",
"PrefixListOwnerId": "123456789012",
"State": "deleting",
"Blackhole": false,
"TransitGatewayAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-aabbccddaabbccaab",
"ResourceType": "vpc",
"ResourceId": "vpc-112233445566aabbc"
}
}
}
```
Para obter mais informações, consulte [Referências de lista de prefixos](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-prefix-lists.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [DeleteTransitGatewayPrefixListReference](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-prefix-list-reference.html)em *Referência de AWS CLI Comandos*.
### `delete-transit-gateway-route-table`
O código de exemplo a seguir mostra como usar `delete-transit-gateway-route-table`.
**AWS CLI**
**Excluir uma tabela de rotas do gateway de trânsito**
O exemplo `delete-transit-gateway-route-table` a seguir exclui a tabela de rotas de gateway de trânsito especificada.
```
aws ec2 delete-transit-gateway-route-table \
--transit-gateway-route-table-id tgw-rtb-0b6f6aaa01EXAMPLE
```
Saída:
```
{
"TransitGatewayRouteTable": {
"TransitGatewayRouteTableId": "tgw-rtb-0b6f6aaa01EXAMPLE",
"TransitGatewayId": "tgw-02f776b1a7EXAMPLE",
"State": "deleting",
"DefaultAssociationRouteTable": false,
"DefaultPropagationRouteTable": false,
"CreationTime": "2019-07-17T20:27:26.000Z"
}
}
```
Para obter mais informações, consulte [Excluir uma tabelas de rotas do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html#delete-tgw-route-table) no *Guia de gateway de trânsito*.
+ Para obter detalhes da API, consulte [DeleteTransitGatewayRouteTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-route-table.html)em *Referência de AWS CLI Comandos*.
### `delete-transit-gateway-route`
O código de exemplo a seguir mostra como usar `delete-transit-gateway-route`.
**AWS CLI**
**Excluir um bloco CIDR de uma tabela de rotas**
O exemplo `delete-transit-gateway-route` a seguir exclui o bloco CIDR da tabela de rotas do gateway de trânsito especificado.
```
aws ec2 delete-transit-gateway-route \
--transit-gateway-route-table-id tgw-rtb-0b6f6aaa01EXAMPLE \
--destination-cidr-block 10.0.2.0/24
```
Saída:
```
{
"Route": {
"DestinationCidrBlock": "10.0.2.0/24",
"TransitGatewayAttachments": [
{
"ResourceId": "vpc-0065acced4EXAMPLE",
"TransitGatewayAttachmentId": "tgw-attach-0b5968d3b6EXAMPLE",
"ResourceType": "vpc"
}
],
"Type": "static",
"State": "deleted"
}
}
```
Para obter mais informações, consulte [Excluir uma rota estática](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html#tgw-delete-static-route) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [DeleteTransitGatewayRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-route.html)em *Referência de AWS CLI Comandos*.
### `delete-transit-gateway-vpc-attachment`
O código de exemplo a seguir mostra como usar `delete-transit-gateway-vpc-attachment`.
**AWS CLI**
**Excluir um anexo VPC do gateway de trânsito**
O exemplo `delete-transit-gateway-vpc-attachment` a seguir exclui o anexo VPC especificado.
```
aws ec2 delete-transit-gateway-vpc-attachment \
--transit-gateway-attachment-id tgw-attach-0d2c54bdbEXAMPLE
```
Saída:
```
{
"TransitGatewayVpcAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-0d2c54bdb3EXAMPLE",
"TransitGatewayId": "tgw-02f776b1a7EXAMPLE",
"VpcId": "vpc-0065acced4f61c651",
"VpcOwnerId": "111122223333",
"State": "deleting",
"CreationTime": "2019-07-17T16:04:27.000Z"
}
}
```
Para obter mais informações, consulte [Excluir um anexo de VPC](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html#delete-vpc-attachment) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [DeleteTransitGatewayVpcAttachment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-vpc-attachment.html)em *Referência de AWS CLI Comandos*.
### `delete-transit-gateway`
O código de exemplo a seguir mostra como usar `delete-transit-gateway`.
**AWS CLI**
**Excluir um gateway de trânsito**
O exemplo `delete-transit-gateway` a seguir exclui o gateway de trânsito especificado.
```
aws ec2 delete-transit-gateway \
--transit-gateway-id tgw-01f04542b2EXAMPLE
```
Saída:
```
{
"TransitGateway": {
"TransitGatewayId": "tgw-01f04542b2EXAMPLE",
"State": "deleting",
"OwnerId": "123456789012",
"Description": "Example Transit Gateway",
"CreationTime": "2019-08-27T15:04:35.000Z",
"Options": {
"AmazonSideAsn": 64515,
"AutoAcceptSharedAttachments": "disable",
"DefaultRouteTableAssociation": "enable",
"AssociationDefaultRouteTableId": "tgw-rtb-0ce7a6948fEXAMPLE",
"DefaultRouteTablePropagation": "enable",
"PropagationDefaultRouteTableId": "tgw-rtb-0ce7a6948fEXAMPLE",
"VpnEcmpSupport": "enable",
"DnsSupport": "enable"
}
}
}
```
Para obter mais informações, consulte [Excluir um gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-transit-gateways.html#delete-tgw) no *Guia de gateway de trânsito*.
+ Para obter detalhes da API, consulte [DeleteTransitGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway.html)em *Referência de AWS CLI Comandos*.
### `delete-verified-access-endpoint`
O código de exemplo a seguir mostra como usar `delete-verified-access-endpoint`.
**AWS CLI**
**Excluir um endpoint do acesso verificado**
O exemplo `delete-verified-access-endpoint` a seguir exclui o endpoint especificado do acesso verificado.
```
aws ec2 delete-verified-access-endpoint \
--verified-access-endpoint-id vae-066fac616d4d546f2
```
Saída:
```
{
"VerifiedAccessEndpoint": {
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"VerifiedAccessGroupId": "vagr-0dbe967baf14b7235",
"VerifiedAccessEndpointId": "vae-066fac616d4d546f2",
"ApplicationDomain": "example.com",
"EndpointType": "network-interface",
"AttachmentType": "vpc",
"DomainCertificateArn": "arn:aws:acm:us-east-2:123456789012:certificate/eb065ea0-26f9-4e75-a6ce-0a1a7EXAMPLE",
"EndpointDomain": "my-ava-app.edge-00c3372d53b1540bb.vai-0ce000c0b7643abea.prod.verified-access.us-east-2.amazonaws.com",
"SecurityGroupIds": [
"sg-004915970c4c8f13a"
],
"NetworkInterfaceOptions": {
"NetworkInterfaceId": "eni-0aec70418c8d87a0f",
"Protocol": "https",
"Port": 443
},
"Status": {
"Code": "deleting"
},
"Description": "Testing Verified Access",
"CreationTime": "2023-08-25T20:54:43",
"LastUpdatedTime": "2023-08-25T22:46:32"
}
}
```
Para obter mais informações, consulte [Endpoints de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-endpoints.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [DeleteVerifiedAccessEndpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-verified-access-endpoint.html)em *Referência de AWS CLI Comandos*.
### `delete-verified-access-group`
O código de exemplo a seguir mostra como usar `delete-verified-access-group`.
**AWS CLI**
**Excluir um grupo do acesso verificado**
O exemplo `delete-verified-access-group` a seguir exclui o grupo especificado do acesso verificado.
```
aws ec2 delete-verified-access-group \
--verified-access-group-id vagr-0dbe967baf14b7235
```
Saída:
```
{
"VerifiedAccessGroup": {
"VerifiedAccessGroupId": "vagr-0dbe967baf14b7235",
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"Description": "Testing Verified Access",
"Owner": "123456789012",
"VerifiedAccessGroupArn": "arn:aws:ec2:us-east-2:123456789012:verified-access-group/vagr-0dbe967baf14b7235",
"CreationTime": "2023-08-25T19:55:19",
"LastUpdatedTime": "2023-08-25T22:49:03",
"DeletionTime": "2023-08-26T00:58:31"
}
}
```
Para obter mais informações, consulte [Grupos de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-groups.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [DeleteVerifiedAccessGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-verified-access-group.html)em *Referência de AWS CLI Comandos*.
### `delete-verified-access-instance`
O código de exemplo a seguir mostra como usar `delete-verified-access-instance`.
**AWS CLI**
**Excluir uma instância do acesso verificado**
O exemplo `delete-verified-access-instance` a seguir exclui a instância especificada do acesso verificado.
```
aws ec2 delete-verified-access-instance \
--verified-access-instance-id vai-0ce000c0b7643abea
```
Saída:
```
{
"VerifiedAccessInstance": {
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"Description": "Testing Verified Access",
"VerifiedAccessTrustProviders": [],
"CreationTime": "2023-08-25T18:27:56",
"LastUpdatedTime": "2023-08-26T01:00:18"
}
}
```
Para obter mais informações, consulte [Instâncias de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-instances.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [DeleteVerifiedAccessInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-verified-access-instance.html)em *Referência de AWS CLI Comandos*.
### `delete-verified-access-trust-provider`
O código de exemplo a seguir mostra como usar `delete-verified-access-trust-provider`.
**AWS CLI**
**Excluir um provedor confiável de dispositivos de acesso verificado**
O exemplo `delete-verified-access-trust-provider` a seguir exclui o provedor de confiança especificado do acesso verificado.
```
aws ec2 delete-verified-access-trust-provider \
--verified-access-trust-provider-id vatp-0bb32de759a3e19e7
```
Saída:
```
{
"VerifiedAccessTrustProvider": {
"VerifiedAccessTrustProviderId": "vatp-0bb32de759a3e19e7",
"Description": "Testing Verified Access",
"TrustProviderType": "user",
"UserTrustProviderType": "iam-identity-center",
"PolicyReferenceName": "idc",
"CreationTime": "2023-08-25T18:40:36",
"LastUpdatedTime": "2023-08-25T18:40:36"
}
}
```
Para obter mais informações, consulte [Provedores confiáveis para acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/trust-providers.html) no *Guia do usuário de acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [DeleteVerifiedAccessTrustProvider](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-verified-access-trust-provider.html)em *Referência de AWS CLI Comandos*.
### `delete-volume`
O código de exemplo a seguir mostra como usar `delete-volume`.
**AWS CLI**
**Excluir um volume**
Este exemplo de comando exclui um volume disponível com o ID do volume de `vol-049df61146c4d7901`. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-volume --volume-id vol-049df61146c4d7901
```
+ Para obter detalhes da API, consulte [DeleteVolume](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-volume.html)em *Referência de AWS CLI Comandos*.
### `delete-vpc-endpoint-connection-notifications`
O código de exemplo a seguir mostra como usar `delete-vpc-endpoint-connection-notifications`.
**AWS CLI**
**Excluir uma notificação de conexão de endpoint**
Este exemplo exclui a notificação de conexão de endpoint especificada.
Comando:
```
aws ec2 delete-vpc-endpoint-connection-notifications --connection-notification-ids vpce-nfn-008776de7e03f5abc
```
Saída:
```
{
"Unsuccessful": []
}
```
+ Para obter detalhes da API, consulte [DeleteVpcEndpointConnectionNotifications](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-vpc-endpoint-connection-notifications.html)em *Referência de AWS CLI Comandos*.
### `delete-vpc-endpoint-service-configurations`
O código de exemplo a seguir mostra como usar `delete-vpc-endpoint-service-configurations`.
**AWS CLI**
**Excluir uma configuração de serviço de endpoint**
Este exemplo exclui a configuração especificada do serviço de endpoint.
Comando:
```
aws ec2 delete-vpc-endpoint-service-configurations --service-ids vpce-svc-03d5ebb7d9579a2b3
```
Saída:
```
{
"Unsuccessful": []
}
```
+ Para obter detalhes da API, consulte [DeleteVpcEndpointServiceConfigurations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-vpc-endpoint-service-configurations.html)em *Referência de AWS CLI Comandos*.
### `delete-vpc-endpoints`
O código de exemplo a seguir mostra como usar `delete-vpc-endpoints`.
**AWS CLI**
**Para excluir um endpoint**
Este exemplo exclui os endpoints vpce-aa22bb33 e vpce-1a2b3c4d. Se o comando for parcialmente bem-sucedido ou malsucedido, uma lista de itens malsucedidos será retornada. Se houver sucesso, a lista retornada ficará vazia.
Comando:
```
aws ec2 delete-vpc-endpoints --vpc-endpoint-ids vpce-aa22bb33 vpce-1a2b3c4d
```
Saída:
```
{
"Unsuccessful": []
}
```
+ Para obter detalhes da API, consulte [DeleteVpcEndpoints](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-vpc-endpoints.html)em *Referência de AWS CLI Comandos*.
### `delete-vpc-peering-connection`
O código de exemplo a seguir mostra como usar `delete-vpc-peering-connection`.
**AWS CLI**
**Excluir uma conexão de emparelhamento da VPC**
Este exemplo exclui a conexão de emparelhamento da VPC especificada.
Comando:
```
aws ec2 delete-vpc-peering-connection --vpc-peering-connection-id pcx-1a2b3c4d
```
Saída:
```
{
"Return": true
}
```
+ Para obter detalhes da API, consulte [DeleteVpcPeeringConnection](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-vpc-peering-connection.html)em *Referência de AWS CLI Comandos*.
### `delete-vpc`
O código de exemplo a seguir mostra como usar `delete-vpc`.
**AWS CLI**
**Para excluir uma VPC**
Este exemplo exclui a VPC especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-vpc --vpc-id vpc-a01106c2
```
+ Para obter detalhes da API, consulte [DeleteVpc](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-vpc.html)em *Referência de AWS CLI Comandos*.
### `delete-vpn-connection-route`
O código de exemplo a seguir mostra como usar `delete-vpn-connection-route`.
**AWS CLI**
**Excluir uma rota estática de uma conexão VPN**
Este exemplo exclui a rota estática especificada da conexão VPN especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-vpn-connection-route --vpn-connection-id vpn-40f41529 --destination-cidr-block 11.12.0.0/16
```
+ Para obter detalhes da API, consulte [DeleteVpnConnectionRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-vpn-connection-route.html)em *Referência de AWS CLI Comandos*.
### `delete-vpn-connection`
O código de exemplo a seguir mostra como usar `delete-vpn-connection`.
**AWS CLI**
**Excluir uma conexão VPN**
Este exemplo exclui a conexão VPN especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-vpn-connection --vpn-connection-id vpn-40f41529
```
+ Para obter detalhes da API, consulte [DeleteVpnConnection](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-vpn-connection.html)em *Referência de AWS CLI Comandos*.
### `delete-vpn-gateway`
O código de exemplo a seguir mostra como usar `delete-vpn-gateway`.
**AWS CLI**
**Excluir um gateway privado virtual**
Este exemplo exclui o gateway privado virtual especificado. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 delete-vpn-gateway --vpn-gateway-id vgw-9a4cacf3
```
+ Para obter detalhes da API, consulte [DeleteVpnGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-vpn-gateway.html)em *Referência de AWS CLI Comandos*.
### `deprovision-byoip-cidr`
O código de exemplo a seguir mostra como usar `deprovision-byoip-cidr`.
**AWS CLI**
**Remover um intervalo de endereços IP do uso**
O exemplo a seguir remove o intervalo de endereços especificado do uso com AWS.
```
aws ec2 deprovision-byoip-cidr \
--cidr 203.0.113.25/24
```
Saída:
```
{
"ByoipCidr": {
"Cidr": "203.0.113.25/24",
"State": "pending-deprovision"
}
}
```
+ Para obter detalhes da API, consulte [DeprovisionByoipCidr](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/deprovision-byoip-cidr.html)em *Referência de AWS CLI Comandos*.
### `deprovision-ipam-pool-cidr`
O código de exemplo a seguir mostra como usar `deprovision-ipam-pool-cidr`.
**AWS CLI**
**Desprovisionar um CIDR do pool do IPAM**
O exemplo `deprovision-ipam-pool-cidr` a seguir desprovisiona um CIDR provisionado para um grupo do IPAM.
(Linux):
```
aws ec2 deprovision-ipam-pool-cidr \
--ipam-pool-id ipam-pool-02ec043a19bbe5d08 \
--cidr 11.0.0.0/16
```
(Windows):
```
aws ec2 deprovision-ipam-pool-cidr ^
--ipam-pool-id ipam-pool-02ec043a19bbe5d08 ^
--cidr 11.0.0.0/16
```
Saída:
```
{
"IpamPoolCidr": {
"Cidr": "11.0.0.0/16",
"State": "pending-deprovision"
}
}
```
Para obter mais informações, consulte [Pool de desprovisionamento CIDRs](https://docs.aws.amazon.com/vpc/latest/ipam/depro-pool-cidr-ipam.html) no Guia do usuário *IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [DeprovisionIpamPoolCidr](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/deprovision-ipam-pool-cidr.html)em *Referência de AWS CLI Comandos*.
### `deregister-image`
O código de exemplo a seguir mostra como usar `deregister-image`.
**AWS CLI**
**Cancelar o registro de uma AMI**
Este exemplo cancela o registro da AMI especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 deregister-image --image-id ami-4fa54026
```
+ Para obter detalhes da API, consulte [DeregisterImage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/deregister-image.html)em *Referência de AWS CLI Comandos*.
### `deregister-instance-event-notification-attributes`
O código de exemplo a seguir mostra como usar `deregister-instance-event-notification-attributes`.
**AWS CLI**
**Exemplo 1: remover todas as tags das notificações de eventos**
O exemplo `deregister-instance-event-notification-attributes` a seguir remove `IncludeAllTagsOfInstance=true`, o que tem o efeito de definir `IncludeAllTagsOfInstance` como `false`.
```
aws ec2 deregister-instance-event-notification-attributes \
--instance-tag-attribute IncludeAllTagsOfInstance=true
```
Saída:
```
{
"InstanceTagAttribute": {
"InstanceTagKeys": [],
"IncludeAllTagsOfInstance": true
}
}
```
Para obter mais informações, consulte [Eventos programados para suas instâncias](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html) no *Guia do usuário do Amazon Elastic Compute Cloud para Instâncias Linux*.
**Exemplo 2: remover tags específicas de notificações de eventos**
O exemplo `deregister-instance-event-notification-attributes` a seguir remove a tag especificada das tags incluídas nas notificações de eventos. Para descrever as tags restantes incluídas nas notificações de eventos, use `describe-instance-event-notification-attributes`.
```
aws ec2 deregister-instance-event-notification-attributes \
--instance-tag-attribute InstanceTagKeys="tag-key2"
```
Saída:
```
{
"InstanceTagAttribute": {
"InstanceTagKeys": [
"tag-key2"
],
"IncludeAllTagsOfInstance": false
}
}
```
Para obter mais informações, consulte [Eventos programados para suas instâncias](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html) no *Guia do usuário do Amazon Elastic Compute Cloud para Instâncias Linux*.
+ Para obter detalhes da API, consulte [DeregisterInstanceEventNotificationAttributes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/deregister-instance-event-notification-attributes.html)em *Referência de AWS CLI Comandos*.
### `deregister-transit-gateway-multicast-group-members`
O código de exemplo a seguir mostra como usar `deregister-transit-gateway-multicast-group-members`.
**AWS CLI**
**Cancelar o registro de membros de grupo de um grupo de multicast**
Este exemplo cancela o registro do membro do grupo de interface de rede especificado do grupo multicast do gateway de trânsito.
```
aws ec2 deregister-transit-gateway-multicast-group-members \
--transit-gateway-multicast-domain-id tgw-mcast-domain-0c4905cef7EXAMPLE \
--group-ip-address 224.0.1.0 \
--network-interface-ids eni-0e246d3269EXAMPLE
```
Saída:
```
{
"DeregisteredMulticastGroupMembers": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-0c4905cef7EXAMPLE",
"RegisteredNetworkInterfaceIds": [
"eni-0e246d3269EXAMPLE"
],
"GroupIpAddress": "224.0.1.0"
}
}
```
Para obter mais informações, consulte [Cancelar o registro de membros de um grupo multicast](https://docs.aws.amazon.com/vpc/latest/tgw/working-with-multicast.html#remove-members-multicast-group) no *Guia do usuário de Gateways de trânsito da AWS *.
+ Para obter detalhes da API, consulte [DeregisterTransitGatewayMulticastGroupMembers](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/deregister-transit-gateway-multicast-group-members.html)em *Referência de AWS CLI Comandos*.
### `deregister-transit-gateway-multicast-group-source`
O código de exemplo a seguir mostra como usar `deregister-transit-gateway-multicast-group-source`.
**AWS CLI**
**Cancelar o registro de uma origem do grupo de multicast do gateway de trânsito**
Este exemplo cancela o registro da origem do grupo de interface de rede especificado do grupo multicast.
```
aws ec2 register-transit-gateway-multicast-group-sources \
--transit-gateway-multicast-domain-id tgw-mcast-domain-0c4905cef79d6e597 \
--group-ip-address 224.0.1.0 \
--network-interface-ids eni-07f290fc3c090cbae
```
Saída:
```
{
"DeregisteredMulticastGroupSources": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-0c4905cef79d6e597",
"DeregisteredNetworkInterfaceIds": [
"eni-07f290fc3c090cbae"
],
"GroupIpAddress": "224.0.1.0"
}
}
```
Para obter mais informações, consulte [Cancelar o registro de fontes de um grupo multicast](https://docs.aws.amazon.com/vpc/latest/tgw/working-with-multicast.html#remove-source-multicast-group) no *Guia do usuário de Gateways de trânsito da AWS *.
+ Para obter detalhes da API, consulte [DeregisterTransitGatewayMulticastGroupSource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/deregister-transit-gateway-multicast-group-source.html)em *Referência de AWS CLI Comandos*.
### `describe-account-attributes`
O código de exemplo a seguir mostra como usar `describe-account-attributes`.
**AWS CLI**
**Para descrever todos os atributos da sua AWS conta**
Este exemplo descreve os atributos da sua AWS conta.
Comando:
```
aws ec2 describe-account-attributes
```
Saída:
```
{
"AccountAttributes": [
{
"AttributeName": "vpc-max-security-groups-per-interface",
"AttributeValues": [
{
"AttributeValue": "5"
}
]
},
{
"AttributeName": "max-instances",
"AttributeValues": [
{
"AttributeValue": "20"
}
]
},
{
"AttributeName": "supported-platforms",
"AttributeValues": [
{
"AttributeValue": "EC2"
},
{
"AttributeValue": "VPC"
}
]
},
{
"AttributeName": "default-vpc",
"AttributeValues": [
{
"AttributeValue": "none"
}
]
},
{
"AttributeName": "max-elastic-ips",
"AttributeValues": [
{
"AttributeValue": "5"
}
]
},
{
"AttributeName": "vpc-max-elastic-ips",
"AttributeValues": [
{
"AttributeValue": "5"
}
]
}
]
}
```
**Para descrever um único atributo para sua AWS conta**
Este exemplo descreve o `supported-platforms` atributo da sua AWS conta.
Comando:
```
aws ec2 describe-account-attributes --attribute-names supported-platforms
```
Saída:
```
{
"AccountAttributes": [
{
"AttributeName": "supported-platforms",
"AttributeValues": [
{
"AttributeValue": "EC2"
},
{
"AttributeValue": "VPC"
}
]
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeAccountAttributes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-account-attributes.html)em *Referência de AWS CLI Comandos*.
### `describe-address-transfers`
O código de exemplo a seguir mostra como usar `describe-address-transfers`.
**AWS CLI**
**Descrever uma transferência de endereço IP elástico**
O exemplo `describe-address-transfers` a seguir descreve a transferência do endereço IP Elástico para o endereço IP Elástico especificado.
```
aws ec2 describe-address-transfers \
--allocation-ids eipalloc-09ad461b0d03f6aaf
```
Saída:
```
{
"AddressTransfers": [
{
"PublicIp": "100.21.184.216",
"AllocationId": "eipalloc-09ad461b0d03f6aaf",
"TransferAccountId": "123456789012",
"TransferOfferExpirationTimestamp": "2023-02-22T22:51:01.000Z",
"AddressTransferStatus": "pending"
}
]
}
```
Para obter mais informações, consulte [Transferir endereços IP elásticos](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-eips.html#transfer-EIPs-intro) no *Guia do usuário do Amazon VPC*.
+ Para obter detalhes da API, consulte [DescribeAddressTransfers](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-address-transfers.html)em *Referência de AWS CLI Comandos*.
### `describe-addresses-attribute`
O código de exemplo a seguir mostra como usar `describe-addresses-attribute`.
**AWS CLI**
**Visualizar os atributos do nome de domínio associado a um endereço IP elástico**
Os exemplos `describe-addresses-attribute` a seguir retornam os atributos do nome de domínio associado ao endereço IP elástico.
Linux
```
aws ec2 describe-addresses-attribute \
--allocation-ids eipalloc-abcdef01234567890 \
--attribute domain-name
```
Windows:
```
aws ec2 describe-addresses-attribute ^
--allocation-ids eipalloc-abcdef01234567890 ^
--attribute domain-name
```
Saída:
```
{
"Addresses": [
{
"PublicIp": "192.0.2.0",
"AllocationId": "eipalloc-abcdef01234567890",
"PtrRecord": "example.com."
}
]
}
```
Para visualizar os atributos de um endereço IP elástico, você deve primeiro associar um nome de domínio ao endereço IP elástico. Para obter mais informações, consulte [Usar DNS reverso para aplicativos de e-mail](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html#Using_Elastic_Addressing_Reverse_DNS) no Guia do *usuário do Amazon EC2 [modify-address-attribute](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-address-attribute.html)*ou na Referência de comandos da *AWS CLI*.
+ Para obter detalhes da API, consulte [DescribeAddressesAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-addresses-attribute.html)em *Referência de AWS CLI Comandos*.
### `describe-addresses`
O código de exemplo a seguir mostra como usar `describe-addresses`.
**AWS CLI**
**Exemplo 1: recuperar detalhes de todos os seus endereços IP elásticos**
O exemplo `describe addresses` a seguir mostra os detalhes dos seus endereços IP elásticos.
```
aws ec2 describe-addresses
```
Saída:
```
{
"Addresses": [
{
"InstanceId": "i-1234567890abcdef0",
"PublicIp": "198.51.100.0",
"PublicIpv4Pool": "amazon",
"Domain": "standard"
},
{
"Domain": "vpc",
"PublicIpv4Pool": "amazon",
"InstanceId": "i-1234567890abcdef0",
"NetworkInterfaceId": "eni-12345678",
"AssociationId": "eipassoc-12345678",
"NetworkInterfaceOwnerId": "123456789012",
"PublicIp": "203.0.113.0",
"AllocationId": "eipalloc-12345678",
"PrivateIpAddress": "10.0.1.241"
}
]
}
```
**Exemplo 2: recuperar detalhes dos seus endereços IP elásticos para EC2-VPC**
O exemplo `describe-addresses` a seguir mostra os detalhes dos seus endereços IP elásticos para usar com instâncias em uma VPC.
```
aws ec2 describe-addresses \
--filters "Name=domain,Values=vpc"
```
Saída:
```
{
"Addresses": [
{
"Domain": "vpc",
"PublicIpv4Pool": "amazon",
"InstanceId": "i-1234567890abcdef0",
"NetworkInterfaceId": "eni-12345678",
"AssociationId": "eipassoc-12345678",
"NetworkInterfaceOwnerId": "123456789012",
"PublicIp": "203.0.113.0",
"AllocationId": "eipalloc-12345678",
"PrivateIpAddress": "10.0.1.241"
}
]
}
```
**Exemplo 3: recuperar detalhes sobre um endereço IP elástico especificado pelo ID de alocação**
O exemplo `describe-addresses` a seguir exibe os detalhes do endereço IP elástico com o ID de alocação especificado, que está associado a uma instância no EC2-VPC.
```
aws ec2 describe-addresses \
--allocation-ids eipalloc-282d9641
```
Saída:
```
{
"Addresses": [
{
"Domain": "vpc",
"PublicIpv4Pool": "amazon",
"InstanceId": "i-1234567890abcdef0",
"NetworkInterfaceId": "eni-1a2b3c4d",
"AssociationId": "eipassoc-123abc12",
"NetworkInterfaceOwnerId": "1234567891012",
"PublicIp": "203.0.113.25",
"AllocationId": "eipalloc-282d9641",
"PrivateIpAddress": "10.251.50.12"
}
]
}
```
**Exemplo 4: recuperar detalhes sobre um endereço IP elástico especificado pelo endereço IP privado de VPC**
O exemplo `describe-addresses` a seguir mostra os detalhes do endereço IP elástico associado a um determinado endereço IP privado no EC2-VPC.
```
aws ec2 describe-addresses \
--filters "Name=private-ip-address,Values=10.251.50.12"
```
**Exemplo 5: recuperar detalhes sobre endereços IP elásticos no EC2-Classic**
O exemplo `describe-addresses` a seguir mostra os detalhes dos seus endereços IP elásticos para usar no EC2-Classic.
```
aws ec2 describe-addresses \
--filters "Name=domain,Values=standard"
```
Saída:
```
{
"Addresses": [
{
"InstanceId": "i-1234567890abcdef0",
"PublicIp": "203.0.110.25",
"PublicIpv4Pool": "amazon",
"Domain": "standard"
}
]
}
```
**Exemplo 6: recuperar detalhes sobre um endereço IP elástico especificado pelo endereço IP público**
O exemplo `describe-addresses` a seguir mostra os detalhes do endereço IP elástico com o valor`203.0.110.25`, que está associado a uma instância no EC2-Classic.
```
aws ec2 describe-addresses \
--public-ips 203.0.110.25
```
Saída:
```
{
"Addresses": [
{
"InstanceId": "i-1234567890abcdef0",
"PublicIp": "203.0.110.25",
"PublicIpv4Pool": "amazon",
"Domain": "standard"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeAddresses](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-addresses.html)em *Referência de AWS CLI Comandos*.
### `describe-aggregate-id-format`
O código de exemplo a seguir mostra como usar `describe-aggregate-id-format`.
**AWS CLI**
**Descrever as configurações do formato de ID mais longo para todos os tipos de recurso em uma região**
O exemplo `describe-aggregate-id-format` a seguir descreve o status geral do formato de ID longo para a região atual. O valor `Deadline` indica que os prazos para que esses recursos mudassem permanentemente do formato de ID curto para o formato de ID longo expiraram. O valor `UseLongIdsAggregated` indica que todos os usuários do IAM e perfis do IAM estão configurados para usar o formato de ID longo para todos os tipos de recursos.
```
aws ec2 describe-aggregate-id-format
```
Saída:
```
{
"UseLongIdsAggregated": true,
"Statuses": [
{
"Deadline": "2018-08-13T02:00:00.000Z",
"Resource": "network-interface-attachment",
"UseLongIds": true
},
{
"Deadline": "2016-12-13T02:00:00.000Z",
"Resource": "instance",
"UseLongIds": true
},
{
"Deadline": "2018-08-13T02:00:00.000Z",
"Resource": "elastic-ip-association",
"UseLongIds": true
},
...
]
}
```
+ Para obter detalhes da API, consulte [DescribeAggregateIdFormat](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-aggregate-id-format.html)em *Referência de AWS CLI Comandos*.
### `describe-availability-zones`
O código de exemplo a seguir mostra como usar `describe-availability-zones`.
**AWS CLI**
**Para descrever suas zonas de disponibilidade**
O exemplo `describe-availability-zones` a seguir exibe detalhes das zonas de disponibilidade disponíveis para você. A resposta inclui zonas de disponibilidade somente para a região atual. Neste exemplo, ela usa a região padrão dos perfis do `us-west-2` (Oregon).
```
aws ec2 describe-availability-zones
```
Saída:
```
{
"AvailabilityZones": [
{
"State": "available",
"OptInStatus": "opt-in-not-required",
"Messages": [],
"RegionName": "us-west-2",
"ZoneName": "us-west-2a",
"ZoneId": "usw2-az1",
"GroupName": "us-west-2",
"NetworkBorderGroup": "us-west-2"
},
{
"State": "available",
"OptInStatus": "opt-in-not-required",
"Messages": [],
"RegionName": "us-west-2",
"ZoneName": "us-west-2b",
"ZoneId": "usw2-az2",
"GroupName": "us-west-2",
"NetworkBorderGroup": "us-west-2"
},
{
"State": "available",
"OptInStatus": "opt-in-not-required",
"Messages": [],
"RegionName": "us-west-2",
"ZoneName": "us-west-2c",
"ZoneId": "usw2-az3",
"GroupName": "us-west-2",
"NetworkBorderGroup": "us-west-2"
},
{
"State": "available",
"OptInStatus": "opt-in-not-required",
"Messages": [],
"RegionName": "us-west-2",
"ZoneName": "us-west-2d",
"ZoneId": "usw2-az4",
"GroupName": "us-west-2",
"NetworkBorderGroup": "us-west-2"
},
{
"State": "available",
"OptInStatus": "opted-in",
"Messages": [],
"RegionName": "us-west-2",
"ZoneName": "us-west-2-lax-1a",
"ZoneId": "usw2-lax1-az1",
"GroupName": "us-west-2-lax-1",
"NetworkBorderGroup": "us-west-2-lax-1"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeAvailabilityZones](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-availability-zones.html)em *Referência de AWS CLI Comandos*.
### `describe-aws-network-performance-metric-subscription`
O código de exemplo a seguir mostra como usar `describe-aws-network-performance-metric-subscription`.
**AWS CLI**
**Descrever suas assinaturas métricas**
O exemplo `describe-aws-network-performance-metric-subscriptions` a seguir descreve suas assinaturas métricas.
```
aws ec2 describe-aws-network-performance-metric-subscriptions
```
Saída:
```
{
"Subscriptions": [
{
"Source": "us-east-1",
"Destination": "eu-west-1",
"Metric": "aggregate-latency",
"Statistic": "p50",
"Period": "five-minutes"
}
]
}
```
Para obter mais informações, consulte [Gerenciar assinaturas](https://docs.aws.amazon.com/network-manager/latest/infrastructure-performance/nmip-subscriptions-cw.html) no *Guia do usuário de desempenho da infraestrutura*.
+ Para obter detalhes da API, consulte [DescribeAwsNetworkPerformanceMetricSubscription](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-aws-network-performance-metric-subscription.html)em *Referência de AWS CLI Comandos*.
### `describe-aws-network-performance-metric-subscriptions`
O código de exemplo a seguir mostra como usar `describe-aws-network-performance-metric-subscriptions`.
**AWS CLI**
**Descrever suas assinaturas métricas**
O exemplo `describe-aws-network-performance-metric-subscriptions` a seguir descreve suas assinaturas métricas.
```
aws ec2 describe-aws-network-performance-metric-subscriptions
```
Saída:
```
{
"Subscriptions": [
{
"Source": "us-east-1",
"Destination": "eu-west-1",
"Metric": "aggregate-latency",
"Statistic": "p50",
"Period": "five-minutes"
}
]
}
```
Para obter mais informações, consulte [Gerenciar assinaturas](https://docs.aws.amazon.com/network-manager/latest/infrastructure-performance/nmip-subscriptions-cw.html) no *Guia do usuário de desempenho da infraestrutura*.
+ Para obter detalhes da API, consulte [DescribeAwsNetworkPerformanceMetricSubscriptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-aws-network-performance-metric-subscriptions.html)em *Referência de AWS CLI Comandos*.
### `describe-bundle-tasks`
O código de exemplo a seguir mostra como usar `describe-bundle-tasks`.
**AWS CLI**
**Descrever suas tarefas de empacotamento**
Este exemplo descreve todas as tarefas de empacotamento.
Comando:
```
aws ec2 describe-bundle-tasks
```
Saída:
```
{
"BundleTasks": [
{
"UpdateTime": "2015-09-15T13:26:54.000Z",
"InstanceId": "i-1234567890abcdef0",
"Storage": {
"S3": {
"Prefix": "winami",
"Bucket": "bundletasks"
}
},
"State": "bundling",
"StartTime": "2015-09-15T13:24:35.000Z",
"Progress": "3%",
"BundleId": "bun-2a4e041c"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeBundleTasks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-bundle-tasks.html)em *Referência de AWS CLI Comandos*.
### `describe-byoip-cidrs`
O código de exemplo a seguir mostra como usar `describe-byoip-cidrs`.
**AWS CLI**
**Descrever seus intervalos de endereços provisionados**
O `describe-byoip-cidrs` exemplo a seguir exibe detalhes sobre os intervalos de IPv4 endereços públicos que você provisionou para uso. AWS
```
aws ec2 describe-byoip-cidrs
```
Saída:
```
{
"ByoipCidrs": [
{
"Cidr": "203.0.113.25/24",
"StatusMessage": "ipv4pool-ec2-1234567890abcdef0",
"State": "provisioned"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeByoipCidrs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-byoip-cidrs.html)em *Referência de AWS CLI Comandos*.
### `describe-capacity-reservation-fleets`
O código de exemplo a seguir mostra como usar `describe-capacity-reservation-fleets`.
**AWS CLI**
**Visualizar uma frota de reserva de capacidade**
O exemplo `describe-capacity-reservation-fleets` a seguir lista as informações de configuração e capacidade da frota de reserva de capacidade especificada. Ele também lista detalhes sobre as reservas de capacidade individuais que estão na frota.
```
aws ec2 describe-capacity-reservation-fleets \
--capacity-reservation-fleet-ids crf-abcdef01234567890
```
Saída:
```
{
"CapacityReservationFleets": [
{
"State": "active",
"EndDate": "2022-12-31T23:59:59.000Z",
"InstanceMatchCriteria": "open",
"Tags": [],
"CapacityReservationFleetId": "crf-abcdef01234567890",
"Tenancy": "default",
"InstanceTypeSpecifications": [
{
"CapacityReservationId": "cr-1234567890abcdef0",
"AvailabilityZone": "us-east-1a",
"FulfilledCapacity": 5.0,
"Weight": 1.0,
"CreateDate": "2022-07-02T08:34:33.398Z",
"InstancePlatform": "Linux/UNIX",
"TotalInstanceCount": 5,
"Priority": 1,
"EbsOptimized": true,
"InstanceType": "m5.xlarge"
}
],
"TotalTargetCapacity": 5,
"TotalFulfilledCapacity": 5.0,
"CreateTime": "2022-07-02T08:34:33.397Z",
"AllocationStrategy": "prioritized"
}
]
}
```
Para obter mais informações sobre as Frotas de Reserva de Capacidade, consulte [Frotas de reserva de capacidade](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cr-fleets.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DescribeCapacityReservationFleets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-capacity-reservation-fleets.html)em *Referência de AWS CLI Comandos*.
### `describe-capacity-reservations`
O código de exemplo a seguir mostra como usar `describe-capacity-reservations`.
**AWS CLI**
**Exemplo 1: descrever uma ou mais de suas reservas de capacidade**
O `describe-capacity-reservations` exemplo a seguir exibe detalhes sobre todas as suas reservas de capacidade na AWS região atual.
```
aws ec2 describe-capacity-reservations
```
Saída:
```
{
"CapacityReservations": [
{
"CapacityReservationId": "cr-1234abcd56EXAMPLE ",
"OwnerId": "123456789111",
"CapacityReservationArn": "arn:aws:ec2:us-east-1:123456789111:capacity-reservation/cr-1234abcd56EXAMPLE",
"AvailabilityZoneId": "use1-az2",
"InstanceType": "c5.large",
"InstancePlatform": "Linux/UNIX",
"AvailabilityZone": "us-east-1a",
"Tenancy": "default",
"TotalInstanceCount": 1,
"AvailableInstanceCount": 1,
"EbsOptimized": true,
"EphemeralStorage": false,
"State": "active",
"StartDate": "2024-10-23T15:00:24+00:00",
"EndDateType": "unlimited",
"InstanceMatchCriteria": "open",
"CreateDate": "2024-10-23T15:00:24+00:00",
"Tags": [],
"CapacityAllocations": []
},
{
"CapacityReservationId": "cr-abcdEXAMPLE9876ef ",
"OwnerId": "123456789111",
"CapacityReservationArn": "arn:aws:ec2:us-east-1:123456789111:capacity-reservation/cr-abcdEXAMPLE9876ef",
"AvailabilityZoneId": "use1-az2",
"InstanceType": "c4.large",
"InstancePlatform": "Linux/UNIX",
"AvailabilityZone": "us-east-1a",
"Tenancy": "default",
"TotalInstanceCount": 1,
"AvailableInstanceCount": 1,
"EbsOptimized": true,
"EphemeralStorage": false,
"State": "cancelled",
"StartDate": "2024-10-23T15:01:03+00:00",
"EndDateType": "unlimited",
"InstanceMatchCriteria": "open",
"CreateDate": "2024-10-23T15:01:02+00:00",
"Tags": [],
"CapacityAllocations": []
}
]
}
```
**Exemplo 2: descrever uma ou mais de suas reservas de capacidade**
O exemplo `describe-capacity-reservations` a seguir exibe os detalhes da reserva de capacidade especificada.
```
aws ec2 describe-capacity-reservations \
--capacity-reservation-ids cr-1234abcd56EXAMPLE
```
Saída:
```
{
"CapacityReservations": [
{
"CapacityReservationId": "cr-abcdEXAMPLE9876ef ",
"OwnerId": "123456789111",
"CapacityReservationArn": "arn:aws:ec2:us-east-1:123456789111:capacity-reservation/cr-abcdEXAMPLE9876ef",
"AvailabilityZoneId": "use1-az2",
"InstanceType": "c4.large",
"InstancePlatform": "Linux/UNIX",
"AvailabilityZone": "us-east-1a",
"Tenancy": "default",
"TotalInstanceCount": 1,
"AvailableInstanceCount": 1,
"EbsOptimized": true,
"EphemeralStorage": false,
"State": "active",
"StartDate": "2024-10-23T15:01:03+00:00",
"EndDateType": "unlimited",
"InstanceMatchCriteria": "open",
"CreateDate": "2024-10-23T15:01:02+00:00",
"Tags": [],
"CapacityAllocations": []
}
]
}
```
Para obter mais informações, consulte [Visualizar uma reserva de capacidade](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservations-using.html#capacity-reservations-view) no *Guia do usuário do Amazon Elastic Compute Cloud para instâncias Linux*.
+ Para obter detalhes da API, consulte [DescribeCapacityReservations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-capacity-reservations.html)em *Referência de AWS CLI Comandos*.
### `describe-carrier-gateways`
O código de exemplo a seguir mostra como usar `describe-carrier-gateways`.
**AWS CLI**
**Descrever todos os gateways da operadora**
O exemplo `describe-carrier-gateways` a seguir lista todos os gateways da operadora.
```
aws ec2 describe-carrier-gateways
```
Saída:
```
{
"CarrierGateways": [
{
"CarrierGatewayId": "cagw-0465cdEXAMPLE1111",
"VpcId": "vpc-0c529aEXAMPLE",
"State": "available",
"OwnerId": "123456789012",
"Tags": [
{
"Key": "example",
"Value": "tag"
}
]
}
]
}
```
*Para obter mais informações, consulte Carrier gateways< https://docs.aws.amazon.com/vpc/ latest/userguide/Carrier \$1gateway.html> no Guia do usuário da Amazon Virtual Private Cloud.*
+ Para obter detalhes da API, consulte [DescribeCarrierGateways](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-carrier-gateways.html)em *Referência de AWS CLI Comandos*.
### `describe-classic-link-instances`
O código de exemplo a seguir mostra como usar `describe-classic-link-instances`.
**AWS CLI**
**Descrever instâncias vinculadas do EC2-Classic**
Este exemplo lista todas as suas instâncias vinculadas do EC2-Classic.
Comando:
```
aws ec2 describe-classic-link-instances
```
Saída:
```
{
"Instances": [
{
"InstanceId": "i-1234567890abcdef0",
"VpcId": "vpc-88888888",
"Groups": [
{
"GroupId": "sg-11122233"
}
],
"Tags": [
{
"Value": "ClassicInstance",
"Key": "Name"
}
]
},
{
"InstanceId": "i-0598c7d356eba48d7",
"VpcId": "vpc-12312312",
"Groups": [
{
"GroupId": "sg-aabbccdd"
}
],
"Tags": [
{
"Value": "ClassicInstance2",
"Key": "Name"
}
]
}
]
}
```
Este exemplo lista todas as suas instâncias do EC2-Classic vinculadas e filtra a resposta para incluir somente instâncias vinculadas à VPC vpc-88888888.
Comando:
```
aws ec2 describe-classic-link-instances --filter "Name=vpc-id,Values=vpc-88888888"
```
Saída:
```
{
"Instances": [
{
"InstanceId": "i-1234567890abcdef0",
"VpcId": "vpc-88888888",
"Groups": [
{
"GroupId": "sg-11122233"
}
],
"Tags": [
{
"Value": "ClassicInstance",
"Key": "Name"
}
]
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeClassicLinkInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-classic-link-instances.html)em *Referência de AWS CLI Comandos*.
### `describe-client-vpn-authorization-rules`
O código de exemplo a seguir mostra como usar `describe-client-vpn-authorization-rules`.
**AWS CLI**
**Descrever as regras de autorização de um endpoint de Client VPN**
O exemplo `describe-client-vpn-authorization-rules` a seguir exibe detalhes sobre as regras de autorização para o endpoint Client VPN especificado.
```
aws ec2 describe-client-vpn-authorization-rules \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde
```
Saída:
```
{
"AuthorizationRules": [
{
"ClientVpnEndpointId": "cvpn-endpoint-123456789123abcde",
"GroupId": "",
"AccessAll": true,
"DestinationCidr": "0.0.0.0/0",
"Status": {
"Code": "active"
}
}
]
}
```
Para obter mais informações, consulte [Regras de autorização](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-rules.html) no *Guia do administrador do Cliente VPN da AWS *.
+ Para obter detalhes da API, consulte [DescribeClientVpnAuthorizationRules](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-client-vpn-authorization-rules.html)em *Referência de AWS CLI Comandos*.
### `describe-client-vpn-connections`
O código de exemplo a seguir mostra como usar `describe-client-vpn-connections`.
**AWS CLI**
**Descrever as conexões com um endpoint do Client VPN**
O exemplo `describe-client-vpn-connections` a seguir exibe detalhes sobre as conexões do cliente com o endpoint do Client VPN especificado.
```
aws ec2 describe-client-vpn-connections \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde
```
Saída:
```
{
"Connections": [
{
"ClientVpnEndpointId": "cvpn-endpoint-123456789123abcde",
"Timestamp": "2019-08-12 07:58:34",
"ConnectionId": "cvpn-connection-0e03eb24267165acd",
"ConnectionEstablishedTime": "2019-08-12 07:57:14",
"IngressBytes": "32302",
"EgressBytes": "5696",
"IngressPackets": "332",
"EgressPackets": "67",
"ClientIp": "172.31.0.225",
"CommonName": "client1.domain.tld",
"Status": {
"Code": "terminated"
},
"ConnectionEndTime": "2019-08-12 07:58:34"
},
{
"ClientVpnEndpointId": "cvpn-endpoint-123456789123abcde",
"Timestamp": "2019-08-12 08:02:54",
"ConnectionId": "cvpn-connection-00668867a40f18253",
"ConnectionEstablishedTime": "2019-08-12 08:02:53",
"IngressBytes": "2951",
"EgressBytes": "2611",
"IngressPackets": "9",
"EgressPackets": "6",
"ClientIp": "172.31.0.226",
"CommonName": "client1.domain.tld",
"Status": {
"Code": "active"
},
"ConnectionEndTime": "-"
}
]
}
```
Para obter mais informações, consulte [Conexões do cliente](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-connections.html) no *Guia do administrador do AWS Client VPN*.
+ Para obter detalhes da API, consulte [DescribeClientVpnConnections](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-client-vpn-connections.html)em *Referência de AWS CLI Comandos*.
### `describe-client-vpn-endpoints`
O código de exemplo a seguir mostra como usar `describe-client-vpn-endpoints`.
**AWS CLI**
**Descrever seus endpoints do Client VPN**
O exemplo `describe-client-vpn-endpoints` a seguir exibe detalhes sobre todos os seus endpoints do Client VPN.
```
aws ec2 describe-client-vpn-endpoints
```
Saída:
```
{
"ClientVpnEndpoints": [
{
"ClientVpnEndpointId": "cvpn-endpoint-123456789123abcde",
"Description": "Endpoint for Admin access",
"Status": {
"Code": "available"
},
"CreationTime": "2020-11-13T11:37:27",
"DnsName": "*.cvpn-endpoint-123456789123abcde.prod.clientvpn.ap-south-1.amazonaws.com",
"ClientCidrBlock": "172.31.0.0/16",
"DnsServers": [
"8.8.8.8"
],
"SplitTunnel": false,
"VpnProtocol": "openvpn",
"TransportProtocol": "udp",
"VpnPort": 443,
"ServerCertificateArn": "arn:aws:acm:ap-south-1:123456789012:certificate/a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"AuthenticationOptions": [
{
"Type": "certificate-authentication",
"MutualAuthentication": {
"ClientRootCertificateChain": "arn:aws:acm:ap-south-1:123456789012:certificate/a1b2c3d4-5678-90ab-cdef-22222EXAMPLE"
}
}
],
"ConnectionLogOptions": {
"Enabled": true,
"CloudwatchLogGroup": "Client-vpn-connection-logs",
"CloudwatchLogStream": "cvpn-endpoint-123456789123abcde-ap-south-1-2020/11/13-FCD8HEMVaCcw"
},
"Tags": [
{
"Key": "Name",
"Value": "Client VPN"
}
],
"SecurityGroupIds": [
"sg-aabbcc11223344567"
],
"VpcId": "vpc-a87f92c1",
"SelfServicePortalUrl": "https://self-service.clientvpn.amazonaws.com/endpoints/cvpn-endpoint-123456789123abcde",
"ClientConnectOptions": {
"Enabled": false
}
}
]
}
```
Para obter mais informações, consulte [Endpoints de Client VPN](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-endpoints.html) no *Guia do administrador do Cliente VPN da AWS *.
+ Para obter detalhes da API, consulte [DescribeClientVpnEndpoints](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-client-vpn-endpoints.html)em *Referência de AWS CLI Comandos*.
### `describe-client-vpn-routes`
O código de exemplo a seguir mostra como usar `describe-client-vpn-routes`.
**AWS CLI**
**Descrever as rotas de um endpoint de Client VPN**
O exemplo `describe-client-vpn-routes` a seguir exibe detalhes sobre as rotas para o endpoint de Client VPN especificado.
```
aws ec2 describe-client-vpn-routes \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde
```
Saída:
```
{
"Routes": [
{
"ClientVpnEndpointId": "cvpn-endpoint-123456789123abcde",
"DestinationCidr": "10.0.0.0/16",
"TargetSubnet": "subnet-0123456789abcabca",
"Type": "Nat",
"Origin": "associate",
"Status": {
"Code": "active"
},
"Description": "Default Route"
},
{
"ClientVpnEndpointId": "cvpn-endpoint-123456789123abcde",
"DestinationCidr": "0.0.0.0/0",
"TargetSubnet": "subnet-0123456789abcabca",
"Type": "Nat",
"Origin": "add-route",
"Status": {
"Code": "active"
}
}
]
}
```
Para obter mais informações, consulte [Rotas](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-routes.html) no *Guia do administrador de cliente VPN da AWS *.
+ Para obter detalhes da API, consulte [DescribeClientVpnRoutes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-client-vpn-routes.html)em *Referência de AWS CLI Comandos*.
### `describe-client-vpn-target-networks`
O código de exemplo a seguir mostra como usar `describe-client-vpn-target-networks`.
**AWS CLI**
**Descrever as redes de destino de um endpoint de Client VPN**
O exemplo `describe-client-vpn-target-networks` a seguir exibe detalhes sobre as redes de destino para o endpoint de Client VPN especificado.
```
aws ec2 describe-client-vpn-target-networks \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde
```
Saída:
```
{
"ClientVpnTargetNetworks": [
{
"AssociationId": "cvpn-assoc-012e837060753dc3d",
"VpcId": "vpc-11111222222333333",
"TargetNetworkId": "subnet-0123456789abcabca",
"ClientVpnEndpointId": "cvpn-endpoint-123456789123abcde",
"Status": {
"Code": "associating"
},
"SecurityGroups": [
"sg-012345678910abcab"
]
}
]
}
```
Para obter mais informações, consulte [Redes de destino](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-target.html) no *Guia do administrador da AWS *.
+ Para obter detalhes da API, consulte [DescribeClientVpnTargetNetworks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-client-vpn-target-networks.html)em *Referência de AWS CLI Comandos*.
### `describe-coip-pools`
O código de exemplo a seguir mostra como usar `describe-coip-pools`.
**AWS CLI**
**Descrever os grupos de endereços IP pertencentes ao cliente**
O `describe-coip-pools` exemplo a seguir descreve os pools de endereços IP de propriedade do cliente em sua AWS conta.
```
aws ec2 describe-coip-pools
```
Saída:
```
{
"CoipPools": [
{
"PoolId": "ipv4pool-coip-123a45678bEXAMPLE",
"PoolCidrs": [
"0.0.0.0/0"
],
"LocalGatewayRouteTableId": "lgw-rtb-059615ef7dEXAMPLE",
"PoolArn": "arn:aws:ec2:us-west-2:123456789012:coip-pool/ipv4pool-coip-123a45678bEXAMPLE"
}
]
}
```
Para obter mais informações, consulte [Endereços IP pertencentes ao cliente](https://docs.aws.amazon.com/outposts/latest/userguide/outposts-networking-components.html#ip-addressing) no *Guia do usuário do AWS Outposts*.
+ Para obter detalhes da API, consulte [DescribeCoipPools](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-coip-pools.html)em *Referência de AWS CLI Comandos*.
### `describe-conversion-tasks`
O código de exemplo a seguir mostra como usar `describe-conversion-tasks`.
**AWS CLI**
**Visualizar o status de uma tarefa de conversão**
Este exemplo retorna o status de uma tarefa de conversão com o ID import-i-ffvko 9js.
Comando:
```
aws ec2 describe-conversion-tasks --conversion-task-ids import-i-ffvko9js
```
Saída:
```
{
"ConversionTasks": [
{
"ConversionTaskId": "import-i-ffvko9js",
"ImportInstance": {
"InstanceId": "i-1234567890abcdef0",
"Volumes": [
{
"Volume": {
"Id": "vol-049df61146c4d7901",
"Size": 16
},
"Status": "completed",
"Image": {
"Size": 1300687360,
"ImportManifestUrl": "https://s3.amazonaws.com/myimportbucket/411443cd-d620-4f1c-9d66-13144EXAMPLE/RHEL5.vmdkmanifest.xml?AWSAccessKeyId=AKIAIOSFODNN7EXAMPLE&Expires=140EXAMPLE&Signature=XYNhznHNgCqsjDxL9wRL%2FJvEXAMPLE",
"Format": "VMDK"
},
"BytesConverted": 1300682960,
"AvailabilityZone": "us-east-1d"
}
]
},
"ExpirationTime": "2014-05-14T22:06:23Z",
"State": "completed"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeConversionTasks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-conversion-tasks.html)em *Referência de AWS CLI Comandos*.
### `describe-customer-gateways`
O código de exemplo a seguir mostra como usar `describe-customer-gateways`.
**AWS CLI**
**Descrever os gateways do cliente**
Este exemplo descreve os gateways do cliente.
Comando:
```
aws ec2 describe-customer-gateways
```
Saída:
```
{
"CustomerGateways": [
{
"CustomerGatewayId": "cgw-b4dc3961",
"IpAddress": "203.0.113.12",
"State": "available",
"Type": "ipsec.1",
"BgpAsn": "65000"
},
{
"CustomerGatewayId": "cgw-0e11f167",
"IpAddress": "12.1.2.3",
"State": "available",
"Type": "ipsec.1",
"BgpAsn": "65534"
}
]
}
```
**Descrever um gateway do cliente específico**
Este exemplo descreve o gateway do cliente especificado.
Comando:
```
aws ec2 describe-customer-gateways --customer-gateway-ids cgw-0e11f167
```
Saída:
```
{
"CustomerGateways": [
{
"CustomerGatewayId": "cgw-0e11f167",
"IpAddress": "12.1.2.3",
"State": "available",
"Type": "ipsec.1",
"BgpAsn": "65534"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeCustomerGateways](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-customer-gateways.html)em *Referência de AWS CLI Comandos*.
### `describe-dhcp-options`
O código de exemplo a seguir mostra como usar `describe-dhcp-options`.
**AWS CLI**
**Exemplo 1: descrever as opções de DHCP**
O exemplo `describe-dhcp-options` a seguir recupera detalhes das suas opções DHCP.
```
aws ec2 describe-dhcp-options
```
Saída:
```
{
"DhcpOptions": [
{
"DhcpConfigurations": [
{
"Key": "domain-name",
"Values": [
{
"Value": "us-east-2.compute.internal"
}
]
},
{
"Key": "domain-name-servers",
"Values": [
{
"Value": "AmazonProvidedDNS"
}
]
}
],
"DhcpOptionsId": "dopt-19edf471",
"OwnerId": "111122223333"
},
{
"DhcpConfigurations": [
{
"Key": "domain-name",
"Values": [
{
"Value": "us-east-2.compute.internal"
}
]
},
{
"Key": "domain-name-servers",
"Values": [
{
"Value": "AmazonProvidedDNS"
}
]
}
],
"DhcpOptionsId": "dopt-fEXAMPLE",
"OwnerId": "111122223333"
}
]
}
```
Para obter mais informações, consulte [Trabalhar com conjuntos de opções DHCP](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html#DHCPOptionSet) no *Guia do usuário da AWS VPC*.
**Exemplo 2: descrever suas opções de DHCP e filtrar o resultado**
O exemplo `describe-dhcp-options` a seguir descreve as opções de DHCP e usa um filtro para retornar somente as opções de DHCP que têm `example.com` como o servidor de nomes de domínio. O exemplo usa o parâmetro `--query` para exibir somente as informações de configuração e o ID no resultado.
```
aws ec2 describe-dhcp-options \
--filters Name=key,Values=domain-name-servers Name=value,Values=example.com \
--query "DhcpOptions[*].[DhcpConfigurations,DhcpOptionsId]"
```
Saída:
```
[
[
[
{
"Key": "domain-name",
"Values": [
{
"Value": "example.com"
}
]
},
{
"Key": "domain-name-servers",
"Values": [
{
"Value": "172.16.16.16"
}
]
}
],
"dopt-001122334455667ab"
]
]
```
Para obter mais informações, consulte [Trabalhar com conjuntos de opções DHCP](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html#DHCPOptionSet) no *Guia do usuário da AWS VPC*.
+ Para obter detalhes da API, consulte [DescribeDhcpOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-dhcp-options.html)em *Referência de AWS CLI Comandos*.
### `describe-egress-only-internet-gateways`
O código de exemplo a seguir mostra como usar `describe-egress-only-internet-gateways`.
**AWS CLI**
**Descrever um gateway da Internet somente de saída**
Este exemplo descreve seus gateways da Internet somente de saída.
Comando:
```
aws ec2 describe-egress-only-internet-gateways
```
Saída:
```
{
"EgressOnlyInternetGateways": [
{
"EgressOnlyInternetGatewayId": "eigw-015e0e244e24dfe8a",
"Attachments": [
{
"State": "attached",
"VpcId": "vpc-0c62a468"
}
]
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeEgressOnlyInternetGateways](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-egress-only-internet-gateways.html)em *Referência de AWS CLI Comandos*.
### `describe-elastic-gpus`
O código de exemplo a seguir mostra como usar `describe-elastic-gpus`.
**AWS CLI**
**Descrever uma GPU Elastic**
Comando:
```
aws ec2 describe-elastic-gpus --elastic-gpu-ids egpu-12345678901234567890abcdefghijkl
```
+ Para obter detalhes da API, consulte [DescribeElasticGpus](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-elastic-gpus.html)em *Referência de AWS CLI Comandos*.
### `describe-export-image-tasks`
O código de exemplo a seguir mostra como usar `describe-export-image-tasks`.
**AWS CLI**
**Monitorar uma tarefa de exportação de imagem**
O exemplo `describe-export-image-tasks` a seguir verifica o status da tarefa de exportação de imagem especificada. O arquivo de imagem resultante no Amazon S3 é `my-export-bucket/exports/export-ami-1234567890abcdef0.vmdk`.
```
aws ec2 describe-export-image-tasks \
--export-image-task-ids export-ami-1234567890abcdef0
```
Saída para uma tarefa de exportação de imagem que está em andamento.
```
{
"ExportImageTasks": [
{
"ExportImageTaskId": "export-ami-1234567890abcdef0"
"Progress": "21",
"S3ExportLocation": {
"S3Bucket": "my-export-bucket",
"S3Prefix": "exports/"
},
"Status": "active",
"StatusMessage": "updating"
}
]
}
```
Saída para uma tarefa de exportação de imagem concluída.
```
{
"ExportImageTasks": [
{
"ExportImageTaskId": "export-ami-1234567890abcdef0"
"S3ExportLocation": {
"S3Bucket": "my-export-bucket",
"S3Prefix": "exports/"
},
"Status": "completed"
}
]
}
```
Para obter mais informações, consulte [Exportar uma VM de uma AMI](https://docs.aws.amazon.com/vm-import/latest/userguide/vmexport_image.html) no Guia do * Import/Export usuário da VM*.
+ Para obter detalhes da API, consulte [DescribeExportImageTasks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-export-image-tasks.html)em *Referência de AWS CLI Comandos*.
### `describe-export-tasks`
O código de exemplo a seguir mostra como usar `describe-export-tasks`.
**AWS CLI**
**Listar detalhes sobre uma tarefa de exportação de instância**
Este exemplo descreve a tarefa de exportação com ID export-i-fh 8sjjsq.
Comando:
```
aws ec2 describe-export-tasks --export-task-ids export-i-fh8sjjsq
```
Saída:
```
{
"ExportTasks": [
{
"State": "active",
"InstanceExportDetails": {
"InstanceId": "i-1234567890abcdef0",
"TargetEnvironment": "vmware"
},
"ExportToS3Task": {
"S3Bucket": "myexportbucket",
"S3Key": "RHEL5export-i-fh8sjjsq.ova",
"DiskImageFormat": "vmdk",
"ContainerFormat": "ova"
},
"Description": "RHEL5 instance",
"ExportTaskId": "export-i-fh8sjjsq"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeExportTasks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-export-tasks.html)em *Referência de AWS CLI Comandos*.
### `describe-fast-launch-images`
O código de exemplo a seguir mostra como usar `describe-fast-launch-images`.
**AWS CLI**
**Para descrever os detalhes do Windows AMIs que estão configurados para um lançamento mais rápido**
O `describe-fast-launch-images` exemplo a seguir descreve os detalhes de cada um AMIs em sua conta que está configurado para lançamento mais rápido, incluindo o tipo de recurso, a configuração do snapshot, os detalhes do modelo de execução, o número máximo de inicializações paralelas, o ID do proprietário da AMI, o estado da configuração de inicialização rápida, o motivo pelo qual o estado foi alterado e a hora em que a mudança de estado ocorreu.
```
aws ec2 describe-fast-launch-images
```
Saída:
```
{
"FastLaunchImages": [
{
"ImageId": "ami-01234567890abcedf",
"ResourceType": "snapshot",
"SnapshotConfiguration": {},
"LaunchTemplate": {
"LaunchTemplateId": "lt-01234567890abcedf",
"LaunchTemplateName": "EC2FastLaunchDefaultResourceCreation-a8c6215d-94e6-441b-9272-dbd1f87b07e2",
"Version": "1"
},
"MaxParallelLaunches": 6,
"OwnerId": "0123456789123",
"State": "enabled",
"StateTransitionReason": "Client.UserInitiated",
"StateTransitionTime": "2022-01-27T22:20:06.552000+00:00"
}
]
}
```
Para obter mais informações sobre como configurar uma AMI do Windows para uma inicialização mais rápida, consulte [Configurar AMI para uma execução mais rápida](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/windows-ami-version-history.html#win-ami-config-fast-launch) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DescribeFastLaunchImages](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-fast-launch-images.html)em *Referência de AWS CLI Comandos*.
### `describe-fast-snapshot-restores`
O código de exemplo a seguir mostra como usar `describe-fast-snapshot-restores`.
**AWS CLI**
**Descrever restaurações rápidas de snapshot**
O exemplo `describe-fast-snapshot-restores` a seguir exibe detalhes de todas as restaurações rápidas de snapshots com um estado `disabled`.
```
aws ec2 describe-fast-snapshot-restores \
--filters Name=state,Values=disabled
```
Saída:
```
{
"FastSnapshotRestores": [
{
"SnapshotId": "snap-1234567890abcdef0",
"AvailabilityZone": "us-west-2c",
"State": "disabled",
"StateTransitionReason": "Client.UserInitiated - Lifecycle state transition",
"OwnerId": "123456789012",
"EnablingTime": "2020-01-25T23:57:49.596Z",
"OptimizingTime": "2020-01-25T23:58:25.573Z",
"EnabledTime": "2020-01-25T23:59:29.852Z",
"DisablingTime": "2020-01-26T00:40:56.069Z",
"DisabledTime": "2020-01-26T00:41:27.390Z"
}
]
}
```
O exemplo `describe-fast-snapshot-restores` a seguir descreve todas as restaurações rápidas de snapshots.
```
aws ec2 describe-fast-snapshot-restores
```
+ Para obter detalhes da API, consulte [DescribeFastSnapshotRestores](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-fast-snapshot-restores.html)em *Referência de AWS CLI Comandos*.
### `describe-fleet-history`
O código de exemplo a seguir mostra como usar `describe-fleet-history`.
**AWS CLI**
**Descrever a história da frota EC2**
O exemplo `describe-fleet-history` a seguir retorna o histórico da Frota do EC2 especificada a partir da hora determinada. O resultado é para uma frota do EC2 com duas instâncias em execução.
```
aws ec2 describe-fleet-history \
--fleet-id fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE \
--start-time 2020-09-01T00:00:00Z
```
Saída:
```
{
"HistoryRecords": [
{
"EventInformation": {
"EventSubType": "submitted"
},
"EventType": "fleetRequestChange",
"Timestamp": "2020-09-01T18:26:05.000Z"
},
{
"EventInformation": {
"EventSubType": "active"
},
"EventType": "fleetRequestChange",
"Timestamp": "2020-09-01T18:26:15.000Z"
},
{
"EventInformation": {
"EventDescription": "t2.small, ami-07c8bc5c1ce9598c3, ...",
"EventSubType": "progress"
},
"EventType": "fleetRequestChange",
"Timestamp": "2020-09-01T18:26:17.000Z"
},
{
"EventInformation": {
"EventDescription": "{\"instanceType\":\"t2.small\", ...}",
"EventSubType": "launched",
"InstanceId": "i-083a1c446e66085d2"
},
"EventType": "instanceChange",
"Timestamp": "2020-09-01T18:26:17.000Z"
},
{
"EventInformation": {
"EventDescription": "{\"instanceType\":\"t2.small\", ...}",
"EventSubType": "launched",
"InstanceId": "i-090db02406cc3c2d6"
},
"EventType": "instanceChange",
"Timestamp": "2020-09-01T18:26:17.000Z"
}
],
"LastEvaluatedTime": "2020-09-01T19:10:19.000Z",
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE",
"StartTime": "2020-08-31T23:53:20.000Z"
}
```
Para obter mais informações, consulte [Gerenciar uma Frota EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html) no *Guia do usuário do Amazon Elastic Compute Cloud para instâncias Linux*.
+ Para obter detalhes da API, consulte [DescribeFleetHistory](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-fleet-history.html)em *Referência de AWS CLI Comandos*.
### `describe-fleet-instances`
O código de exemplo a seguir mostra como usar `describe-fleet-instances`.
**AWS CLI**
**Descrever as instâncias em execução de uma frota do EC2**
O exemplo `describe-fleet-instances` a seguir descreve as instâncias em execução da Frota do EC2 especificada.
```
aws ec2 describe-fleet-instances \
--fleet-id 12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE
```
Saída:
```
{
"ActiveInstances": [
{
"InstanceId": "i-090db02406cc3c2d6",
"InstanceType": "t2.small",
"SpotInstanceRequestId": "sir-a43gtpfk",
"InstanceHealth": "healthy"
},
{
"InstanceId": "i-083a1c446e66085d2",
"InstanceType": "t2.small",
"SpotInstanceRequestId": "sir-iwcit2nj",
"InstanceHealth": "healthy"
}
],
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE"
}
```
Para obter mais informações, consulte [Gerenciar uma Frota EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html) no *Guia do usuário do Amazon Elastic Compute Cloud para instâncias Linux*.
+ Para obter detalhes da API, consulte [DescribeFleetInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-fleet-instances.html)em *Referência de AWS CLI Comandos*.
### `describe-fleets`
O código de exemplo a seguir mostra como usar `describe-fleets`.
**AWS CLI**
**Descrever uma frota EC2**
O exemplo `describe-fleets` a seguir descreve a Frota EC2 especificada.
```
aws ec2 describe-fleets \
--fleet-ids fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE
```
Saída:
```
{
"Fleets": [
{
"ActivityStatus": "pending_fulfillment",
"CreateTime": "2020-09-01T18:26:05.000Z",
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE",
"FleetState": "active",
"ExcessCapacityTerminationPolicy": "termination",
"FulfilledCapacity": 0.0,
"FulfilledOnDemandCapacity": 0.0,
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-0e632f2855a979cd5",
"Version": "1"
}
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 2,
"OnDemandTargetCapacity": 0,
"SpotTargetCapacity": 2,
"DefaultTargetCapacityType": "spot"
},
"TerminateInstancesWithExpiration": false,
"Type": "maintain",
"ReplaceUnhealthyInstances": false,
"SpotOptions": {
"AllocationStrategy": "lowestPrice",
"InstanceInterruptionBehavior": "terminate",
"InstancePoolsToUseCount": 1
},
"OnDemandOptions": {
"AllocationStrategy": "lowestPrice"
}
}
]
}
```
Para obter mais informações, consulte [Gerenciar uma Frota EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html) no *Guia do usuário do Amazon Elastic Compute Cloud para instâncias Linux*.
+ Para obter detalhes da API, consulte [DescribeFleets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-fleets.html)em *Referência de AWS CLI Comandos*.
### `describe-flow-logs`
O código de exemplo a seguir mostra como usar `describe-flow-logs`.
**AWS CLI**
**Exemplo 1: descrever todos os seus logs de fluxo**
O exemplo `describe-flow-logs` a seguir exibe detalhes de todos os logs de fluxo.
```
aws ec2 describe-flow-logs
```
Saída:
```
{
"FlowLogs": [
{
"CreationTime": "2018-02-21T13:22:12.644Z",
"DeliverLogsPermissionArn": "arn:aws:iam::123456789012:role/flow-logs-role",
"DeliverLogsStatus": "SUCCESS",
"FlowLogId": "fl-aabbccdd112233445",
"MaxAggregationInterval": 600,
"FlowLogStatus": "ACTIVE",
"LogGroupName": "FlowLogGroup",
"ResourceId": "subnet-12345678901234567",
"TrafficType": "ALL",
"LogDestinationType": "cloud-watch-logs",
"LogFormat": "${version} ${account-id} ${interface-id} ${srcaddr} ${dstaddr} ${srcport} ${dstport} ${protocol} ${packets} ${bytes} ${start} ${end} ${action} ${log-status}"
},
{
"CreationTime": "2020-02-04T15:22:29.986Z",
"DeliverLogsStatus": "SUCCESS",
"FlowLogId": "fl-01234567890123456",
"MaxAggregationInterval": 60,
"FlowLogStatus": "ACTIVE",
"ResourceId": "vpc-00112233445566778",
"TrafficType": "ACCEPT",
"LogDestinationType": "s3",
"LogDestination": "arn:aws:s3:::my-flow-log-bucket/custom",
"LogFormat": "${version} ${vpc-id} ${subnet-id} ${instance-id} ${interface-id} ${account-id} ${type} ${srcaddr} ${dstaddr} ${srcport} ${dstport} ${pkt-srcaddr} ${pkt-dstaddr} ${protocol} ${bytes} ${packets} ${start} ${end} ${action} ${tcp-flags} ${log-status}"
}
]
}
```
**Exemplo 2: descrever um subconjunto dos seus logs de fluxo**
O `describe-flow-logs` exemplo a seguir usa um filtro para exibir detalhes somente dos registros de fluxo que estão no grupo de registros especificado no Amazon CloudWatch Logs.
```
aws ec2 describe-flow-logs \
--filter "Name=log-group-name,Values=MyFlowLogs"
```
+ Para obter detalhes da API, consulte [DescribeFlowLogs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-flow-logs.html)em *Referência de AWS CLI Comandos*.
### `describe-fpga-image-attribute`
O código de exemplo a seguir mostra como usar `describe-fpga-image-attribute`.
**AWS CLI**
**Descrever os atributos de uma imagem do Amazon FPGA**
Este exemplo descreve as permissões de carga para a AFI especificada.
Comando:
```
aws ec2 describe-fpga-image-attribute --fpga-image-id afi-0d123e123bfc85abc --attribute loadPermission
```
Saída:
```
{
"FpgaImageAttribute": {
"FpgaImageId": "afi-0d123e123bfc85abc",
"LoadPermissions": [
{
"UserId": "123456789012"
}
]
}
}
```
+ Para obter detalhes da API, consulte [DescribeFpgaImageAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-fpga-image-attribute.html)em *Referência de AWS CLI Comandos*.
### `describe-fpga-images`
O código de exemplo a seguir mostra como usar `describe-fpga-images`.
**AWS CLI**
**Descrever imagens do Amazon FPGA**
Este exemplo descreve AFIs que são de propriedade da conta`123456789012`.
Comando:
```
aws ec2 describe-fpga-images --filters Name=owner-id,Values=123456789012
```
Saída:
```
{
"FpgaImages": [
{
"UpdateTime": "2017-12-22T12:09:14.000Z",
"Name": "my-afi",
"PciId": {
"SubsystemVendorId": "0xfedd",
"VendorId": "0x1d0f",
"DeviceId": "0xf000",
"SubsystemId": "0x1d51"
},
"FpgaImageGlobalId": "agfi-123cb27b5e84a0abc",
"Public": false,
"State": {
"Code": "available"
},
"ShellVersion": "0x071417d3",
"OwnerId": "123456789012",
"FpgaImageId": "afi-0d123e123bfc85abc",
"CreateTime": "2017-12-22T11:43:33.000Z",
"Description": "my-afi"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeFpgaImages](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-fpga-images.html)em *Referência de AWS CLI Comandos*.
### `describe-host-reservation-offerings`
O código de exemplo a seguir mostra como usar `describe-host-reservation-offerings`.
**AWS CLI**
**Descrever as ofertas de reserva de host dedicado**
Este exemplo descreve as Reservas de Host Dedicado para a família de instâncias M4 que estão disponíveis para compra.
Comando:
```
aws ec2 describe-host-reservation-offerings --filter Name=instance-family,Values=m4
```
Saída:
```
{
"OfferingSet": [
{
"HourlyPrice": "1.499",
"OfferingId": "hro-03f707bf363b6b324",
"InstanceFamily": "m4",
"PaymentOption": "NoUpfront",
"UpfrontPrice": "0.000",
"Duration": 31536000
},
{
"HourlyPrice": "1.045",
"OfferingId": "hro-0ef9181cabdef7a02",
"InstanceFamily": "m4",
"PaymentOption": "NoUpfront",
"UpfrontPrice": "0.000",
"Duration": 94608000
},
{
"HourlyPrice": "0.714",
"OfferingId": "hro-04567a15500b92a51",
"InstanceFamily": "m4",
"PaymentOption": "PartialUpfront",
"UpfrontPrice": "6254.000",
"Duration": 31536000
},
{
"HourlyPrice": "0.484",
"OfferingId": "hro-0d5d7a9d23ed7fbfe",
"InstanceFamily": "m4",
"PaymentOption": "PartialUpfront",
"UpfrontPrice": "12720.000",
"Duration": 94608000
},
{
"HourlyPrice": "0.000",
"OfferingId": "hro-05da4108ca998c2e5",
"InstanceFamily": "m4",
"PaymentOption": "AllUpfront",
"UpfrontPrice": "23913.000",
"Duration": 94608000
},
{
"HourlyPrice": "0.000",
"OfferingId": "hro-0a9f9be3b95a3dc8f",
"InstanceFamily": "m4",
"PaymentOption": "AllUpfront",
"UpfrontPrice": "12257.000",
"Duration": 31536000
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeHostReservationOfferings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-host-reservation-offerings.html)em *Referência de AWS CLI Comandos*.
### `describe-host-reservations`
O código de exemplo a seguir mostra como usar `describe-host-reservations`.
**AWS CLI**
**Descrever as reservas de host dedicado em sua conta**
Este exemplo descreve as Reservas de Host Dedicado em sua conta.
Comando:
```
aws ec2 describe-host-reservations
```
Saída:
```
{
"HostReservationSet": [
{
"Count": 1,
"End": "2019-01-10T12:14:09Z",
"HourlyPrice": "1.499",
"InstanceFamily": "m4",
"OfferingId": "hro-03f707bf363b6b324",
"PaymentOption": "NoUpfront",
"State": "active",
"HostIdSet": [
"h-013abcd2a00cbd123"
],
"Start": "2018-01-10T12:14:09Z",
"HostReservationId": "hr-0d418a3a4ffc669ae",
"UpfrontPrice": "0.000",
"Duration": 31536000
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeHostReservations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-host-reservations.html)em *Referência de AWS CLI Comandos*.
### `describe-hosts`
O código de exemplo a seguir mostra como usar `describe-hosts`.
**AWS CLI**
**Visualizar os detalhes de um Host dedicado**
O `describe-hosts` exemplo a seguir exibe detalhes dos hosts `available` dedicados em sua AWS conta.
```
aws ec2 describe-hosts --filter "Name=state,Values=available"
```
Saída:
```
{
"Hosts": [
{
"HostId": "h-07879acf49EXAMPLE",
"Tags": [
{
"Value": "production",
"Key": "purpose"
}
],
"HostProperties": {
"Cores": 48,
"TotalVCpus": 96,
"InstanceType": "m5.large",
"Sockets": 2
},
"Instances": [],
"State": "available",
"AvailabilityZone": "eu-west-1a",
"AvailableCapacity": {
"AvailableInstanceCapacity": [
{
"AvailableCapacity": 48,
"InstanceType": "m5.large",
"TotalCapacity": 48
}
],
"AvailableVCpus": 96
},
"HostRecovery": "on",
"AllocationTime": "2019-08-19T08:57:44.000Z",
"AutoPlacement": "off"
}
]
}
```
Para obter mais informações, consulte [Visualizar Hosts Dedicados](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/how-dedicated-hosts-work.html#dedicated-hosts-managing) no *Guia do usuário do Amazon Elastic Compute Cloud para instâncias do Linux*.
+ Para obter detalhes da API, consulte [DescribeHosts](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-hosts.html)em *Referência de AWS CLI Comandos*.
### `describe-iam-instance-profile-associations`
O código de exemplo a seguir mostra como usar `describe-iam-instance-profile-associations`.
**AWS CLI**
**Para descrever as associações do perfil de instância do IAM**
Este exemplo descreve todas as suas associações de perfil de instância do IAM.
Comando:
```
aws ec2 describe-iam-instance-profile-associations
```
Saída:
```
{
"IamInstanceProfileAssociations": [
{
"InstanceId": "i-09eb09efa73ec1dee",
"State": "associated",
"AssociationId": "iip-assoc-0db249b1f25fa24b8",
"IamInstanceProfile": {
"Id": "AIPAJVQN4F5WVLGCJDRGM",
"Arn": "arn:aws:iam::123456789012:instance-profile/admin-role"
}
},
{
"InstanceId": "i-0402909a2f4dffd14",
"State": "associating",
"AssociationId": "iip-assoc-0d1ec06278d29f44a",
"IamInstanceProfile": {
"Id": "AGJAJVQN4F5WVLGCJABCM",
"Arn": "arn:aws:iam::123456789012:instance-profile/user1-role"
}
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeIamInstanceProfileAssociations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-iam-instance-profile-associations.html)em *Referência de AWS CLI Comandos*.
### `describe-id-format`
O código de exemplo a seguir mostra como usar `describe-id-format`.
**AWS CLI**
**Exemplo 1: descrever o formato de ID de um recurso**
O exemplo `describe-id-format` a seguir descreve o formato de ID para grupos de segurança.
```
aws ec2 describe-id-format \
--resource security-group
```
No exemplo de saída a seguir, o valor `Deadline` indica que o prazo para esse tipo de recurso mudar permanentemente do formato de ID curto para o formato de ID longo expirou às 00:00 UTC de 15 de agosto de 2018.
```
{
"Statuses": [
{
"Deadline": "2018-08-15T00:00:00.000Z",
"Resource": "security-group",
"UseLongIds": true
}
]
}
```
**Exemplo 2: descrever o formato de ID de todos os recursos**
O exemplo `describe-id-format` a seguir descreve o formato de ID para todos os tipos de recursos. Todos os tipos de recursos compatíveis com o formato de ID curto foram alterados para o formato de ID longo.
```
aws ec2 describe-id-format
```
+ Para obter detalhes da API, consulte [DescribeIdFormat](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-id-format.html)em *Referência de AWS CLI Comandos*.
### `describe-identity-id-format`
O código de exemplo a seguir mostra como usar `describe-identity-id-format`.
**AWS CLI**
**Descrever o formato de ID de um perfil do IAM**
O `describe-identity-id-format` exemplo a seguir descreve o formato de ID recebido pelas instâncias criadas pela função do IAM `EC2Role` em sua AWS conta.
```
aws ec2 describe-identity-id-format \
--principal-arn arn:aws:iam::123456789012:role/my-iam-role \
--resource instance
```
O resultado a seguir indica que as instâncias criadas por essa função recebem IDs em formato de ID longo.
```
{
"Statuses": [
{
"Deadline": "2016-12-15T00:00:00Z",
"Resource": "instance",
"UseLongIds": true
}
]
}
```
**Descrever o formato de ID de um usuário do IAM**
O `describe-identity-id-format` exemplo a seguir descreve o formato de ID recebido pelos snapshots criados pelo usuário do IAM `AdminUser` em sua AWS conta.
```
aws ec2 describe-identity-id-format \
--principal-arn arn:aws:iam::123456789012:user/AdminUser \
--resource snapshot
```
A saída indica que os instantâneos criados por esse usuário são recebidos IDs no formato de ID longo.
```
{
"Statuses": [
{
"Deadline": "2016-12-15T00:00:00Z",
"Resource": "snapshot",
"UseLongIds": true
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeIdentityIdFormat](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-identity-id-format.html)em *Referência de AWS CLI Comandos*.
### `describe-image-attribute`
O código de exemplo a seguir mostra como usar `describe-image-attribute`.
**AWS CLI**
**Descrever as permissões de lançamento de uma AMI**
Este exemplo descreve as permissões de lançamento da AMI especificada.
Comando:
```
aws ec2 describe-image-attribute --image-id ami-5731123e --attribute launchPermission
```
Saída:
```
{
"LaunchPermissions": [
{
"UserId": "123456789012"
}
],
"ImageId": "ami-5731123e",
}
```
**Descrever os códigos de produto de uma AMI**
Este exemplo descreve os códigos de produto para a AMI especificada. Observe que essa AMI não tem códigos de produto.
Comando:
```
aws ec2 describe-image-attribute --image-id ami-5731123e --attribute productCodes
```
Saída:
```
{
"ProductCodes": [],
"ImageId": "ami-5731123e",
}
```
+ Para obter detalhes da API, consulte [DescribeImageAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-image-attribute.html)em *Referência de AWS CLI Comandos*.
### `describe-images`
O código de exemplo a seguir mostra como usar `describe-images`.
**AWS CLI**
**Exemplo 1: descrever uma AMI**
O exemplo `describe-images` a seguir descreve a AMI especificada na região especificada.
```
aws ec2 describe-images \
--region us-east-1 \
--image-ids ami-1234567890EXAMPLE
```
Saída:
```
{
"Images": [
{
"VirtualizationType": "hvm",
"Description": "Provided by Red Hat, Inc.",
"PlatformDetails": "Red Hat Enterprise Linux",
"EnaSupport": true,
"Hypervisor": "xen",
"State": "available",
"SriovNetSupport": "simple",
"ImageId": "ami-1234567890EXAMPLE",
"UsageOperation": "RunInstances:0010",
"BlockDeviceMappings": [
{
"DeviceName": "/dev/sda1",
"Ebs": {
"SnapshotId": "snap-111222333444aaabb",
"DeleteOnTermination": true,
"VolumeType": "gp2",
"VolumeSize": 10,
"Encrypted": false
}
}
],
"Architecture": "x86_64",
"ImageLocation": "123456789012/RHEL-8.0.0_HVM-20190618-x86_64-1-Hourly2-GP2",
"RootDeviceType": "ebs",
"OwnerId": "123456789012",
"RootDeviceName": "/dev/sda1",
"CreationDate": "2019-05-10T13:17:12.000Z",
"Public": true,
"ImageType": "machine",
"Name": "RHEL-8.0.0_HVM-20190618-x86_64-1-Hourly2-GP2"
}
]
}
```
Para obter mais informações, consulte [Imagens de máquina da Amazon (AMIs)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) no *Guia do usuário do Amazon EC2*.
**Exemplo 2: Para descrever AMIs com base em filtros**
O `describe-images` exemplo a seguir descreve os Windows AMIs fornecidos pela Amazon que são apoiados pelo Amazon EBS.
```
aws ec2 describe-images \
--owners amazon \
--filters "Name=platform,Values=windows" "Name=root-device-type,Values=ebs"
```
Para obter um exemplo da saída de `describe-images`, consulte o Exemplo 1.
Para obter mais exemplos do uso de filtros, consulte [Listar e filtrar seus recursos](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Filtering.html#Filtering_Resources_CLI) no *Guia do usuário do Amazon EC2*.
**Exemplo 3: Para descrever AMIs com base em tags**
O `describe-images` exemplo a seguir descreve todos os AMIs que têm a tag`Type=Custom`. O exemplo usa o `--query` parâmetro para exibir somente a AMI IDs.
```
aws ec2 describe-images \
--filters "Name=tag:Type,Values=Custom" \
--query 'Images[*].[ImageId]' \
--output text
```
Saída:
```
ami-1234567890EXAMPLE
ami-0abcdef1234567890
```
Para obter mais exemplos do uso de filtros de tags, consulte [Trabalhando com tags](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_CLI) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DescribeImages](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-images.html)em *Referência de AWS CLI Comandos*.
### `describe-import-image-tasks`
O código de exemplo a seguir mostra como usar `describe-import-image-tasks`.
**AWS CLI**
**Monitorar uma tarefa de importação de imagem**
O exemplo `describe-import-image-tasks` a seguir verifica o status da tarefa de importação de imagem especificada.
```
aws ec2 describe-import-image-tasks \
--import-task-ids import-ami-1234567890abcdef0
```
Resultado para uma tarefa de importação de imagem que está em andamento.
```
{
"ImportImageTasks": [
{
"ImportTaskId": "import-ami-1234567890abcdef0",
"Progress": "28",
"SnapshotDetails": [
{
"DiskImageSize": 705638400.0,
"Format": "ova",
"Status": "completed",
"UserBucket": {
"S3Bucket": "my-import-bucket",
"S3Key": "vms/my-server-vm.ova"
}
}
],
"Status": "active",
"StatusMessage": "converting"
}
]
}
```
Resultado para uma tarefa de importação de imagem concluída. O ID da AMI resultante é fornecido por `ImageId`.
```
{
"ImportImageTasks": [
{
"ImportTaskId": "import-ami-1234567890abcdef0",
"ImageId": "ami-1234567890abcdef0",
"SnapshotDetails": [
{
"DiskImageSize": 705638400.0,
"Format": "ova",
"SnapshotId": "snap-1234567890abcdef0"
"Status": "completed",
"UserBucket": {
"S3Bucket": "my-import-bucket",
"S3Key": "vms/my-server-vm.ova"
}
}
],
"Status": "completed"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeImportImageTasks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-import-image-tasks.html)em *Referência de AWS CLI Comandos*.
### `describe-import-snapshot-tasks`
O código de exemplo a seguir mostra como usar `describe-import-snapshot-tasks`.
**AWS CLI**
**Monitorar uma tarefa de importação de snapshots**
O exemplo `describe-import-snapshot-tasks` a seguir verifica o status da tarefa de importação instantânea especificada.
```
aws ec2 describe-import-snapshot-tasks \
--import-task-ids import-snap-1234567890abcdef0
```
Resultado de uma tarefa de captura de snapshot de importação que está em andamento:
```
{
"ImportSnapshotTasks": [
{
"Description": "My server VMDK",
"ImportTaskId": "import-snap-1234567890abcdef0",
"SnapshotTaskDetail": {
"Description": "My server VMDK",
"DiskImageSize": "705638400.0",
"Format": "VMDK",
"Progress": "42",
"Status": "active",
"StatusMessage": "downloading/converting",
"UserBucket": {
"S3Bucket": "my-import-bucket",
"S3Key": "vms/my-server-vm.vmdk"
}
}
}
]
}
```
Resultado para uma tarefa de importação de snapshot concluída. O ID do snapshot resultante é fornecido por `SnapshotId`.
```
{
"ImportSnapshotTasks": [
{
"Description": "My server VMDK",
"ImportTaskId": "import-snap-1234567890abcdef0",
"SnapshotTaskDetail": {
"Description": "My server VMDK",
"DiskImageSize": "705638400.0",
"Format": "VMDK",
"SnapshotId": "snap-1234567890abcdef0"
"Status": "completed",
"UserBucket": {
"S3Bucket": "my-import-bucket",
"S3Key": "vms/my-server-vm.vmdk"
}
}
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeImportSnapshotTasks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-import-snapshot-tasks.html)em *Referência de AWS CLI Comandos*.
### `describe-instance-attribute`
O código de exemplo a seguir mostra como usar `describe-instance-attribute`.
**AWS CLI**
**Descrever o tipo de instância**
Este exemplo descreve o tipo de instância da instância especificada.
Comando:
```
aws ec2 describe-instance-attribute --instance-id i-1234567890abcdef0 --attribute instanceType
```
Saída:
```
{
"InstanceId": "i-1234567890abcdef0"
"InstanceType": {
"Value": "t1.micro"
}
}
```
**Para descrever o disableApiTermination atributo**
Este exemplo descreve o atributo `disableApiTermination` da instância especificada.
Comando:
```
aws ec2 describe-instance-attribute --instance-id i-1234567890abcdef0 --attribute disableApiTermination
```
Saída:
```
{
"InstanceId": "i-1234567890abcdef0"
"DisableApiTermination": {
"Value": "false"
}
}
```
**Descrever um mapeamento de dispositivos de blocos para uma instância**
Este exemplo descreve o atributo `blockDeviceMapping` da instância especificada.
Comando:
```
aws ec2 describe-instance-attribute --instance-id i-1234567890abcdef0 --attribute blockDeviceMapping
```
Saída:
```
{
"InstanceId": "i-1234567890abcdef0"
"BlockDeviceMappings": [
{
"DeviceName": "/dev/sda1",
"Ebs": {
"Status": "attached",
"DeleteOnTermination": true,
"VolumeId": "vol-049df61146c4d7901",
"AttachTime": "2013-05-17T22:42:34.000Z"
}
},
{
"DeviceName": "/dev/sdf",
"Ebs": {
"Status": "attached",
"DeleteOnTermination": false,
"VolumeId": "vol-049df61146c4d7901",
"AttachTime": "2013-09-10T23:07:00.000Z"
}
}
],
}
```
+ Para obter detalhes da API, consulte [DescribeInstanceAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-attribute.html)em *Referência de AWS CLI Comandos*.
### `describe-instance-connect-endpoints`
O código de exemplo a seguir mostra como usar `describe-instance-connect-endpoints`.
**AWS CLI**
**Descrever um endpoint de conexão de instância EC2**
O exemplo `describe-instance-connect-endpoints` a seguir descreve o endpoint de conexão de instância EC2 especificado.
```
aws ec2 describe-instance-connect-endpoints \
--region us-east-1 \
--instance-connect-endpoint-ids eice-0123456789example
```
Saída:
```
{
"InstanceConnectEndpoints": [
{
"OwnerId": "111111111111",
"InstanceConnectEndpointId": "eice-0123456789example",
"InstanceConnectEndpointArn": "arn:aws:ec2:us-east-1:111111111111:instance-connect-endpoint/eice-0123456789example",
"State": "create-complete",
"StateMessage": "",
"DnsName": "eice-0123456789example.b67b86ba.ec2-instance-connect-endpoint.us-east-1.amazonaws.com",
"NetworkInterfaceIds": [
"eni-0123456789example"
],
"VpcId": "vpc-0123abcd",
"AvailabilityZone": "us-east-1d",
"CreatedAt": "2023-02-07T12:05:37+00:00",
"SubnetId": "subnet-0123abcd",
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Criar um endpoint de conexão de instância EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-ec2-instance-connect-endpoints.html) no *Guiado usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DescribeInstanceConnectEndpoints](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-connect-endpoints.html)em *Referência de AWS CLI Comandos*.
### `describe-instance-credit-specifications`
O código de exemplo a seguir mostra como usar `describe-instance-credit-specifications`.
**AWS CLI**
**Descrever a opção de crédito para uso de CPU de uma ou mais instâncias**
O exemplo `describe-instance-credit-specifications` a seguir descreve a opção de crédito de CPU para a instância especificada.
```
aws ec2 describe-instance-credit-specifications \
--instance-ids i-1234567890abcdef0
```
Saída:
```
{
"InstanceCreditSpecifications": [
{
"InstanceId": "i-1234567890abcdef0",
"CpuCredits": "unlimited"
}
]
}
```
Para obter mais informações, consulte [Trabalhar com instâncias de desempenho expansível](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-how-to.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DescribeInstanceCreditSpecifications](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-credit-specifications.html)em *Referência de AWS CLI Comandos*.
### `describe-instance-event-notification-attributes`
O código de exemplo a seguir mostra como usar `describe-instance-event-notification-attributes`.
**AWS CLI**
**Descrever as tags para notificações de eventos agendados**
O exemplo `describe-instance-event-notification-attributes` a seguir descreve as tags que aparecerão nas notificações de eventos programados.
```
aws ec2 describe-instance-event-notification-attributes
```
Saída:
```
{
"InstanceTagAttribute": {
"InstanceTagKeys": [],
"IncludeAllTagsOfInstance": true
}
}
```
Para obter mais informações, consulte [Eventos programados para suas instâncias](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html) no *Guia do usuário do Amazon Elastic Compute Cloud para Instâncias Linux*.
+ Para obter detalhes da API, consulte [DescribeInstanceEventNotificationAttributes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-event-notification-attributes.html)em *Referência de AWS CLI Comandos*.
### `describe-instance-event-windows`
O código de exemplo a seguir mostra como usar `describe-instance-event-windows`.
**AWS CLI**
**Exemplo 1: descrever todas as janelas de eventos**
O exemplo `describe-instance-event-windows` a seguir descreve todas as janelas de eventos na região especificada.
```
aws ec2 describe-instance-event-windows \
--region us-east-1
```
Saída:
```
{
"InstanceEventWindows": [
{
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"AssociationTarget": {
"InstanceIds": [
"i-1234567890abcdef0",
"i-0598c7d356eba48d7"
],
"Tags": [],
"DedicatedHostIds": []
},
"State": "active",
"Tags": []
}
...
],
"NextToken": "9d624e0c-388b-4862-a31e-a85c64fc1d4a"
}
```
**Exemplo 2: descrever uma janela de eventos específica**
O exemplo `describe-instance-event-windows` a seguir descreve um evento específico usando o parâmetro `instance-event-window` para descrever uma janela de evento específica.
```
aws ec2 describe-instance-event-windows \
--region us-east-1 \
--instance-event-window-ids iew-0abcdef1234567890
```
Saída:
```
{
"InstanceEventWindows": [
{
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"AssociationTarget": {
"InstanceIds": [
"i-1234567890abcdef0",
"i-0598c7d356eba48d7"
],
"Tags": [],
"DedicatedHostIds": []
},
"State": "active",
"Tags": []
}
}
```
**Exemplo 3: descrever janelas de eventos que correspondam a um ou mais filtros**
O exemplo `describe-instance-event-windows` a seguir descreve janelas de eventos que correspondam a um ou mais filtros usando o parâmetro `filter`. O filtro `instance-id` é usado para descrever todas as janelas de eventos que estão associadas à instância especificada. Quando um filtro é usado, ele executa uma correspondência direta. No entanto, o`instance-id`é diferente. Se não houver correspondência direta com o ID da instância, ele voltará para associações indiretas com a janela de eventos, como tags da instância ou ID de host dedicado (se a instância estiver em um host dedicado).
```
aws ec2 describe-instance-event-windows \
--region us-east-1 \
--filters Name=instance-id,Values=i-1234567890abcdef0 \
--max-results 100 \
--next-token
```
Saída:
```
{
"InstanceEventWindows": [
{
"InstanceEventWindowId": "iew-0dbc0adb66f235982",
"TimeRanges": [
{
"StartWeekDay": "sunday",
"StartHour": 2,
"EndWeekDay": "sunday",
"EndHour": 8
}
],
"Name": "myEventWindowName",
"AssociationTarget": {
"InstanceIds": [],
"Tags": [],
"DedicatedHostIds": [
"h-0140d9a7ecbd102dd"
]
},
"State": "active",
"Tags": []
}
]
}
```
No exemplo de saída, a instância está em um Host Dedicado, que está associado à janela de evento.
Para restrições da janela de eventos, consulte [Considerações](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DescribeInstanceEventWindows](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-event-windows.html)em *Referência de AWS CLI Comandos*.
### `describe-instance-image-metadata`
O código de exemplo a seguir mostra como usar `describe-instance-image-metadata`.
**AWS CLI**
**Exemplo 1: como descrever os metadados de AMI de todas as instâncias**
O `describe-instance-image-metadata` exemplo a seguir descreve os metadados da AMI de todas as instâncias em sua AWS conta na região especificada.
```
aws ec2 describe-instance-image-metadata \
--region us-east-1
```
Saída:
```
{
"InstanceImageMetadata": [
{
"InstanceId": "i-1234567890EXAMPLE",
"InstanceType": "t2.micro",
"LaunchTime": "2024-08-28T11:25:45+00:00",
"AvailabilityZone": "us-east-1a",
"State": {
"Code": 16,
"Name": "running"
},
"OwnerId": "123412341234",
"Tags": [
{
"Key": "MyTagName",
"Value": "my-tag-value"
}
],
"ImageMetadata": {
"ImageId": "ami-0b752bf1df193a6c4",
"Name": "al2023-ami-2023.5.20240819.0-kernel-6.1-x86_64",
"OwnerId": "137112412989",
"State": "available",
"ImageOwnerAlias": "amazon",
"CreationDate": "2023-01-25T17:20:40Z",
"DeprecationTime": "2025-01-25T17:20:40Z",
"IsPublic": true
}
}
],
"NextToken": "...EXAMPLEwIAABAA2JHaFxLnEXAMPLE..."
}
```
Consulte mais informações em [Imagens de máquina da Amazon no Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) no *Manual do usuário do Amazon EC2*.
**Exemplo 2: como descrever os metadados de AMI das instâncias especificadas**
O exemplo de `describe-instance-image-metadata` a seguir descreve os metadados de AMI das instâncias especificadas.
```
aws ec2 describe-instance-image-metadata \
--region us-east-1 \
--instance-ids i-1234567890EXAMPLE i-0987654321EXAMPLE
```
Saída:
```
{
"InstanceImageMetadata": [
{
"InstanceId": "i-1234567890EXAMPLE",
"InstanceType": "t2.micro",
"LaunchTime": "2024-08-28T11:25:45+00:00",
"AvailabilityZone": "us-east-1a",
"State": {
"Code": 16,
"Name": "running"
},
"OwnerId": "123412341234",
"Tags": [
{
"Key": "MyTagName",
"Value": "my-tag-value"
}
],
"ImageMetadata": {
"ImageId": "ami-0b752bf1df193a6c4",
"Name": "al2023-ami-2023.5.20240819.0-kernel-6.1-x86_64",
"OwnerId": "137112412989",
"State": "available",
"ImageOwnerAlias": "amazon",
"CreationDate": "2023-01-25T17:20:40Z",
"DeprecationTime": "2025-01-25T17:20:40Z",
"IsPublic": true
}
},
{
"InstanceId": "i-0987654321EXAMPLE",
"InstanceType": "t2.micro",
"LaunchTime": "2024-08-28T11:25:45+00:00",
"AvailabilityZone": "us-east-1a",
"State": {
"Code": 16,
"Name": "running"
},
"OwnerId": "123412341234",
"Tags": [
{
"Key": "MyTagName",
"Value": "my-tag-value"
}
],
"ImageMetadata": {
"ImageId": "ami-0b752bf1df193a6c4",
"Name": "al2023-ami-2023.5.20240819.0-kernel-6.1-x86_64",
"OwnerId": "137112412989",
"State": "available",
"ImageOwnerAlias": "amazon",
"CreationDate": "2023-01-25T17:20:40Z",
"DeprecationTime": "2025-01-25T17:20:40Z",
"IsPublic": true
}
}
]
}
```
Consulte mais informações em [Imagens de máquina da Amazon no Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) no *Manual do usuário do Amazon EC2*.
**Exemplo 3: como descrever os metadados de AMI das instâncias com base em filtros**
O exemplo de `describe-instance-image-metadata` a seguir descreve os metadados de AMI das instâncias `t2.nano` e `t2.micro` na zona de disponibilidade `us-east-1a`.
```
aws ec2 describe-instance-image-metadata \
--region us-east-1 \
--filters Name=availability-zone,Values=us-east-1a Name=instance-type,Values=t2.nano,t2.micro
```
Saída:
```
{
"InstanceImageMetadata": [
{
"InstanceId": "i-1234567890EXAMPLE",
"InstanceType": "t2.micro",
"LaunchTime": "2024-08-28T11:25:45+00:00",
"AvailabilityZone": "us-east-1a",
"State": {
"Code": 16,
"Name": "running"
},
"OwnerId": "123412341234",
"Tags": [
{
"Key": "MyTagName",
"Value": "my-tag-value"
}
],
"ImageMetadata": {
"ImageId": "ami-0b752bf1df193a6c4",
"Name": "al2023-ami-2023.5.20240819.0-kernel-6.1-x86_64",
"OwnerId": "137112412989",
"State": "available",
"ImageOwnerAlias": "amazon",
"CreationDate": "2023-01-25T17:20:40Z",
"DeprecationTime": "2025-01-25T17:20:40Z",
"IsPublic": true
}
},
{
"InstanceId": "i-0987654321EXAMPLE",
"InstanceType": "t2.micro",
"LaunchTime": "2024-08-28T11:25:45+00:00",
"AvailabilityZone": "us-east-1a",
"State": {
"Code": 16,
"Name": "running"
},
"OwnerId": "123412341234",
"Tags": [
{
"Key": "MyTagName",
"Value": "my-tag-value"
}
],
"ImageMetadata": {
"ImageId": "ami-0b752bf1df193a6c4",
"Name": "al2023-ami-2023.5.20240819.0-kernel-6.1-x86_64",
"OwnerId": "137112412989",
"State": "available",
"ImageOwnerAlias": "amazon",
"CreationDate": "2023-01-25T17:20:40Z",
"DeprecationTime": "2025-01-25T17:20:40Z",
"IsPublic": true
}
}
],
"NextToken": "...EXAMPLEV7ixRYHwIAABAA2JHaFxLnDAzpatfEXAMPLE..."
}
```
Consulte mais informações em [Imagens de máquina da Amazon no Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DescribeInstanceImageMetadata](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-image-metadata.html)em *Referência de AWS CLI Comandos*.
### `describe-instance-status`
O código de exemplo a seguir mostra como usar `describe-instance-status`.
**AWS CLI**
**Para descrever o status de uma instância**
O exemplo `describe-instance-status` a seguir descreve o status atual da instância especificada.
```
aws ec2 describe-instance-status \
--instance-ids i-1234567890abcdef0
```
Saída:
```
{
"InstanceStatuses": [
{
"InstanceId": "i-1234567890abcdef0",
"InstanceState": {
"Code": 16,
"Name": "running"
},
"AvailabilityZone": "us-east-1d",
"SystemStatus": {
"Status": "ok",
"Details": [
{
"Status": "passed",
"Name": "reachability"
}
]
},
"InstanceStatus": {
"Status": "ok",
"Details": [
{
"Status": "passed",
"Name": "reachability"
}
]
}
}
]
}
```
Para obter mais informações, consulte [Monitorar o status das instâncias](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DescribeInstanceStatus](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-status.html)em *Referência de AWS CLI Comandos*.
### `describe-instance-topology`
O código de exemplo a seguir mostra como usar `describe-instance-topology`.
**AWS CLI**
**Descrever a topologia da instância de todas as suas instâncias**
O exemplo `describe-instance-topology` a seguir descreve a topologia de todas as instâncias que correspondem aos tipos de instância compatíveis com esse comando.
```
aws ec2 describe-instance-topology \
--region us-west-2
```
Saída:
```
{
"Instances": [
{
"InstanceId": "i-1111111111example",
"InstanceType": "p4d.24xlarge",
"GroupName": "my-ml-cpg",
"NetworkNodes": [
"nn-1111111111example",
"nn-2222222222example",
"nn-3333333333example"
],
"ZoneId": "usw2-az2",
"AvailabilityZone": "us-west-2a"
},
{
"InstanceId": "i-2222222222example",
"InstanceType": "p4d.24xlarge",
"NetworkNodes": [
"nn-1111111111example",
"nn-2222222222example",
"nn-3333333333example"
],
"ZoneId": "usw2-az2",
"AvailabilityZone": "us-west-2a"
},
{
"InstanceId": "i-3333333333example",
"InstanceType": "trn1.32xlarge",
"NetworkNodes": [
"nn-1212121212example",
"nn-1211122211example",
"nn-1311133311example"
],
"ZoneId": "usw2-az4",
"AvailabilityZone": "us-west-2d"
},
{
"InstanceId": "i-444444444example",
"InstanceType": "trn1.2xlarge",
"NetworkNodes": [
"nn-1111111111example",
"nn-5434334334example",
"nn-1235301234example"
],
"ZoneId": "usw2-az2",
"AvailabilityZone": "us-west-2a"
}
],
"NextToken": "SomeEncryptedToken"
}
```
Para obter mais informações, incluindo mais exemplos, consulte a [Topologia de instâncias do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-topology.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DescribeInstanceTopology](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-topology.html)em *Referência de AWS CLI Comandos*.
### `describe-instance-type-offerings`
O código de exemplo a seguir mostra como usar `describe-instance-type-offerings`.
**AWS CLI**
**Exemplo 1: listar os tipos de instância oferecidos em uma região**
O `describe-instance-type-offerings` exemplo a seguir lista os tipos de instância oferecidos na região configurada como a região padrão para a AWS CLI.
```
aws ec2 describe-instance-type-offerings
```
Para oferecer os tipos de instância oferecidos em uma região diferente, especifique a região usando o parâmetro `--region`.
```
aws ec2 describe-instance-type-offerings \
--region us-east-2
```
Saída:
```
{
"InstanceTypeOfferings": [
{
"InstanceType": "m5.2xlarge",
"LocationType": "region",
"Location": "us-east-2"
},
{
"InstanceType": "t3.micro",
"LocationType": "region",
"Location": "us-east-2"
},
...
]
}
```
**Exemplo 2: listar os tipos de instância oferecidos em uma zona de disponibilidade**
O exemplo `describe-instance-type-offerings` a seguir lista os tipos de instância oferecidos na Zona de Disponibilidade especificada. A Zona de Disponibilidade deve estar na região especificada.
```
aws ec2 describe-instance-type-offerings \
--location-type availability-zone \
--filters Name=location,Values=us-east-2a \
--region us-east-2
```
**Exemplo 3: verificar se um tipo de instância é compatível**
O comando `describe-instance-type-offerings` a seguir indica se o tipo de instância `c5.xlarge` é compatível com a região especificada.
```
aws ec2 describe-instance-type-offerings \
--filters Name=instance-type,Values=c5.xlarge \
--region us-east-2
```
O exemplo `describe-instance-type-offerings` a seguir lista todos os tipos de instância C5 que são compatíveis com a região especificada.
```
aws ec2 describe-instance-type-offerings \
--filters Name=instance-type,Values=c5* \
--query "InstanceTypeOfferings[].InstanceType" \
--region us-east-2
```
Saída:
```
[
"c5d.12xlarge",
"c5d.9xlarge",
"c5n.xlarge",
"c5.xlarge",
"c5d.metal",
"c5n.metal",
"c5.large",
"c5d.2xlarge",
"c5n.4xlarge",
"c5.2xlarge",
"c5n.large",
"c5n.9xlarge",
"c5d.large",
"c5.18xlarge",
"c5d.18xlarge",
"c5.12xlarge",
"c5n.18xlarge",
"c5.metal",
"c5d.4xlarge",
"c5.24xlarge",
"c5d.xlarge",
"c5n.2xlarge",
"c5d.24xlarge",
"c5.9xlarge",
"c5.4xlarge"
]
```
+ Para obter detalhes da API, consulte [DescribeInstanceTypeOfferings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-type-offerings.html)em *Referência de AWS CLI Comandos*.
### `describe-instance-types`
O código de exemplo a seguir mostra como usar `describe-instance-types`.
**AWS CLI**
**Exemplo 1: descrever um tipo de instância**
O exemplo `describe-instance-types` a seguir exibe os detalhes do tipo da instância especificado.
```
aws ec2 describe-instance-types \
--instance-types t2.micro
```
Saída:
```
{
"InstanceTypes": [
{
"InstanceType": "t2.micro",
"CurrentGeneration": true,
"FreeTierEligible": true,
"SupportedUsageClasses": [
"on-demand",
"spot"
],
"SupportedRootDeviceTypes": [
"ebs"
],
"BareMetal": false,
"Hypervisor": "xen",
"ProcessorInfo": {
"SupportedArchitectures": [
"i386",
"x86_64"
],
"SustainedClockSpeedInGhz": 2.5
},
"VCpuInfo": {
"DefaultVCpus": 1,
"DefaultCores": 1,
"DefaultThreadsPerCore": 1,
"ValidCores": [
1
],
"ValidThreadsPerCore": [
1
]
},
"MemoryInfo": {
"SizeInMiB": 1024
},
"InstanceStorageSupported": false,
"EbsInfo": {
"EbsOptimizedSupport": "unsupported",
"EncryptionSupport": "supported"
},
"NetworkInfo": {
"NetworkPerformance": "Low to Moderate",
"MaximumNetworkInterfaces": 2,
"Ipv4AddressesPerInterface": 2,
"Ipv6AddressesPerInterface": 2,
"Ipv6Supported": true,
"EnaSupport": "unsupported"
},
"PlacementGroupInfo": {
"SupportedStrategies": [
"partition",
"spread"
]
},
"HibernationSupported": false,
"BurstablePerformanceSupported": true,
"DedicatedHostsSupported": false,
"AutoRecoverySupported": true
}
]
}
```
Para obter mais informações, consulte [Tipos de instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) no *Guia do usuário do Amazon Elastic Compute Cloud para Instâncias Linux*.
**Exemplo 2: filtrar os tipos de instância disponíveis**
Você pode especificar um filtro para definir o escopo dos resultados para os tipos de instância que tenham uma característica específica. O exemplo `describe-instance-types` a seguir lista os tipos de instância compatíveis com hibernação.
```
aws ec2 describe-instance-types \
--filters Name=hibernation-supported,Values=true --query 'InstanceTypes[*].InstanceType'
```
Saída:
```
[
"m5.8xlarge",
"r3.large",
"c3.8xlarge",
"r5.large",
"m4.4xlarge",
"c4.large",
"m5.xlarge",
"m4.xlarge",
"c3.large",
"c4.8xlarge",
"c4.4xlarge",
"c5.xlarge",
"c5.12xlarge",
"r5.4xlarge",
"c5.4xlarge"
]
```
Para obter mais informações, consulte [Tipos de instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) no *Guia do usuário do Amazon Elastic Compute Cloud para Instâncias Linux*.
+ Para obter detalhes da API, consulte [DescribeInstanceTypes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-types.html)em *Referência de AWS CLI Comandos*.
### `describe-instances`
O código de exemplo a seguir mostra como usar `describe-instances`.
**AWS CLI**
**Exemplo 1: descrever uma instância**
O exemplo `describe-instances` a seguir descreve a instância especificada.
```
aws ec2 describe-instances \
--instance-ids i-1234567890abcdef0
```
Saída:
```
{
"Reservations": [
{
"Groups": [],
"Instances": [
{
"AmiLaunchIndex": 0,
"ImageId": "ami-0abcdef1234567890",
"InstanceId": "i-1234567890abcdef0",
"InstanceType": "t3.nano",
"KeyName": "my-key-pair",
"LaunchTime": "2022-11-15T10:48:59+00:00",
"Monitoring": {
"State": "disabled"
},
"Placement": {
"AvailabilityZone": "us-east-2a",
"GroupName": "",
"Tenancy": "default"
},
"PrivateDnsName": "ip-10-0-0-157.us-east-2.compute.internal",
"PrivateIpAddress": "10-0-0-157",
"ProductCodes": [],
"PublicDnsName": "ec2-34-253-223-13.us-east-2.compute.amazonaws.com",
"PublicIpAddress": "34.253.223.13",
"State": {
"Code": 16,
"Name": "running"
},
"StateTransitionReason": "",
"SubnetId": "subnet-04a636d18e83cfacb",
"VpcId": "vpc-1234567890abcdef0",
"Architecture": "x86_64",
"BlockDeviceMappings": [
{
"DeviceName": "/dev/xvda",
"Ebs": {
"AttachTime": "2022-11-15T10:49:00+00:00",
"DeleteOnTermination": true,
"Status": "attached",
"VolumeId": "vol-02e6ccdca7de29cf2"
}
}
],
"ClientToken": "1234abcd-1234-abcd-1234-d46a8903e9bc",
"EbsOptimized": true,
"EnaSupport": true,
"Hypervisor": "xen",
"IamInstanceProfile": {
"Arn": "arn:aws:iam::111111111111:instance-profile/AmazonSSMRoleForInstancesQuickSetup",
"Id": "111111111111111111111"
},
"NetworkInterfaces": [
{
"Association": {
"IpOwnerId": "amazon",
"PublicDnsName": "ec2-34-253-223-13.us-east-2.compute.amazonaws.com",
"PublicIp": "34.253.223.13"
},
"Attachment": {
"AttachTime": "2022-11-15T10:48:59+00:00",
"AttachmentId": "eni-attach-1234567890abcdefg",
"DeleteOnTermination": true,
"DeviceIndex": 0,
"Status": "attached",
"NetworkCardIndex": 0
},
"Description": "",
"Groups": [
{
"GroupName": "launch-wizard-146",
"GroupId": "sg-1234567890abcdefg"
}
],
"Ipv6Addresses": [],
"MacAddress": "00:11:22:33:44:55",
"NetworkInterfaceId": "eni-1234567890abcdefg",
"OwnerId": "104024344472",
"PrivateDnsName": "ip-10-0-0-157.us-east-2.compute.internal",
"PrivateIpAddress": "10-0-0-157",
"PrivateIpAddresses": [
{
"Association": {
"IpOwnerId": "amazon",
"PublicDnsName": "ec2-34-253-223-13.us-east-2.compute.amazonaws.com",
"PublicIp": "34.253.223.13"
},
"Primary": true,
"PrivateDnsName": "ip-10-0-0-157.us-east-2.compute.internal",
"PrivateIpAddress": "10-0-0-157"
}
],
"SourceDestCheck": true,
"Status": "in-use",
"SubnetId": "subnet-1234567890abcdefg",
"VpcId": "vpc-1234567890abcdefg",
"InterfaceType": "interface"
}
],
"RootDeviceName": "/dev/xvda",
"RootDeviceType": "ebs",
"SecurityGroups": [
{
"GroupName": "launch-wizard-146",
"GroupId": "sg-1234567890abcdefg"
}
],
"SourceDestCheck": true,
"Tags": [
{
"Key": "Name",
"Value": "my-instance"
}
],
"VirtualizationType": "hvm",
"CpuOptions": {
"CoreCount": 1,
"ThreadsPerCore": 2
},
"CapacityReservationSpecification": {
"CapacityReservationPreference": "open"
},
"HibernationOptions": {
"Configured": false
},
"MetadataOptions": {
"State": "applied",
"HttpTokens": "optional",
"HttpPutResponseHopLimit": 1,
"HttpEndpoint": "enabled",
"HttpProtocolIpv6": "disabled",
"InstanceMetadataTags": "enabled"
},
"EnclaveOptions": {
"Enabled": false
},
"PlatformDetails": "Linux/UNIX",
"UsageOperation": "RunInstances",
"UsageOperationUpdateTime": "2022-11-15T10:48:59+00:00",
"PrivateDnsNameOptions": {
"HostnameType": "ip-name",
"EnableResourceNameDnsARecord": true,
"EnableResourceNameDnsAAAARecord": false
},
"MaintenanceOptions": {
"AutoRecovery": "default"
}
}
],
"OwnerId": "111111111111",
"ReservationId": "r-1234567890abcdefg"
}
]
}
```
**Exemplo 2: para filtrar instâncias com o tipo especificado**
O exemplo `describe-instances` a seguir usa filtros para definir o escopo dos resultados para instâncias do tipo especificado.
```
aws ec2 describe-instances \
--filters Name=instance-type,Values=m5.large
```
Para obter um exemplo da saída, consulte o Exemplo 1.
Para obter mais informações, consulte [Listar e filtrar usando a CLI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Filtering.html#Filtering_Resources_CLI) no *Guia do usuário do Amazon EC2*.
**Exemplo 3: filtrar instâncias com o tipo e a zona de disponibilidade especificados**
O exemplo `describe-instances` a seguir usa vários filtros para definir o escopo dos resultados para instâncias com o tipo especificado que também estão na zona de disponibilidade especificada.
```
aws ec2 describe-instances \
--filters Name=instance-type,Values=t2.micro,t3.micro Name=availability-zone,Values=us-east-2c
```
Para obter um exemplo da saída, consulte o Exemplo 1.
**Exemplo 4: filtrar instâncias com o tipo e a zona de disponibilidade especificados usando um arquivo JSON**
O exemplo `describe-instances` a seguir usa um arquivo de entrada JSON para realizar a mesma filtragem do exemplo anterior. Quando os filtros ficam mais complicados, pode ser mais fácil especificá-los em um arquivo JSON.
```
aws ec2 describe-instances \
--filters file://filters.json
```
Conteúdo de `filters.json`:
```
[
{
"Name": "instance-type",
"Values": ["t2.micro", "t3.micro"]
},
{
"Name": "availability-zone",
"Values": ["us-east-2c"]
}
]
```
Para obter um exemplo da saída, consulte o Exemplo 1.
**Exemplo 5: filtrar instâncias com a tag Proprietário especificada**
O exemplo `describe-instances` a seguir usa filtros de tag para definir o escopo dos resultados para instâncias que têm uma tag com a chave de tag especificada (Proprietário), independentemente do valor da tag.
```
aws ec2 describe-instances \
--filters "Name=tag-key,Values=Owner"
```
Para obter um exemplo da saída, consulte o Exemplo 1.
**Exemplo 6: filtrar instâncias com o valor especificado my-team da tag**
O exemplo `describe-instances` a seguir usa filtros de tag para definir o escopo dos resultados para instâncias que têm uma tag com o valor especificado da tag (my-team), independentemente da chave da tag.
```
aws ec2 describe-instances \
--filters "Name=tag-value,Values=my-team"
```
Para obter um exemplo da saída, consulte o Exemplo 1.
**Exemplo 7: filtrar instâncias com a tag Proprietário e o valor my-team especificados**
O exemplo `describe-instances` a seguir usa filtros de tag para definir o escopo dos resultados para instâncias que têm a tag especificada (Owner=my-team).
```
aws ec2 describe-instances \
--filters "Name=tag:Owner,Values=my-team"
```
Para obter um exemplo da saída, consulte o Exemplo 1.
**Exemplo 8: Para exibir somente a instância e a sub-rede IDs para todas as instâncias**
Os `describe-instances` exemplos a seguir usam o `--query` parâmetro para exibir somente a instância e a sub-rede de todas IDs as instâncias, no formato JSON.
Linux e macOS:
```
aws ec2 describe-instances \
--query 'Reservations[*].Instances[*].{Instance:InstanceId,Subnet:SubnetId}' \
--output json
```
Windows:
```
aws ec2 describe-instances ^
--query "Reservations[*].Instances[*].{Instance:InstanceId,Subnet:SubnetId}" ^
--output json
```
Saída:
```
[
{
"Instance": "i-057750d42936e468a",
"Subnet": "subnet-069beee9b12030077"
},
{
"Instance": "i-001efd250faaa6ffa",
"Subnet": "subnet-0b715c6b7db68927a"
},
{
"Instance": "i-027552a73f021f3bd",
"Subnet": "subnet-0250c25a1f4e15235"
}
...
]
```
**Exemplo 9: Para filtrar instâncias do tipo especificado e exibir somente sua instância IDs**
O `describe-instances` exemplo a seguir usa filtros para definir o escopo dos resultados para instâncias do tipo especificado e o `--query` parâmetro para exibir somente a instância IDs.
```
aws ec2 describe-instances \
--filters "Name=instance-type,Values=t2.micro" \
--query "Reservations[*].Instances[*].[InstanceId]" \
--output text
```
Saída:
```
i-031c0dc19de2fb70c
i-00d8bff789a736b75
i-0b715c6b7db68927a
i-0626d4edd54f1286d
i-00b8ae04f9f99908e
i-0fc71c25d2374130c
```
**Exemplo 10: filtrar instâncias do tipo especificado e exibir somente a instância IDs, a zona de disponibilidade e o valor da tag especificada**
Os exemplos `describe-instances` a seguir exibem o ID da instância, a zona de disponibilidade e o valor da tag `Name` para instâncias que têm uma tag com o nome `tag-key`, em formato de tabela.
Linux e macOS:
```
aws ec2 describe-instances \
--filters Name=tag-key,Values=Name \
--query 'Reservations[*].Instances[*].{Instance:InstanceId,AZ:Placement.AvailabilityZone,Name:Tags[?Key==`Name`]|[0].Value}' \
--output table
```
Windows:
```
aws ec2 describe-instances ^
--filters Name=tag-key,Values=Name ^
--query "Reservations[*].Instances[*].{Instance:InstanceId,AZ:Placement.AvailabilityZone,Name:Tags[?Key=='Name']|[0].Value}" ^
--output table
```
Saída:
```
-------------------------------------------------------------
| DescribeInstances |
+--------------+-----------------------+--------------------+
| AZ | Instance | Name |
+--------------+-----------------------+--------------------+
| us-east-2b | i-057750d42936e468a | my-prod-server |
| us-east-2a | i-001efd250faaa6ffa | test-server-1 |
| us-east-2a | i-027552a73f021f3bd | test-server-2 |
+--------------+-----------------------+--------------------+
```
**Exemplo 11: descrever instâncias em um grupo com posicionamento em partições**
O exemplo `describe-instances` a seguir descreve a instância especificada. A saída inclui as informações de posicionamento da instância, o que contém o nome do grupo de posicionamento e o número da partição da instância.
```
aws ec2 describe-instances \
--instance-ids i-0123a456700123456 \
--query "Reservations[*].Instances[*].Placement"
```
Saída:
```
[
[
{
"AvailabilityZone": "us-east-1c",
"GroupName": "HDFS-Group-A",
"PartitionNumber": 3,
"Tenancy": "default"
}
]
]
```
Para obter mais informações, consulte [Descrever instâncias em um grupo de posicionamento](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html#describe-instance-placement) no *Guia do usuário do Amazon EC2*.
**Exemplo 12: filtrar instâncias com o grupo de posicionamento e o número de partição especificados**
O exemplo `describe-instances` a seguir filtra os resultados somente para as instâncias com o grupo de posicionamento e o número de partição especificados.
```
aws ec2 describe-instances \
--filters "Name=placement-group-name,Values=HDFS-Group-A" "Name=placement-partition-number,Values=7"
```
A seguir, são mostradas somente as informações relevantes da saída.
```
"Instances": [
{
"InstanceId": "i-0123a456700123456",
"InstanceType": "r4.large",
"Placement": {
"AvailabilityZone": "us-east-1c",
"GroupName": "HDFS-Group-A",
"PartitionNumber": 7,
"Tenancy": "default"
}
},
{
"InstanceId": "i-9876a543210987654",
"InstanceType": "r4.large",
"Placement": {
"AvailabilityZone": "us-east-1c",
"GroupName": "HDFS-Group-A",
"PartitionNumber": 7,
"Tenancy": "default"
}
],
```
Para obter mais informações, consulte [Descrever instâncias em um grupo de posicionamento](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html#describe-instance-placement) no *Guia do usuário do Amazon EC2*.
**Exemplo 13: filtrar instâncias configuradas para permitir o acesso às tags dos metadados da instância**
O exemplo `describe-instances` a seguir filtra os resultados somente para as instâncias que estão configuradas para permitir o acesso às tags de instância nos metadados da instância.
```
aws ec2 describe-instances \
--filters "Name=metadata-options.instance-metadata-tags,Values=enabled" \
--query "Reservations[*].Instances[*].InstanceId" \
--output text
```
A saída esperada é mostrada a seguir.
```
i-1234567890abcdefg
i-abcdefg1234567890
i-11111111aaaaaaaaa
i-aaaaaaaa111111111
```
Para obter mais informações, consulte [Work with instance tags in instance metadata](https://docs.aws.amazon.com/en_us/AWSEC2/latest/UserGuide/Using_Tags.html#view-access-to-tags-in-IMDS) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DescribeInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instances.html)em *Referência de AWS CLI Comandos*.
### `describe-internet-gateways`
O código de exemplo a seguir mostra como usar `describe-internet-gateways`.
**AWS CLI**
**Descrever um gateway da internet**
O exemplo `describe-internet-gateways` a seguir descreve o gateway da internet especificado.
```
aws ec2 describe-internet-gateways \
--internet-gateway-ids igw-0d0fb496b3EXAMPLE
```
Saída:
```
{
"InternetGateways": [
{
"Attachments": [
{
"State": "available",
"VpcId": "vpc-0a60eb65b4EXAMPLE"
}
],
"InternetGatewayId": "igw-0d0fb496b3EXAMPLE",
"OwnerId": "123456789012",
"Tags": [
{
"Key": "Name",
"Value": "my-igw"
}
]
}
]
}
```
Para obter mais informações, consulte [Gateways da Internet](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [DescribeInternetGateways](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-internet-gateways.html)em *Referência de AWS CLI Comandos*.
### `describe-ipam-pools`
O código de exemplo a seguir mostra como usar `describe-ipam-pools`.
**AWS CLI**
**Visualizar os detalhes de um pool IPAM**
O exemplo `describe-ipam-pools` a seguir mostra os detalhes de pools.
(Linux):
```
aws ec2 describe-ipam-pools \
--filters Name=owner-id,Values=123456789012 Name=ipam-scope-id,Values=ipam-scope-02fc38cd4c48e7d38
```
(Windows):
```
aws ec2 describe-ipam-pools ^
--filters Name=owner-id,Values=123456789012 Name=ipam-scope-id,Values=ipam-scope-02fc38cd4c48e7d38
```
Saída:
```
{
"IpamPools": [
{
"OwnerId": "123456789012",
"IpamPoolId": "ipam-pool-02ec043a19bbe5d08",
"IpamPoolArn": "arn:aws:ec2::123456789012:ipam-pool/ipam-pool-02ec043a19bbe5d08",
"IpamScopeArn": "arn:aws:ec2::123456789012:ipam-scope/ipam-scope-02fc38cd4c48e7d38",
"IpamScopeType": "private",
"IpamArn": "arn:aws:ec2::123456789012:ipam/ipam-08440e7a3acde3908",
"IpamRegion": "us-east-1",
"Locale": "None",
"PoolDepth": 1,
"State": "create-complete",
"AutoImport": true,
"AddressFamily": "ipv4",
"AllocationMinNetmaskLength": 16,
"AllocationMaxNetmaskLength": 26,
"AllocationDefaultNetmaskLength": 24,
"AllocationResourceTags": [
{
"Key": "Environment",
"Value": "Preprod"
}
],
"Tags": [
{
"Key": "Name",
"Value": "Preprod pool"
}
]
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeIpamPools](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-ipam-pools.html)em *Referência de AWS CLI Comandos*.
### `describe-ipam-resource-discoveries`
O código de exemplo a seguir mostra como usar `describe-ipam-resource-discoveries`.
**AWS CLI**
**Exemplo 1: visualizar detalhes completos das descobertas de recursos**
Neste exemplo, você é um administrador delegado do IPAM que deseja criar e compartilhar uma descoberta de recursos com o administrador do IPAM em outra AWS organização para que o administrador possa gerenciar e monitorar os endereços IP dos recursos na sua organização.
Esse exemplo pode ser útil se:
Você tentou criar uma descoberta de recursos, mas recebeu um erro informando que atingiu o limite de 1. Você percebeu que talvez já tenha criado uma descoberta de recursos e deseja visualizá-la em sua conta. Você tem recursos em uma Região que não estão sendo descobertos pelo IPAM. Você quer ver o `--operating-regions` definido para o recurso e garantir que você tenha adicionado a região certa como uma região operacional para que os recursos lá possam ser descobertos.
O `describe-ipam-resource-discoveries` exemplo a seguir lista os detalhes da descoberta de recursos em sua AWS conta. Você pode ter uma descoberta de recursos por AWS região.
```
aws ec2 describe-ipam-resource-discoveries \
--region us-east-1
```
Saída:
```
{
"IpamResourceDiscoveries": [
{
"OwnerId": "149977607591",
"IpamResourceDiscoveryId": "ipam-res-disco-0f8bdee9067137c0d",
"IpamResourceDiscoveryArn": "arn:aws:ec2::149977607591:ipam-resource-discovery/ipam-res-disco-0f8bdee9067137c0d",
"IpamResourceDiscoveryRegion": "us-east-1",
"OperatingRegions": [
{
"RegionName": "us-east-1"
}
],
"IsDefault": false,
"State": "create-complete",
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Integrar o IPAM com contas fora da sua organização](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam-outside-org.html) no *Guia do usuário do IPAM da Amazon VPC*.
**Exemplo 2: Exibir somente a descoberta de recursos IDs**
O `describe-ipam-resource-discoveries` exemplo a seguir lista o ID da descoberta do recurso em sua AWS conta. Você pode ter uma descoberta de recursos por AWS região.
```
aws ec2 describe-ipam-resource-discoveries \
--query "IpamResourceDiscoveries[*].IpamResourceDiscoveryId" \
--output text
```
Saída:
```
ipam-res-disco-0481e39b242860333
```
Para obter mais informações, consulte [Integrar o IPAM com contas fora da sua organização](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam-outside-org.html) no *Guia do usuário do IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [DescribeIpamResourceDiscoveries](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-ipam-resource-discoveries.html)em *Referência de AWS CLI Comandos*.
### `describe-ipam-resource-discovery-associations`
O código de exemplo a seguir mostra como usar `describe-ipam-resource-discovery-associations`.
**AWS CLI**
**Visualizar todas as associações de descoberta de recursos com seu IPAM**
Neste exemplo, você é um administrador delegado do IPAM que associou descobertas de recursos ao seu IPAM para integrar outras contas ao seu IPAM. Você notou que seu IPAM não está descobrindo os recursos nas regiões operacionais da descoberta de recursos conforme o esperado. Você deseja verificar o status e o estado da descoberta de recursos para garantir que a conta que a criou ainda esteja ativa e que a descoberta de recursos ainda esteja sendo compartilhada.
`--region` deve ser a região de origem do IPAM.
O `describe-ipam-resource-discovery-associations` exemplo a seguir lista as associações de descoberta de recursos em sua AWS conta.
```
aws ec2 describe-ipam-resource-discovery-associations \
--region us-east-1
```
Saída:
```
{
"IpamResourceDiscoveryAssociations": [
{
"OwnerId": "320805250157",
"IpamResourceDiscoveryAssociationId": "ipam-res-disco-assoc-05e6b45eca5bf5cf7",
"IpamResourceDiscoveryAssociationArn": "arn:aws:ec2::320805250157:ipam-resource-discovery-association/ipam-res-disco-assoc-05e6b45eca5bf5cf7",
"IpamResourceDiscoveryId": "ipam-res-disco-0f4ef577a9f37a162",
"IpamId": "ipam-005f921c17ebd5107",
"IpamArn": "arn:aws:ec2::320805250157:ipam/ipam-005f921c17ebd5107",
"IpamRegion": "us-east-1",
"IsDefault": true,
"ResourceDiscoveryStatus": "active",
"State": "associate-complete",
"Tags": []
},
{
"OwnerId": "149977607591",
"IpamResourceDiscoveryAssociationId": "ipam-res-disco-assoc-0dfd21ae189ab5f62",
"IpamResourceDiscoveryAssociationArn": "arn:aws:ec2::149977607591:ipam-resource-discovery-association/ipam-res-disco-assoc-0dfd21ae189ab5f62",
"IpamResourceDiscoveryId": "ipam-res-disco-0365d2977fc1672fe",
"IpamId": "ipam-005f921c17ebd5107",
"IpamArn": "arn:aws:ec2::149977607591:ipam/ipam-005f921c17ebd5107",
"IpamRegion": "us-east-1",
"IsDefault": false,
"ResourceDiscoveryStatus": "active",
"State": "create-complete",
"Tags": []
}
]
}
```
Neste exemplo, depois de executar esse comando, você percebe que tem uma descoberta de recurso não padrão (`"IsDefault": false ``) that is ``"ResourceDiscoveryStatus": "not-found"` e `"State": "create-complete"`. A conta do proprietário da descoberta de recursos foi encerrada. Se, em outro caso, você perceber que é `"ResourceDiscoveryStatus": "not-found"` e `"State": "associate-complete"`, isso indica que uma das seguintes coisas aconteceu:
A descoberta do recurso foi excluída pelo proprietário da descoberta do recurso. O proprietário da descoberta do recurso cancelou o compartilhamento da descoberta do recurso.
Para obter mais informações, consulte [Integrar o IPAM com contas fora da sua organização](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam-outside-org.html) no *Guia do usuário do IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [DescribeIpamResourceDiscoveryAssociations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-ipam-resource-discovery-associations.html)em *Referência de AWS CLI Comandos*.
### `describe-ipam-scopes`
O código de exemplo a seguir mostra como usar `describe-ipam-scopes`.
**AWS CLI**
**Visualizar os detalhes de um escopo IPAM**
O exemplo `describe-ipam-scopes` a seguir mostra os detalhes dos escopos.
```
aws ec2 describe-ipam-scopes \
--filters Name=owner-id,Values=123456789012 Name=ipam-id,Values=ipam-08440e7a3acde3908
```
Saída:
```
{
"IpamScopes": [
{
"OwnerId": "123456789012",
"IpamScopeId": "ipam-scope-02fc38cd4c48e7d38",
"IpamScopeArn": "arn:aws:ec2::123456789012:ipam-scope/ipam-scope-02fc38cd4c48e7d38",
"IpamArn": "arn:aws:ec2::123456789012:ipam/ipam-08440e7a3acde3908",
"IpamRegion": "us-east-1",
"IpamScopeType": "private",
"IsDefault": true,
"PoolCount": 2,
"State": "create-complete",
"Tags": []
},
{
"OwnerId": "123456789012",
"IpamScopeId": "ipam-scope-0b9eed026396dbc16",
"IpamScopeArn": "arn:aws:ec2::123456789012:ipam-scope/ipam-scope-0b9eed026396dbc16",
"IpamArn": "arn:aws:ec2::123456789012:ipam/ipam-08440e7a3acde3908",
"IpamRegion": "us-east-1",
"IpamScopeType": "public",
"IsDefault": true,
"PoolCount": 0,
"State": "create-complete",
"Tags": []
},
{
"OwnerId": "123456789012",
"IpamScopeId": "ipam-scope-0f1aff29486355c22",
"IpamScopeArn": "arn:aws:ec2::123456789012:ipam-scope/ipam-scope-0f1aff29486355c22",
"IpamArn": "arn:aws:ec2::123456789012:ipam/ipam-08440e7a3acde3908",
"IpamRegion": "us-east-1",
"IpamScopeType": "private",
"IsDefault": false,
"Description": "Example description",
"PoolCount": 0,
"State": "create-complete",
"Tags": [
{
"Key": "Name",
"Value": "Example name value"
}
]
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeIpamScopes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-ipam-scopes.html)em *Referência de AWS CLI Comandos*.
### `describe-ipams`
O código de exemplo a seguir mostra como usar `describe-ipams`.
**AWS CLI**
**Visualizar os detalhes de um IPAM**
O exemplo `describe-ipams` a seguir mostra os detalhes de um IPAM.
```
aws ec2 describe-ipams \
--filters Name=owner-id,Values=123456789012
```
Saída:
```
{
"Ipams": [
{
"OwnerId": "123456789012",
"IpamId": "ipam-08440e7a3acde3908",
"IpamArn": "arn:aws:ec2::123456789012:ipam/ipam-08440e7a3acde3908",
"IpamRegion": "us-east-1",
"PublicDefaultScopeId": "ipam-scope-0b9eed026396dbc16",
"PrivateDefaultScopeId": "ipam-scope-02fc38cd4c48e7d38",
"ScopeCount": 3,
"OperatingRegions": [
{
"RegionName": "us-east-1"
},
{
"RegionName": "us-east-2"
},
{
"RegionName": "us-west-1"
}
],
"State": "create-complete",
"Tags": [
{
"Key": "Name",
"Value": "ExampleIPAM"
}
]
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeIpams](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-ipams.html)em *Referência de AWS CLI Comandos*.
### `describe-ipv6-pools`
O código de exemplo a seguir mostra como usar `describe-ipv6-pools`.
**AWS CLI**
**Para descrever seus grupos IPv6 de endereços**
O `describe-ipv6-pools` exemplo a seguir exibe detalhes de todos os seus grupos de IPv6 endereços.
```
aws ec2 describe-ipv6-pools
```
Saída:
```
{
"Ipv6Pools": [
{
"PoolId": "ipv6pool-ec2-012345abc12345abc",
"PoolCidrBlocks": [
{
"Cidr": "2001:db8:123::/48"
}
],
"Tags": [
{
"Key": "pool-1",
"Value": "public"
}
]
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeIpv6Pools](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-ipv6-pools.html) na *Referência de AWS CLI Comandos*.
### `describe-key-pairs`
O código de exemplo a seguir mostra como usar `describe-key-pairs`.
**AWS CLI**
**Exibir um par de chaves**
O exemplo `describe-key-pairs` a seguir mostra as informações do par de chaves especificado.
```
aws ec2 describe-key-pairs \
--key-names my-key-pair
```
Saída:
```
{
"KeyPairs": [
{
"KeyPairId": "key-0b94643da6EXAMPLE",
"KeyFingerprint": "1f:51:ae:28:bf:89:e9:d8:1f:25:5d:37:2d:7d:b8:ca:9f:f5:f1:6f",
"KeyName": "my-key-pair",
"KeyType": "rsa",
"Tags": [],
"CreateTime": "2022-05-27T21:51:16.000Z"
}
]
}
```
Para obter mais informações, consulte [Descrever chaves públicas](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/describe-keys.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DescribeKeyPairs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-key-pairs.html)em *Referência de AWS CLI Comandos*.
### `describe-launch-template-versions`
O código de exemplo a seguir mostra como usar `describe-launch-template-versions`.
**AWS CLI**
**Descrever uma versão de modelo de lançamento**
Este exemplo descreve as versões do modelo de lançamento especificado.
Comando:
```
aws ec2 describe-launch-template-versions --launch-template-id lt-068f72b72934aff71
```
Saída:
```
{
"LaunchTemplateVersions": [
{
"LaunchTemplateId": "lt-068f72b72934aff71",
"LaunchTemplateName": "Webservers",
"VersionNumber": 3,
"CreatedBy": "arn:aws:iam::123456789102:root",
"LaunchTemplateData": {
"KeyName": "kp-us-east",
"ImageId": "ami-6057e21a",
"InstanceType": "t2.small",
"NetworkInterfaces": [
{
"SubnetId": "subnet-7b16de0c",
"DeviceIndex": 0,
"Groups": [
"sg-7c227019"
]
}
]
},
"DefaultVersion": false,
"CreateTime": "2017-11-20T13:19:54.000Z"
},
{
"LaunchTemplateId": "lt-068f72b72934aff71",
"LaunchTemplateName": "Webservers",
"VersionNumber": 2,
"CreatedBy": "arn:aws:iam::123456789102:root",
"LaunchTemplateData": {
"KeyName": "kp-us-east",
"ImageId": "ami-6057e21a",
"InstanceType": "t2.medium",
"NetworkInterfaces": [
{
"SubnetId": "subnet-1a2b3c4d",
"DeviceIndex": 0,
"Groups": [
"sg-7c227019"
]
}
]
},
"DefaultVersion": false,
"CreateTime": "2017-11-20T13:12:32.000Z"
},
{
"LaunchTemplateId": "lt-068f72b72934aff71",
"LaunchTemplateName": "Webservers",
"VersionNumber": 1,
"CreatedBy": "arn:aws:iam::123456789102:root",
"LaunchTemplateData": {
"UserData": "",
"KeyName": "kp-us-east",
"ImageId": "ami-aabbcc11",
"InstanceType": "t2.medium",
"NetworkInterfaces": [
{
"SubnetId": "subnet-7b16de0c",
"DeviceIndex": 0,
"DeleteOnTermination": false,
"Groups": [
"sg-7c227019"
],
"AssociatePublicIpAddress": true
}
]
},
"DefaultVersion": true,
"CreateTime": "2017-11-20T12:52:33.000Z"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeLaunchTemplateVersions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-launch-template-versions.html)em *Referência de AWS CLI Comandos*.
### `describe-launch-templates`
O código de exemplo a seguir mostra como usar `describe-launch-templates`.
**AWS CLI**
**Descrever os modelos de lançamento**
Este exemplo descreve os modelos de lançamento.
Comando:
```
aws ec2 describe-launch-templates
```
Saída:
```
{
"LaunchTemplates": [
{
"LatestVersionNumber": 2,
"LaunchTemplateId": "lt-0e06d290751193123",
"LaunchTemplateName": "TemplateForWebServer",
"DefaultVersionNumber": 2,
"CreatedBy": "arn:aws:iam::123456789012:root",
"CreateTime": "2017-11-27T09:30:23.000Z"
},
{
"LatestVersionNumber": 6,
"LaunchTemplateId": "lt-0c45b5e061ec98456",
"LaunchTemplateName": "DBServersTemplate",
"DefaultVersionNumber": 1,
"CreatedBy": "arn:aws:iam::123456789012:root",
"CreateTime": "2017-11-20T09:25:22.000Z"
},
{
"LatestVersionNumber": 1,
"LaunchTemplateId": "lt-0d47d774e8e52dabc",
"LaunchTemplateName": "MyLaunchTemplate2",
"DefaultVersionNumber": 1,
"CreatedBy": "arn:aws:iam::123456789012:root",
"CreateTime": "2017-11-02T12:06:21.000Z"
},
{
"LatestVersionNumber": 3,
"LaunchTemplateId": "lt-01e5f948eb4f589d6",
"LaunchTemplateName": "testingtemplate2",
"DefaultVersionNumber": 1,
"CreatedBy": "arn:aws:sts::123456789012:assumed-role/AdminRole/i-03ee35176e2e5aabc",
"CreateTime": "2017-12-01T08:19:48.000Z"
},
]
}
```
+ Para obter detalhes da API, consulte [DescribeLaunchTemplates](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-launch-templates.html)em *Referência de AWS CLI Comandos*.
### `describe-local-gateway-route-table-virtual-interface-group-associations`
O código de exemplo a seguir mostra como usar `describe-local-gateway-route-table-virtual-interface-group-associations`.
**AWS CLI**
**Descrever as associações entre grupos de interface virtual e tabelas de rotas de gateway local**
O `describe-local-gateway-route-table-virtual-interface-group-associations` exemplo a seguir descreve as associações entre grupos de interface virtual e tabelas de rotas de gateway local em sua AWS conta.
```
aws ec2 describe-local-gateway-route-table-virtual-interface-group-associations
```
Saída:
```
{
"LocalGatewayRouteTableVirtualInterfaceGroupAssociations": [
{
"LocalGatewayRouteTableVirtualInterfaceGroupAssociationId": "lgw-vif-grp-assoc-07145b276bEXAMPLE",
"LocalGatewayVirtualInterfaceGroupId": "lgw-vif-grp-07145b276bEXAMPLE",
"LocalGatewayId": "lgw-0ab1c23d4eEXAMPLE",
"LocalGatewayRouteTableId": "lgw-rtb-059615ef7dEXAMPLE",
"LocalGatewayRouteTableArn": "arn:aws:ec2:us-west-2:123456789012:local-gateway-route-table/lgw-rtb-059615ef7dEXAMPLE",
"OwnerId": "123456789012",
"State": "associated",
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Trabalhar com gateways locais](https://docs.aws.amazon.com/outposts/latest/userguide/outposts-local-gateways.html) no *Guia do usuário do AWS Outposts*.
+ Para obter detalhes da API, consulte [DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-local-gateway-route-table-virtual-interface-group-associations.html)em *Referência de AWS CLI Comandos*.
### `describe-local-gateway-route-table-vpc-associations`
O código de exemplo a seguir mostra como usar `describe-local-gateway-route-table-vpc-associations`.
**AWS CLI**
**Para descrever as associações entre VPCs as tabelas de rotas do gateway local**
O `describe-local-gateway-route-table-vpc-associations` exemplo a seguir exibe informações sobre a associação especificada entre VPCs as tabelas de rotas do gateway local.
```
aws ec2 describe-local-gateway-route-table-vpc-associations \
--local-gateway-route-table-vpc-association-ids lgw-vpc-assoc-0e0f27af15EXAMPLE
```
Saída:
```
{
"LocalGatewayRouteTableVpcAssociation": {
"LocalGatewayRouteTableVpcAssociationId": "lgw-vpc-assoc-0e0f27af1EXAMPLE",
"LocalGatewayRouteTableId": "lgw-rtb-059615ef7dEXAMPLE",
"LocalGatewayId": "lgw-09b493aa7cEXAMPLE",
"VpcId": "vpc-0efe9bde08EXAMPLE",
"State": "associated"
}
}
```
Para ter mais informações, consulte [Tabelas de rotas do gateway local](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html) no *Guia do usuário do Outposts*.
+ Para obter detalhes da API, consulte [DescribeLocalGatewayRouteTableVpcAssociations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-local-gateway-route-table-vpc-associations.html)em *Referência de AWS CLI Comandos*.
### `describe-local-gateway-route-tables`
O código de exemplo a seguir mostra como usar `describe-local-gateway-route-tables`.
**AWS CLI**
**Descrever suas tabelas de rotas de gateway local**
O exemplo `describe-local-gateway-route-tables` a seguir exibe detalhes sobre as tabelas de rotas do gateway local.
```
aws ec2 describe-local-gateway-route-tables
```
Saída:
```
{
"LocalGatewayRouteTables": [
{
"LocalGatewayRouteTableId": "lgw-rtb-059615ef7deEXAMPLE",
"LocalGatewayId": "lgw-09b493aa7cEXAMPLE",
"OutpostArn": "arn:aws:outposts:us-west-2:111122223333:outpost/op-0dc11b66edEXAMPLE",
"State": "available"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeLocalGatewayRouteTables](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-local-gateway-route-tables.html)em *Referência de AWS CLI Comandos*.
### `describe-local-gateway-virtual-interface-groups`
O código de exemplo a seguir mostra como usar `describe-local-gateway-virtual-interface-groups`.
**AWS CLI**
**Descrever grupos de interface virtual de gateway local**
O `describe-local-gateway-virtual-interface-groups` exemplo a seguir descreve os grupos de interface virtual do gateway local em sua AWS conta.
```
aws ec2 describe-local-gateway-virtual-interface-groups
```
Saída:
```
{
"LocalGatewayVirtualInterfaceGroups": [
{
"LocalGatewayVirtualInterfaceGroupId": "lgw-vif-grp-07145b276bEXAMPLE",
"LocalGatewayVirtualInterfaceIds": [
"lgw-vif-01a23bc4d5EXAMPLE",
"lgw-vif-543ab21012EXAMPLE"
],
"LocalGatewayId": "lgw-0ab1c23d4eEXAMPLE",
"OwnerId": "123456789012",
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Trabalhar com gateways locais](https://docs.aws.amazon.com/outposts/latest/userguide/outposts-local-gateways.html) no *Guia do usuário do AWS Outposts*.
+ Para obter detalhes da API, consulte [DescribeLocalGatewayVirtualInterfaceGroups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-local-gateway-virtual-interface-groups.html)em *Referência de AWS CLI Comandos*.
### `describe-local-gateway-virtual-interfaces`
O código de exemplo a seguir mostra como usar `describe-local-gateway-virtual-interfaces`.
**AWS CLI**
**Descrever interfaces virtuais de gateway local**
O `describe-local-gateway-virtual-interfaces` exemplo a seguir descreve as interfaces virtuais do gateway local em sua AWS conta.
```
aws ec2 describe-local-gateway-virtual-interfaces
```
Saída:
```
{
"LocalGatewayVirtualInterfaces": [
{
"LocalGatewayVirtualInterfaceId": "lgw-vif-01a23bc4d5EXAMPLE",
"LocalGatewayId": "lgw-0ab1c23d4eEXAMPLE",
"Vlan": 2410,
"LocalAddress": "0.0.0.0/0",
"PeerAddress": "0.0.0.0/0",
"LocalBgpAsn": 65010,
"PeerBgpAsn": 65000,
"OwnerId": "123456789012",
"Tags": []
},
{
"LocalGatewayVirtualInterfaceId": "lgw-vif-543ab21012EXAMPLE",
"LocalGatewayId": "lgw-0ab1c23d4eEXAMPLE",
"Vlan": 2410,
"LocalAddress": "0.0.0.0/0",
"PeerAddress": "0.0.0.0/0",
"LocalBgpAsn": 65010,
"PeerBgpAsn": 65000,
"OwnerId": "123456789012",
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Trabalhar com gateways locais](https://docs.aws.amazon.com/outposts/latest/userguide/outposts-local-gateways.html) no *Guia do usuário do AWS Outposts*.
+ Para obter detalhes da API, consulte [DescribeLocalGatewayVirtualInterfaces](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-local-gateway-virtual-interfaces.html)em *Referência de AWS CLI Comandos*.
### `describe-local-gateways`
O código de exemplo a seguir mostra como usar `describe-local-gateways`.
**AWS CLI**
**Descrever seus gateways locais**
O exemplo `describe-local-gateways` a seguir exibe detalhes dos gateways locais disponíveis para você.
```
aws ec2 describe-local-gateways
```
Saída:
```
{
"LocalGateways": [
{
"LocalGatewayId": "lgw-09b493aa7cEXAMPLE",
"OutpostArn": "arn:aws:outposts:us-west-2:123456789012:outpost/op-0dc11b66ed59f995a",
"OwnerId": "123456789012",
"State": "available"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeLocalGateways](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-local-gateways.html)em *Referência de AWS CLI Comandos*.
### `describe-locked-snapshots`
O código de exemplo a seguir mostra como usar `describe-locked-snapshots`.
**AWS CLI**
**Descrever o status de bloqueio de um snapshot**
O exemplo `describe-locked-snapshots` a seguir descreve o status de bloqueio do snapshot especificado.
```
aws ec2 describe-locked-snapshots \
--snapshot-ids snap-0b5e733b4a8df6e0d
```
Saída:
```
{
"Snapshots": [
{
"OwnerId": "123456789012",
"SnapshotId": "snap-0b5e733b4a8df6e0d",
"LockState": "governance",
"LockDuration": 365,
"LockCreatedOn": "2024-05-05T00:56:06.208000+00:00",
"LockDurationStartTime": "2024-05-05T00:56:06.208000+00:00",
"LockExpiresOn": "2025-05-05T00:56:06.208000+00:00"
}
]
}
```
Para obter mais informações, consulte [Bloqueio de snapshots](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-snapshot-lock.html) no *Guia do usuário do Amazon EBS*.
+ Para obter detalhes da API, consulte [DescribeLockedSnapshots](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-locked-snapshots.html)em *Referência de AWS CLI Comandos*.
### `describe-managed-prefix-lists`
O código de exemplo a seguir mostra como usar `describe-managed-prefix-lists`.
**AWS CLI**
**Descrever listas de prefixos gerenciadas**
O `describe-managed-prefix-lists` exemplo a seguir descreve as listas de prefixos pertencentes à AWS conta`123456789012`.
```
aws ec2 describe-managed-prefix-lists \
--filters Name=owner-id,Values=123456789012
```
Saída:
```
{
"PrefixLists": [
{
"PrefixListId": "pl-11223344556677aab",
"AddressFamily": "IPv6",
"State": "create-complete",
"PrefixListArn": "arn:aws:ec2:us-west-2:123456789012:prefix-list/pl-11223344556677aab",
"PrefixListName": "vpc-ipv6-cidrs",
"MaxEntries": 25,
"Version": 1,
"Tags": [],
"OwnerId": "123456789012"
},
{
"PrefixListId": "pl-0123456abcabcabc1",
"AddressFamily": "IPv4",
"State": "active",
"PrefixListArn": "arn:aws:ec2:us-west-2:123456789012:prefix-list/pl-0123456abcabcabc1",
"PrefixListName": "vpc-cidrs",
"MaxEntries": 10,
"Version": 1,
"Tags": [],
"OwnerId": "123456789012"
}
]
}
```
Para obter mais informações, consulte [Listas de prefixos gerenciados](https://docs.aws.amazon.com/vpc/latest/userguide/managed-prefix-lists.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [DescribeManagedPrefixLists](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-managed-prefix-lists.html)em *Referência de AWS CLI Comandos*.
### `describe-moving-addresses`
O código de exemplo a seguir mostra como usar `describe-moving-addresses`.
**AWS CLI**
**Descrever seus endereços em movimento**
Este exemplo descreve todos os seus endereços IP Elastic em movimento.
Comando:
```
aws ec2 describe-moving-addresses
```
Saída:
```
{
"MovingAddressStatuses": [
{
"PublicIp": "198.51.100.0",
"MoveStatus": "MovingToVpc"
}
]
}
```
Este exemplo descreve todos os endereços que estão sendo movidos para a plataforma EC2-VPC.
Comando:
```
aws ec2 describe-moving-addresses --filters Name=moving-status,Values=MovingToVpc
```
+ Para obter detalhes da API, consulte [DescribeMovingAddresses](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-moving-addresses.html)em *Referência de AWS CLI Comandos*.
### `describe-nat-gateways`
O código de exemplo a seguir mostra como usar `describe-nat-gateways`.
**AWS CLI**
**Exemplo 1: descrever um gateway NAT público**
O exemplo `describe-nat-gateways` a seguir descreve o gateway NAT público especificado.
```
aws ec2 describe-nat-gateways \
--nat-gateway-id nat-01234567890abcdef
```
Saída:
```
{
"NatGateways": [
{
"CreateTime": "2023-08-25T01:56:51.000Z",
"NatGatewayAddresses": [
{
"AllocationId": "eipalloc-0790180cd2EXAMPLE",
"NetworkInterfaceId": "eni-09cc4b2558794f7f9",
"PrivateIp": "10.0.0.211",
"PublicIp": "54.85.121.213",
"AssociationId": "eipassoc-04d295cc9b8815b24",
"IsPrimary": true,
"Status": "succeeded"
},
{
"AllocationId": "eipalloc-0be6ecac95EXAMPLE",
"NetworkInterfaceId": "eni-09cc4b2558794f7f9",
"PrivateIp": "10.0.0.74",
"PublicIp": "3.211.231.218",
"AssociationId": "eipassoc-0f96bdca17EXAMPLE",
"IsPrimary": false,
"Status": "succeeded"
}
],
"NatGatewayId": "nat-01234567890abcdef",
"State": "available",
"SubnetId": "subnet-655eab5f08EXAMPLE",
"VpcId": "vpc-098eb5ef58EXAMPLE",
"Tags": [
{
"Key": "Name",
"Value": "public-nat"
}
],
"ConnectivityType": "public"
}
]
}
```
**Exemplo 2: descrever um gateway NAT privado**
O exemplo `describe-nat-gateways` a seguir descreve o gateway NAT privado especificado.
```
aws ec2 describe-nat-gateways \
--nat-gateway-id nat-1234567890abcdef0
```
Saída:
```
{
"NatGateways": [
{
"CreateTime": "2023-08-25T00:50:05.000Z",
"NatGatewayAddresses": [
{
"NetworkInterfaceId": "eni-0065a61b324d1897a",
"PrivateIp": "10.0.20.240",
"IsPrimary": true,
"Status": "succeeded"
},
{
"NetworkInterfaceId": "eni-0065a61b324d1897a",
"PrivateIp": "10.0.20.33",
"IsPrimary": false,
"Status": "succeeded"
},
{
"NetworkInterfaceId": "eni-0065a61b324d1897a",
"PrivateIp": "10.0.20.197",
"IsPrimary": false,
"Status": "succeeded"
}
],
"NatGatewayId": "nat-1234567890abcdef0",
"State": "available",
"SubnetId": "subnet-08fc749671EXAMPLE",
"VpcId": "vpc-098eb5ef58EXAMPLE",
"Tags": [
{
"Key": "Name",
"Value": "private-nat"
}
],
"ConnectivityType": "private"
}
]
}
```
Para obter mais informações, consulte [Gateways NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [DescribeNatGateways](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-nat-gateways.html)em *Referência de AWS CLI Comandos*.
### `describe-network-acls`
O código de exemplo a seguir mostra como usar `describe-network-acls`.
**AWS CLI**
**Para descrever sua rede ACLs**
O `describe-network-acls` exemplo a seguir recupera detalhes sobre sua rede ACLs.
```
aws ec2 describe-network-acls
```
Saída:
```
{
"NetworkAcls": [
{
"Associations": [
{
"NetworkAclAssociationId": "aclassoc-0c1679dc41EXAMPLE",
"NetworkAclId": "acl-0ea1f54ca7EXAMPLE",
"SubnetId": "subnet-0931fc2fa5EXAMPLE"
}
],
"Entries": [
{
"CidrBlock": "0.0.0.0/0",
"Egress": true,
"Protocol": "-1",
"RuleAction": "allow",
"RuleNumber": 100
},
{
"CidrBlock": "0.0.0.0/0",
"Egress": true,
"Protocol": "-1",
"RuleAction": "deny",
"RuleNumber": 32767
},
{
"CidrBlock": "0.0.0.0/0",
"Egress": false,
"Protocol": "-1",
"RuleAction": "allow",
"RuleNumber": 100
},
{
"CidrBlock": "0.0.0.0/0",
"Egress": false,
"Protocol": "-1",
"RuleAction": "deny",
"RuleNumber": 32767
}
],
"IsDefault": true,
"NetworkAclId": "acl-0ea1f54ca7EXAMPLE",
"Tags": [],
"VpcId": "vpc-06e4ab6c6cEXAMPLE",
"OwnerId": "111122223333"
},
{
"Associations": [],
"Entries": [
{
"CidrBlock": "0.0.0.0/0",
"Egress": true,
"Protocol": "-1",
"RuleAction": "allow",
"RuleNumber": 100
},
{
"Egress": true,
"Ipv6CidrBlock": "::/0",
"Protocol": "-1",
"RuleAction": "allow",
"RuleNumber": 101
},
{
"CidrBlock": "0.0.0.0/0",
"Egress": true,
"Protocol": "-1",
"RuleAction": "deny",
"RuleNumber": 32767
},
{
"Egress": true,
"Ipv6CidrBlock": "::/0",
"Protocol": "-1",
"RuleAction": "deny",
"RuleNumber": 32768
},
{
"CidrBlock": "0.0.0.0/0",
"Egress": false,
"Protocol": "-1",
"RuleAction": "allow",
"RuleNumber": 100
},
{
"Egress": false,
"Ipv6CidrBlock": "::/0",
"Protocol": "-1",
"RuleAction": "allow",
"RuleNumber": 101
},
{
"CidrBlock": "0.0.0.0/0",
"Egress": false,
"Protocol": "-1",
"RuleAction": "deny",
"RuleNumber": 32767
},
{
"Egress": false,
"Ipv6CidrBlock": "::/0",
"Protocol": "-1",
"RuleAction": "deny",
"RuleNumber": 32768
}
],
"IsDefault": true,
"NetworkAclId": "acl-0e2a78e4e2EXAMPLE",
"Tags": [],
"VpcId": "vpc-03914afb3eEXAMPLE",
"OwnerId": "111122223333"
}
]
}
```
Para obter mais informações, consulte [Rede ACLs](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html) no Guia do *usuário da AWS VPC*.
+ Para obter detalhes da API, consulte [DescribeNetworkAcls](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-network-acls.html)em *Referência de AWS CLI Comandos*.
### `describe-network-insights-access-scope-analyses`
O código de exemplo a seguir mostra como usar `describe-network-insights-access-scope-analyses`.
**AWS CLI**
**Descrever as análises do escopo de acesso do Network Insights**
O `describe-network-insights-access-scope-analyses` exemplo a seguir descreve a análise do escopo de acesso em sua AWS conta.
```
aws ec2 describe-network-insights-access-scope-analyses \
--region us-east-1
```
Saída:
```
{
"NetworkInsightsAccessScopeAnalyses": [
{
"NetworkInsightsAccessScopeAnalysisId": "nisa-123456789111",
"NetworkInsightsAccessScopeAnalysisArn": "arn:aws:ec2:us-east-1:123456789012:network-insights-access-scope-analysis/nisa-123456789111",
"NetworkInsightsAccessScopeId": "nis-123456789222",
"Status": "succeeded",
"StartDate": "2022-01-25T19:45:36.842000+00:00",
"FindingsFound": "true",
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Introdução ao Network Access Analyzer usando a AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli-naa.html) no Guia *do Network Access* Analyzer.
+ Para obter detalhes da API, consulte [DescribeNetworkInsightsAccessScopeAnalyses](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-network-insights-access-scope-analyses.html)em *Referência de AWS CLI Comandos*.
### `describe-network-insights-access-scopes`
O código de exemplo a seguir mostra como usar `describe-network-insights-access-scopes`.
**AWS CLI**
**Descrever os escopos de acesso do Network Insights**
O `describe-network-insights-access-scopes` exemplo a seguir descreve as análises do escopo de acesso em sua AWS conta.
```
aws ec2 describe-network-insights-access-scopes \
--region us-east-1
```
Saída:
```
{
"NetworkInsightsAccessScopes": [
{
"NetworkInsightsAccessScopeId": "nis-123456789111",
"NetworkInsightsAccessScopeArn": "arn:aws:ec2:us-east-1:123456789012:network-insights-access-scope/nis-123456789111",
"CreatedDate": "2021-11-29T21:12:41.416000+00:00",
"UpdatedDate": "2021-11-29T21:12:41.416000+00:00",
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Introdução ao Network Access Analyzer usando a AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli-naa.html) no Guia *do Network Access* Analyzer.
+ Para obter detalhes da API, consulte [DescribeNetworkInsightsAccessScopes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-network-insights-access-scopes.html)em *Referência de AWS CLI Comandos*.
### `describe-network-insights-analyses`
O código de exemplo a seguir mostra como usar `describe-network-insights-analyses`.
**AWS CLI**
**Visualizar os resultados de uma análise de caminho**
O exemplo `describe-network-insights-analyses` a seguir descreve a análise especificada. Neste exemplo, a origem é um gateway da Internet, o destino é uma instância do EC2 e o protocolo é TCP. A análise foi bem-sucedida (`Status` é `succeeded`) e o caminho não é alcançável (`NetworkPathFound` é `false`). O código de explicação `ENI_SG_RULES_MISMATCH` indica que o grupo de segurança da instância não contém uma regra que permita tráfego na porta de destino.
```
aws ec2 describe-network-insights-analyses \
--network-insights-analysis-ids nia-02207aa13eb480c7a
```
Saída:
```
{
"NetworkInsightsAnalyses": [
{
"NetworkInsightsAnalysisId": "nia-02207aa13eb480c7a",
"NetworkInsightsAnalysisArn": "arn:aws:ec2:us-east-1:123456789012:network-insights-analysis/nia-02207aa13eb480c7a",
"NetworkInsightsPathId": "nip-0b26f224f1d131fa8",
"StartDate": "2021-01-20T22:58:37.495Z",
"Status": "succeeded",
"NetworkPathFound": false,
"Explanations": [
{
"Direction": "ingress",
"ExplanationCode": "ENI_SG_RULES_MISMATCH",
"NetworkInterface": {
"Id": "eni-0a25edef15a6cc08c",
"Arn": "arn:aws:ec2:us-east-1:123456789012:network-interface/eni-0a25edef15a6cc08c"
},
"SecurityGroups": [
{
"Id": "sg-02f0d35a850ba727f",
"Arn": "arn:aws:ec2:us-east-1:123456789012:security-group/sg-02f0d35a850ba727f"
}
],
"Subnet": {
"Id": "subnet-004ff41eccb4d1194",
"Arn": "arn:aws:ec2:us-east-1:123456789012:subnet/subnet-004ff41eccb4d1194"
},
"Vpc": {
"Id": "vpc-f1663d98ad28331c7",
"Arn": "arn:aws:ec2:us-east-1:123456789012:vpc/vpc-f1663d98ad28331c7"
}
}
],
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Introdução ao uso da AWS CLI](https://docs.aws.amazon.com/vpc/latest/reachability/getting-started-cli.html) no Guia do *Reachability Analyzer*.
+ Para obter detalhes da API, consulte [DescribeNetworkInsightsAnalyses](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-network-insights-analyses.html)em *Referência de AWS CLI Comandos*.
### `describe-network-insights-paths`
O código de exemplo a seguir mostra como usar `describe-network-insights-paths`.
**AWS CLI**
**Descrever um caminho**
O exemplo `describe-network-insights-paths` a seguir descreve o caminho especificado.
```
aws ec2 describe-network-insights-paths \
--network-insights-path-ids nip-0b26f224f1d131fa8
```
Saída:
```
{
"NetworkInsightsPaths": [
{
"NetworkInsightsPathId": "nip-0b26f224f1d131fa8",
"NetworkInsightsPathArn": "arn:aws:ec2:us-east-1:123456789012:network-insights-path/nip-0b26f224f1d131fa8",
"CreatedDate": "2021-01-20T22:43:46.933Z",
"Source": "igw-0797cccdc9d73b0e5",
"Destination": "i-0495d385ad28331c7",
"Protocol": "tcp"
}
]
}
```
Para obter mais informações, consulte [Introdução ao uso da AWS CLI](https://docs.aws.amazon.com/vpc/latest/reachability/getting-started-cli.html) no Guia do *Reachability Analyzer*.
+ Para obter detalhes da API, consulte [DescribeNetworkInsightsPaths](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-network-insights-paths.html)em *Referência de AWS CLI Comandos*.
### `describe-network-interface-attribute`
O código de exemplo a seguir mostra como usar `describe-network-interface-attribute`.
**AWS CLI**
**Descrever o atributo de anexo de uma interface de rede**
Este exemplo de comando descreve o atributo `attachment` da interface de rede especificada.
Comando:
```
aws ec2 describe-network-interface-attribute --network-interface-id eni-686ea200 --attribute attachment
```
Saída:
```
{
"NetworkInterfaceId": "eni-686ea200",
"Attachment": {
"Status": "attached",
"DeviceIndex": 0,
"AttachTime": "2015-05-21T20:02:20.000Z",
"InstanceId": "i-1234567890abcdef0",
"DeleteOnTermination": true,
"AttachmentId": "eni-attach-43348162",
"InstanceOwnerId": "123456789012"
}
}
```
**Descrever o atributo de descrição de uma interface de rede**
Este exemplo de comando descreve o atributo `description` da interface de rede especificada.
Comando:
```
aws ec2 describe-network-interface-attribute --network-interface-id eni-686ea200 --attribute description
```
Saída:
```
{
"NetworkInterfaceId": "eni-686ea200",
"Description": {
"Value": "My description"
}
}
```
**Descrever o atributo groupSet de uma interface de rede**
Este exemplo de comando descreve o atributo `groupSet` da interface de rede especificada.
Comando:
```
aws ec2 describe-network-interface-attribute --network-interface-id eni-686ea200 --attribute groupSet
```
Saída:
```
{
"NetworkInterfaceId": "eni-686ea200",
"Groups": [
{
"GroupName": "my-security-group",
"GroupId": "sg-903004f8"
}
]
}
```
**Para descrever o sourceDestCheck atributo de uma interface de rede**
Este exemplo de comando descreve o atributo `sourceDestCheck` da interface de rede especificada.
Comando:
```
aws ec2 describe-network-interface-attribute --network-interface-id eni-686ea200 --attribute sourceDestCheck
```
Saída:
```
{
"NetworkInterfaceId": "eni-686ea200",
"SourceDestCheck": {
"Value": true
}
}
```
+ Para obter detalhes da API, consulte [DescribeNetworkInterfaceAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-network-interface-attribute.html)em *Referência de AWS CLI Comandos*.
### `describe-network-interface-permissions`
O código de exemplo a seguir mostra como usar `describe-network-interface-permissions`.
**AWS CLI**
**Descrever suas permissões de interface de rede**
Este exemplo descreve todas as permissões da interface de rede.
Comando:
```
aws ec2 describe-network-interface-permissions
```
Saída:
```
{
"NetworkInterfacePermissions": [
{
"PermissionState": {
"State": "GRANTED"
},
"NetworkInterfacePermissionId": "eni-perm-06fd19020ede149ea",
"NetworkInterfaceId": "eni-b909511a",
"Permission": "INSTANCE-ATTACH",
"AwsAccountId": "123456789012"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeNetworkInterfacePermissions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-network-interface-permissions.html)em *Referência de AWS CLI Comandos*.
### `describe-network-interfaces`
O código de exemplo a seguir mostra como usar `describe-network-interfaces`.
**AWS CLI**
**Descrever suas interfaces de rede**
Este exemplo descreve todas as interfaces de rede.
Comando:
```
aws ec2 describe-network-interfaces
```
Saída:
```
{
"NetworkInterfaces": [
{
"Status": "in-use",
"MacAddress": "02:2f:8f:b0:cf:75",
"SourceDestCheck": true,
"VpcId": "vpc-a01106c2",
"Description": "my network interface",
"Association": {
"PublicIp": "203.0.113.12",
"AssociationId": "eipassoc-0fbb766a",
"PublicDnsName": "ec2-203-0-113-12.compute-1.amazonaws.com",
"IpOwnerId": "123456789012"
},
"NetworkInterfaceId": "eni-e5aa89a3",
"PrivateIpAddresses": [
{
"PrivateDnsName": "ip-10-0-1-17.ec2.internal",
"Association": {
"PublicIp": "203.0.113.12",
"AssociationId": "eipassoc-0fbb766a",
"PublicDnsName": "ec2-203-0-113-12.compute-1.amazonaws.com",
"IpOwnerId": "123456789012"
},
"Primary": true,
"PrivateIpAddress": "10.0.1.17"
}
],
"RequesterManaged": false,
"Ipv6Addresses": [],
"PrivateDnsName": "ip-10-0-1-17.ec2.internal",
"AvailabilityZone": "us-east-1d",
"Attachment": {
"Status": "attached",
"DeviceIndex": 1,
"AttachTime": "2013-11-30T23:36:42.000Z",
"InstanceId": "i-1234567890abcdef0",
"DeleteOnTermination": false,
"AttachmentId": "eni-attach-66c4350a",
"InstanceOwnerId": "123456789012"
},
"Groups": [
{
"GroupName": "default",
"GroupId": "sg-8637d3e3"
}
],
"SubnetId": "subnet-b61f49f0",
"OwnerId": "123456789012",
"TagSet": [],
"PrivateIpAddress": "10.0.1.17"
},
{
"Status": "in-use",
"MacAddress": "02:58:f5:ef:4b:06",
"SourceDestCheck": true,
"VpcId": "vpc-a01106c2",
"Description": "Primary network interface",
"Association": {
"PublicIp": "198.51.100.0",
"IpOwnerId": "amazon"
},
"NetworkInterfaceId": "eni-f9ba99bf",
"PrivateIpAddresses": [
{
"Association": {
"PublicIp": "198.51.100.0",
"IpOwnerId": "amazon"
},
"Primary": true,
"PrivateIpAddress": "10.0.1.149"
}
],
"RequesterManaged": false,
"Ipv6Addresses": [],
"AvailabilityZone": "us-east-1d",
"Attachment": {
"Status": "attached",
"DeviceIndex": 0,
"AttachTime": "2013-11-30T23:35:33.000Z",
"InstanceId": "i-0598c7d356eba48d7",
"DeleteOnTermination": true,
"AttachmentId": "eni-attach-1b9db777",
"InstanceOwnerId": "123456789012"
},
"Groups": [
{
"GroupName": "default",
"GroupId": "sg-8637d3e3"
}
],
"SubnetId": "subnet-b61f49f0",
"OwnerId": "123456789012",
"TagSet": [],
"PrivateIpAddress": "10.0.1.149"
}
]
}
```
Este exemplo descreve interfaces de rede que têm uma tag com a chave `Purpose` e o valor `Prod`.
Comando:
```
aws ec2 describe-network-interfaces --filters Name=tag:Purpose,Values=Prod
```
Saída:
```
{
"NetworkInterfaces": [
{
"Status": "available",
"MacAddress": "12:2c:bd:f9:bf:17",
"SourceDestCheck": true,
"VpcId": "vpc-8941ebec",
"Description": "ProdENI",
"NetworkInterfaceId": "eni-b9a5ac93",
"PrivateIpAddresses": [
{
"PrivateDnsName": "ip-10-0-1-55.ec2.internal",
"Primary": true,
"PrivateIpAddress": "10.0.1.55"
},
{
"PrivateDnsName": "ip-10-0-1-117.ec2.internal",
"Primary": false,
"PrivateIpAddress": "10.0.1.117"
}
],
"RequesterManaged": false,
"PrivateDnsName": "ip-10-0-1-55.ec2.internal",
"AvailabilityZone": "us-east-1d",
"Ipv6Addresses": [],
"Groups": [
{
"GroupName": "MySG",
"GroupId": "sg-905002f5"
}
],
"SubnetId": "subnet-31d6c219",
"OwnerId": "123456789012",
"TagSet": [
{
"Value": "Prod",
"Key": "Purpose"
}
],
"PrivateIpAddress": "10.0.1.55"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeNetworkInterfaces](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-network-interfaces.html)em *Referência de AWS CLI Comandos*.
### `describe-placement-groups`
O código de exemplo a seguir mostra como usar `describe-placement-groups`.
**AWS CLI**
**Descrever todos os seus grupos de posicionamento**
Este exemplo de comando descreve todos os grupos de posicionamento.
Comando:
```
aws ec2 describe-placement-groups
```
Saída:
```
{
"PlacementGroups": [
{
"GroupName": "my-cluster",
"State": "available",
"Strategy": "cluster"
},
...
]
}
```
+ Para obter detalhes da API, consulte [DescribePlacementGroups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-placement-groups.html)em *Referência de AWS CLI Comandos*.
### `describe-prefix-lists`
O código de exemplo a seguir mostra como usar `describe-prefix-lists`.
**AWS CLI**
**Descrever listas de prefixo**
Este exemplo lista todas as listas de prefixos disponíveis para a região.
Comando:
```
aws ec2 describe-prefix-lists
```
Saída:
```
{
"PrefixLists": [
{
"PrefixListName": "com.amazonaws.us-east-1.s3",
"Cidrs": [
"54.231.0.0/17"
],
"PrefixListId": "pl-63a5400a"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribePrefixLists](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-prefix-lists.html)em *Referência de AWS CLI Comandos*.
### `describe-principal-id-format`
O código de exemplo a seguir mostra como usar `describe-principal-id-format`.
**AWS CLI**
**Descrever o formato de ID para usuários e perfis do IAM com o formato de ID longo ativado**
O exemplo `describe-principal-id-format` a seguir descreve o formato de ID para o usuário-raiz, todos os perfis do IAM e todos os usuários do IAM com o formato de ID longo ativado.
```
aws ec2 describe-principal-id-format \
--resource instance
```
Saída:
```
{
"Principals": [
{
"Arn": "arn:aws:iam::123456789012:root",
"Statuses": [
{
"Deadline": "2016-12-15T00:00:00.000Z",
"Resource": "reservation",
"UseLongIds": true
},
{
"Deadline": "2016-12-15T00:00:00.000Z",
"Resource": "instance",
"UseLongIds": true
},
{
"Deadline": "2016-12-15T00:00:00.000Z",
"Resource": "volume",
"UseLongIds": true
},
]
},
...
]
}
```
+ Para obter detalhes da API, consulte [DescribePrincipalIdFormat](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-principal-id-format.html)em *Referência de AWS CLI Comandos*.
### `describe-public-ipv4-pools`
O código de exemplo a seguir mostra como usar `describe-public-ipv4-pools`.
**AWS CLI**
**Para descrever seus grupos IPv4 de endereços públicos**
O `describe-public-ipv4-pools` exemplo a seguir exibe detalhes sobre os grupos de endereços que foram criados quando você provisionou intervalos de IPv4 endereços públicos usando Bring Your Own IP Addresses (BYOIP).
```
aws ec2 describe-public-ipv4-pools
```
Saída:
```
{
"PublicIpv4Pools": [
{
"PoolId": "ipv4pool-ec2-1234567890abcdef0",
"PoolAddressRanges": [
{
"FirstAddress": "203.0.113.0",
"LastAddress": "203.0.113.255",
"AddressCount": 256,
"AvailableAddressCount": 256
}
],
"TotalAddressCount": 256,
"TotalAvailableAddressCount": 256
}
]
}
```
+ Para obter detalhes da API, consulte [DescribePublicIpv4Pools](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-public-ipv4-pools.html) na *Referência de AWS CLI Comandos*.
### `describe-regions`
O código de exemplo a seguir mostra como usar `describe-regions`.
**AWS CLI**
**Exemplo 1: descrever todas as suas regiões habilitadas**
O exemplo `describe-regions` a seguir descreve todas as regiões habilitadas para a sua conta.
```
aws ec2 describe-regions
```
Saída:
```
{
"Regions": [
{
"Endpoint": "ec2.eu-north-1.amazonaws.com",
"RegionName": "eu-north-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.ap-south-1.amazonaws.com",
"RegionName": "ap-south-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.eu-west-3.amazonaws.com",
"RegionName": "eu-west-3",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.eu-west-2.amazonaws.com",
"RegionName": "eu-west-2",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.eu-west-1.amazonaws.com",
"RegionName": "eu-west-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.ap-northeast-3.amazonaws.com",
"RegionName": "ap-northeast-3",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.ap-northeast-2.amazonaws.com",
"RegionName": "ap-northeast-2",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.ap-northeast-1.amazonaws.com",
"RegionName": "ap-northeast-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.sa-east-1.amazonaws.com",
"RegionName": "sa-east-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.ca-central-1.amazonaws.com",
"RegionName": "ca-central-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.ap-southeast-1.amazonaws.com",
"RegionName": "ap-southeast-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.ap-southeast-2.amazonaws.com",
"RegionName": "ap-southeast-2",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.eu-central-1.amazonaws.com",
"RegionName": "eu-central-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.us-east-1.amazonaws.com",
"RegionName": "us-east-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.us-east-2.amazonaws.com",
"RegionName": "us-east-2",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.us-west-1.amazonaws.com",
"RegionName": "us-west-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.us-west-2.amazonaws.com",
"RegionName": "us-west-2",
"OptInStatus": "opt-in-not-required"
}
]
}
```
Para obter mais informações, consulte [Regiões e zonas](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) no *Guia do usuário do Amazon EC2*.
**Exemplo 2: para descrever as regiões habilitadas com um endpoint cujo nome contém uma string específica**
O exemplo `describe-regions` a seguir descreve todas as regiões que você habilitou e que têm a string “us” no endpoint.
```
aws ec2 describe-regions \
--filters "Name=endpoint,Values=*us*"
```
Saída:
```
{
"Regions": [
{
"Endpoint": "ec2.us-east-1.amazonaws.com",
"RegionName": "us-east-1"
},
{
"Endpoint": "ec2.us-east-2.amazonaws.com",
"RegionName": "us-east-2"
},
{
"Endpoint": "ec2.us-west-1.amazonaws.com",
"RegionName": "us-west-1"
},
{
"Endpoint": "ec2.us-west-2.amazonaws.com",
"RegionName": "us-west-2"
}
]
}
```
Para obter mais informações, consulte [Regiões e zonas](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) no *Guia do usuário do Amazon EC2*.
**Exemplo 3: descrever todas as regiões**
O exemplo `describe-regions` a seguir descreve todas as regiões disponíveis, incluindo as que estão desabilitadas.
```
aws ec2 describe-regions \
--all-regions
```
Saída:
```
{
"Regions": [
{
"Endpoint": "ec2.eu-north-1.amazonaws.com",
"RegionName": "eu-north-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.ap-south-1.amazonaws.com",
"RegionName": "ap-south-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.eu-west-3.amazonaws.com",
"RegionName": "eu-west-3",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.eu-west-2.amazonaws.com",
"RegionName": "eu-west-2",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.eu-west-1.amazonaws.com",
"RegionName": "eu-west-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.ap-northeast-3.amazonaws.com",
"RegionName": "ap-northeast-3",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.me-south-1.amazonaws.com",
"RegionName": "me-south-1",
"OptInStatus": "not-opted-in"
},
{
"Endpoint": "ec2.ap-northeast-2.amazonaws.com",
"RegionName": "ap-northeast-2",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.ap-northeast-1.amazonaws.com",
"RegionName": "ap-northeast-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.sa-east-1.amazonaws.com",
"RegionName": "sa-east-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.ca-central-1.amazonaws.com",
"RegionName": "ca-central-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.ap-east-1.amazonaws.com",
"RegionName": "ap-east-1",
"OptInStatus": "not-opted-in"
},
{
"Endpoint": "ec2.ap-southeast-1.amazonaws.com",
"RegionName": "ap-southeast-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.ap-southeast-2.amazonaws.com",
"RegionName": "ap-southeast-2",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.eu-central-1.amazonaws.com",
"RegionName": "eu-central-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.us-east-1.amazonaws.com",
"RegionName": "us-east-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.us-east-2.amazonaws.com",
"RegionName": "us-east-2",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.us-west-1.amazonaws.com",
"RegionName": "us-west-1",
"OptInStatus": "opt-in-not-required"
},
{
"Endpoint": "ec2.us-west-2.amazonaws.com",
"RegionName": "us-west-2",
"OptInStatus": "opt-in-not-required"
}
]
}
```
Para obter mais informações, consulte [Regiões e zonas](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) no *Guia do usuário do Amazon EC2*.
**Exemplo 4: listar somente os nomes das regiões**
O exemplo `describe-regions` a seguir usa o parâmetro `--query` para filtrar a saída e retornar somente os nomes das regiões como texto.
```
aws ec2 describe-regions \
--all-regions \
--query "Regions[].{Name:RegionName}" \
--output text
```
Saída:
```
eu-north-1
ap-south-1
eu-west-3
eu-west-2
eu-west-1
ap-northeast-3
ap-northeast-2
me-south-1
ap-northeast-1
sa-east-1
ca-central-1
ap-east-1
ap-southeast-1
ap-southeast-2
eu-central-1
us-east-1
us-east-2
us-west-1
us-west-2
```
Para obter mais informações, consulte [Regiões e zonas](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DescribeRegions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-regions.html)em *Referência de AWS CLI Comandos*.
### `describe-replace-root-volume-tasks`
O código de exemplo a seguir mostra como usar `describe-replace-root-volume-tasks`.
**AWS CLI**
**Exemplo 1: visualizar informações sobre uma tarefa específica de substituição do volume raiz**
O exemplo `describe-replace-root-volume-tasks` a seguir descreve a tarefa de substituição do volume raiz replacevol-0111122223333abcd.
```
aws ec2 describe-replace-root-volume-tasks \
--replace-root-volume-task-ids replacevol-0111122223333abcd
```
Saída:
```
{
"ReplaceRootVolumeTasks": [
{
"ReplaceRootVolumeTaskId": "replacevol-0111122223333abcd",
"Tags": [],
"InstanceId": "i-0123456789abcdefa",
"TaskState": "succeeded",
"StartTime": "2022-03-14T15:16:28Z",
"CompleteTime": "2022-03-14T15:16:52Z"
}
]
}
```
Para obter mais informações, consulte [Substituir um volume raiz](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-restoring-volume.html#replace-root) no *Guia do usuário do Amazon Elastic Compute Cloud*.
**Exemplo 2: visualizar informações sobre todas as tarefas de substituição do volume raiz de uma instância específica**
O exemplo `describe-replace-root-volume-tasks` a seguir descreve todas as tarefas de substituição do volume raiz para a instância i-0123456789abcdefa.
```
aws ec2 describe-replace-root-volume-tasks \
--filters Name=instance-id,Values=i-0123456789abcdefa
```
Saída:
```
{
"ReplaceRootVolumeTasks": [
{
"ReplaceRootVolumeTaskId": "replacevol-0111122223333abcd",
"Tags": [],
"InstanceId": "i-0123456789abcdefa",
"TaskState": "succeeded",
"StartTime": "2022-03-14T15:06:38Z",
"CompleteTime": "2022-03-14T15:07:03Z"
},
{
"ReplaceRootVolumeTaskId": "replacevol-0444455555555abcd",
"Tags": [],
"InstanceId": "i-0123456789abcdefa",
"TaskState": "succeeded",
"StartTime": "2022-03-14T15:16:28Z",
"CompleteTime": "2022-03-14T15:16:52Z"
}
]
}
```
Para obter mais informações, consulte [Substituir um volume raiz](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-restoring-volume.html#replace-root) no *Guia do usuário do Amazon Elastic Compute Cloud*.
+ Para obter detalhes da API, consulte [DescribeReplaceRootVolumeTasks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-replace-root-volume-tasks.html)em *Referência de AWS CLI Comandos*.
### `describe-reserved-instances-listings`
O código de exemplo a seguir mostra como usar `describe-reserved-instances-listings`.
**AWS CLI**
**Descrever uma lista de instâncias reservadas**
O exemplo `describe-reserved-instances-listings` a seguir retorna informações sobre a Instância Reservada especificada.
```
aws ec2 describe-reserved-instances-listings \
--reserved-instances-listing-id 5ec28771-05ff-4b9b-aa31-9e57dexample
```
Este comando não produz saída.
+ Para obter detalhes da API, consulte [DescribeReservedInstancesListings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-reserved-instances-listings.html)em *Referência de AWS CLI Comandos*.
### `describe-reserved-instances-modifications`
O código de exemplo a seguir mostra como usar `describe-reserved-instances-modifications`.
**AWS CLI**
**Descrever modificações de Instâncias Reservadas**
Este exemplo de comando descreve todas as solicitações de modificação de Instâncias Reservadas que foram enviadas para sua conta.
Comando:
```
aws ec2 describe-reserved-instances-modifications
```
Saída:
```
{
"ReservedInstancesModifications": [
{
"Status": "fulfilled",
"ModificationResults": [
{
"ReservedInstancesId": "93bbbca2-62f1-4d9d-b225-16bada29e6c7",
"TargetConfiguration": {
"AvailabilityZone": "us-east-1b",
"InstanceType": "m1.large",
"InstanceCount": 3
}
},
{
"ReservedInstancesId": "1ba8e2e3-aabb-46c3-bcf5-3fe2fda922e6",
"TargetConfiguration": {
"AvailabilityZone": "us-east-1d",
"InstanceType": "m1.xlarge",
"InstanceCount": 1
}
}
],
"EffectiveDate": "2015-08-12T17:00:00.000Z",
"CreateDate": "2015-08-12T17:52:52.630Z",
"UpdateDate": "2015-08-12T18:08:06.698Z",
"ClientToken": "c9adb218-3222-4889-8216-0cf0e52dc37e:
"ReservedInstancesModificationId": "rimod-d3ed4335-b1d3-4de6-ab31-0f13aaf46687",
"ReservedInstancesIds": [
{
"ReservedInstancesId": "b847fa93-e282-4f55-b59a-1342f5bd7c02"
}
]
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeReservedInstancesModifications](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-reserved-instances-modifications.html)em *Referência de AWS CLI Comandos*.
### `describe-reserved-instances-offerings`
O código de exemplo a seguir mostra como usar `describe-reserved-instances-offerings`.
**AWS CLI**
**Descrever ofertas de Instâncias Reservadas**
Este exemplo de comando descreve todas as instâncias reservadas disponíveis para compra na região.
Comando:
```
aws ec2 describe-reserved-instances-offerings
```
Saída:
```
{
"ReservedInstancesOfferings": [
{
"OfferingType": "Partial Upfront",
"AvailabilityZone": "us-east-1b",
"InstanceTenancy": "default",
"PricingDetails": [],
"ProductDescription": "Red Hat Enterprise Linux",
"UsagePrice": 0.0,
"RecurringCharges": [
{
"Amount": 0.088,
"Frequency": "Hourly"
}
],
"Marketplace": false,
"CurrencyCode": "USD",
"FixedPrice": 631.0,
"Duration": 94608000,
"ReservedInstancesOfferingId": "9a06095a-bdc6-47fe-a94a-2a382f016040",
"InstanceType": "c1.medium"
},
{
"OfferingType": "PartialUpfront",
"AvailabilityZone": "us-east-1b",
"InstanceTenancy": "default",
"PricingDetails": [],
"ProductDescription": "Linux/UNIX",
"UsagePrice": 0.0,
"RecurringCharges": [
{
"Amount": 0.028,
"Frequency": "Hourly"
}
],
"Marketplace": false,
"CurrencyCode": "USD",
"FixedPrice": 631.0,
"Duration": 94608000,
"ReservedInstancesOfferingId": "bfbefc6c-0d10-418d-b144-7258578d329d",
"InstanceType": "c1.medium"
},
...
}
```
**Descrever suas ofertas de instâncias reservadas usando opções**
Este exemplo lista as instâncias reservadas oferecidas pela AWS com as seguintes especificações: tipos de instância t1.micro, produtos Windows (Amazon VPC) e ofertas de utilização pesada.
Comando:
```
aws ec2 describe-reserved-instances-offerings --no-include-marketplace --instance-type "t1.micro" --product-description "Windows (Amazon VPC)" --offering-type "no upfront"
```
Saída:
```
{
"ReservedInstancesOfferings": [
{
"OfferingType": "No Upfront",
"AvailabilityZone": "us-east-1b",
"InstanceTenancy": "default",
"PricingDetails": [],
"ProductDescription": "Windows",
"UsagePrice": 0.0,
"RecurringCharges": [
{
"Amount": 0.015,
"Frequency": "Hourly"
}
],
"Marketplace": false,
"CurrencyCode": "USD",
"FixedPrice": 0.0,
"Duration": 31536000,
"ReservedInstancesOfferingId": "c48ab04c-fe69-4f94-8e39-a23842292823",
"InstanceType": "t1.micro"
},
...
{
"OfferingType": "No Upfront",
"AvailabilityZone": "us-east-1d",
"InstanceTenancy": "default",
"PricingDetails": [],
"ProductDescription": "Windows (Amazon VPC)",
"UsagePrice": 0.0,
"RecurringCharges": [
{
"Amount": 0.015,
"Frequency": "Hourly"
}
],
"Marketplace": false,
"CurrencyCode": "USD",
"FixedPrice": 0.0,
"Duration": 31536000,
"ReservedInstancesOfferingId": "3a98bf7d-2123-42d4-b4f5-8dbec4b06dc6",
"InstanceType": "t1.micro"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeReservedInstancesOfferings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-reserved-instances-offerings.html)em *Referência de AWS CLI Comandos*.
### `describe-reserved-instances`
O código de exemplo a seguir mostra como usar `describe-reserved-instances`.
**AWS CLI**
**Descrever suas instâncias reservadas**
Este exemplo de comando descreve as instâncias reservadas que você possui.
Comando:
```
aws ec2 describe-reserved-instances
```
Saída:
```
{
"ReservedInstances": [
{
"ReservedInstancesId": "b847fa93-e282-4f55-b59a-1342fexample",
"OfferingType": "No Upfront",
"AvailabilityZone": "us-west-1c",
"End": "2016-08-14T21:34:34.000Z",
"ProductDescription": "Linux/UNIX",
"UsagePrice": 0.00,
"RecurringCharges": [
{
"Amount": 0.104,
"Frequency": "Hourly"
}
],
"Start": "2015-08-15T21:34:35.086Z",
"State": "active",
"FixedPrice": 0.0,
"CurrencyCode": "USD",
"Duration": 31536000,
"InstanceTenancy": "default",
"InstanceType": "m3.medium",
"InstanceCount": 2
},
...
]
}
```
**Descrever suas instâncias reservadas usando filtros**
Este exemplo filtra a resposta para incluir somente instâncias Linux/UNIX reservadas t2.micro de três anos em us-west-1c.
Comando:
```
aws ec2 describe-reserved-instances --filters Name=duration,Values=94608000 Name=instance-type,Values=t2.micro Name=product-description,Values=Linux/UNIX Name=availability-zone,Values=us-east-1e
```
Saída:
```
{
"ReservedInstances": [
{
"ReservedInstancesId": "f127bd27-edb7-44c9-a0eb-0d7e09259af0",
"OfferingType": "All Upfront",
"AvailabilityZone": "us-east-1e",
"End": "2018-03-26T21:34:34.000Z",
"ProductDescription": "Linux/UNIX",
"UsagePrice": 0.00,
"RecurringCharges": [],
"Start": "2015-03-27T21:34:35.848Z",
"State": "active",
"FixedPrice": 151.0,
"CurrencyCode": "USD",
"Duration": 94608000,
"InstanceTenancy": "default",
"InstanceType": "t2.micro",
"InstanceCount": 1
}
]
}
```
Para obter mais informações, consulte Using Amazon EC2 Instances no *Guia do usuário da AWS Command Line Interface*.
+ Para obter detalhes da API, consulte [DescribeReservedInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-reserved-instances.html)em *Referência de AWS CLI Comandos*.
### `describe-route-tables`
O código de exemplo a seguir mostra como usar `describe-route-tables`.
**AWS CLI**
**Descrever suas tabelas de rotas**
O exemplo `describe-route-tables` a seguir recupera detalhes das tabelas de rotas
```
aws ec2 describe-route-tables
```
Saída:
```
{
"RouteTables": [
{
"Associations": [
{
"Main": true,
"RouteTableAssociationId": "rtbassoc-0df3f54e06EXAMPLE",
"RouteTableId": "rtb-09ba434c1bEXAMPLE"
}
],
"PropagatingVgws": [],
"RouteTableId": "rtb-09ba434c1bEXAMPLE",
"Routes": [
{
"DestinationCidrBlock": "10.0.0.0/16",
"GatewayId": "local",
"Origin": "CreateRouteTable",
"State": "active"
},
{
"DestinationCidrBlock": "0.0.0.0/0",
"NatGatewayId": "nat-06c018cbd8EXAMPLE",
"Origin": "CreateRoute",
"State": "blackhole"
}
],
"Tags": [],
"VpcId": "vpc-0065acced4EXAMPLE",
"OwnerId": "111122223333"
},
{
"Associations": [
{
"Main": true,
"RouteTableAssociationId": "rtbassoc-9EXAMPLE",
"RouteTableId": "rtb-a1eec7de"
}
],
"PropagatingVgws": [],
"RouteTableId": "rtb-a1eec7de",
"Routes": [
{
"DestinationCidrBlock": "172.31.0.0/16",
"GatewayId": "local",
"Origin": "CreateRouteTable",
"State": "active"
},
{
"DestinationCidrBlock": "0.0.0.0/0",
"GatewayId": "igw-fEXAMPLE",
"Origin": "CreateRoute",
"State": "active"
}
],
"Tags": [],
"VpcId": "vpc-3EXAMPLE",
"OwnerId": "111122223333"
},
{
"Associations": [
{
"Main": false,
"RouteTableAssociationId": "rtbassoc-0b100c28b2EXAMPLE",
"RouteTableId": "rtb-07a98f76e5EXAMPLE",
"SubnetId": "subnet-0d3d002af8EXAMPLE"
}
],
"PropagatingVgws": [],
"RouteTableId": "rtb-07a98f76e5EXAMPLE",
"Routes": [
{
"DestinationCidrBlock": "10.0.0.0/16",
"GatewayId": "local",
"Origin": "CreateRouteTable",
"State": "active"
},
{
"DestinationCidrBlock": "0.0.0.0/0",
"GatewayId": "igw-06cf664d80EXAMPLE",
"Origin": "CreateRoute",
"State": "active"
}
],
"Tags": [],
"VpcId": "vpc-0065acced4EXAMPLE",
"OwnerId": "111122223333"
}
]
}
```
Para obter mais informações, consulte [Trabalhar com tabelas de rotas](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html#WorkWithRouteTables) no *Guia do usuário da AWS VPC*.
+ Para obter detalhes da API, consulte [DescribeRouteTables](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-route-tables.html)em *Referência de AWS CLI Comandos*.
### `describe-scheduled-instance-availability`
O código de exemplo a seguir mostra como usar `describe-scheduled-instance-availability`.
**AWS CLI**
**Descrever um cronograma disponível**
Este exemplo descreve uma programação que ocorre toda semana no domingo, começando na data especificada.
Comando:
```
aws ec2 describe-scheduled-instance-availability --recurrence Frequency=Weekly,Interval=1,OccurrenceDays=[1] --first-slot-start-time-range EarliestTime=2016-01-31T00:00:00Z,LatestTime=2016-01-31T04:00:00Z
```
Saída:
```
{
"ScheduledInstanceAvailabilitySet": [
{
"AvailabilityZone": "us-west-2b",
"TotalScheduledInstanceHours": 1219,
"PurchaseToken": "eyJ2IjoiMSIsInMiOjEsImMiOi...",
"MinTermDurationInDays": 366,
"AvailableInstanceCount": 20,
"Recurrence": {
"OccurrenceDaySet": [
1
],
"Interval": 1,
"Frequency": "Weekly",
"OccurrenceRelativeToEnd": false
},
"Platform": "Linux/UNIX",
"FirstSlotStartTime": "2016-01-31T00:00:00Z",
"MaxTermDurationInDays": 366,
"SlotDurationInHours": 23,
"NetworkPlatform": "EC2-VPC",
"InstanceType": "c4.large",
"HourlyPrice": "0.095"
},
...
]
}
```
Para restringir os resultados, você pode adicionar filtros que especificam o sistema operacional, a rede e o tipo de instância.
Comando:
--filters Name=platform,Values=Linux/UNIX Name=network-platform,Values=EC2-VPC Name=instance-type,Values=c4.large
+ Para obter detalhes da API, consulte [DescribeScheduledInstanceAvailability](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-scheduled-instance-availability.html)em *Referência de AWS CLI Comandos*.
### `describe-scheduled-instances`
O código de exemplo a seguir mostra como usar `describe-scheduled-instances`.
**AWS CLI**
**Descrever suas instâncias agendadas**
Este exemplo descreve a Instância Agendada especificada.
Comando:
```
aws ec2 describe-scheduled-instances --scheduled-instance-ids sci-1234-1234-1234-1234-123456789012
```
Saída:
```
{
"ScheduledInstanceSet": [
{
"AvailabilityZone": "us-west-2b",
"ScheduledInstanceId": "sci-1234-1234-1234-1234-123456789012",
"HourlyPrice": "0.095",
"CreateDate": "2016-01-25T21:43:38.612Z",
"Recurrence": {
"OccurrenceDaySet": [
1
],
"Interval": 1,
"Frequency": "Weekly",
"OccurrenceRelativeToEnd": false,
"OccurrenceUnit": ""
},
"Platform": "Linux/UNIX",
"TermEndDate": "2017-01-31T09:00:00Z",
"InstanceCount": 1,
"SlotDurationInHours": 32,
"TermStartDate": "2016-01-31T09:00:00Z",
"NetworkPlatform": "EC2-VPC",
"TotalScheduledInstanceHours": 1696,
"NextSlotStartTime": "2016-01-31T09:00:00Z",
"InstanceType": "c4.large"
}
]
}
```
Este exemplo descreve todas as suas instâncias agendadas.
Comando:
```
aws ec2 describe-scheduled-instances
```
+ Para obter detalhes da API, consulte [DescribeScheduledInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-scheduled-instances.html)em *Referência de AWS CLI Comandos*.
### `describe-security-group-references`
O código de exemplo a seguir mostra como usar `describe-security-group-references`.
**AWS CLI**
**Descrever as referências do grupo de segurança**
Este exemplo descreve as referências do grupo de segurança para `sg-bbbb2222`. A resposta indica que o grupo de segurança `sg-bbbb2222` está sendo referenciado por um grupo de segurança na VPC `vpc-aaaaaaaa`:
Comando:
```
aws ec2 describe-security-group-references --group-id sg-bbbbb22222
```
Saída:
```
{
"SecurityGroupsReferenceSet": [
{
"ReferencingVpcId": "vpc-aaaaaaaa ",
"GroupId": "sg-bbbbb22222",
"VpcPeeringConnectionId": "pcx-b04deed9"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeSecurityGroupReferences](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-security-group-references.html)em *Referência de AWS CLI Comandos*.
### `describe-security-group-rules`
O código de exemplo a seguir mostra como usar `describe-security-group-rules`.
**AWS CLI**
**Exemplo 1: descrever as regras de grupo de segurança para um grupo de segurança**
O exemplo `describe-security-group-rules` a seguir descreve as regras do grupo de segurança de um grupo de segurança especificado. Use a opção `filters` para definir o escopo dos resultados para um grupo de segurança específico.
```
aws ec2 describe-security-group-rules \
--filters Name="group-id",Values="sg-1234567890abcdef0"
```
Saída:
```
{
"SecurityGroupRules": [
{
"SecurityGroupRuleId": "sgr-abcdef01234567890",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "111122223333",
"IsEgress": false,
"IpProtocol": "-1",
"FromPort": -1,
"ToPort": -1,
"ReferencedGroupInfo": {
"GroupId": "sg-1234567890abcdef0",
"UserId": "111122223333"
},
"Tags": []
},
{
"SecurityGroupRuleId": "sgr-bcdef01234567890a",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "111122223333",
"IsEgress": true,
"IpProtocol": "-1",
"FromPort": -1,
"ToPort": -1,
"CidrIpv6": "::/0",
"Tags": []
},
{
"SecurityGroupRuleId": "sgr-cdef01234567890ab",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "111122223333",
"IsEgress": true,
"IpProtocol": "-1",
"FromPort": -1,
"ToPort": -1,
"CidrIpv4": "0.0.0.0/0",
"Tags": []
}
]
}
```
**Exemplo 2: descrever uma regra do grupo de segurança**
O exemplo `describe-security-group-rules` a seguir descreve a regra do grupo de segurança especificado.
```
aws ec2 describe-security-group-rules \
--security-group-rule-ids sgr-cdef01234567890ab
```
Saída:
```
{
"SecurityGroupRules": [
{
"SecurityGroupRuleId": "sgr-cdef01234567890ab",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "111122223333",
"IsEgress": true,
"IpProtocol": "-1",
"FromPort": -1,
"ToPort": -1,
"CidrIpv4": "0.0.0.0/0",
"Tags": []
}
]
}
```
Para ter mais informações, consulte [Security group rules](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [DescribeSecurityGroupRules](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-security-group-rules.html)em *Referência de AWS CLI Comandos*.
### `describe-security-group-vpc-associations`
O código de exemplo a seguir mostra como usar `describe-security-group-vpc-associations`.
**AWS CLI**
**Como descrever associações de VPC**
O exemplo `describe-security-group-vpc-associations` a seguir descreve as associações de VPC do grupo de segurança especificado.
```
aws ec2 describe-security-group-vpc-associations \
--filters Name=group-id,Values=sg-04dbb43907d3f8a78
```
Saída:
```
{
"SecurityGroupVpcAssociations": [
{
"GroupId": "sg-04dbb43907d3f8a78",
"VpcId": "vpc-0bf4c2739bc05a694",
"VpcOwnerId": "123456789012",
"State": "associated"
}
]
}
```
Para obter mais informações, consulte [Associar grupos de segurança a vários VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-assoc.html) no Guia do *usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [DescribeSecurityGroupVpcAssociations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-security-group-vpc-associations.html)em *Referência de AWS CLI Comandos*.
### `describe-security-groups`
O código de exemplo a seguir mostra como usar `describe-security-groups`.
**AWS CLI**
**Exemplo 1: descrever um grupo de segurança**
O exemplo `describe-security-groups` a seguir descreve o grupo de segurança especificado.
```
aws ec2 describe-security-groups \
--group-ids sg-903004f8
```
Saída:
```
{
"SecurityGroups": [
{
"IpPermissionsEgress": [
{
"IpProtocol": "-1",
"IpRanges": [
{
"CidrIp": "0.0.0.0/0"
}
],
"UserIdGroupPairs": [],
"PrefixListIds": []
}
],
"Description": "My security group",
"Tags": [
{
"Value": "SG1",
"Key": "Name"
}
],
"IpPermissions": [
{
"IpProtocol": "-1",
"IpRanges": [],
"UserIdGroupPairs": [
{
"UserId": "123456789012",
"GroupId": "sg-903004f8"
}
],
"PrefixListIds": []
},
{
"PrefixListIds": [],
"FromPort": 22,
"IpRanges": [
{
"Description": "Access from NY office",
"CidrIp": "203.0.113.0/24"
}
],
"ToPort": 22,
"IpProtocol": "tcp",
"UserIdGroupPairs": []
}
],
"GroupName": "MySecurityGroup",
"VpcId": "vpc-1a2b3c4d",
"OwnerId": "123456789012",
"GroupId": "sg-903004f8",
}
]
}
```
**Exemplo 2: descrever grupos de segurança com regras específicas**
O exemplo `describe-security-groups` a seguir usa filtros para definir os resultados para grupos de segurança que tenham uma regra que permita tráfego SSH (porta 22) e uma regra que permita tráfego de todos os endereços (`0.0.0.0/0`). O exemplo usa o parâmetro `--query` para exibir somente os nomes dos grupos de segurança. Os grupos de segurança devem corresponder a todos os filtros para serem retornados nos resultados; no entanto, uma única regra não precisa corresponder a todos os filtros. Por exemplo, a saída retorna um grupo de segurança com uma regra que permite o tráfego SSH de um endereço IP específico e outra regra que permite o tráfego HTTP de todos os endereços.
```
aws ec2 describe-security-groups \
--filters Name=ip-permission.from-port,Values=22 Name=ip-permission.to-port,Values=22 Name=ip-permission.cidr,Values='0.0.0.0/0' \
--query "SecurityGroups[*].[GroupName]" \
--output text
```
Saída:
```
default
my-security-group
web-servers
launch-wizard-1
```
**Exemplo 3: descrever grupos de segurança com base em tags**
O exemplo a seguir `describe-security-groups` usa filtros para definir o escopo dos resultados para grupos de segurança que incluem `test` no nome do grupo de segurança e contêm a tag `Test=To-delete`. O exemplo usa o `--query` parâmetro para exibir somente os nomes e os grupos IDs de segurança.
```
aws ec2 describe-security-groups \
--filters Name=group-name,Values=*test* Name=tag:Test,Values=To-delete \
--query "SecurityGroups[*].{Name:GroupName,ID:GroupId}"
```
Saída:
```
[
{
"Name": "testfornewinstance",
"ID": "sg-33bb22aa"
},
{
"Name": "newgrouptest",
"ID": "sg-1a2b3c4d"
}
]
```
Para obter mais exemplos do uso de filtros de tags, consulte [Trabalhando com tags](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_CLI) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DescribeSecurityGroups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-security-groups.html)em *Referência de AWS CLI Comandos*.
### `describe-snapshot-attribute`
O código de exemplo a seguir mostra como usar `describe-snapshot-attribute`.
**AWS CLI**
**Descrever os atributos de um snapshot**
O exemplo `describe-snapshot-attribute` a seguir lista as contas com as quais um snapshot é compartilhado.
```
aws ec2 describe-snapshot-attribute \
--snapshot-id snap-01234567890abcedf \
--attribute createVolumePermission
```
Saída:
```
{
"SnapshotId": "snap-01234567890abcedf",
"CreateVolumePermissions": [
{
"UserId": "123456789012"
}
]
}
```
Para obter mais informações, consulte [Compartilhar um snapshot do Amazon EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-modifying-snapshot-permissions.html#share-unencrypted-snapshot) no *Guia do usuário do Amazon Elastic Compute Cloud*.
+ Para obter detalhes da API, consulte [DescribeSnapshotAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-snapshot-attribute.html)em *Referência de AWS CLI Comandos*.
### `describe-snapshot-tier-status`
O código de exemplo a seguir mostra como usar `describe-snapshot-tier-status`.
**AWS CLI**
Para visualizar informações de arquivamento sobre um snapshot arquivado
O exemplo `describe-snapshot-tier-status` a seguir fornece informações de arquivamento sobre um snapshot arquivado.
```
aws ec2 describe-snapshot-tier-status \
--filters "Name=snapshot-id, Values=snap-01234567890abcedf"
```
Saída:
```
{
"SnapshotTierStatuses": [
{
"Status": "completed",
"ArchivalCompleteTime": "2021-09-15T17:33:16.147Z",
"LastTieringProgress": 100,
"Tags": [],
"VolumeId": "vol-01234567890abcedf",
"LastTieringOperationState": "archival-completed",
"StorageTier": "archive",
"OwnerId": "123456789012",
"SnapshotId": "snap-01234567890abcedf",
"LastTieringStartTime": "2021-09-15T16:44:37.574Z"
}
]
}
```
Para obter mais informações, consulte [View archived snapshots](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-snapshot-archiving.html#view-archived-snapshot) no *Guia do usuário do Amazon Elastic Compute Cloud*.
+ Para obter detalhes da API, consulte [DescribeSnapshotTierStatus](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-snapshot-tier-status.html)em *Referência de AWS CLI Comandos*.
### `describe-snapshots`
O código de exemplo a seguir mostra como usar `describe-snapshots`.
**AWS CLI**
**Exemplo 1: descrever um snapshot**
O exemplo `describe-snapshots` a seguir descreve o snapshot especificado.
```
aws ec2 describe-snapshots \
--snapshot-ids snap-1234567890abcdef0
```
Saída:
```
{
"Snapshots": [
{
"Description": "This is my snapshot",
"Encrypted": false,
"VolumeId": "vol-049df61146c4d7901",
"State": "completed",
"VolumeSize": 8,
"StartTime": "2019-02-28T21:28:32.000Z",
"Progress": "100%",
"OwnerId": "012345678910",
"SnapshotId": "snap-01234567890abcdef",
"Tags": [
{
"Key": "Stack",
"Value": "test"
}
]
}
]
}
```
Para obter mais informações, consulte [Snapshots do Amazon EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSSnapshots.html) no *Guia do usuário do Amazon EC2*.
**Exemplo 2: descrever snapshots com base em filtros**
O `describe-snapshots` exemplo a seguir usa filtros para definir o escopo dos resultados para instantâneos pertencentes à sua AWS conta que estão no `pending` estado. O exemplo usa o `--query` parâmetro para exibir somente o instantâneo IDs e a hora em que o instantâneo foi iniciado.
```
aws ec2 describe-snapshots \
--owner-ids self \
--filters Name=status,Values=pending \
--query "Snapshots[*].{ID:SnapshotId,Time:StartTime}"
```
Saída:
```
[
{
"ID": "snap-1234567890abcdef0",
"Time": "2019-08-04T12:48:18.000Z"
},
{
"ID": "snap-066877671789bd71b",
"Time": "2019-08-04T02:45:16.000Z
},
...
]
```
O exemplo `describe-snapshots` a seguir usa filtros para definir o escopo dos resultados para snapshots criados no volume especificado. O exemplo usa o `--query` parâmetro para exibir somente o instantâneo IDs.
```
aws ec2 describe-snapshots \
--filters Name=volume-id,Values=049df61146c4d7901 \
--query "Snapshots[*].[SnapshotId]" \
--output text
```
Saída:
```
snap-1234567890abcdef0
snap-08637175a712c3fb9
...
```
Para obter mais exemplos do uso de filtros, consulte [Listar e filtrar seus recursos](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Filtering.html#Filtering_Resources_CLI) no *Guia do usuário do Amazon EC2*.
**Exemplo 3: descrever snapshots com base em tags**
O exemplo `describe-snapshots` a seguir usa filtros de tag para definir o escopo dos resultados para snapshots que tenham a tag `Stack=Prod`.
```
aws ec2 describe-snapshots \
--filters Name=tag:Stack,Values=prod
```
Para obter um exemplo da saída de `describe-snapshots`, consulte o Exemplo 1.
Para obter mais exemplos do uso de filtros de tags, consulte [Trabalhando com tags](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_CLI) no *Guia do usuário do Amazon EC2*.
**Exemplo 4: descrever snapshots com base na idade**
O `describe-snapshots` exemplo a seguir usa JMESPath expressões para descrever todos os instantâneos criados pela sua AWS conta antes da data especificada. Ele exibe somente o instantâneo IDs.
```
aws ec2 describe-snapshots \
--owner-ids 012345678910 \
--query "Snapshots[?(StartTime<='2020-03-31')].[SnapshotId]"
```
Para obter mais exemplos do uso de filtros, consulte [Listar e filtrar seus recursos](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Filtering.html#Filtering_Resources_CLI) no *Guia do usuário do Amazon EC2*.
**Exemplo 5: visualizar somente snapshots arquivados**
O exemplo `describe-snapshots` a seguir lista apenas os snapshots armazenados no nível de arquivamento.
```
aws ec2 describe-snapshots \
--filters "Name=storage-tier,Values=archive"
```
Saída:
```
{
"Snapshots": [
{
"Description": "Snap A",
"Encrypted": false,
"VolumeId": "vol-01234567890aaaaaa",
"State": "completed",
"VolumeSize": 8,
"StartTime": "2021-09-07T21:00:00.000Z",
"Progress": "100%",
"OwnerId": "123456789012",
"SnapshotId": "snap-01234567890aaaaaa",
"StorageTier": "archive",
"Tags": []
},
]
}
```
Para obter mais informações, consulte [View archived snapshots](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-snapshot-archiving.html#view-archived-snapshot) no *Guia do usuário do Amazon Elastic Compute Cloud*.
+ Para obter detalhes da API, consulte [DescribeSnapshots](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-snapshots.html)em *Referência de AWS CLI Comandos*.
### `describe-spot-datafeed-subscription`
O código de exemplo a seguir mostra como usar `describe-spot-datafeed-subscription`.
**AWS CLI**
**Descrever a assinatura do feed de dados da Instância Spot para uma conta**
Este exemplo de comando descreve o feed de dados da conta.
Comando:
```
aws ec2 describe-spot-datafeed-subscription
```
Saída:
```
{
"SpotDatafeedSubscription": {
"OwnerId": "123456789012",
"Prefix": "spotdata",
"Bucket": "amzn-s3-demo-bucket",
"State": "Active"
}
}
```
+ Para obter detalhes da API, consulte [DescribeSpotDatafeedSubscription](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-spot-datafeed-subscription.html)em *Referência de AWS CLI Comandos*.
### `describe-spot-fleet-instances`
O código de exemplo a seguir mostra como usar `describe-spot-fleet-instances`.
**AWS CLI**
**Descrever as Instâncias Spot associadas a uma Frota Spot**
Este exemplo de comando lista as Instâncias Spot associadas à Frota Spot especificada.
Comando:
```
aws ec2 describe-spot-fleet-instances --spot-fleet-request-id sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE
```
Saída:
```
{
"ActiveInstances": [
{
"InstanceId": "i-1234567890abcdef0",
"InstanceType": "m3.medium",
"SpotInstanceRequestId": "sir-08b93456"
},
...
],
"SpotFleetRequestId": "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE"
}
```
+ Para obter detalhes da API, consulte [DescribeSpotFleetInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-spot-fleet-instances.html)em *Referência de AWS CLI Comandos*.
### `describe-spot-fleet-request-history`
O código de exemplo a seguir mostra como usar `describe-spot-fleet-request-history`.
**AWS CLI**
**Descrever o histórico da frota Spot**
Este comando de exemplo retorna o histórico da frota Spot especificada a partir da hora especificada.
Comando:
```
aws ec2 describe-spot-fleet-request-history --spot-fleet-request-id sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE --start-time 2015-05-26T00:00:00Z
```
O exemplo de saída a seguir mostra os lançamentos bem-sucedidos de duas Instâncias Spot para a frota Spot.
Saída:
```
{
"HistoryRecords": [
{
"Timestamp": "2015-05-26T23:17:20.697Z",
"EventInformation": {
"EventSubType": "submitted"
},
"EventType": "fleetRequestChange"
},
{
"Timestamp": "2015-05-26T23:17:20.873Z",
"EventInformation": {
"EventSubType": "active"
},
"EventType": "fleetRequestChange"
},
{
"Timestamp": "2015-05-26T23:21:21.712Z",
"EventInformation": {
"InstanceId": "i-1234567890abcdef0",
"EventSubType": "launched"
},
"EventType": "instanceChange"
},
{
"Timestamp": "2015-05-26T23:21:21.816Z",
"EventInformation": {
"InstanceId": "i-1234567890abcdef1",
"EventSubType": "launched"
},
"EventType": "instanceChange"
}
],
"SpotFleetRequestId": "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE",
"NextToken": "CpHNsscimcV5oH7bSbub03CI2Qms5+ypNpNm+53MNlR0YcXAkp0xFlfKf91yVxSExmbtma3awYxMFzNA663ZskT0AHtJ6TCb2Z8bQC2EnZgyELbymtWPfpZ1ZbauVg+P+TfGlWxWWB/Vr5dk5d4LfdgA/DRAHUrYgxzrEXAMPLE=",
"StartTime": "2015-05-26T00:00:00Z"
}
```
+ Para obter detalhes da API, consulte [DescribeSpotFleetRequestHistory](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-spot-fleet-request-history.html)em *Referência de AWS CLI Comandos*.
### `describe-spot-fleet-requests`
O código de exemplo a seguir mostra como usar `describe-spot-fleet-requests`.
**AWS CLI**
**Descrever suas solicitações de frota Spot**
Este exemplo descreve todas as suas solicitações de frota Spot.
Comando:
```
aws ec2 describe-spot-fleet-requests
```
Saída:
```
{
"SpotFleetRequestConfigs": [
{
"SpotFleetRequestId": "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE",
"SpotFleetRequestConfig": {
"TargetCapacity": 20,
"LaunchSpecifications": [
{
"EbsOptimized": false,
"NetworkInterfaces": [
{
"SubnetId": "subnet-a61dafcf",
"DeviceIndex": 0,
"DeleteOnTermination": false,
"AssociatePublicIpAddress": true,
"SecondaryPrivateIpAddressCount": 0
}
],
"InstanceType": "cc2.8xlarge",
"ImageId": "ami-1a2b3c4d"
},
{
"EbsOptimized": false,
"NetworkInterfaces": [
{
"SubnetId": "subnet-a61dafcf",
"DeviceIndex": 0,
"DeleteOnTermination": false,
"AssociatePublicIpAddress": true,
"SecondaryPrivateIpAddressCount": 0
}
],
"InstanceType": "r3.8xlarge",
"ImageId": "ami-1a2b3c4d"
}
],
"SpotPrice": "0.05",
"IamFleetRole": "arn:aws:iam::123456789012:role/my-spot-fleet-role"
},
"SpotFleetRequestState": "active"
},
{
"SpotFleetRequestId": "sfr-306341ed-9739-402e-881b-ce47bEXAMPLE",
"SpotFleetRequestConfig": {
"TargetCapacity": 20,
"LaunchSpecifications": [
{
"EbsOptimized": false,
"NetworkInterfaces": [
{
"SubnetId": "subnet-6e7f829e",
"DeviceIndex": 0,
"DeleteOnTermination": false,
"AssociatePublicIpAddress": true,
"SecondaryPrivateIpAddressCount": 0
}
],
"InstanceType": "m3.medium",
"ImageId": "ami-1a2b3c4d"
}
],
"SpotPrice": "0.05",
"IamFleetRole": "arn:aws:iam::123456789012:role/my-spot-fleet-role"
},
"SpotFleetRequestState": "active"
}
]
}
```
**Descrever uma solicitação de frota spot**
Este exemplo descreve a solicitação de frota Spot especificada.
Comando:
```
aws ec2 describe-spot-fleet-requests --spot-fleet-request-ids sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE
```
Saída:
```
{
"SpotFleetRequestConfigs": [
{
"SpotFleetRequestId": "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE",
"SpotFleetRequestConfig": {
"TargetCapacity": 20,
"LaunchSpecifications": [
{
"EbsOptimized": false,
"NetworkInterfaces": [
{
"SubnetId": "subnet-a61dafcf",
"DeviceIndex": 0,
"DeleteOnTermination": false,
"AssociatePublicIpAddress": true,
"SecondaryPrivateIpAddressCount": 0
}
],
"InstanceType": "cc2.8xlarge",
"ImageId": "ami-1a2b3c4d"
},
{
"EbsOptimized": false,
"NetworkInterfaces": [
{
"SubnetId": "subnet-a61dafcf",
"DeviceIndex": 0,
"DeleteOnTermination": false,
"AssociatePublicIpAddress": true,
"SecondaryPrivateIpAddressCount": 0
}
],
"InstanceType": "r3.8xlarge",
"ImageId": "ami-1a2b3c4d"
}
],
"SpotPrice": "0.05",
"IamFleetRole": "arn:aws:iam::123456789012:role/my-spot-fleet-role"
},
"SpotFleetRequestState": "active"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeSpotFleetRequests](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-spot-fleet-requests.html)em *Referência de AWS CLI Comandos*.
### `describe-spot-instance-requests`
O código de exemplo a seguir mostra como usar `describe-spot-instance-requests`.
**AWS CLI**
**Exemplo 1: descrever uma solicitação de Instância Spot**
O exemplo `describe-spot-instance-requests` a seguir descreve a Instância Spot especificada.
```
aws ec2 describe-spot-instance-requests \
--spot-instance-request-ids sir-08b93456
```
Saída:
```
{
"SpotInstanceRequests": [
{
"CreateTime": "2018-04-30T18:14:55.000Z",
"InstanceId": "i-1234567890abcdef1",
"LaunchSpecification": {
"InstanceType": "t2.micro",
"ImageId": "ami-003634241a8fcdec0",
"KeyName": "my-key-pair",
"SecurityGroups": [
{
"GroupName": "default",
"GroupId": "sg-e38f24a7"
}
],
"BlockDeviceMappings": [
{
"DeviceName": "/dev/sda1",
"Ebs": {
"DeleteOnTermination": true,
"SnapshotId": "snap-0e54a519c999adbbd",
"VolumeSize": 8,
"VolumeType": "standard",
"Encrypted": false
}
}
],
"NetworkInterfaces": [
{
"DeleteOnTermination": true,
"DeviceIndex": 0,
"SubnetId": "subnet-049df61146c4d7901"
}
],
"Placement": {
"AvailabilityZone": "us-east-2b",
"Tenancy": "default"
},
"Monitoring": {
"Enabled": false
}
},
"LaunchedAvailabilityZone": "us-east-2b",
"ProductDescription": "Linux/UNIX",
"SpotInstanceRequestId": "sir-08b93456",
"SpotPrice": "0.010000"
"State": "active",
"Status": {
"Code": "fulfilled",
"Message": "Your Spot request is fulfilled.",
"UpdateTime": "2018-04-30T18:16:21.000Z"
},
"Tags": [],
"Type": "one-time",
"InstanceInterruptionBehavior": "terminate"
}
]
}
```
**Exemplo 2: descrever solicitações de Instância Spot com base em filtros**
O exemplo `describe-spot-instance-requests` a seguir usa filtros para definir o escopo dos resultados para solicitações de Instâncias Spot com o tipo de instância especificado que também estão na Zona de Disponibilidade especificada. O exemplo usa o `--query` parâmetro para exibir somente a instância IDs.
```
aws ec2 describe-spot-instance-requests \
--filters Name=launch.instance-type,Values=m3.medium Name=launched-availability-zone,Values=us-east-2a \
--query "SpotInstanceRequests[*].[InstanceId]" \
--output text
```
Saída:
```
i-057750d42936e468a
i-001efd250faaa6ffa
i-027552a73f021f3bd
...
```
Para obter mais exemplos do uso de filtros, consulte [Listar e filtrar seus recursos](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Filtering.html#Filtering_Resources_CLI) no *Guia do usuário do Amazon Elastic Computer Cloud*.
**Exemplo 3: descrever solicitações de Instância Spot com base em tags**
O exemplo `describe-spot-instance-requests` a seguir usa filtros de tag para definir o escopo dos resultados das solicitações de Instância Spot que tenham a tag `cost-center=cc123`.
```
aws ec2 describe-spot-instance-requests \
--filters Name=tag:cost-center,Values=cc123
```
Para obter um exemplo da saída de `describe-spot-instance-requests`, consulte o Exemplo 1.
Para obter mais exemplos do uso de filtros de tags, consulte [Trabalhando com tags](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_CLI) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DescribeSpotInstanceRequests](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-spot-instance-requests.html)em *Referência de AWS CLI Comandos*.
### `describe-spot-price-history`
O código de exemplo a seguir mostra como usar `describe-spot-price-history`.
**AWS CLI**
**Descrever o histórico de preço Spot**
Esse exemplo de comando retorna o histórico de preços spot para instâncias m1.xlarge em um determinado dia de janeiro.
Comando:
```
aws ec2 describe-spot-price-history --instance-types m1.xlarge --start-time 2014-01-06T07:08:09 --end-time 2014-01-06T08:09:10
```
Saída:
```
{
"SpotPriceHistory": [
{
"Timestamp": "2014-01-06T07:10:55.000Z",
"ProductDescription": "SUSE Linux",
"InstanceType": "m1.xlarge",
"SpotPrice": "0.087000",
"AvailabilityZone": "us-west-1b"
},
{
"Timestamp": "2014-01-06T07:10:55.000Z",
"ProductDescription": "SUSE Linux",
"InstanceType": "m1.xlarge",
"SpotPrice": "0.087000",
"AvailabilityZone": "us-west-1c"
},
{
"Timestamp": "2014-01-06T05:42:36.000Z",
"ProductDescription": "SUSE Linux (Amazon VPC)",
"InstanceType": "m1.xlarge",
"SpotPrice": "0.087000",
"AvailabilityZone": "us-west-1a"
},
...
}
```
**Para descrever o histórico de preços spot da Linux/UNIX Amazon VPC**
Esse exemplo de comando retorna o histórico de preços spot para instâncias m1.xlarge da Amazon Linux/UNIX VPC de um determinado dia de janeiro.
Comando:
```
aws ec2 describe-spot-price-history --instance-types m1.xlarge --product-description "Linux/UNIX (Amazon VPC)" --start-time 2014-01-06T07:08:09 --end-time 2014-01-06T08:09:10
```
Saída:
```
{
"SpotPriceHistory": [
{
"Timestamp": "2014-01-06T04:32:53.000Z",
"ProductDescription": "Linux/UNIX (Amazon VPC)",
"InstanceType": "m1.xlarge",
"SpotPrice": "0.080000",
"AvailabilityZone": "us-west-1a"
},
{
"Timestamp": "2014-01-05T11:28:26.000Z",
"ProductDescription": "Linux/UNIX (Amazon VPC)",
"InstanceType": "m1.xlarge",
"SpotPrice": "0.080000",
"AvailabilityZone": "us-west-1c"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeSpotPriceHistory](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-spot-price-history.html)em *Referência de AWS CLI Comandos*.
### `describe-stale-security-groups`
O código de exemplo a seguir mostra como usar `describe-stale-security-groups`.
**AWS CLI**
**Descrever grupos de segurança obsoletos**
Este exemplo descreve regras de grupo de segurança obsoletos para `vpc-11223344`. A resposta mostra que sg-5fa68d3a em sua conta tem uma regra SSH de entrada obsoleta que faz referência a `sg-279ab042` na VPC de mesmo nível, e que `sg-fe6fba9a` em sua conta tem uma regra SSH de saída obsoleta que faz referência a `sg-ef6fba8b` na VPC de mesmo nível.
Comando:
```
aws ec2 describe-stale-security-groups --vpc-id vpc-11223344
```
Saída:
```
{
"StaleSecurityGroupSet": [
{
"VpcId": "vpc-11223344",
"StaleIpPermissionsEgress": [
{
"ToPort": 22,
"FromPort": 22,
"UserIdGroupPairs": [
{
"VpcId": "vpc-7a20e51f",
"GroupId": "sg-ef6fba8b",
"VpcPeeringConnectionId": "pcx-b04deed9",
"PeeringStatus": "active"
}
],
"IpProtocol": "tcp"
}
],
"GroupName": "MySG1",
"StaleIpPermissions": [],
"GroupId": "sg-fe6fba9a",
"Description": MySG1"
},
{
"VpcId": "vpc-11223344",
"StaleIpPermissionsEgress": [],
"GroupName": "MySG2",
"StaleIpPermissions": [
{
"ToPort": 22,
"FromPort": 22,
"UserIdGroupPairs": [
{
"VpcId": "vpc-7a20e51f",
"GroupId": "sg-279ab042",
"Description": "Access from pcx-b04deed9",
"VpcPeeringConnectionId": "pcx-b04deed9",
"PeeringStatus": "active"
}
],
"IpProtocol": "tcp"
}
],
"GroupId": "sg-5fa68d3a",
"Description": "MySG2"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeStaleSecurityGroups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-stale-security-groups.html)em *Referência de AWS CLI Comandos*.
### `describe-store-image-tasks`
O código de exemplo a seguir mostra como usar `describe-store-image-tasks`.
**AWS CLI**
**Descrever o andamento de uma tarefa de armazenamento de AMI**
O exemplo `describe-store-image-tasks` a seguir descreve o andamento de uma tarefa de armazenamento de AMI.
```
aws ec2 describe-store-image-tasks
```
Saída:
```
{
"StoreImageTaskResults": [
{
"AmiId": "ami-1234567890abcdef0",
"Bucket": "my-ami-bucket",
"ProgressPercentage": 17,
"S3objectKey": "ami-1234567890abcdef0.bin",
"StoreTaskState": "InProgress",
"StoreTaskFailureReason": null,
"TaskStartTime": "2022-01-01T01:01:01.001Z"
}
]
}
```
*Para obter mais informações sobre como armazenar e restaurar uma AMI usando o S3, consulte Armazenar e restaurar uma AMI usando S3 no Guia do usuário do Amazon EC2.*
+ Para obter detalhes da API, consulte [DescribeStoreImageTasks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-store-image-tasks.html)em *Referência de AWS CLI Comandos*.
### `describe-subnets`
O código de exemplo a seguir mostra como usar `describe-subnets`.
**AWS CLI**
**Exemplo 1: descrever todas as suas sub-redes**
O exemplo `describe-subnets` a seguir mostra os detalhes das suas sub-redes.
```
aws ec2 describe-subnets
```
Saída:
```
{
"Subnets": [
{
"AvailabilityZone": "us-east-1d",
"AvailabilityZoneId": "use1-az2",
"AvailableIpAddressCount": 4089,
"CidrBlock": "172.31.80.0/20",
"DefaultForAz": true,
"MapPublicIpOnLaunch": false,
"MapCustomerOwnedIpOnLaunch": true,
"State": "available",
"SubnetId": "subnet-0bb1c79de3EXAMPLE",
"VpcId": "vpc-0ee975135dEXAMPLE",
"OwnerId": "111122223333",
"AssignIpv6AddressOnCreation": false,
"Ipv6CidrBlockAssociationSet": [],
"CustomerOwnedIpv4Pool:": 'pool-2EXAMPLE',
"SubnetArn": "arn:aws:ec2:us-east-2:111122223333:subnet/subnet-0bb1c79de3EXAMPLE",
"EnableDns64": false,
"Ipv6Native": false,
"PrivateDnsNameOptionsOnLaunch": {
"HostnameType": "ip-name",
"EnableResourceNameDnsARecord": false,
"EnableResourceNameDnsAAAARecord": false
}
},
{
"AvailabilityZone": "us-east-1d",
"AvailabilityZoneId": "use1-az2",
"AvailableIpAddressCount": 4089,
"CidrBlock": "172.31.80.0/20",
"DefaultForAz": true,
"MapPublicIpOnLaunch": true,
"MapCustomerOwnedIpOnLaunch": false,
"State": "available",
"SubnetId": "subnet-8EXAMPLE",
"VpcId": "vpc-3EXAMPLE",
"OwnerId": "1111222233333",
"AssignIpv6AddressOnCreation": false,
"Ipv6CidrBlockAssociationSet": [],
"Tags": [
{
"Key": "Name",
"Value": "MySubnet"
}
],
"SubnetArn": "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-8EXAMPLE",
"EnableDns64": false,
"Ipv6Native": false,
"PrivateDnsNameOptionsOnLaunch": {
"HostnameType": "ip-name",
"EnableResourceNameDnsARecord": false,
"EnableResourceNameDnsAAAARecord": false
}
}
]
}
```
Para obter mais informações, consulte [Trabalho com sub-redes VPCs e sub-redes no Guia](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html) do usuário da *AWS VPC*.
**Exemplo 2: descrever as sub-redes de uma VPC específica**
O exemplo de `describe-subnets` a seguir usa um filtro para recuperar detalhes das sub-redes da VPC especificada.
```
aws ec2 describe-subnets \
--filters "Name=vpc-id,Values=vpc-3EXAMPLE"
```
Saída:
```
{
"Subnets": [
{
"AvailabilityZone": "us-east-1d",
"AvailabilityZoneId": "use1-az2",
"AvailableIpAddressCount": 4089,
"CidrBlock": "172.31.80.0/20",
"DefaultForAz": true,
"MapPublicIpOnLaunch": true,
"MapCustomerOwnedIpOnLaunch": false,
"State": "available",
"SubnetId": "subnet-8EXAMPLE",
"VpcId": "vpc-3EXAMPLE",
"OwnerId": "1111222233333",
"AssignIpv6AddressOnCreation": false,
"Ipv6CidrBlockAssociationSet": [],
"Tags": [
{
"Key": "Name",
"Value": "MySubnet"
}
],
"SubnetArn": "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-8EXAMPLE",
"EnableDns64": false,
"Ipv6Native": false,
"PrivateDnsNameOptionsOnLaunch": {
"HostnameType": "ip-name",
"EnableResourceNameDnsARecord": false,
"EnableResourceNameDnsAAAARecord": false
}
}
]
}
```
Para obter mais informações, consulte [Trabalho com sub-redes VPCs e sub-redes no Guia](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html) do usuário da *AWS VPC*.
**Exemplo 3: descrever as sub-redes com uma tag específica**
O `describe-subnets` exemplo a seguir usa um filtro para recuperar os detalhes dessas sub-redes com a tag `CostCenter=123` e o `--query` parâmetro para exibir a sub-rede IDs das sub-redes com essa tag.
```
aws ec2 describe-subnets \
--filters "Name=tag:CostCenter,Values=123" \
--query "Subnets[*].SubnetId" \
--output text
```
Saída:
```
subnet-0987a87c8b37348ef
subnet-02a95061c45f372ee
subnet-03f720e7de2788d73
```
Para obter mais informações, consulte [Trabalho com sub-redes VPCs e sub-redes no Guia](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html) do usuário da Amazon *VPC*.
+ Para obter detalhes da API, consulte [DescribeSubnets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-subnets.html)em *Referência de AWS CLI Comandos*.
### `describe-tags`
O código de exemplo a seguir mostra como usar `describe-tags`.
**AWS CLI**
**Exemplo 1: descrever todas as tags de um único recurso**
O exemplo `describe-tags` a seguir descreve as tags da instância especificada.
```
aws ec2 describe-tags \
--filters "Name=resource-id,Values=i-1234567890abcdef8"
```
Saída:
```
{
"Tags": [
{
"ResourceType": "instance",
"ResourceId": "i-1234567890abcdef8",
"Value": "Test",
"Key": "Stack"
},
{
"ResourceType": "instance",
"ResourceId": "i-1234567890abcdef8",
"Value": "Beta Server",
"Key": "Name"
}
]
}
```
**Exemplo 2: descrever todas as tags de um tipo de recurso**
O exemplo `describe-tags` a seguir descreve as tags para os volumes.
```
aws ec2 describe-tags \
--filters "Name=resource-type,Values=volume"
```
Saída:
```
{
"Tags": [
{
"ResourceType": "volume",
"ResourceId": "vol-1234567890abcdef0",
"Value": "Project1",
"Key": "Purpose"
},
{
"ResourceType": "volume",
"ResourceId": "vol-049df61146c4d7901",
"Value": "Logs",
"Key": "Purpose"
}
]
}
```
**Exemplo 3: descrever todas as tags**
O exemplo `describe-tags` a seguir descreve as tags de todos os recursos.
```
aws ec2 describe-tags
```
**Exemplo 4: descrever as tags dos recursos com base em uma chave de tag**
O exemplo `describe-tags` a seguir descreve as tags dos seus recursos que têm uma tag com a chave `Stack`.
```
aws ec2 describe-tags \
--filters Name=key,Values=Stack
```
Saída:
```
{
"Tags": [
{
"ResourceType": "volume",
"ResourceId": "vol-027552a73f021f3b",
"Value": "Production",
"Key": "Stack"
},
{
"ResourceType": "instance",
"ResourceId": "i-1234567890abcdef8",
"Value": "Test",
"Key": "Stack"
}
]
}
```
**Exemplo 5: descrever as tags de seus recursos com base na chave e no valor da tag**
O exemplo `describe-tags` a seguir descreve as tags dos seus recursos que têm a tag `Stack=Test`.
```
aws ec2 describe-tags \
--filters Name=key,Values=Stack Name=value,Values=Test
```
Saída:
```
{
"Tags": [
{
"ResourceType": "image",
"ResourceId": "ami-3ac336533f021f3bd",
"Value": "Test",
"Key": "Stack"
},
{
"ResourceType": "instance",
"ResourceId": "i-1234567890abcdef8",
"Value": "Test",
"Key": "Stack"
}
]
}
```
O exemplo `describe-tags` a seguir usa uma sintaxe alternativa para descrever recursos com a tag `Stack=Test`.
```
aws ec2 describe-tags \
--filters "Name=tag:Stack,Values=Test"
```
O exemplo `describe-tags` a seguir descreve as tags de todas as suas instâncias que têm uma tag com a chave `Purpose` e sem valor.
```
aws ec2 describe-tags \
--filters "Name=resource-type,Values=instance" "Name=key,Values=Purpose" "Name=value,Values="
```
Saída:
```
{
"Tags": [
{
"ResourceType": "instance",
"ResourceId": "i-1234567890abcdef5",
"Value": null,
"Key": "Purpose"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeTags](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-tags.html)em *Referência de AWS CLI Comandos*.
### `describe-traffic-mirror-filters`
O código de exemplo a seguir mostra como usar `describe-traffic-mirror-filters`.
**AWS CLI**
**Visualizar seus filtros de espelhamento de tráfego**
O exemplo `describe-traffic-mirror-filters` a seguir exibe detalhes de todos os seus filtros de espelhamento de tráfego.
```
aws ec2 describe-traffic-mirror-filters
```
Saída:
```
{
"TrafficMirrorFilters": [
{
"TrafficMirrorFilterId": "tmf-0293f26e86EXAMPLE",
"IngressFilterRules": [
{
"TrafficMirrorFilterRuleId": "tmfr-0ca76e0e08EXAMPLE",
"TrafficMirrorFilterId": "tmf-0293f26e86EXAMPLE",
"TrafficDirection": "ingress",
"RuleNumber": 100,
"RuleAction": "accept",
"Protocol": 6,
"DestinationCidrBlock": "10.0.0.0/24",
"SourceCidrBlock": "10.0.0.0/24",
"Description": "TCP Rule"
}
],
"EgressFilterRules": [],
"NetworkServices": [],
"Description": "Example filter",
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Visualizar filtros de espelhamento de tráfego](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-filter.html#view-traffic-mirroring-filter) no *Guia de espelhamento de tráfego*.
+ Para obter detalhes da API, consulte [DescribeTrafficMirrorFilters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-traffic-mirror-filters.html)em *Referência de AWS CLI Comandos*.
### `describe-traffic-mirror-sessions`
O código de exemplo a seguir mostra como usar `describe-traffic-mirror-sessions`.
**AWS CLI**
**Descrever uma sessão de espelhamento de tráfego**
O exemplo `describe-traffic-mirror-sessions` a seguir exibe detalhes das suas sessões de Espelhamento de Tráfego.
```
aws ec2 describe-traffic-mirror-sessions
```
Saída:
```
{
"TrafficMirrorSessions": [
{
"Tags": [],
"VirtualNetworkId": 42,
"OwnerId": "111122223333",
"Description": "TCP Session",
"NetworkInterfaceId": "eni-0a471a5cf3EXAMPLE",
"TrafficMirrorTargetId": "tmt-0dabe9b0a6EXAMPLE",
"TrafficMirrorFilterId": "tmf-083e18f985EXAMPLE",
"PacketLength": 20,
"SessionNumber": 1,
"TrafficMirrorSessionId": "tms-0567a4c684EXAMPLE"
},
{
"Tags": [
{
"Key": "Name",
"Value": "tag test"
}
],
"VirtualNetworkId": 13314501,
"OwnerId": "111122223333",
"Description": "TCP Session",
"NetworkInterfaceId": "eni-0a471a5cf3EXAMPLE",
"TrafficMirrorTargetId": "tmt-03665551cbEXAMPLE",
"TrafficMirrorFilterId": "tmf-06c787846cEXAMPLE",
"SessionNumber": 2,
"TrafficMirrorSessionId": "tms-0060101cf8EXAMPLE"
}
]
}
```
Para obter mais informações, consulte [Visualizar detalhes de uma sessão de espelhamento de tráfego](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-session.html#view-traffic-mirroring-session) no *Guia de espelhamento de tráfego da AWS *.
+ Para obter detalhes da API, consulte [DescribeTrafficMirrorSessions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-traffic-mirror-sessions.html)em *Referência de AWS CLI Comandos*.
### `describe-traffic-mirror-targets`
O código de exemplo a seguir mostra como usar `describe-traffic-mirror-targets`.
**AWS CLI**
**Descrever um destino de espelhamento de tráfego**
O exemplo `describe-traffic-mirror-targets` a seguir mostra as informações do destino de espelhamento de tráfego especificado.
```
aws ec2 describe-traffic-mirror-targets \
--traffic-mirror-target-ids tmt-0dabe9b0a6EXAMPLE
```
Saída:
```
{
"TrafficMirrorTargets": [
{
"TrafficMirrorTargetId": "tmt-0dabe9b0a6EXAMPLE",
"NetworkLoadBalancerArn": "arn:aws:elasticloadbalancing:us-east-1:111122223333:loadbalancer/net/NLB/7cdec873fEXAMPLE",
"Type": "network-load-balancer",
"Description": "Example Network Load Balancer target",
"OwnerId": "111122223333",
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Destinos de espelhamento de tráfego](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-target.html) no *Guia do Amazon VPC Traffic Mirroring*.
+ Para obter detalhes da API, consulte [DescribeTrafficMirrorTargets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-traffic-mirror-targets.html)em *Referência de AWS CLI Comandos*.
### `describe-transit-gateway-attachments`
O código de exemplo a seguir mostra como usar `describe-transit-gateway-attachments`.
**AWS CLI**
**Visualizar os anexos do gateway de trânsito**
O exemplo `describe-transit-gateway-attachments` a seguir exibe detalhes de seus anexos do gateway de trânsito.
```
aws ec2 describe-transit-gateway-attachments
```
Saída:
```
{
"TransitGatewayAttachments": [
{
"TransitGatewayAttachmentId": "tgw-attach-01f8100bc7EXAMPLE",
"TransitGatewayId": "tgw-02f776b1a7EXAMPLE",
"TransitGatewayOwnerId": "123456789012",
"ResourceOwnerId": "123456789012",
"ResourceType": "vpc",
"ResourceId": "vpc-3EXAMPLE",
"State": "available",
"Association": {
"TransitGatewayRouteTableId": "tgw-rtb-002573ed1eEXAMPLE",
"State": "associated"
},
"CreationTime": "2019-08-26T14:59:25.000Z",
"Tags": [
{
"Key": "Name",
"Value": "Example"
}
]
},
{
"TransitGatewayAttachmentId": "tgw-attach-0b5968d3b6EXAMPLE",
"TransitGatewayId": "tgw-02f776b1a7EXAMPLE",
"TransitGatewayOwnerId": "123456789012",
"ResourceOwnerId": "123456789012",
"ResourceType": "vpc",
"ResourceId": "vpc-0065acced4EXAMPLE",
"State": "available",
"Association": {
"TransitGatewayRouteTableId": "tgw-rtb-002573ed1eEXAMPLE",
"State": "associated"
},
"CreationTime": "2019-08-07T17:03:07.000Z",
"Tags": []
},
{
"TransitGatewayAttachmentId": "tgw-attach-08e0bc912cEXAMPLE",
"TransitGatewayId": "tgw-02f776b1a7EXAMPLE",
"TransitGatewayOwnerId": "123456789012",
"ResourceOwnerId": "123456789012",
"ResourceType": "direct-connect-gateway",
"ResourceId": "11460968-4ac1-4fd3-bdb2-00599EXAMPLE",
"State": "available",
"Association": {
"TransitGatewayRouteTableId": "tgw-rtb-002573ed1eEXAMPLE",
"State": "associated"
},
"CreationTime": "2019-08-14T20:27:44.000Z",
"Tags": []
},
{
"TransitGatewayAttachmentId": "tgw-attach-0a89069f57EXAMPLE",
"TransitGatewayId": "tgw-02f776b1a7EXAMPLE",
"TransitGatewayOwnerId": "123456789012",
"ResourceOwnerId": "123456789012",
"ResourceType": "direct-connect-gateway",
"ResourceId": "8384da05-13ce-4a91-aada-5a1baEXAMPLE",
"State": "available",
"Association": {
"TransitGatewayRouteTableId": "tgw-rtb-002573ed1eEXAMPLE",
"State": "associated"
},
"CreationTime": "2019-08-14T20:33:02.000Z",
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Trabalhar com gateways de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/working-with-transit-gateways.html) no *Guia do usuário de gateways de trânsito*.
+ Para obter detalhes da API, consulte [DescribeTransitGatewayAttachments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateway-attachments.html)em *Referência de AWS CLI Comandos*.
### `describe-transit-gateway-connect-peers`
O código de exemplo a seguir mostra como usar `describe-transit-gateway-connect-peers`.
**AWS CLI**
**Descrever um emparelhamento de conexão de gateway de trânsito**
O exemplo `describe-transit-gateway-connect-peers` a seguir descreve o emparelhamento de Conexão especificado.
```
aws ec2 describe-transit-gateway-connect-peers \
--transit-gateway-connect-peer-ids tgw-connect-peer-0666adbac4EXAMPLE
```
Saída:
```
{
"TransitGatewayConnectPeers": [
{
"TransitGatewayAttachmentId": "tgw-attach-0f0927767cEXAMPLE",
"TransitGatewayConnectPeerId": "tgw-connect-peer-0666adbac4EXAMPLE",
"State": "available",
"CreationTime": "2021-10-13T03:35:17.000Z",
"ConnectPeerConfiguration": {
"TransitGatewayAddress": "10.0.0.234",
"PeerAddress": "172.31.1.11",
"InsideCidrBlocks": [
"169.254.6.0/29"
],
"Protocol": "gre",
"BgpConfigurations": [
{
"TransitGatewayAsn": 64512,
"PeerAsn": 64512,
"TransitGatewayAddress": "169.254.6.2",
"PeerAddress": "169.254.6.1",
"BgpStatus": "down"
},
{
"TransitGatewayAsn": 64512,
"PeerAsn": 64512,
"TransitGatewayAddress": "169.254.6.3",
"PeerAddress": "169.254.6.1",
"BgpStatus": "down"
}
]
},
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Anexos de conexão do gateway de trânsito e pares de conexão do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [DescribeTransitGatewayConnectPeers](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateway-connect-peers.html)em *Referência de AWS CLI Comandos*.
### `describe-transit-gateway-connects`
O código de exemplo a seguir mostra como usar `describe-transit-gateway-connects`.
**AWS CLI**
**Descrever um anexo da conexão do gateway de trânsito**
O exemplo `describe-transit-gateway-connects` a seguir descreve o anexo de Conexão especificado.
```
aws ec2 describe-transit-gateway-connects \
--transit-gateway-attachment-ids tgw-attach-037012e5dcEXAMPLE
```
Saída:
```
{
"TransitGatewayConnects": [
{
"TransitGatewayAttachmentId": "tgw-attach-037012e5dcEXAMPLE",
"TransportTransitGatewayAttachmentId": "tgw-attach-0a89069f57EXAMPLE",
"TransitGatewayId": "tgw-02f776b1a7EXAMPLE",
"State": "available",
"CreationTime": "2021-03-09T19:59:17+00:00",
"Options": {
"Protocol": "gre"
},
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Anexos de conexão do gateway de trânsito e pares de conexão do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [DescribeTransitGatewayConnects](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateway-connects.html)em *Referência de AWS CLI Comandos*.
### `describe-transit-gateway-multicast-domains`
O código de exemplo a seguir mostra como usar `describe-transit-gateway-multicast-domains`.
**AWS CLI**
**Descrever seus domínios de multicast do gateway de trânsito**
O exemplo `describe-transit-gateway-multicast-domains` a seguir exibe detalhes de todos os seus domínios multicast do Gateway de Trânsito.
```
aws ec2 describe-transit-gateway-multicast-domains
```
Saída:
```
{
"TransitGatewayMulticastDomains": [
{
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-000fb24d04EXAMPLE",
"TransitGatewayId": "tgw-0bf0bffefaEXAMPLE",
"TransitGatewayMulticastDomainArn": "arn:aws:ec2:us-east-1:123456789012:transit-gateway-multicast-domain/tgw-mcast-domain-000fb24d04EXAMPLE",
"OwnerId": "123456789012",
"Options": {
"Igmpv2Support": "disable",
"StaticSourcesSupport": "enable",
"AutoAcceptSharedAssociations": "disable"
},
"State": "available",
"CreationTime": "2019-12-10T18:32:50+00:00",
"Tags": [
{
"Key": "Name",
"Value": "mc1"
}
]
}
]
}
```
Para obter mais informações, consulte [Como gerenciar domínios multicast](https://docs.aws.amazon.com/vpc/latest/tgw/manage-domain.html) no *Guia de gateway de trânsito*.
+ Para obter detalhes da API, consulte [DescribeTransitGatewayMulticastDomains](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateway-multicast-domains.html)em *Referência de AWS CLI Comandos*.
### `describe-transit-gateway-peering-attachments`
O código de exemplo a seguir mostra como usar `describe-transit-gateway-peering-attachments`.
**AWS CLI**
**Descrever os anexos de emparelhamento do gateway de trânsito**
O exemplo `describe-transit-gateway-peering-attachments` a seguir exibe detalhes de todos os anexos de emparelhamento do Gateway de trânsito.
```
aws ec2 describe-transit-gateway-peering-attachments
```
Saída:
```
{
"TransitGatewayPeeringAttachments": [
{
"TransitGatewayAttachmentId": "tgw-attach-4455667788aabbccd",
"RequesterTgwInfo": {
"TransitGatewayId": "tgw-123abc05e04123abc",
"OwnerId": "123456789012",
"Region": "us-west-2"
},
"AccepterTgwInfo": {
"TransitGatewayId": "tgw-11223344aabbcc112",
"OwnerId": "123456789012",
"Region": "us-east-2"
},
"State": "pendingAcceptance",
"CreationTime": "2019-12-09T11:38:05.000Z",
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Anexos de pareamento do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-peering.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [DescribeTransitGatewayPeeringAttachments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateway-peering-attachments.html)em *Referência de AWS CLI Comandos*.
### `describe-transit-gateway-policy-tables`
O código de exemplo a seguir mostra como usar `describe-transit-gateway-policy-tables`.
**AWS CLI**
**Descrever uma tabela de políticas de gateway de trânsito**
O exemplo `describe-transit-gateway-policy-tables` a seguir descreve a tabela de políticas de gateway de trânsito especificada.
```
aws ec2 describe-transit-gateway-policy-tables \
--transit-gateway-policy-table-ids tgw-ptb-0a16f134b78668a81
```
Saída:
```
{
"TransitGatewayPolicyTables": [
{
"TransitGatewayPolicyTableId": "tgw-ptb-0a16f134b78668a81",
"TransitGatewayId": "tgw-067f8505c18f0bd6e",
"State": "available",
"CreationTime": "2023-11-28T16:36:43+00:00",
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Tabelas de política do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-policy-tables.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [DescribeTransitGatewayPolicyTables](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateway-policy-tables.html)em *Referência de AWS CLI Comandos*.
### `describe-transit-gateway-route-tables`
O código de exemplo a seguir mostra como usar `describe-transit-gateway-route-tables`.
**AWS CLI**
**Descrever as tabelas de rotas do gateway de trânsito**
O exemplo `describe-transit-gateway-route-tables` a seguir exibe detalhes das tabelas de rotas do gateway de trânsito.
```
aws ec2 describe-transit-gateway-route-tables
```
Saída:
```
{
"TransitGatewayRouteTables": [
{
"TransitGatewayRouteTableId": "tgw-rtb-0ca78a549EXAMPLE",
"TransitGatewayId": "tgw-0bc994abffEXAMPLE",
"State": "available",
"DefaultAssociationRouteTable": true,
"DefaultPropagationRouteTable": true,
"CreationTime": "2018-11-28T14:24:49.000Z",
"Tags": []
},
{
"TransitGatewayRouteTableId": "tgw-rtb-0e8f48f148EXAMPLE",
"TransitGatewayId": "tgw-0043d72bb4EXAMPLE",
"State": "available",
"DefaultAssociationRouteTable": true,
"DefaultPropagationRouteTable": true,
"CreationTime": "2018-11-28T14:24:00.000Z",
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Visualizar tabelas de rota do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html#view-tgw-route-tables) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [DescribeTransitGatewayRouteTables](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateway-route-tables.html)em *Referência de AWS CLI Comandos*.
### `describe-transit-gateway-vpc-attachments`
O código de exemplo a seguir mostra como usar `describe-transit-gateway-vpc-attachments`.
**AWS CLI**
**Descrever os anexos da VPC do gateway de trânsito**
O exemplo `describe-transit-gateway-vpc-attachments` a seguir exibe detalhes dos anexos da VPC do gateway de trânsito.
```
aws ec2 describe-transit-gateway-vpc-attachments
```
Saída:
```
{
"TransitGatewayVpcAttachments": [
{
"TransitGatewayAttachmentId": "tgw-attach-0a08e88308EXAMPLE",
"TransitGatewayId": "tgw-0043d72bb4EXAMPLE",
"VpcId": "vpc-0f501f7ee8EXAMPLE",
"VpcOwnerId": "111122223333",
"State": "available",
"SubnetIds": [
"subnet-045d586432EXAMPLE",
"subnet-0a0ad478a6EXAMPLE"
],
"CreationTime": "2019-02-13T11:04:02.000Z",
"Options": {
"DnsSupport": "enable",
"Ipv6Support": "disable"
},
"Tags": [
{
"Key": "Name",
"Value": "attachment name"
}
]
}
]
}
```
Para obter mais informações, consulte [Visualizar anexos da VPC](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html#view-vpc-attachment) no *Guia de Gateways de Trânsito*.
+ Para obter detalhes da API, consulte [DescribeTransitGatewayVpcAttachments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateway-vpc-attachments.html)em *Referência de AWS CLI Comandos*.
### `describe-transit-gateways`
O código de exemplo a seguir mostra como usar `describe-transit-gateways`.
**AWS CLI**
**Descrever os gateways de trânsito**
O exemplo `describe-transit-gateways` a seguir recupera detalhes dos gateways de trânsito.
```
aws ec2 describe-transit-gateways
```
Saída:
```
{
"TransitGateways": [
{
"TransitGatewayId": "tgw-0262a0e521EXAMPLE",
"TransitGatewayArn": "arn:aws:ec2:us-east-2:111122223333:transit-gateway/tgw-0262a0e521EXAMPLE",
"State": "available",
"OwnerId": "111122223333",
"Description": "MyTGW",
"CreationTime": "2019-07-10T14:02:12.000Z",
"Options": {
"AmazonSideAsn": 64516,
"AutoAcceptSharedAttachments": "enable",
"DefaultRouteTableAssociation": "enable",
"AssociationDefaultRouteTableId": "tgw-rtb-018774adf3EXAMPLE",
"DefaultRouteTablePropagation": "enable",
"PropagationDefaultRouteTableId": "tgw-rtb-018774adf3EXAMPLE",
"VpnEcmpSupport": "enable",
"DnsSupport": "enable"
},
"Tags": []
},
{
"TransitGatewayId": "tgw-0fb8421e2dEXAMPLE",
"TransitGatewayArn": "arn:aws:ec2:us-east-2:111122223333:transit-gateway/tgw-0fb8421e2da853bf3",
"State": "available",
"OwnerId": "111122223333",
"CreationTime": "2019-03-15T22:57:33.000Z",
"Options": {
"AmazonSideAsn": 65412,
"AutoAcceptSharedAttachments": "disable",
"DefaultRouteTableAssociation": "enable",
"AssociationDefaultRouteTableId": "tgw-rtb-06a241a3d8EXAMPLE",
"DefaultRouteTablePropagation": "enable",
"PropagationDefaultRouteTableId": "tgw-rtb-06a241a3d8EXAMPLE",
"VpnEcmpSupport": "enable",
"DnsSupport": "enable"
},
"Tags": [
{
"Key": "Name",
"Value": "TGW1"
}
]
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeTransitGateways](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateways.html)em *Referência de AWS CLI Comandos*.
### `describe-verified-access-endpoints`
O código de exemplo a seguir mostra como usar `describe-verified-access-endpoints`.
**AWS CLI**
**Descrever um endpoint do acesso verificado**
O exemplo `describe-verified-access-endpoints` a seguir descreve o endpoint do acesso verificado especificado.
```
aws ec2 describe-verified-access-endpoints \
--verified-access-endpoint-ids vae-066fac616d4d546f2
```
Saída:
```
{
"VerifiedAccessEndpoints": [
{
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"VerifiedAccessGroupId": "vagr-0dbe967baf14b7235",
"VerifiedAccessEndpointId": "vae-066fac616d4d546f2",
"ApplicationDomain": "example.com",
"EndpointType": "network-interface",
"AttachmentType": "vpc",
"DomainCertificateArn": "arn:aws:acm:us-east-2:123456789012:certificate/eb065ea0-26f9-4e75-a6ce-0a1a7EXAMPLE",
"EndpointDomain": "my-ava-app.edge-00c3372d53b1540bb.vai-0ce000c0b7643abea.prod.verified-access.us-east-2.amazonaws.com",
"SecurityGroupIds": [
"sg-004915970c4c8f13a"
],
"NetworkInterfaceOptions": {
"NetworkInterfaceId": "eni-0aec70418c8d87a0f",
"Protocol": "https",
"Port": 443
},
"Status": {
"Code": "active"
},
"Description": "",
"CreationTime": "2023-08-25T20:54:43",
"LastUpdatedTime": "2023-08-25T22:17:26",
"Tags": [
{
"Key": "Name",
"Value": "my-va-endpoint"
}
]
}
]
}
```
Para obter mais informações, consulte [Endpoints de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-endpoints.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [DescribeVerifiedAccessEndpoints](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-verified-access-endpoints.html)em *Referência de AWS CLI Comandos*.
### `describe-verified-access-groups`
O código de exemplo a seguir mostra como usar `describe-verified-access-groups`.
**AWS CLI**
**Descrever um grupo do acesso verificado**
O exemplo `describe-verified-access-groups` a seguir descreve o grupo especificado do acesso verificado.
```
aws ec2 describe-verified-access-groups \
--verified-access-group-ids vagr-0dbe967baf14b7235
```
Saída:
```
{
"VerifiedAccessGroups": [
{
"VerifiedAccessGroupId": "vagr-0dbe967baf14b7235",
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"Description": "Testing Verified Access",
"Owner": "123456789012",
"VerifiedAccessGroupArn": "arn:aws:ec2:us-east-2:123456789012:verified-access-group/vagr-0dbe967baf14b7235",
"CreationTime": "2023-08-25T19:55:19",
"LastUpdatedTime": "2023-08-25T22:17:25",
"Tags": [
{
"Key": "Name",
"Value": "my-va-group"
}
]
}
]
}
```
Para obter mais informações, consulte [Grupos de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-groups.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [DescribeVerifiedAccessGroups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-verified-access-groups.html)em *Referência de AWS CLI Comandos*.
### `describe-verified-access-instance-logging-configurations`
O código de exemplo a seguir mostra como usar `describe-verified-access-instance-logging-configurations`.
**AWS CLI**
**Descrever a configuração de log para uma instância do acesso verificado**
O exemplo `describe-verified-access-instance-logging-configurations` a seguir descreve a configuração de log da instância especificada do acesso verificado.
```
aws ec2 describe-verified-access-instance-logging-configurations \
--verified-access-instance-ids vai-0ce000c0b7643abea
```
Saída:
```
{
"LoggingConfigurations": [
{
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"AccessLogs": {
"S3": {
"Enabled": false
},
"CloudWatchLogs": {
"Enabled": true,
"DeliveryStatus": {
"Code": "success"
},
"LogGroup": "my-log-group"
},
"KinesisDataFirehose": {
"Enabled": false
},
"LogVersion": "ocsf-1.0.0-rc.2",
"IncludeTrustContext": false
}
}
]
}
```
Para obter mais informações, consulte [Logs do acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/access-logs.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [DescribeVerifiedAccessInstanceLoggingConfigurations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-verified-access-instance-logging-configurations.html)em *Referência de AWS CLI Comandos*.
### `describe-verified-access-instances`
O código de exemplo a seguir mostra como usar `describe-verified-access-instances`.
**AWS CLI**
**Descrever uma instância do acesso verificado**
O exemplo `describe-verified-access-instances` a seguir descreve a instância especificada do acesso verificado.
```
aws ec2 describe-verified-access-instances \
--verified-access-instance-ids vai-0ce000c0b7643abea
```
Saída:
```
{
"VerifiedAccessInstances": [
{
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"Description": "Testing Verified Access",
"VerifiedAccessTrustProviders": [
{
"VerifiedAccessTrustProviderId": "vatp-0bb32de759a3e19e7",
"TrustProviderType": "user",
"UserTrustProviderType": "iam-identity-center"
}
],
"CreationTime": "2023-08-25T18:27:56",
"LastUpdatedTime": "2023-08-25T19:03:32",
"Tags": [
{
"Key": "Name",
"Value": "my-ava-instance"
}
]
}
]
}
```
Para obter mais informações, consulte [Instâncias de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-instances.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [DescribeVerifiedAccessInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-verified-access-instances.html)em *Referência de AWS CLI Comandos*.
### `describe-verified-access-trust-providers`
O código de exemplo a seguir mostra como usar `describe-verified-access-trust-providers`.
**AWS CLI**
**Descrever um provedor confiável de acesso verificado**
O exemplo `describe-verified-access-trust-providers` a seguir descreve o provedor de confiança especificado do acesso verificado.
```
aws ec2 describe-verified-access-trust-providers \
--verified-access-trust-provider-ids vatp-0bb32de759a3e19e7
```
Saída:
```
{
"VerifiedAccessTrustProviders": [
{
"VerifiedAccessTrustProviderId": "vatp-0bb32de759a3e19e7",
"Description": "Testing Verified Access",
"TrustProviderType": "user",
"UserTrustProviderType": "iam-identity-center",
"PolicyReferenceName": "idc",
"CreationTime": "2023-08-25T19:00:38",
"LastUpdatedTime": "2023-08-25T19:03:32",
"Tags": [
{
"Key": "Name",
"Value": "my-va-trust-provider"
}
]
}
]
}
```
Para obter mais informações, consulte [Provedores confiáveis para acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/trust-providers.html) no *Guia do usuário de acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [DescribeVerifiedAccessTrustProviders](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-verified-access-trust-providers.html)em *Referência de AWS CLI Comandos*.
### `describe-volume-attribute`
O código de exemplo a seguir mostra como usar `describe-volume-attribute`.
**AWS CLI**
**Descrever um atributo de volume**
Este exemplo de comando descreve o atributo `autoEnableIo` do volume com o ID `vol-049df61146c4d7901`.
Comando:
```
aws ec2 describe-volume-attribute --volume-id vol-049df61146c4d7901 --attribute autoEnableIO
```
Saída:
```
{
"AutoEnableIO": {
"Value": false
},
"VolumeId": "vol-049df61146c4d7901"
}
```
+ Para obter detalhes da API, consulte [DescribeVolumeAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-volume-attribute.html)em *Referência de AWS CLI Comandos*.
### `describe-volume-status`
O código de exemplo a seguir mostra como usar `describe-volume-status`.
**AWS CLI**
**Descrever o status de um único volume**
Este exemplo de comando descreve o status do volume `vol-1234567890abcdef0`.
Comando:
```
aws ec2 describe-volume-status --volume-ids vol-1234567890abcdef0
```
Saída:
```
{
"VolumeStatuses": [
{
"VolumeStatus": {
"Status": "ok",
"Details": [
{
"Status": "passed",
"Name": "io-enabled"
},
{
"Status": "not-applicable",
"Name": "io-performance"
}
]
},
"AvailabilityZone": "us-east-1a",
"VolumeId": "vol-1234567890abcdef0",
"Actions": [],
"Events": []
}
]
}
```
**Descrever o status dos volumes danificados**
Este exemplo de comando descreve o status de todos os volumes que estão danificados. Neste exemplo de saída, não há volumes comprometidos.
Comando:
```
aws ec2 describe-volume-status --filters Name=volume-status.status,Values=impaired
```
Saída:
```
{
"VolumeStatuses": []
}
```
Se você tiver um volume com um status de falha em uma verificação de status (o status é comprometido), consulte Trabalhar com um volume comprometido no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DescribeVolumeStatus](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-volume-status.html)em *Referência de AWS CLI Comandos*.
### `describe-volumes-modifications`
O código de exemplo a seguir mostra como usar `describe-volumes-modifications`.
**AWS CLI**
**Descrever o status de modificação de um volume**
O exemplo `describe-volumes-modifications` a seguir descreve o status de modificação do volume especificado.
```
aws ec2 describe-volumes-modifications \
--volume-ids vol-1234567890abcdef0
```
Saída:
```
{
"VolumeModification": {
"TargetSize": 150,
"TargetVolumeType": "io1",
"ModificationState": "optimizing",
"VolumeId": " vol-1234567890abcdef0",
"TargetIops": 100,
"StartTime": "2019-05-17T11:27:19.000Z",
"Progress": 70,
"OriginalVolumeType": "io1",
"OriginalIops": 100,
"OriginalSize": 100
}
}
```
+ Para obter detalhes da API, consulte [DescribeVolumesModifications](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-volumes-modifications.html)em *Referência de AWS CLI Comandos*.
### `describe-volumes`
O código de exemplo a seguir mostra como usar `describe-volumes`.
**AWS CLI**
**Exemplo 1: descrever um volume**
O exemplo `describe-volumes` a seguir descreve os volumes especificados na região atual.
```
aws ec2 describe-volumes \
--volume-ids vol-049df61146c4d7901 vol-1234567890abcdef0
```
Saída:
```
{
"Volumes": [
{
"AvailabilityZone": "us-east-1a",
"Attachments": [
{
"AttachTime": "2013-12-18T22:35:00.000Z",
"InstanceId": "i-1234567890abcdef0",
"VolumeId": "vol-049df61146c4d7901",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"Encrypted": true,
"KmsKeyId": "arn:aws:kms:us-east-2a:123456789012:key/8c5b2c63-b9bc-45a3-a87a-5513eEXAMPLE,
"VolumeType": "gp2",
"VolumeId": "vol-049df61146c4d7901",
"State": "in-use",
"Iops": 100,
"SnapshotId": "snap-1234567890abcdef0",
"CreateTime": "2019-12-18T22:35:00.084Z",
"Size": 8
},
{
"AvailabilityZone": "us-east-1a",
"Attachments": [],
"Encrypted": false,
"VolumeType": "gp2",
"VolumeId": "vol-1234567890abcdef0",
"State": "available",
"Iops": 300,
"SnapshotId": "",
"CreateTime": "2020-02-27T00:02:41.791Z",
"Size": 100
}
]
}
```
**Exemplo 2: descrever volumes anexados a uma instância específica**
O exemplo `describe-volumes` a seguir descreve todos os volumes anexados à instância especificada e definidos para serem excluídos quando a instância for encerrada.
```
aws ec2 describe-volumes \
--region us-east-1 \
--filters Name=attachment.instance-id,Values=i-1234567890abcdef0 Name=attachment.delete-on-termination,Values=true
```
Para obter um exemplo da saída de `describe-volumes`, consulte o Exemplo 1.
**Exemplo 3: descrever os volumes disponíveis em uma Zona de Disponibilidade específica**
O exemplo `describe-volumes` a seguir descreve todos os volumes que têm um status `available` e estão na Zona de Disponibilidade especificada.
```
aws ec2 describe-volumes \
--filters Name=status,Values=available Name=availability-zone,Values=us-east-1a
```
Para obter um exemplo da saída de `describe-volumes`, consulte o Exemplo 1.
**Exemplo 4: descrever volumes com base em tags**
O exemplo `describe-volumes` a seguir descreve todos os volumes que têm a chave de tag `Name` e um valor que começa com `Test`. A saída é então filtrada com uma consulta que exibe somente as tags e IDs os volumes.
```
aws ec2 describe-volumes \
--filters Name=tag:Name,Values=Test* \
--query "Volumes[*].{ID:VolumeId,Tag:Tags}"
```
Saída:
```
[
{
"Tag": [
{
"Value": "Test2",
"Key": "Name"
}
],
"ID": "vol-1234567890abcdef0"
},
{
"Tag": [
{
"Value": "Test1",
"Key": "Name"
}
],
"ID": "vol-049df61146c4d7901"
}
]
```
Para obter mais exemplos do uso de filtros de tags, consulte [Trabalhando com tags](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_CLI) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DescribeVolumes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-volumes.html)em *Referência de AWS CLI Comandos*.
### `describe-vpc-attribute`
O código de exemplo a seguir mostra como usar `describe-vpc-attribute`.
**AWS CLI**
**Para descrever o enableDnsSupport atributo**
Este exemplo descreve o atributo `enableDnsSupport`. Esse atributo indica se a VPC conta com resolução de DNS habilitada. Se este atributo é `true`, o servidor de DNS da Amazon resolve os nomes de hosts DNS de suas instâncias para os endereços IP correspondentes; caso contrário, ele não resolve.
Comando:
```
aws ec2 describe-vpc-attribute --vpc-id vpc-a01106c2 --attribute enableDnsSupport
```
Saída:
```
{
"VpcId": "vpc-a01106c2",
"EnableDnsSupport": {
"Value": true
}
}
```
**Para descrever o enableDnsHostnames atributo**
Este exemplo descreve o atributo `enableDnsHostnames`. Esse atributo indica se as instâncias executadas na VPC obtêm nomes de host DNS. Se esse atributo é `true`, as instâncias na VPC obtêm os nomes de hosts DNS; caso contrário, isso não ocorrerá.
Comando:
```
aws ec2 describe-vpc-attribute --vpc-id vpc-a01106c2 --attribute enableDnsHostnames
```
Saída:
```
{
"VpcId": "vpc-a01106c2",
"EnableDnsHostnames": {
"Value": true
}
}
```
+ Para obter detalhes da API, consulte [DescribeVpcAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-attribute.html)em *Referência de AWS CLI Comandos*.
### `describe-vpc-classic-link-dns-support`
O código de exemplo a seguir mostra como usar `describe-vpc-classic-link-dns-support`.
**AWS CLI**
**Para descrever o suporte ClassicLink de DNS para seu VPCs**
Este exemplo descreve o status de suporte de ClassicLink DNS de todos os seus VPCs.
Comando:
```
aws ec2 describe-vpc-classic-link-dns-support
```
Saída:
```
{
"Vpcs": [
{
"VpcId": "vpc-88888888",
"ClassicLinkDnsSupported": true
},
{
"VpcId": "vpc-1a2b3c4d",
"ClassicLinkDnsSupported": false
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeVpcClassicLinkDnsSupport](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-classic-link-dns-support.html)em *Referência de AWS CLI Comandos*.
### `describe-vpc-classic-link`
O código de exemplo a seguir mostra como usar `describe-vpc-classic-link`.
**AWS CLI**
**Para descrever o ClassicLink status do seu VPCs**
Este exemplo lista o ClassicLink status de vpc-88888888.
Comando:
```
aws ec2 describe-vpc-classic-link --vpc-id vpc-88888888
```
Saída:
```
{
"Vpcs": [
{
"ClassicLinkEnabled": true,
"VpcId": "vpc-88888888",
"Tags": [
{
"Value": "classiclinkvpc",
"Key": "Name"
}
]
}
]
}
```
Este exemplo lista somente os VPCs que estão habilitados para o Classiclink (o valor do filtro de `is-classic-link-enabled` está definido como). `true`
Comando:
```
aws ec2 describe-vpc-classic-link --filter "Name=is-classic-link-enabled,Values=true"
```
+ Para obter detalhes da API, consulte [DescribeVpcClassicLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-classic-link.html)em *Referência de AWS CLI Comandos*.
### `describe-vpc-endpoint-associations`
O código de exemplo a seguir mostra como usar `describe-vpc-endpoint-associations`.
**AWS CLI**
**Como descrever associações de endpoint da VPC**
O exemplo de `describe-vpc-endpoint-associations` a seguir descreve as associações de endpoint da VPC.
```
aws ec2 describe-vpc-endpoint-associations
```
Saída:
```
{
"VpcEndpointAssociations": [
{
"Id": "vpce-rsc-asc-0a810ca6ac8866bf9",
"VpcEndpointId": "vpce-019b90d6f16d4f958",
"AssociatedResourceAccessibility": "Accessible",
"DnsEntry": {
"DnsName": "vpce-019b90d6f16d4f958.rcfg-07129f3acded87625.4232ccc.vpc-lattice-rsc.us-east-2.on.aws",
"HostedZoneId": "Z03265862FOUNWMZOKUF4"
},
"AssociatedResourceArn": "arn:aws:vpc-lattice:us-east-1:123456789012:resourceconfiguration/rcfg-07129f3acded87625"
}
]
}
```
*Para obter mais informações, consulte [Gerenciar associações de endpoints VPC no Guia](https://docs.aws.amazon.com/vpc/latest/privatelink/resource-configuration-associations.html#resource-config-manage-ep-association) do AWS PrivateLink usuário.*
+ Para obter detalhes da API, consulte [DescribeVpcEndpointAssociations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-endpoint-associations.html)em *Referência de AWS CLI Comandos*.
### `describe-vpc-endpoint-connection-notifications`
O código de exemplo a seguir mostra como usar `describe-vpc-endpoint-connection-notifications`.
**AWS CLI**
**Descrever as notificações de conexão do endpoint**
O exemplo `describe-vpc-endpoint-connection-notifications` a seguir descreve todas as notificações de conexão de endpoint.
```
aws ec2 describe-vpc-endpoint-connection-notifications
```
Saída:
```
{
"ConnectionNotificationSet": [
{
"ConnectionNotificationState": "Enabled",
"ConnectionNotificationType": "Topic",
"ConnectionEvents": [
"Accept",
"Reject",
"Delete",
"Connect"
],
"ConnectionNotificationId": "vpce-nfn-04bcb952bc8af7abc",
"ConnectionNotificationArn": "arn:aws:sns:us-east-1:123456789012:VpceNotification",
"VpcEndpointId": "vpce-0324151a02f327123"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeVpcEndpointConnectionNotifications](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-endpoint-connection-notifications.html)em *Referência de AWS CLI Comandos*.
### `describe-vpc-endpoint-connections`
O código de exemplo a seguir mostra como usar `describe-vpc-endpoint-connections`.
**AWS CLI**
**Descrever as conexões de endpoint da VPC**
Este exemplo descreve as conexões do endpoint da interface com seu serviço de endpoint e filtra os resultados para exibir os endpoints que estão `PendingAcceptance`.
Comando:
```
aws ec2 describe-vpc-endpoint-connections --filters Name=vpc-endpoint-state,Values=pendingAcceptance
```
Saída:
```
{
"VpcEndpointConnections": [
{
"VpcEndpointId": "vpce-0abed31004e618123",
"ServiceId": "vpce-svc-0abced088d20def56",
"CreationTimestamp": "2017-11-30T10:00:24.350Z",
"VpcEndpointState": "pendingAcceptance",
"VpcEndpointOwner": "123456789012"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeVpcEndpointConnections](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-endpoint-connections.html)em *Referência de AWS CLI Comandos*.
### `describe-vpc-endpoint-service-configurations`
O código de exemplo a seguir mostra como usar `describe-vpc-endpoint-service-configurations`.
**AWS CLI**
**Descrever configurações de serviço de endpoint**
O exemplo `describe-vpc-endpoint-service-configurations` a seguir descreve suas configurações de serviço de endpoint.
```
aws ec2 describe-vpc-endpoint-service-configurations
```
Saída:
```
{
"ServiceConfigurations": [
{
"ServiceType": [
{
"ServiceType": "GatewayLoadBalancer"
}
],
"ServiceId": "vpce-svc-012d33a1c4321cabc",
"ServiceName": "com.amazonaws.vpce.us-east-1.vpce-svc-012d33a1c4321cabc",
"ServiceState": "Available",
"AvailabilityZones": [
"us-east-1d"
],
"AcceptanceRequired": false,
"ManagesVpcEndpoints": false,
"GatewayLoadBalancerArns": [
"arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/gwy/GWLBService/123210844e429123"
],
"Tags": []
},
{
"ServiceType": [
{
"ServiceType": "Interface"
}
],
"ServiceId": "vpce-svc-123cabc125efa123",
"ServiceName": "com.amazonaws.vpce.us-east-1.vpce-svc-123cabc125efa123",
"ServiceState": "Available",
"AvailabilityZones": [
"us-east-1a"
],
"AcceptanceRequired": true,
"ManagesVpcEndpoints": false,
"NetworkLoadBalancerArns": [
"arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/net/NLBforService/1238753950b25123"
],
"BaseEndpointDnsNames": [
"vpce-svc-123cabc125efa123.us-east-1.vpce.amazonaws.com"
],
"PrivateDnsName": "example.com",
"PrivateDnsNameConfiguration": {
"State": "failed",
"Type": "TXT",
"Value": "vpce:qUAth3FdeABCApUiXabc",
"Name": "_1d367jvbg34znqvyefrj"
},
"Tags": []
}
]
}
```
Para obter mais informações, consulte [Conceitos](https://docs.aws.amazon.com/vpc/latest/privatelink/concepts.html) no *Guia AWS PrivateLink do usuário*.
+ Para obter detalhes da API, consulte [DescribeVpcEndpointServiceConfigurations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-endpoint-service-configurations.html)em *Referência de AWS CLI Comandos*.
### `describe-vpc-endpoint-service-permissions`
O código de exemplo a seguir mostra como usar `describe-vpc-endpoint-service-permissions`.
**AWS CLI**
**Descrever as permissões do serviço de endpoint**
Este exemplo descreve as permissões para o serviço de endpoint especificado.
Comando:
```
aws ec2 describe-vpc-endpoint-service-permissions --service-id vpce-svc-03d5ebb7d9579a2b3
```
Saída:
```
{
"AllowedPrincipals": [
{
"PrincipalType": "Account",
"Principal": "arn:aws:iam::123456789012:root"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeVpcEndpointServicePermissions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-endpoint-service-permissions.html)em *Referência de AWS CLI Comandos*.
### `describe-vpc-endpoint-services`
O código de exemplo a seguir mostra como usar `describe-vpc-endpoint-services`.
**AWS CLI**
**Exemplo 1: descrever todos os serviços de endpoint da VPC**
O `describe-vpc-endpoint-services` exemplo a seguir lista todos os serviços de VPC endpoint para uma região. AWS
```
aws ec2 describe-vpc-endpoint-services
```
Saída:
```
{
"ServiceDetails": [
{
"ServiceType": [
{
"ServiceType": "Gateway"
}
],
"AcceptanceRequired": false,
"ServiceName": "com.amazonaws.us-east-1.dynamodb",
"VpcEndpointPolicySupported": true,
"Owner": "amazon",
"AvailabilityZones": [
"us-east-1a",
"us-east-1b",
"us-east-1c",
"us-east-1d",
"us-east-1e",
"us-east-1f"
],
"BaseEndpointDnsNames": [
"dynamodb.us-east-1.amazonaws.com"
]
},
{
"ServiceType": [
{
"ServiceType": "Interface"
}
],
"PrivateDnsName": "ec2.us-east-1.amazonaws.com",
"ServiceName": "com.amazonaws.us-east-1.ec2",
"VpcEndpointPolicySupported": false,
"Owner": "amazon",
"AvailabilityZones": [
"us-east-1a",
"us-east-1b",
"us-east-1c",
"us-east-1d",
"us-east-1e",
"us-east-1f"
],
"AcceptanceRequired": false,
"BaseEndpointDnsNames": [
"ec2.us-east-1.vpce.amazonaws.com"
]
},
{
"ServiceType": [
{
"ServiceType": "Interface"
}
],
"PrivateDnsName": "ssm.us-east-1.amazonaws.com",
"ServiceName": "com.amazonaws.us-east-1.ssm",
"VpcEndpointPolicySupported": true,
"Owner": "amazon",
"AvailabilityZones": [
"us-east-1a",
"us-east-1b",
"us-east-1c",
"us-east-1d",
"us-east-1e"
],
"AcceptanceRequired": false,
"BaseEndpointDnsNames": [
"ssm.us-east-1.vpce.amazonaws.com"
]
}
],
"ServiceNames": [
"com.amazonaws.us-east-1.dynamodb",
"com.amazonaws.us-east-1.ec2",
"com.amazonaws.us-east-1.ec2messages",
"com.amazonaws.us-east-1.elasticloadbalancing",
"com.amazonaws.us-east-1.kinesis-streams",
"com.amazonaws.us-east-1.s3",
"com.amazonaws.us-east-1.ssm"
]
}
```
**Exemplo 2: descrever os detalhes sobre um serviço de endpoint**
O exemplo de `describe-vpc-endpoint-services` a seguir lista os detalhes do serviço de endpoint da interface do Amazon S3.
```
aws ec2 describe-vpc-endpoint-services \
--filter 'Name=service-type,Values=Interface' Name=service-name,Values=com.amazonaws.us-east-1.s3
```
Saída:
```
{
"ServiceDetails": [
{
"ServiceName": "com.amazonaws.us-east-1.s3",
"ServiceId": "vpce-svc-081d84efcdEXAMPLE",
"ServiceType": [
{
"ServiceType": "Interface"
}
],
"AvailabilityZones": [
"us-east-1a",
"us-east-1b",
"us-east-1c",
"us-east-1d",
"us-east-1e",
"us-east-1f"
],
"Owner": "amazon",
"BaseEndpointDnsNames": [
"s3.us-east-1.vpce.amazonaws.com"
],
"VpcEndpointPolicySupported": true,
"AcceptanceRequired": false,
"ManagesVpcEndpoints": false,
"Tags": []
}
],
"ServiceNames": [
"com.amazonaws.us-east-1.s3"
]
}
```
Para obter mais informações, consulte [Exibir nomes AWS de serviços disponíveis](https://docs.aws.amazon.com/vpc/latest/privatelink/aws-services-privatelink-support.html#vpce-view-available-services) no *Guia AWS PrivateLink do usuário*.
+ Para obter detalhes da API, consulte [DescribeVpcEndpointServices](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-endpoint-services.html)em *Referência de AWS CLI Comandos*.
### `describe-vpc-endpoints`
O código de exemplo a seguir mostra como usar `describe-vpc-endpoints`.
**AWS CLI**
**Descrever seus endpoint da VPC**
O exemplo `describe-vpc-endpoints` a seguir exibe detalhes de todos os seus endpoints da VPC.
```
aws ec2 describe-vpc-endpoints
```
Saída:
```
{
"VpcEndpoints": [
{
"PolicyDocument": "{\"Version\":\"2008-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":\"*\",\"Action\":\"*\",\"Resource\":\"*\"}]}",
"VpcId": "vpc-aabb1122",
"NetworkInterfaceIds": [],
"SubnetIds": [],
"PrivateDnsEnabled": true,
"State": "available",
"ServiceName": "com.amazonaws.us-east-1.dynamodb",
"RouteTableIds": [
"rtb-3d560345"
],
"Groups": [],
"VpcEndpointId": "vpce-032a826a",
"VpcEndpointType": "Gateway",
"CreationTimestamp": "2017-09-05T20:41:28Z",
"DnsEntries": [],
"OwnerId": "123456789012"
},
{
"PolicyDocument": "{\n \"Statement\": [\n {\n \"Action\": \"*\", \n \"Effect\": \"Allow\", \n \"Principal\": \"*\", \n \"Resource\": \"*\"\n }\n ]\n}",
"VpcId": "vpc-1a2b3c4d",
"NetworkInterfaceIds": [
"eni-2ec2b084",
"eni-1b4a65cf"
],
"SubnetIds": [
"subnet-d6fcaa8d",
"subnet-7b16de0c"
],
"PrivateDnsEnabled": false,
"State": "available",
"ServiceName": "com.amazonaws.us-east-1.elasticloadbalancing",
"RouteTableIds": [],
"Groups": [
{
"GroupName": "default",
"GroupId": "sg-54e8bf31"
}
],
"VpcEndpointId": "vpce-0f89a33420c1931d7",
"VpcEndpointType": "Interface",
"CreationTimestamp": "2017-09-05T17:55:27.583Z",
"DnsEntries": [
{
"HostedZoneId": "Z7HUB22UULQXV",
"DnsName": "vpce-0f89a33420c1931d7-bluzidnv.elasticloadbalancing.us-east-1.vpce.amazonaws.com"
},
{
"HostedZoneId": "Z7HUB22UULQXV",
"DnsName": "vpce-0f89a33420c1931d7-bluzidnv-us-east-1b.elasticloadbalancing.us-east-1.vpce.amazonaws.com"
},
{
"HostedZoneId": "Z7HUB22UULQXV",
"DnsName": "vpce-0f89a33420c1931d7-bluzidnv-us-east-1a.elasticloadbalancing.us-east-1.vpce.amazonaws.com"
}
],
"OwnerId": "123456789012"
},
{
"VpcEndpointId": "vpce-aabbaabbaabbaabba",
"VpcEndpointType": "GatewayLoadBalancer",
"VpcId": "vpc-111122223333aabbc",
"ServiceName": "com.amazonaws.vpce.us-east-1.vpce-svc-123123a1c43abc123",
"State": "available",
"SubnetIds": [
"subnet-0011aabbcc2233445"
],
"RequesterManaged": false,
"NetworkInterfaceIds": [
"eni-01010120203030405"
],
"CreationTimestamp": "2020-11-11T08:06:03.522Z",
"Tags": [],
"OwnerId": "123456789012"
}
]
}
```
Para obter mais informações, consulte [Conceitos](https://docs.aws.amazon.com/vpc/latest/privatelink/concepts.html) no *Guia AWS PrivateLink do usuário*.
+ Para obter detalhes da API, consulte [DescribeVpcEndpoints](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-endpoints.html)em *Referência de AWS CLI Comandos*.
### `describe-vpc-peering-connections`
O código de exemplo a seguir mostra como usar `describe-vpc-peering-connections`.
**AWS CLI**
**Descrever as conexões de emparelhamento da VPC**
Este exemplo descreve todas as conexões de emparelhamento da VPC.
Comando:
```
aws ec2 describe-vpc-peering-connections
```
Saída:
```
{
"VpcPeeringConnections": [
{
"Status": {
"Message": "Active",
"Code": "active"
},
"Tags": [
{
"Value": "Peering-1",
"Key": "Name"
}
],
"AccepterVpcInfo": {
"OwnerId": "111122223333",
"VpcId": "vpc-1a2b3c4d",
"CidrBlock": "10.0.1.0/28"
},
"VpcPeeringConnectionId": "pcx-11122233",
"RequesterVpcInfo": {
"PeeringOptions": {
"AllowEgressFromLocalVpcToRemoteClassicLink": false,
"AllowEgressFromLocalClassicLinkToRemoteVpc": false
},
"OwnerId": "444455556666",
"VpcId": "vpc-123abc45",
"CidrBlock": "192.168.0.0/16"
}
},
{
"Status": {
"Message": "Pending Acceptance by 444455556666",
"Code": "pending-acceptance"
},
"Tags": [],
"RequesterVpcInfo": {
"PeeringOptions": {
"AllowEgressFromLocalVpcToRemoteClassicLink": false,
"AllowEgressFromLocalClassicLinkToRemoteVpc": false
},
"OwnerId": "444455556666",
"VpcId": "vpc-11aa22bb",
"CidrBlock": "10.0.0.0/28"
},
"VpcPeeringConnectionId": "pcx-abababab",
"ExpirationTime": "2014-04-03T09:12:43.000Z",
"AccepterVpcInfo": {
"OwnerId": "444455556666",
"VpcId": "vpc-33cc44dd"
}
}
]
}
```
**Descrever conexões específicas de emparelhamento da VPC**
Este exemplo descreve todas as conexões de emparelhamento da VPC que estão no estado de aceitação pendente.
Comando:
```
aws ec2 describe-vpc-peering-connections --filters Name=status-code,Values=pending-acceptance
```
Este exemplo descreve todas as conexões de emparelhamento da VPC que têm a tag Owner=Finance.
Comando:
```
aws ec2 describe-vpc-peering-connections --filters Name=tag:Owner,Values=Finance
```
Este exemplo descreve todas as conexões de emparelhamento da VPC que você solicitou para a VPC especificada, vpc-1a2b3c4d.
Comando:
```
aws ec2 describe-vpc-peering-connections --filters Name=requester-vpc-info.vpc-id,Values=vpc-1a2b3c4d
```
+ Para obter detalhes da API, consulte [DescribeVpcPeeringConnections](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-peering-connections.html)em *Referência de AWS CLI Comandos*.
### `describe-vpcs`
O código de exemplo a seguir mostra como usar `describe-vpcs`.
**AWS CLI**
**Exemplo 1: Para descrever todas as suas VPCs**
O `describe-vpcs` exemplo a seguir recupera detalhes sobre seu VPCs.
```
aws ec2 describe-vpcs
```
Saída:
```
{
"Vpcs": [
{
"CidrBlock": "30.1.0.0/16",
"DhcpOptionsId": "dopt-19edf471",
"State": "available",
"VpcId": "vpc-0e9801d129EXAMPLE",
"OwnerId": "111122223333",
"InstanceTenancy": "default",
"CidrBlockAssociationSet": [
{
"AssociationId": "vpc-cidr-assoc-062c64cfafEXAMPLE",
"CidrBlock": "30.1.0.0/16",
"CidrBlockState": {
"State": "associated"
}
}
],
"IsDefault": false,
"Tags": [
{
"Key": "Name",
"Value": "Not Shared"
}
]
},
{
"CidrBlock": "10.0.0.0/16",
"DhcpOptionsId": "dopt-19edf471",
"State": "available",
"VpcId": "vpc-06e4ab6c6cEXAMPLE",
"OwnerId": "222222222222",
"InstanceTenancy": "default",
"CidrBlockAssociationSet": [
{
"AssociationId": "vpc-cidr-assoc-00b17b4eddEXAMPLE",
"CidrBlock": "10.0.0.0/16",
"CidrBlockState": {
"State": "associated"
}
}
],
"IsDefault": false,
"Tags": [
{
"Key": "Name",
"Value": "Shared VPC"
}
]
}
]
}
```
**Exemplo 2: descrever uma VPC especificada**
O exemplo de `describe-vpcs` a seguir recupera detalhes da VPC especificada.
```
aws ec2 describe-vpcs \
--vpc-ids vpc-06e4ab6c6cEXAMPLE
```
Saída:
```
{
"Vpcs": [
{
"CidrBlock": "10.0.0.0/16",
"DhcpOptionsId": "dopt-19edf471",
"State": "available",
"VpcId": "vpc-06e4ab6c6cEXAMPLE",
"OwnerId": "111122223333",
"InstanceTenancy": "default",
"CidrBlockAssociationSet": [
{
"AssociationId": "vpc-cidr-assoc-00b17b4eddEXAMPLE",
"CidrBlock": "10.0.0.0/16",
"CidrBlockState": {
"State": "associated"
}
}
],
"IsDefault": false,
"Tags": [
{
"Key": "Name",
"Value": "Shared VPC"
}
]
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeVpcs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpcs.html)em *Referência de AWS CLI Comandos*.
### `describe-vpn-connections`
O código de exemplo a seguir mostra como usar `describe-vpn-connections`.
**AWS CLI**
**Exemplo 1: descrever as conexões VPN**
O `describe-vpn-connections` exemplo a seguir descreve todas as suas conexões Site-to-Site VPN.
```
aws ec2 describe-vpn-connections
```
Saída:
```
{
"VpnConnections": [
{
"CustomerGatewayConfiguration": "...configuration information...",
"CustomerGatewayId": "cgw-01234567abcde1234",
"Category": "VPN",
"State": "available",
"Type": "ipsec.1",
"VpnConnectionId": "vpn-1122334455aabbccd",
"TransitGatewayId": "tgw-00112233445566aab",
"Options": {
"EnableAcceleration": false,
"StaticRoutesOnly": true,
"LocalIpv4NetworkCidr": "0.0.0.0/0",
"RemoteIpv4NetworkCidr": "0.0.0.0/0",
"TunnelInsideIpVersion": "ipv4"
},
"Routes": [],
"Tags": [
{
"Key": "Name",
"Value": "CanadaVPN"
}
],
"VgwTelemetry": [
{
"AcceptedRouteCount": 0,
"LastStatusChange": "2020-07-29T10:35:11.000Z",
"OutsideIpAddress": "203.0.113.3",
"Status": "DOWN",
"StatusMessage": ""
},
{
"AcceptedRouteCount": 0,
"LastStatusChange": "2020-09-02T09:09:33.000Z",
"OutsideIpAddress": "203.0.113.5",
"Status": "UP",
"StatusMessage": ""
}
]
}
]
}
```
Para obter mais informações, consulte [Como a AWS Site-to-Site VPN funciona](https://docs.aws.amazon.com/vpn/latest/s2svpn/how_it_works.html) no *Guia do usuário da AWS Site-to-Site VPN*.
**Exemplo 2: descrever as conexões VPN disponíveis**
O `describe-vpn-connections` exemplo a seguir descreve suas conexões Site-to-Site VPN com um estado de`available`.
```
aws ec2 describe-vpn-connections \
--filters "Name=state,Values=available"
```
Para obter mais informações, consulte [Como a AWS Site-to-Site VPN funciona](https://docs.aws.amazon.com/vpn/latest/s2svpn/how_it_works.html) no *Guia do usuário da AWS Site-to-Site VPN*.
+ Para obter detalhes da API, consulte [DescribeVpnConnections](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpn-connections.html)em *Referência de AWS CLI Comandos*.
### `describe-vpn-gateways`
O código de exemplo a seguir mostra como usar `describe-vpn-gateways`.
**AWS CLI**
**Descrever seus gateways privados virtuais**
Este exemplo descreve seus gateways privados virtuais.
Comando:
```
aws ec2 describe-vpn-gateways
```
Saída:
```
{
"VpnGateways": [
{
"State": "available",
"Type": "ipsec.1",
"VpnGatewayId": "vgw-f211f09b",
"VpcAttachments": [
{
"State": "attached",
"VpcId": "vpc-98eb5ef5"
}
]
},
{
"State": "available",
"Type": "ipsec.1",
"VpnGatewayId": "vgw-9a4cacf3",
"VpcAttachments": [
{
"State": "attaching",
"VpcId": "vpc-a01106c2"
}
]
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeVpnGateways](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpn-gateways.html)em *Referência de AWS CLI Comandos*.
### `detach-classic-link-vpc`
O código de exemplo a seguir mostra como usar `detach-classic-link-vpc`.
**AWS CLI**
**Desvincular (desanexar) uma instância do EC2-Classic de uma VPC**
Este exemplo desvincula a instância i-0598c7d356eba48d7 da VPC vpc-88888888.
Comando:
```
aws ec2 detach-classic-link-vpc --instance-id i-0598c7d356eba48d7 --vpc-id vpc-88888888
```
Saída:
```
{
"Return": true
}
```
+ Para obter detalhes da API, consulte [DetachClassicLinkVpc](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/detach-classic-link-vpc.html)em *Referência de AWS CLI Comandos*.
### `detach-internet-gateway`
O código de exemplo a seguir mostra como usar `detach-internet-gateway`.
**AWS CLI**
**Separar um gateway da Internet da VPC**
O exemplo `detach-internet-gateway` a seguir separa o gateway da internet especificado da VPC específica.
```
aws ec2 detach-internet-gateway \
--internet-gateway-id igw-0d0fb496b3EXAMPLE \
--vpc-id vpc-0a60eb65b4EXAMPLE
```
Este comando não produz saída.
Para obter mais informações, consulte [Gateways da Internet](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [DetachInternetGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/detach-internet-gateway.html)em *Referência de AWS CLI Comandos*.
### `detach-network-interface`
O código de exemplo a seguir mostra como usar `detach-network-interface`.
**AWS CLI**
**Desanexar uma interface de rede de uma instância**
Este exemplo desvincula a interface de rede especificada da instância especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 detach-network-interface --attachment-id eni-attach-66c4350a
```
+ Para obter detalhes da API, consulte [DetachNetworkInterface](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/detach-network-interface.html)em *Referência de AWS CLI Comandos*.
### `detach-verified-access-trust-provider`
O código de exemplo a seguir mostra como usar `detach-verified-access-trust-provider`.
**AWS CLI**
**Desanexar um provedor de confiança de uma instância**
O exemplo `detach-verified-access-trust-provider` a seguir desvincula o provedor confiável de acesso verificado especificado da instância de acesso verificado especificada.
```
aws ec2 detach-verified-access-trust-provider \
--verified-access-instance-id vai-0ce000c0b7643abea \
--verified-access-trust-provider-id vatp-0bb32de759a3e19e7
```
Saída:
```
{
"VerifiedAccessTrustProvider": {
"VerifiedAccessTrustProviderId": "vatp-0bb32de759a3e19e7",
"Description": "Testing Verified Access",
"TrustProviderType": "user",
"UserTrustProviderType": "iam-identity-center",
"PolicyReferenceName": "idc",
"CreationTime": "2023-08-25T19:00:38",
"LastUpdatedTime": "2023-08-25T19:00:38"
},
"VerifiedAccessInstance": {
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"Description": "Testing Verified Access",
"VerifiedAccessTrustProviders": [],
"CreationTime": "2023-08-25T18:27:56",
"LastUpdatedTime": "2023-08-25T18:27:56"
}
}
```
Para obter mais informações, consulte [Instâncias de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-instances.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [DetachVerifiedAccessTrustProvider](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/detach-verified-access-trust-provider.html)em *Referência de AWS CLI Comandos*.
### `detach-volume`
O código de exemplo a seguir mostra como usar `detach-volume`.
**AWS CLI**
**Desanexar um volume de uma instância**
Este exemplo de comando separa o volume (`vol-049df61146c4d7901`) da instância à qual ele está conectado.
Comando:
```
aws ec2 detach-volume --volume-id vol-1234567890abcdef0
```
Saída:
```
{
"AttachTime": "2014-02-27T19:23:06.000Z",
"InstanceId": "i-1234567890abcdef0",
"VolumeId": "vol-049df61146c4d7901",
"State": "detaching",
"Device": "/dev/sdb"
}
```
+ Para obter detalhes da API, consulte [DetachVolume](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/detach-volume.html)em *Referência de AWS CLI Comandos*.
### `detach-vpn-gateway`
O código de exemplo a seguir mostra como usar `detach-vpn-gateway`.
**AWS CLI**
**Desanexar um gateway privado virtual da VPC**
Este exemplo desvincula o gateway privado virtual especificado da VPC especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 detach-vpn-gateway --vpn-gateway-id vgw-9a4cacf3 --vpc-id vpc-a01106c2
```
+ Para obter detalhes da API, consulte [DetachVpnGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/detach-vpn-gateway.html)em *Referência de AWS CLI Comandos*.
### `disable-address-transfer`
O código de exemplo a seguir mostra como usar `disable-address-transfer`.
**AWS CLI**
**Desabilitar uma transferência de endereço IP elástico**
O exemplo `disable-address-transfer` a seguir desativa a transferência de endereço IP elástico para o endereço IP elástico especificado.
```
aws ec2 disable-address-transfer \
--allocation-id eipalloc-09ad461b0d03f6aaf
```
Saída:
```
{
"AddressTransfer": {
"PublicIp": "100.21.184.216",
"AllocationId": "eipalloc-09ad461b0d03f6aaf",
"AddressTransferStatus": "disabled"
}
}
```
Para obter mais informações, consulte [Transferir endereços IP elásticos](https://docs.aws.amazon.com/vpc/latest/userguide/WorkWithEIPs.html#transfer-EIPs-intro) no *Guia do usuário do Amazon VPC*.
+ Para obter detalhes da API, consulte [DisableAddressTransfer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-address-transfer.html)em *Referência de AWS CLI Comandos*.
### `disable-aws-network-performance-metric-subscription`
O código de exemplo a seguir mostra como usar `disable-aws-network-performance-metric-subscription`.
**AWS CLI**
**Desativar uma assinatura métrica**
O exemplo `disable-aws-network-performance-metric-subscription` a seguir desativa o monitoramento da latência agregada da rede entre as regiões de origem e destino especificadas.
```
aws ec2 disable-aws-network-performance-metric-subscription \
--source us-east-1 \
--destination eu-west-1 \
--metric aggregate-latency \
--statistic p50
```
Saída:
```
{
"Output": true
}
```
Para obter mais informações, consulte [Gerenciar CloudWatch assinaturas usando a CLI](https://docs.aws.amazon.com/network-manager/latest/infrastructure-performance/getting-started-nmip-cli.html) no Guia do usuário de desempenho da *infraestrutura*.
+ Para obter detalhes da API, consulte [DisableAwsNetworkPerformanceMetricSubscription](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-aws-network-performance-metric-subscription.html)em *Referência de AWS CLI Comandos*.
### `disable-ebs-encryption-by-default`
O código de exemplo a seguir mostra como usar `disable-ebs-encryption-by-default`.
**AWS CLI**
**Desabilitar a criptografia do EBS por padrão**
O `disable-ebs-encryption-by-default` exemplo a seguir desativa a criptografia do EBS por padrão para sua AWS conta na região atual.
```
aws ec2 disable-ebs-encryption-by-default
```
Saída:
```
{
"EbsEncryptionByDefault": false
}
```
+ Para obter detalhes da API, consulte [DisableEbsEncryptionByDefault](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-ebs-encryption-by-default.html)em *Referência de AWS CLI Comandos*.
### `disable-fast-launch`
O código de exemplo a seguir mostra como usar `disable-fast-launch`.
**AWS CLI**
**Interromper o lançamento rápido de uma imagem**
O exemplo de `disable-fast-launch` a seguir interrompe o Fast Launch na AMI especificada e apaga snapshots pré-provisionados.
```
aws ec2 disable-fast-launch \
--image-id ami-01234567890abcedf
```
Saída:
```
{
"ImageId": "ami-01234567890abcedf",
"ResourceType": "snapshot",
"SnapshotConfiguration": {},
"LaunchTemplate": {
"LaunchTemplateId": "lt-01234567890abcedf",
"LaunchTemplateName": "EC2FastLaunchDefaultResourceCreation-a8c6215d-94e6-441b-9272-dbd1f87b07e2",
"Version": "1"
},
"MaxParallelLaunches": 6,
"OwnerId": "0123456789123",
"State": "disabling",
"StateTransitionReason": "Client.UserInitiated",
"StateTransitionTime": "2022-01-27T22:47:29.265000+00:00"
}
```
Consulte mais informações em [Configurar o EC2 Fast Launch para a AMI do Windows](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/win-fast-launch-configure.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DisableFastLaunch](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-fast-launch.html)em *Referência de AWS CLI Comandos*.
### `disable-fast-snapshot-restores`
O código de exemplo a seguir mostra como usar `disable-fast-snapshot-restores`.
**AWS CLI**
**Desativar a restauração rápida de snapshot**
O exemplo `disable-fast-snapshot-restores` a seguir desativa restaurações rápidas de snapshot para os snapshots especificados nas Zonas de Disponibilidade especificadas.
```
aws ec2 disable-fast-snapshot-restores \
--availability-zones us-east-2a \
--source-snapshot-ids snap-1234567890abcdef0
```
Saída:
```
{
"Successful": [
{
"SnapshotId": "snap-1234567890abcdef0"
"AvailabilityZone": "us-east-2a",
"State": "disabling",
"StateTransitionReason": "Client.UserInitiated",
"OwnerId": "123456789012",
"EnablingTime": "2020-01-25T23:57:49.602Z"
}
],
"Unsuccessful": []
}
```
+ Para obter detalhes da API, consulte [DisableFastSnapshotRestores](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-fast-snapshot-restores.html)em *Referência de AWS CLI Comandos*.
### `disable-image-block-public-access`
O código de exemplo a seguir mostra como usar `disable-image-block-public-access`.
**AWS CLI**
**Para desativar o bloqueio do acesso público AMIs na região especificada**
O `disable-image-block-public-access` exemplo a seguir desativa o bloqueio do acesso público AMIs no nível da conta na região especificada.
```
aws ec2 disable-image-block-public-access \
--region us-east-1
```
Saída:
```
{
"ImageBlockPublicAccessState": "unblocked"
}
```
Para obter mais informações, consulte [Bloquear o acesso público ao seu AMIs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-public-access-to-amis.html) no Guia do *usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DisableImageBlockPublicAccess](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-image-block-public-access.html)em *Referência de AWS CLI Comandos*.
### `disable-image-deprecation`
O código de exemplo a seguir mostra como usar `disable-image-deprecation`.
**AWS CLI**
**Cancelar a descontinuação de uma AMI**
O exemplo `disable-image-deprecation` a seguir cancela a depreciação de uma AMI, o que remove o campo `DeprecationTime` da saída `describe-images`. É necessário ser o proprietário da AMI para executar esse procedimento.
```
aws ec2 disable-image-deprecation \
--image-id ami-1234567890abcdef0
```
Saída:
```
{
"RequestID": "11aabb229-4eac-35bd-99ed-be587EXAMPLE",
"Return": "true"
}
```
Consulte mais informações em [Descontinuar uma AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deprecate.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DisableImageDeprecation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-image-deprecation.html)em *Referência de AWS CLI Comandos*.
### `disable-image-deregistration-protection`
O código de exemplo a seguir mostra como usar `disable-image-deregistration-protection`.
**AWS CLI**
**Como desabilitar a proteção contra cancelamento de registro**
O exemplo de `disable-image-deregistration-protection` a seguir desabilita a proteção contra cancelamento de registro para a imagem especificada.
```
aws ec2 disable-image-deregistration-protection \
--image-id ami-0b1a928a144a74ec9
```
Saída:
```
{
"Return": "disabled"
}
```
Consulte mais informações em [Proteger uma AMI do Amazon EC2 de cancelamento de registro](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deregistration-protection.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DisableImageDeregistrationProtection](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-image-deregistration-protection.html)em *Referência de AWS CLI Comandos*.
### `disable-image`
O código de exemplo a seguir mostra como usar `disable-image`.
**AWS CLI**
**Desabilitar uma AMI**
O exemplo `disable-image` a seguir desabilita a AMI especificada.
```
aws ec2 disable-image \
--image-id ami-1234567890abcdef0
```
Saída:
```
{
"Return": "true"
}
```
Para obter mais informações, consulte [Desativar uma AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/disable-an-ami.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DisableImage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-image.html)em *Referência de AWS CLI Comandos*.
### `disable-ipam-organization-admin-account`
O código de exemplo a seguir mostra como usar `disable-ipam-organization-admin-account`.
**AWS CLI**
**Desativar o administrador IPAM delegado**
Em determinados cenários, você integrará o IPAM com AWS Organizations. Quando você faz isso, a conta de gerenciamento do AWS Organizations delega uma conta de membro do AWS Organizations como administrador do IPAM.
Neste exemplo, você é a conta de gerenciamento do AWS Organizations que delegou a conta de administrador do IPAM e deseja desativar essa conta de ser o administrador do IPAM.
Você pode usar qualquer AWS região para `--region` fazer essa solicitação. Você não precisa usar a região na qual delegou originalmente o administrador, onde o IPAM foi criado ou uma região operacional do IPAM. Se você desativar a conta de administrador delegado, poderá reativá-la a qualquer momento ou delegar uma nova conta como administrador do IPAM.
O `disable-ipam-organization-admin-account` exemplo a seguir desativa o administrador IPAM delegado em sua conta. AWS
```
aws ec2 disable-ipam-organization-admin-account \
--delegated-admin-account-id 320805250157 \
--region ap-south-1
```
Saída:
```
{
"Success": true
}
```
Para obter mais informações, consulte [Integrar o IPAM com contas em uma AWS organização no Guia](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam.html) do usuário do *IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [DisableIpamOrganizationAdminAccount](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-ipam-organization-admin-account.html)em *Referência de AWS CLI Comandos*.
### `disable-serial-console-access`
O código de exemplo a seguir mostra como usar `disable-serial-console-access`.
**AWS CLI**
**Desativar o acesso ao console de série do EC2 da sua conta**
O exemplo `disable-serial-console-access` a seguir desabilita o acesso da conta ao console de série.
```
aws ec2 disable-serial-console-access
```
Saída:
```
{
"SerialConsoleAccessEnabled": false
}
```
Para obter mais informações, consulte [Console de Série do EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-serial-console.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DisableSerialConsoleAccess](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-serial-console-access.html)em *Referência de AWS CLI Comandos*.
### `disable-snapshot-block-public-access`
O código de exemplo a seguir mostra como usar `disable-snapshot-block-public-access`.
**AWS CLI**
**Desabilitar o bloqueio do acesso público aos snapshots**
O exemplo `disable-snapshot-block-public-access` a seguir desabilita o bloqueio do acesso público aos snapshots para permitir o compartilhamento público dos snapshots.
```
aws ec2 disable-snapshot-block-public-access
```
Saída:
```
{
"State": "unblocked"
}
```
Para obter mais informações, consulte [Bloquear acesso público aos snapshots](https://docs.aws.amazon.com/ebs/latest/userguide/block-public-access-snapshots.html) no *Guia do usuário do Amazon EBS*.
+ Para obter detalhes da API, consulte [DisableSnapshotBlockPublicAccess](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-snapshot-block-public-access.html)em *Referência de AWS CLI Comandos*.
### `disable-transit-gateway-route-table-propagation`
O código de exemplo a seguir mostra como usar `disable-transit-gateway-route-table-propagation`.
**AWS CLI**
**Desabilitar um anexo do gateway de trânsito para propagar rotas para a tabela de rotas de propagação especificada**
O exemplo `disable-transit-gateway-route-table-propagation` a seguir desativa o anexo especificado para propagar rotas para a tabela de rota de propagação especificada.
```
aws ec2 disable-transit-gateway-route-table-propagation \
--transit-gateway-route-table-id tgw-rtb-0a823edbdeEXAMPLE \
--transit-gateway-attachment-id tgw-attach-09b52ccdb5EXAMPLE
```
Saída:
```
{
"Propagation": {
"TransitGatewayAttachmentId": "tgw-attach-09b52ccdb5EXAMPLE",
"ResourceId": "vpc-4d7de228",
"ResourceType": "vpc",
"TransitGatewayRouteTableId": "tgw-rtb-0a823edbdeEXAMPLE",
"State": "disabled"
}
}
```
Para obter mais informações, consulte [Tabelas de rota do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [DisableTransitGatewayRouteTablePropagation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-transit-gateway-route-table-propagation.html)em *Referência de AWS CLI Comandos*.
### `disable-vgw-route-propagation`
O código de exemplo a seguir mostra como usar `disable-vgw-route-propagation`.
**AWS CLI**
**Desabilitar a propagação de rotas**
Esse exemplo desabilita o gateway privado virtual especificado de propagar rotas estáticas para a tabela de rotas especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 disable-vgw-route-propagation --route-table-id rtb-22574640 --gateway-id vgw-9a4cacf3
```
+ Para obter detalhes da API, consulte [DisableVgwRoutePropagation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-vgw-route-propagation.html)em *Referência de AWS CLI Comandos*.
### `disable-vpc-classic-link-dns-support`
O código de exemplo a seguir mostra como usar `disable-vpc-classic-link-dns-support`.
**AWS CLI**
**Para desativar o suporte ClassicLink de DNS para uma VPC**
Este exemplo desativa o suporte de ClassicLink DNS para. `vpc-88888888`
Comando:
```
aws ec2 disable-vpc-classic-link-dns-support --vpc-id vpc-88888888
```
Saída:
```
{
"Return": true
}
```
+ Para obter detalhes da API, consulte [DisableVpcClassicLinkDnsSupport](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-vpc-classic-link-dns-support.html)em *Referência de AWS CLI Comandos*.
### `disable-vpc-classic-link`
O código de exemplo a seguir mostra como usar `disable-vpc-classic-link`.
**AWS CLI**
**Para desativar ClassicLink para uma VPC**
Este exemplo desativa ClassicLink para vpc-8888888.
Comando:
```
aws ec2 disable-vpc-classic-link --vpc-id vpc-88888888
```
Saída:
```
{
"Return": true
}
```
+ Para obter detalhes da API, consulte [DisableVpcClassicLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-vpc-classic-link.html)em *Referência de AWS CLI Comandos*.
### `disassociate-address`
O código de exemplo a seguir mostra como usar `disassociate-address`.
**AWS CLI**
**Para desassociar um endereço IP elástico no EC2-Classic**
Este exemplo desassocia um endereço IP elástico de uma instância no EC2-Classic. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 disassociate-address --public-ip 198.51.100.0
```
**Para desassociar um endereço IP elástico no EC2-VPC**
Este exemplo desassocia um endereço IP elástico de uma instância em uma VPC. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 disassociate-address --association-id eipassoc-2bebb745
```
+ Para obter detalhes da API, consulte [DisassociateAddress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-address.html)em *Referência de AWS CLI Comandos*.
### `disassociate-client-vpn-target-network`
O código de exemplo a seguir mostra como usar `disassociate-client-vpn-target-network`.
**AWS CLI**
**Desassociar uma rede de destino de um endpoint do Client VPN**
O exemplo `disassociate-client-vpn-target-network` a seguir desassocia a rede de destino associada ao ID de associação `cvpn-assoc-12312312312312312` do endpoint de Client VPN especificado.
```
aws ec2 disassociate-client-vpn-target-network \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde \
--association-id cvpn-assoc-12312312312312312
```
Saída:
```
{
"AssociationId": "cvpn-assoc-12312312312312312",
"Status": {
"Code": "disassociating"
}
}
```
Para obter mais informações, consulte [Redes de destino](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-target.html) no *Guia do administrador da AWS *.
+ Para obter detalhes da API, consulte [DisassociateClientVpnTargetNetwork](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-client-vpn-target-network.html)em *Referência de AWS CLI Comandos*.
### `disassociate-iam-instance-profile`
O código de exemplo a seguir mostra como usar `disassociate-iam-instance-profile`.
**AWS CLI**
**Desassociar um perfil de instância do IAM**
Este exemplo desassocia um perfil de instância do IAM com o ID de associação `iip-assoc-05020b59952902f5f`.
Comando:
```
aws ec2 disassociate-iam-instance-profile --association-id iip-assoc-05020b59952902f5f
```
Saída:
```
{
"IamInstanceProfileAssociation": {
"InstanceId": "i-123456789abcde123",
"State": "disassociating",
"AssociationId": "iip-assoc-05020b59952902f5f",
"IamInstanceProfile": {
"Id": "AIPAI5IVIHMFFYY2DKV5Y",
"Arn": "arn:aws:iam::123456789012:instance-profile/admin-role"
}
}
}
```
+ Para obter detalhes da API, consulte [DisassociateIamInstanceProfile](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-iam-instance-profile.html)em *Referência de AWS CLI Comandos*.
### `disassociate-instance-event-window`
O código de exemplo a seguir mostra como usar `disassociate-instance-event-window`.
**AWS CLI**
**Exemplo 1: desassociar uma ou mais instâncias de uma janela de eventos**
O exemplo `disassociate-instance-event-window` desassocia uma ou mais instâncias de uma janela de evento. Especifique o parâmetro `instance-event-window-id` para especificar a janela do evento. Para dissociar instâncias, especifique o `association-target` parâmetro e, para os valores dos parâmetros, especifique uma ou mais instâncias IDs.
```
aws ec2 disassociate-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890 \
--association-target "InstanceIds=i-1234567890abcdef0,i-0598c7d356eba48d7"
```
Saída:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"AssociationTarget": {
"InstanceIds": [],
"Tags": [],
"DedicatedHostIds": []
},
"State": "creating"
}
}
```
Para restrições da janela de eventos, consulte [Considerações](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) na seção Eventos Programados do *Guia do usuário do Amazon EC2*.
**Exemplo 2: desassociar tags de instância de uma janela de eventos**
O exemplo `disassociate-instance-event-window` a seguir desassocia tags de instância de uma janela de eventos. Especifique o parâmetro `instance-event-window-id` para especificar a janela do evento. Para desassociar tags de instância, especifique o`association-target`e para os valores de parâmetro, especifique uma ou mais tags.
```
aws ec2 disassociate-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890 \
--association-target "InstanceTags=[{Key=k2,Value=v2},{Key=k1,Value=v1}]"
```
Saída:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"AssociationTarget": {
"InstanceIds": [],
"Tags": [],
"DedicatedHostIds": []
},
"State": "creating"
}
}
```
Para restrições da janela de eventos, consulte [Considerações](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) na seção Eventos Programados do *Guia do usuário do Amazon EC2*.
**Exemplo 3: desassociar um host dedicado de uma janela de eventos**
O exemplo `disassociate-instance-event-window` a seguir desassocia um Host Dedicado de uma janela de eventos. Especifique o parâmetro `instance-event-window-id` para especificar a janela do evento. Para desassociar um Host Dedicado, especifique o `association-target` parâmetro e, para os valores dos parâmetros, especifique um ou mais Host IDs Dedicado.
```
aws ec2 disassociate-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890 \
--association-target DedicatedHostIds=h-029fa35a02b99801d
```
Saída:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"AssociationTarget": {
"InstanceIds": [],
"Tags": [],
"DedicatedHostIds": []
},
"State": "creating"
}
}
```
Para restrições da janela de eventos, consulte [Considerações](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) na seção Eventos Programados do *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [DisassociateInstanceEventWindow](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-instance-event-window.html)em *Referência de AWS CLI Comandos*.
### `disassociate-ipam-resource-discovery`
O código de exemplo a seguir mostra como usar `disassociate-ipam-resource-discovery`.
**AWS CLI**
**Desassociar uma descoberta de recursos de um IPAM**
Neste exemplo, você é uma conta de administrador delegado do IPAM e deseja desassociar uma descoberta de recursos do IPAM do seu IPAM. Você executou o comando de descrição e percebeu o `"ResourceDiscoveryStatus": "not-found"`, que você deseja desassociar do seu IPAM para abrir espaço para outras associações.
O `disassociate-ipam-resource-discovery` exemplo a seguir desassocia uma descoberta de recursos IPAM em sua conta. AWS
```
aws ec2 disassociate-ipam-resource-discovery \
--ipam-resource-discovery-association-id ipam-res-disco-assoc-04382a6346357cf82 \
--region us-east-1
```
Saída:
```
{
"IpamResourceDiscoveryAssociation": {
"OwnerId": "320805250157",
"IpamResourceDiscoveryAssociationId": "ipam-res-disco-assoc-04382a6346357cf82",
"IpamResourceDiscoveryAssociationArn": "arn:aws:ec2::320805250157:ipam-resource-discovery-association/ipam-res-disco-assoc-04382a6346357cf82",
"IpamResourceDiscoveryId": "ipam-res-disco-0365d2977fc1672fe",
"IpamId": "ipam-005f921c17ebd5107",
"IpamArn": "arn:aws:ec2::320805250157:ipam/ipam-005f921c17ebd5107",
"IpamRegion": "us-east-1",
"IsDefault": false,
"ResourceDiscoveryStatus": "not-found",
"State": "disassociate-in-progress"
}
}
```
Para obter mais informações, consulte [Integrar o IPAM com contas fora da sua organização](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam-outside-org.html) no *Guia do usuário do IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [DisassociateIpamResourceDiscovery](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-ipam-resource-discovery.html)em *Referência de AWS CLI Comandos*.
### `disassociate-nat-gateway-address`
O código de exemplo a seguir mostra como usar `disassociate-nat-gateway-address`.
**AWS CLI**
**Desassociar um endereço IP elástico a um gateway NAT público**
O exemplo `disassociate-nat-gateway-address` a seguir desassocia o endereço IP elástico especificado do gateway NAT público especificado.
```
aws ec2 disassociate-nat-gateway-address \
--nat-gateway-id nat-1234567890abcdef0 \
--association-ids eipassoc-0f96bdca17EXAMPLE
```
Saída:
```
{
"NatGatewayId": "nat-1234567890abcdef0",
"NatGatewayAddresses": [
{
"AllocationId": "eipalloc-0be6ecac95EXAMPLE",
"NetworkInterfaceId": "eni-09cc4b2558794f7f9",
"PrivateIp": "10.0.0.74",
"PublicIp": "3.211.231.218",
"AssociationId": "eipassoc-0f96bdca17EXAMPLE",
"IsPrimary": false,
"Status": "disassociating"
}
]
}
```
Para obter mais informações, consulte [Gateways NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [DisassociateNatGatewayAddress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-nat-gateway-address.html)em *Referência de AWS CLI Comandos*.
### `disassociate-route-table`
O código de exemplo a seguir mostra como usar `disassociate-route-table`.
**AWS CLI**
**Desassociar uma tabela de rotas**
Este exemplo dissocia a tabela de rotas especificada da sub-rede especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 disassociate-route-table --association-id rtbassoc-781d0d1a
```
+ Para obter detalhes da API, consulte [DisassociateRouteTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-route-table.html)em *Referência de AWS CLI Comandos*.
### `disassociate-security-group-vpc`
O código de exemplo a seguir mostra como usar `disassociate-security-group-vpc`.
**AWS CLI**
**Como desassociar um grupo de segurança de uma VPC**
O exemplo de `disassociate-security-group-vpc` a seguir desassocia o grupo de segurança especificado da VPC especificada.
```
aws ec2 disassociate-security-group-vpc \
--group-id sg-04dbb43907d3f8a78 \
--vpc-id vpc-0bf4c2739bc05a694
```
Saída:
```
{
"State": "disassociating"
}
```
Para obter mais informações, consulte [Associar grupos de segurança a vários VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-assoc.html) no Guia do *usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [DisassociateSecurityGroupVpc](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-security-group-vpc.html)em *Referência de AWS CLI Comandos*.
### `disassociate-subnet-cidr-block`
O código de exemplo a seguir mostra como usar `disassociate-subnet-cidr-block`.
**AWS CLI**
**Para desassociar um bloco IPv6 CIDR de uma sub-rede**
Este exemplo dissocia um bloco IPv6 CIDR de uma sub-rede usando o ID de associação do bloco CIDR.
Comando:
```
aws ec2 disassociate-subnet-cidr-block --association-id subnet-cidr-assoc-3aa54053
```
Saída:
```
{
"SubnetId": "subnet-5f46ec3b",
"Ipv6CidrBlockAssociation": {
"Ipv6CidrBlock": "2001:db8:1234:1a00::/64",
"AssociationId": "subnet-cidr-assoc-3aa54053",
"Ipv6CidrBlockState": {
"State": "disassociating"
}
}
}
```
+ Para obter detalhes da API, consulte [DisassociateSubnetCidrBlock](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-subnet-cidr-block.html)em *Referência de AWS CLI Comandos*.
### `disassociate-transit-gateway-multicast-domain`
O código de exemplo a seguir mostra como usar `disassociate-transit-gateway-multicast-domain`.
**AWS CLI**
**Desassociar sub-redes de um domínio multicast**
O exemplo `disassociate-transit-gateway-multicast-domain` a seguir desassocia uma sub-rede do domínio multicast especificado.
```
aws ec2 disassociate-transit-gateway-multicast-domain \
--transit-gateway-attachment-id tgw-attach-070e571cd1EXAMPLE \
--subnet-id subnet-000de86e3bEXAMPLE \
--transit-gateway-multicast-domain-id tgw-mcast-domain-0c4905cef7EXAMPLE
```
Saída:
```
{
"Associations": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-0c4905cef7EXAMPLE",
"TransitGatewayAttachmentId": "tgw-attach-070e571cd1EXAMPLE",
"ResourceId": "vpc-7EXAMPLE",
"ResourceType": "vpc",
"Subnets": [
{
"SubnetId": "subnet-000de86e3bEXAMPLE",
"State": "disassociating"
}
]
}
}
```
Consulte mais informações em [Multicast domains](https://docs.aws.amazon.com/vpc/latest/tgw/multicast-domains-about.html) no *Guia do Transit Gateway*.
+ Para obter detalhes da API, consulte [DisassociateTransitGatewayMulticastDomain](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-transit-gateway-multicast-domain.html)em *Referência de AWS CLI Comandos*.
### `disassociate-transit-gateway-route-table`
O código de exemplo a seguir mostra como usar `disassociate-transit-gateway-route-table`.
**AWS CLI**
**Desassociar uma tabela de rotas do gateway de trânsito de um anexo de recursos**
O exemplo `disassociate-transit-gateway-route-table` a seguir desassocia o anexo especificado da tabela de rotas de gateway de trânsito.
```
aws ec2 disassociate-transit-gateway-route-table \
--transit-gateway-route-table-id tgw-rtb-002573ed1eEXAMPLE \
--transit-gateway-attachment-id tgw-attach-08e0bc912cEXAMPLE
```
Saída:
```
{
"Association": {
"TransitGatewayRouteTableId": "tgw-rtb-002573ed1eEXAMPLE",
"TransitGatewayAttachmentId": "tgw-attach-08e0bc912cEXAMPLE",
"ResourceId": "11460968-4ac1-4fd3-bdb2-00599EXAMPLE",
"ResourceType": "direct-connect-gateway",
"State": "disassociating"
}
}
```
Para obter mais informações, consulte [Tabelas de rota do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [DisassociateTransitGatewayRouteTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-transit-gateway-route-table.html)em *Referência de AWS CLI Comandos*.
### `disassociate-vpc-cidr-block`
O código de exemplo a seguir mostra como usar `disassociate-vpc-cidr-block`.
**AWS CLI**
**Para desassociar um bloco IPv6 CIDR de uma VPC**
Este exemplo dissocia um bloco IPv6 CIDR de uma VPC usando o ID de associação do bloco CIDR.
Comando:
```
aws ec2 disassociate-vpc-cidr-block --association-id vpc-cidr-assoc-eca54085
```
Saída:
```
{
"Ipv6CidrBlockAssociation": {
"Ipv6CidrBlock": "2001:db8:1234:1a00::/56",
"AssociationId": "vpc-cidr-assoc-eca54085",
"Ipv6CidrBlockState": {
"State": "disassociating"
}
},
"VpcId": "vpc-a034d6c4"
}
```
**Para desassociar um bloco IPv4 CIDR de uma VPC**
Este exemplo dissocia um bloco IPv4 CIDR de uma VPC.
Comando:
```
aws ec2 disassociate-vpc-cidr-block --association-id vpc-cidr-assoc-0287ac6b
```
Saída:
```
{
"CidrBlockAssociation": {
"AssociationId": "vpc-cidr-assoc-0287ac6b",
"CidrBlock": "172.18.0.0/16",
"CidrBlockState": {
"State": "disassociating"
}
},
"VpcId": "vpc-27621243"
}
```
+ Para obter detalhes da API, consulte [DisassociateVpcCidrBlock](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-vpc-cidr-block.html)em *Referência de AWS CLI Comandos*.
### `enable-address-transfer`
O código de exemplo a seguir mostra como usar `enable-address-transfer`.
**AWS CLI**
**Habilitar a transferência de endereços IP elásticos**
O exemplo `enable-address-transfer` a seguir permite a transferência do endereço IP elástico do endereço IP elástico especificado para a conta especificada.
```
aws ec2 enable-address-transfer \
--allocation-id eipalloc-09ad461b0d03f6aaf \
--transfer-account-id 123456789012
```
Saída:
```
{
"AddressTransfer": {
"PublicIp": "100.21.184.216",
"AllocationId": "eipalloc-09ad461b0d03f6aaf",
"TransferAccountId": "123456789012",
"TransferOfferExpirationTimestamp": "2023-02-22T20:51:01.000Z",
"AddressTransferStatus": "pending"
}
}
```
Para obter mais informações, consulte [Transferir endereços IP elásticos](https://docs.aws.amazon.com/vpc/latest/userguide/WorkWithEIPs.html#transfer-EIPs-intro) no *Guia do usuário do Amazon VPC*.
+ Para obter detalhes da API, consulte [EnableAddressTransfer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-address-transfer.html)em *Referência de AWS CLI Comandos*.
### `enable-aws-network-performance-metric-subscription`
O código de exemplo a seguir mostra como usar `enable-aws-network-performance-metric-subscription`.
**AWS CLI**
**Habilitar uma assinatura métrica**
O exemplo `enable-aws-network-performance-metric-subscription` a seguir permite o monitoramento da latência agregada da rede entre as regiões de origem e destino especificadas.
```
aws ec2 enable-aws-network-performance-metric-subscription \
--source us-east-1 \
--destination eu-west-1 \
--metric aggregate-latency \
--statistic p50
```
Saída:
```
{
"Output": true
}
```
Para obter mais informações, consulte [Gerenciar assinaturas](https://docs.aws.amazon.com/network-manager/latest/infrastructure-performance/nmip-subscriptions-cw.html) no *Guia do usuário de desempenho da infraestrutura*.
+ Para obter detalhes da API, consulte [EnableAwsNetworkPerformanceMetricSubscription](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-aws-network-performance-metric-subscription.html)em *Referência de AWS CLI Comandos*.
### `enable-ebs-encryption-by-default`
O código de exemplo a seguir mostra como usar `enable-ebs-encryption-by-default`.
**AWS CLI**
**Habilitar a criptografia do EBS por padrão**
O `enable-ebs-encryption-by-default` exemplo a seguir ativa a criptografia do EBS por padrão para sua AWS conta na região atual.
```
aws ec2 enable-ebs-encryption-by-default
```
Saída:
```
{
"EbsEncryptionByDefault": true
}
```
+ Para obter detalhes da API, consulte [EnableEbsEncryptionByDefault](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-ebs-encryption-by-default.html)em *Referência de AWS CLI Comandos*.
### `enable-fast-launch`
O código de exemplo a seguir mostra como usar `enable-fast-launch`.
**AWS CLI**
**Iniciar o lançamento rápido de uma imagem**
O exemplo de `enable-fast-launch` a seguir configura a AMI especificada para Fast Launch e define o número máximo de instâncias paralelas a serem iniciadas como 6. O tipo de recurso a ser usado para pré-provisionar a AMI está definido como `snapshot`, que também é o valor padrão.
```
aws ec2 enable-fast-launch \
--image-id ami-01234567890abcedf \
--max-parallel-launches 6 \
--resource-type snapshot
```
Saída:
```
{
"ImageId": "ami-01234567890abcedf",
"ResourceType": "snapshot",
"SnapshotConfiguration": {
"TargetResourceCount": 10
},
"LaunchTemplate": {},
"MaxParallelLaunches": 6,
"OwnerId": "0123456789123",
"State": "enabling",
"StateTransitionReason": "Client.UserInitiated",
"StateTransitionTime": "2022-01-27T22:16:03.199000+00:00"
}
```
Consulte mais informações em [Configurar o EC2 Fast Launch para a AMI do Windows](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/win-fast-launch-configure.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [EnableFastLaunch](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-fast-launch.html)em *Referência de AWS CLI Comandos*.
### `enable-fast-snapshot-restores`
O código de exemplo a seguir mostra como usar `enable-fast-snapshot-restores`.
**AWS CLI**
**Habilitar a restauração rápida de snapshot**
O exemplo `enable-fast-snapshot-restores` a seguir habilita restaurações rápidas de snapshot para os snapshots especificados nas Zonas de Disponibilidade especificadas.
```
aws ec2 enable-fast-snapshot-restores \
--availability-zones us-east-2a us-east-2b \
--source-snapshot-ids snap-1234567890abcdef0
```
Saída:
```
{
"Successful": [
{
"SnapshotId": "snap-1234567890abcdef0"
"AvailabilityZone": "us-east-2a",
"State": "enabling",
"StateTransitionReason": "Client.UserInitiated",
"OwnerId": "123456789012",
"EnablingTime": "2020-01-25T23:57:49.602Z"
},
{
"SnapshotId": "snap-1234567890abcdef0"
"AvailabilityZone": "us-east-2b",
"State": "enabling",
"StateTransitionReason": "Client.UserInitiated",
"OwnerId": "123456789012",
"EnablingTime": "2020-01-25T23:57:49.596Z"
}
],
"Unsuccessful": []
}
```
+ Para obter detalhes da API, consulte [EnableFastSnapshotRestores](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-fast-snapshot-restores.html)em *Referência de AWS CLI Comandos*.
### `enable-image-block-public-access`
O código de exemplo a seguir mostra como usar `enable-image-block-public-access`.
**AWS CLI**
**Para habilitar o bloqueio do acesso público AMIs na região especificada**
O `enable-image-block-public-access` exemplo a seguir permite bloquear o acesso público AMIs no nível da conta na região especificada.
```
aws ec2 enable-image-block-public-access \
--region us-east-1 \
--image-block-public-access-state block-new-sharing
```
Saída:
```
{
"ImageBlockPublicAccessState": "block-new-sharing"
}
```
Para obter mais informações, consulte [Bloquear o acesso público ao seu AMIs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sharingamis-intro.html#block-public-access-to-amis) no Guia do *usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [EnableImageBlockPublicAccess](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-image-block-public-access.html)em *Referência de AWS CLI Comandos*.
### `enable-image-deprecation`
O código de exemplo a seguir mostra como usar `enable-image-deprecation`.
**AWS CLI**
**Como descontinuar uma AMI**
O exemplo `enable-image-deprecation` a seguir descontinua uma AMI em uma data e hora específicas. Se você especificar um valor para segundos, o Amazon EC2 arredondará os segundos para o minuto mais próximo. É necessário ser o proprietário da AMI para executar esse procedimento.
```
aws ec2 enable-image-deprecation \
--image-id ami-1234567890abcdef0 \
--deprecate-at '2022-10-15T13:17:12.000Z'
```
Saída:
```
{
"RequestID": "59dbff89-35bd-4eac-99ed-be587EXAMPLE",
"Return": "true"
}
```
Consulte mais informações em [Descontinuar uma AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deprecate.html#deprecate-ami) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [EnableImageDeprecation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-image-deprecation.html)em *Referência de AWS CLI Comandos*.
### `enable-image-deregistration-protection`
O código de exemplo a seguir mostra como usar `enable-image-deregistration-protection`.
**AWS CLI**
**Como habilitar a proteção contra cancelamento de registro**
O exemplo de `enable-image-deregistration-protection` a seguir habilita a proteção contra cancelamento de registro para a imagem especificada.
```
aws ec2 enable-image-deregistration-protection \
--image-id ami-0b1a928a144a74ec9
```
Saída:
```
{
"Return": "enabled-without-cooldown"
}
```
Consulte mais informações em [Proteger uma AMI do Amazon EC2 de cancelamento de registro](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deregistration-protection.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [EnableImageDeregistrationProtection](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-image-deregistration-protection.html)em *Referência de AWS CLI Comandos*.
### `enable-image`
O código de exemplo a seguir mostra como usar `enable-image`.
**AWS CLI**
**Habilitar uma AMI**
O exemplo `enable-image` a seguir habilita a AMI especificada.
```
aws ec2 enable-image \
--image-id ami-1234567890abcdef0
```
Saída:
```
{
"Return": "true"
}
```
Para obter mais informações, consulte [Desativar uma AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/disable-an-ami.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [EnableImage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-image.html)em *Referência de AWS CLI Comandos*.
### `enable-ipam-organization-admin-account`
O código de exemplo a seguir mostra como usar `enable-ipam-organization-admin-account`.
**AWS CLI**
**Para integrar-se com AWS Organizations e delegar uma conta de membro como conta IPAM**
O `enable-ipam-organization-admin-account` exemplo a seguir integra o IPAM com AWS Organizations e delega uma conta de membro como a conta IPAM.
```
aws ec2 enable-ipam-organization-admin-account \
--delegated-admin-account-id 320805250157
```
Saída:
```
{
"Success": true
}
```
Para obter mais informações, consulte [Integrate IPAM with AWS Organizations](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam.html) no Guia do usuário *IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [EnableIpamOrganizationAdminAccount](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-ipam-organization-admin-account.html)em *Referência de AWS CLI Comandos*.
### `enable-reachability-analyzer-organization-sharing`
O código de exemplo a seguir mostra como usar `enable-reachability-analyzer-organization-sharing`.
**AWS CLI**
**Habilitar o acesso confiável com o Reachability Analyzer**
O exemplo `enable-reachability-analyzer-organization-sharing` a seguir permite acesso confiável ao Reachability Analyzer.
```
aws ec2 enable-reachability-analyzer-organization-sharing
```
Este comando não produz saída.
Para obter mais informações, consulte [Análise entre contas](https://docs.aws.amazon.com/vpc/latest/reachability/multi-account.html) no *Guia do usuário do Reachability Analyzer*.
+ Para obter detalhes da API, consulte [EnableReachabilityAnalyzerOrganizationSharing](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-reachability-analyzer-organization-sharing.html)em *Referência de AWS CLI Comandos*.
### `enable-serial-console-access`
O código de exemplo a seguir mostra como usar `enable-serial-console-access`.
**AWS CLI**
**Habilitar o acesso ao console de série para sua conta**
O exemplo `enable-serial-console-access` a seguir habilita o acesso da conta ao console de série.
```
aws ec2 enable-serial-console-access
```
Saída:
```
{
"SerialConsoleAccessEnabled": true
}
```
Para obter mais informações, consulte [Console de Série do EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-serial-console.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [EnableSerialConsoleAccess](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-serial-console-access.html)em *Referência de AWS CLI Comandos*.
### `enable-snapshot-block-public-access`
O código de exemplo a seguir mostra como usar `enable-snapshot-block-public-access`.
**AWS CLI**
**Habilitar o bloqueio do acesso público aos snapshots**
O exemplo `enable-snapshot-block-public-access` a seguir bloqueia todos os compartilhamentos públicos dos snapshots.
```
aws ec2 enable-snapshot-block-public-access \
--state block-all-sharing
```
Saída:
```
{
"State": "block-all-sharing"
}
```
Para obter mais informações, consulte [Bloquear acesso público aos snapshots](https://docs.aws.amazon.com/ebs/latest/userguide/block-public-access-snapshots.html) no *Guia do usuário do Amazon EBS*.
+ Para obter detalhes da API, consulte [EnableSnapshotBlockPublicAccess](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-snapshot-block-public-access.html)em *Referência de AWS CLI Comandos*.
### `enable-transit-gateway-route-table-propagation`
O código de exemplo a seguir mostra como usar `enable-transit-gateway-route-table-propagation`.
**AWS CLI**
**Habilitar um anexo do gateway de trânsito para propagar rotas para a tabela de rotas de propagação especificada**
O exemplo `enable-transit-gateway-route-table-propagation` a seguir habilita o anexo especificado para propagar rotas para a tabela de rota de propagação especificada.
```
aws ec2 enable-transit-gateway-route-table-propagation \
--transit-gateway-route-table-id tgw-rtb-0a823edbdeEXAMPLE \
--transit-gateway-attachment-id tgw-attach-09b52ccdb5EXAMPLE
```
Saída:
```
{
"Propagation": {
"TransitGatewayAttachmentId": "tgw-attach-09b52ccdb5EXAMPLE",
"ResourceId": "vpc-4d7de228",
"ResourceType": "vpc",
"TransitGatewayRouteTableId": "tgw-rtb-0a823edbdeEXAMPLE",
"State": "disabled"
}
}
```
Para obter mais informações, consulte [Tabelas de rota do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [EnableTransitGatewayRouteTablePropagation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-transit-gateway-route-table-propagation.html)em *Referência de AWS CLI Comandos*.
### `enable-vgw-route-propagation`
O código de exemplo a seguir mostra como usar `enable-vgw-route-propagation`.
**AWS CLI**
**Habilitar a propagação de rotas**
Esse exemplo habilita o gateway privado virtual especificado para propagar rotas estáticas para a tabela de rotas especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 enable-vgw-route-propagation --route-table-id rtb-22574640 --gateway-id vgw-9a4cacf3
```
+ Para obter detalhes da API, consulte [EnableVgwRoutePropagation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-vgw-route-propagation.html)em *Referência de AWS CLI Comandos*.
### `enable-volume-io`
O código de exemplo a seguir mostra como usar `enable-volume-io`.
**AWS CLI**
** I/O Para habilitar um volume**
Este exemplo ativa I/O o volume`vol-1234567890abcdef0`.
Comando:
```
aws ec2 enable-volume-io --volume-id vol-1234567890abcdef0
```
Saída:
```
{
"Return": true
}
```
+ Para obter detalhes da API, consulte [EnableVolumeIo](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-volume-io.html)em *Referência de AWS CLI Comandos*.
### `enable-vpc-classic-link-dns-support`
O código de exemplo a seguir mostra como usar `enable-vpc-classic-link-dns-support`.
**AWS CLI**
**Para habilitar o suporte de ClassicLink DNS para uma VPC**
Este exemplo habilita o suporte de ClassicLink DNS para`vpc-88888888`.
Comando:
```
aws ec2 enable-vpc-classic-link-dns-support --vpc-id vpc-88888888
```
Saída:
```
{
"Return": true
}
```
+ Para obter detalhes da API, consulte [EnableVpcClassicLinkDnsSupport](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-vpc-classic-link-dns-support.html)em *Referência de AWS CLI Comandos*.
### `enable-vpc-classic-link`
O código de exemplo a seguir mostra como usar `enable-vpc-classic-link`.
**AWS CLI**
**Para habilitar uma VPC para ClassicLink**
Este exemplo habilita o vpc-8888888 para. ClassicLink
Comando:
```
aws ec2 enable-vpc-classic-link --vpc-id vpc-88888888
```
Saída:
```
{
"Return": true
}
```
+ Para obter detalhes da API, consulte [EnableVpcClassicLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-vpc-classic-link.html)em *Referência de AWS CLI Comandos*.
### `export-client-vpn-client-certificate-revocation-list`
O código de exemplo a seguir mostra como usar `export-client-vpn-client-certificate-revocation-list`.
**AWS CLI**
**Exportar uma lista de revogação de certificados de cliente**
O exemplo `export-client-vpn-client-certificate-revocation-list` a seguir exporta a lista de revogação de certificados de cliente para o endpoint especificado do Client VPN. Neste exemplo, a saída é retornada em formato de texto para facilitar a leitura.
```
aws ec2 export-client-vpn-client-certificate-revocation-list \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde \
--output text
```
Saída:
```
-----BEGIN X509 CRL-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w0BAQUFADCBiDELMAkGA1UEBhMC
VVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6
b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAd
BgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wHhcNMTEwNDI1MjA0NTIxWhcN
MTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYD
VQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25z
b2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFt
YXpvbi5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ
21uUSfwfEvySWtC2XADZ4nB+BLYgVIk60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9T
rDHudUZg3qX4waLG5M43q7Wgc/MbQITxOUSQv7c7ugFFDzQGBzZswY6786m86gpE
Ibb3OhjZnzcvQAaRHhdlQWIMm2nrAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4
nUhVVxYUntneD9+h8Mg9q6q+auNKyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0Fkb
FFBjvSfpJIlJ00zbhNYS5f6GuoEDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTb
NYiytVbZPQUQ5Yaxu2jXnimvw3rrszlaEXAMPLE=
-----END X509 CRL-----
STATUS pending
```
Para obter mais informações, consulte [Listas de revogação de certificados de cliente](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-certificates.html) no *Guia do administrador do AWS Client VPN*.
+ Para obter detalhes da API, consulte [ExportClientVpnClientCertificateRevocationList](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/export-client-vpn-client-certificate-revocation-list.html)em *Referência de AWS CLI Comandos*.
### `export-client-vpn-client-configuration`
O código de exemplo a seguir mostra como usar `export-client-vpn-client-configuration`.
**AWS CLI**
**Exportar a configuração do cliente**
O exemplo `export-client-vpn-client-configuration` a seguir exporta a configuração do cliente para o endpoint de Client VPN especificado. Neste exemplo, a saída é retornada em formato de texto para facilitar a leitura.
```
aws ec2 export-client-vpn-client-configuration \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde \
--output text
```
Saída:
```
client
dev tun
proto udp
remote cvpn-endpoint-123456789123abcde.prod.clientvpn.ap-south-1.amazonaws.com 443
remote-random-hostname
resolv-retry infinite
nobind
persist-key
persist-tun
remote-cert-tls server
cipher AES-256-GCM
verb 3
-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w0BAQUFADCBiDELMAkGA1UEBhMC
VVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6
b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAd
BgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wHhcNMTEwNDI1MjA0NTIxWhcN
MTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYD
VQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25z
b2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFt
YXpvbi5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ
21uUSfwfEvySWtC2XADZ4nB+BLYgVIk60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9T
rDHudUZg3qX4waLG5M43q7Wgc/MbQITxOUSQv7c7ugFFDzQGBzZswY6786m86gpE
Ibb3OhjZnzcvQAaRHhdlQWIMm2nrAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4
nUhVVxYUntneD9+h8Mg9q6q+auNKyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0Fkb
FFBjvSfpJIlJ00zbhNYS5f6GuoEDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTb
NYiytVbZPQUQ5Yaxu2jXnimvw3rrszlaEXAMPLE=
-----END CERTIFICATE-----
reneg-sec 0
```
Consulte mais informações em [Client VPN endpoint configuration file export](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-endpoint-export.html) no *Guia do administrador do AWS Client VPN*.
+ Para obter detalhes da API, consulte [ExportClientVpnClientConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/export-client-vpn-client-configuration.html)em *Referência de AWS CLI Comandos*.
### `export-image`
O código de exemplo a seguir mostra como usar `export-image`.
**AWS CLI**
**Exportar uma VM de uma AMI**
O exemplo `export-image` a seguir exporta a AMI especificada para o bucket especificado no formato especificado.
```
aws ec2 export-image \
--image-id ami-1234567890abcdef0 \
--disk-image-format VMDK \
--s3-export-location S3Bucket=my-export-bucket,S3Prefix=exports/
```
Saída:
```
{
"DiskImageFormat": "vmdk",
"ExportImageTaskId": "export-ami-1234567890abcdef0"
"ImageId": "ami-1234567890abcdef0",
"RoleName": "vmimport",
"Progress": "0",
"S3ExportLocation": {
"S3Bucket": "my-export-bucket",
"S3Prefix": "exports/"
},
"Status": "active",
"StatusMessage": "validating"
}
```
+ Para obter detalhes da API, consulte [ExportImage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/export-image.html)em *Referência de AWS CLI Comandos*.
### `get-associated-ipv6-pool-cidrs`
O código de exemplo a seguir mostra como usar `get-associated-ipv6-pool-cidrs`.
**AWS CLI**
**Para obter as associações para um pool IPv6 de endereços**
O `get-associated-ipv6-pool-cidrs` exemplo a seguir obtém as associações para o pool IPv6 de endereços especificado.
```
aws ec2 get-associated-ipv6-pool-cidrs \
--pool-id ipv6pool-ec2-012345abc12345abc
```
Saída:
```
{
"Ipv6CidrAssociations": [
{
"Ipv6Cidr": "2001:db8:1234:1a00::/56",
"AssociatedResource": "vpc-111111222222333ab"
}
]
}
```
+ Para obter detalhes da API, consulte [GetAssociatedIpv6 PoolCidrs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-associated-ipv6-pool-cidrs.html) em *Referência de AWS CLI comandos*.
### `get-aws-network-performance-data`
O código de exemplo a seguir mostra como usar `get-aws-network-performance-data`.
**AWS CLI**
**Obter dados de desempenho da rede**
O exemplo `get-aws-network-performance-data` a seguir recupera dados sobre o desempenho da rede entre as regiões especificadas no período de tempo especificado.
```
aws ec2 get-aws-network-performance-data \
--start-time 2022-10-26T12:00:00.000Z \
--end-time 2022-10-26T12:30:00.000Z \
--data-queries Id=my-query,Source=us-east-1,Destination=eu-west-1,Metric=aggregate-latency,Statistic=p50,Period=five-minutes
```
Saída:
```
{
"DataResponses": [
{
"Id": "my-query",
"Source": "us-east-1",
"Destination": "eu-west-1",
"Metric": "aggregate-latency",
"Statistic": "p50",
"Period": "five-minutes",
"MetricPoints": [
{
"StartDate": "2022-10-26T12:00:00+00:00",
"EndDate": "2022-10-26T12:05:00+00:00",
"Value": 62.44349,
"Status": "OK"
},
{
"StartDate": "2022-10-26T12:05:00+00:00",
"EndDate": "2022-10-26T12:10:00+00:00",
"Value": 62.483498,
"Status": "OK"
},
{
"StartDate": "2022-10-26T12:10:00+00:00",
"EndDate": "2022-10-26T12:15:00+00:00",
"Value": 62.51248,
"Status": "OK"
},
{
"StartDate": "2022-10-26T12:15:00+00:00",
"EndDate": "2022-10-26T12:20:00+00:00",
"Value": 62.635475,
"Status": "OK"
},
{
"StartDate": "2022-10-26T12:20:00+00:00",
"EndDate": "2022-10-26T12:25:00+00:00",
"Value": 62.733974,
"Status": "OK"
},
{
"StartDate": "2022-10-26T12:25:00+00:00",
"EndDate": "2022-10-26T12:30:00+00:00",
"Value": 62.773975,
"Status": "OK"
},
{
"StartDate": "2022-10-26T12:30:00+00:00",
"EndDate": "2022-10-26T12:35:00+00:00",
"Value": 62.75349,
"Status": "OK"
}
]
}
]
}
```
Para obter mais informações, consulte [Monitorar o desempenho da rede](https://docs.aws.amazon.com/network-manager/latest/infrastructure-performance/nmip-performance-cli.html) no *Guia do usuário de desempenho da infraestrutura*.
+ Para obter detalhes da API, consulte [GetAwsNetworkPerformanceData](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-aws-network-performance-data.html)em *Referência de AWS CLI Comandos*.
### `get-capacity-reservation-usage`
O código de exemplo a seguir mostra como usar `get-capacity-reservation-usage`.
**AWS CLI**
**Para ver o uso da reserva de capacidade em todas AWS as contas**
O exemplo `get-capacity-reservation-usage` a seguir exibe informações de uso para a reserva de capacidade especificada.
```
aws ec2 get-capacity-reservation-usage \
--capacity-reservation-id cr-1234abcd56EXAMPLE
```
Saída:
```
{
"CapacityReservationId": "cr-1234abcd56EXAMPLE ",
"InstanceUsages": [
{
"UsedInstanceCount": 1,
"AccountId": "123456789012"
}
],
"AvailableInstanceCount": 4,
"TotalInstanceCount": 5,
"State": "active",
"InstanceType": "t2.medium"
}
```
Consulte mais informações em [Reservas de capacidade compartilhadas](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservation-sharing.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [GetCapacityReservationUsage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-capacity-reservation-usage.html)em *Referência de AWS CLI Comandos*.
### `get-coip-pool-usage`
O código de exemplo a seguir mostra como usar `get-coip-pool-usage`.
**AWS CLI**
**Obter o uso do grupo de endereços IP pertencentes ao cliente**
O exemplo `get-coip-pool-usage` a seguir obtém os detalhes de uso do grupo especificado de endereços IP pertencentes ao cliente.
```
aws ec2 get-coip-pool-usage \
--pool-id ipv4pool-coip-123a45678bEXAMPLE
```
Saída:
```
{
"CoipPoolId": "ipv4pool-coip-123a45678bEXAMPLE",
"CoipAddressUsages": [
{
"CoIp": "0.0.0.0"
},
{
"AllocationId": "eipalloc-123ab45c6dEXAMPLE",
"AwsAccountId": "123456789012",
"CoIp": "0.0.0.0"
},
{
"AllocationId": "eipalloc-123ab45c6dEXAMPLE",
"AwsAccountId": "123456789111",
"CoIp": "0.0.0.0"
}
],
"LocalGatewayRouteTableId": "lgw-rtb-059615ef7dEXAMPLE"
}
```
Consulte mais informações em [Customer-owned IP addresses](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#ip-addressing) no *Guia do usuário do AWS Outposts para racks do Outposts*.
+ Para obter detalhes da API, consulte [GetCoipPoolUsage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-coip-pool-usage.html)em *Referência de AWS CLI Comandos*.
### `get-console-output`
O código de exemplo a seguir mostra como usar `get-console-output`.
**AWS CLI**
**Exemplo 1: obter a saída do console**
O exemplo `get-console-output` a seguir obtém a saída do console para a instância Linux especificada.
```
aws ec2 get-console-output \
--instance-id i-1234567890abcdef0
```
Saída:
```
{
"InstanceId": "i-1234567890abcdef0",
"Timestamp": "2013-07-25T21:23:53.000Z",
"Output": "..."
}
```
Para obter mais informações, consulte [Saída de console da instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-console.html#instance-console-console-output) no *Guia do usuário Amazon EC2*.
**Exemplo 2: obter a saída mais recente do console**
O exemplo `get-console-output` a seguir obtém a saída mais recente do console para a instância Linux especificada.
```
aws ec2 get-console-output \
--instance-id i-1234567890abcdef0 \
--latest \
--output text
```
Saída:
```
i-1234567890abcdef0 [ 0.000000] Command line: root=LABEL=/ console=tty1 console=ttyS0 selinux=0 nvme_core.io_timeout=4294967295
[ 0.000000] x86/fpu: Supporting XSAVE feature 0x001: 'x87 floating point registers'
[ 0.000000] x86/fpu: Supporting XSAVE feature 0x002: 'SSE registers'
[ 0.000000] x86/fpu: Supporting XSAVE feature 0x004: 'AVX registers'
...
Cloud-init v. 0.7.6 finished at Wed, 09 May 2018 19:01:13 +0000. Datasource DataSourceEc2. Up 21.50 seconds
Amazon Linux AMI release 2018.03
Kernel 4.14.26-46.32.amzn1.x
```
Para obter mais informações, consulte [Saída de console da instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-console.html#instance-console-console-output) no *Guia do usuário Amazon EC2*.
+ Para obter detalhes da API, consulte [GetConsoleOutput](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-console-output.html)em *Referência de AWS CLI Comandos*.
### `get-console-screenshot`
O código de exemplo a seguir mostra como usar `get-console-screenshot`.
**AWS CLI**
**Recuperar uma captura de tela de uma instância em execução**
O exemplo `get-console-screenshot` a seguir recupera uma captura de tela da instância especificada no formato .jpg. A captura de tela é retornada como uma string codificada em Base64.
```
aws ec2 get-console-screenshot \
--instance-id i-1234567890abcdef0
```
Saída:
```
{
"ImageData": "997987/8kgj49ikjhewkwwe0008084EXAMPLE",
"InstanceId": "i-1234567890abcdef0"
}
```
+ Para obter detalhes da API, consulte [GetConsoleScreenshot](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-console-screenshot.html)em *Referência de AWS CLI Comandos*.
### `get-default-credit-specification`
O código de exemplo a seguir mostra como usar `get-default-credit-specification`.
**AWS CLI**
**Descrever a opção de crédito padrão**
O exemplo `get-default-credit-specification` a seguir descreve a opção de crédito padrão para instâncias T2.
```
aws ec2 get-default-credit-specification \
--instance-family t2
```
Saída:
```
{
"InstanceFamilyCreditSpecification": {
"InstanceFamily": "t2",
"CpuCredits": "standard"
}
}
```
+ Para obter detalhes da API, consulte [GetDefaultCreditSpecification](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-default-credit-specification.html)em *Referência de AWS CLI Comandos*.
### `get-ebs-default-kms-key-id`
O código de exemplo a seguir mostra como usar `get-ebs-default-kms-key-id`.
**AWS CLI**
**Descrever sua CMK padrão para criptografia EBS**
O `get-ebs-default-kms-key-id` exemplo a seguir descreve a CMK padrão para criptografia EBS para sua AWS conta.
```
aws ec2 get-ebs-default-kms-key-id
```
A saída mostra a CMK padrão para criptografia do EBS, que é uma CMK AWS gerenciada com o alias. `alias/aws/ebs`
```
{
"KmsKeyId": "alias/aws/ebs"
}
```
A saída a seguir mostra uma CMK personalizada para criptografia do EBS.
```
{
"KmsKeyId": "arn:aws:kms:us-west-2:123456789012:key/0ea3fef3-80a7-4778-9d8c-1c0c6EXAMPLE"
}
```
+ Para obter detalhes da API, consulte [GetEbsDefaultKmsKeyId](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ebs-default-kms-key-id.html)em *Referência de AWS CLI Comandos*.
### `get-ebs-encryption-by-default`
O código de exemplo a seguir mostra como usar `get-ebs-encryption-by-default`.
**AWS CLI**
**Descrever se a criptografia EBS por padrão está habilitada**
O `get-ebs-encryption-by-default` exemplo a seguir indica se a criptografia do EBS, por padrão, está habilitada para sua AWS conta na região atual.
```
aws ec2 get-ebs-encryption-by-default
```
A saída a seguir indica que a criptografia EBS por padrão está desativada.
```
{
"EbsEncryptionByDefault": false
}
```
A saída a seguir indica que a criptografia EBS por padrão está ativada.
```
{
"EbsEncryptionByDefault": true
}
```
+ Para obter detalhes da API, consulte [GetEbsEncryptionByDefault](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ebs-encryption-by-default.html)em *Referência de AWS CLI Comandos*.
### `get-flow-logs-integration-template`
O código de exemplo a seguir mostra como usar `get-flow-logs-integration-template`.
**AWS CLI**
**Para criar um CloudFormation modelo para automatizar a integração dos registros de fluxo da VPC com o Amazon Athena**
Os `get-flow-logs-integration-template` exemplos a seguir criam um CloudFormation modelo para automatizar a integração dos registros de fluxo da VPC com o Amazon Athena.
Linux
```
aws ec2 get-flow-logs-integration-template \
--flow-log-id fl-1234567890abcdef0 \
--config-delivery-s3-destination-arn arn:aws:s3:::amzn-s3-demo-bucket \
--integrate-services AthenaIntegrations='[{IntegrationResultS3DestinationArn=arn:aws:s3:::amzn-s3-demo-bucket,PartitionLoadFrequency=none,PartitionStartDate=2021-07-21T00:40:00,PartitionEndDate=2021-07-21T00:42:00},{IntegrationResultS3DestinationArn=arn:aws:s3:::amzn-s3-demo-bucket,PartitionLoadFrequency=none,PartitionStartDate=2021-07-21T00:40:00,PartitionEndDate=2021-07-21T00:42:00}]'
```
Windows:
```
aws ec2 get-flow-logs-integration-template ^
--flow-log-id fl-1234567890abcdef0 ^
--config-delivery-s3-destination-arn arn:aws:s3:::amzn-s3-demo-bucket ^
--integrate-services AthenaIntegrations=[{IntegrationResultS3DestinationArn=arn:aws:s3:::amzn-s3-demo-bucket,PartitionLoadFrequency=none,PartitionStartDate=2021-07-21T00:40:00,PartitionEndDate=2021-07-21T00:42:00},{IntegrationResultS3DestinationArn=arn:aws:s3:::amzn-s3-demo-bucket,PartitionLoadFrequency=none,PartitionStartDate=2021-07-21T00:40:00,PartitionEndDate=2021-07-21T00:42:00}]
```
Saída:
```
{
"Result": "https://amzn-s3-demo-bucket.s3.us-east-2.amazonaws.com/VPCFlowLogsIntegrationTemplate_fl-1234567890abcdef0_Wed%20Jul%2021%2000%3A57%3A56%20UTC%202021.yml"
}
```
Para obter informações sobre o uso CloudFormation de modelos, consulte Como [trabalhar com AWS CloudFormation modelos](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html) no *Guia AWS CloudFormation do usuário*.
Para obter informações sobre como usar o Amazon Athena e os logs de fluxo, consulte [Consultar logs de fluxo usando o Amazon Athena](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-athena.html) no *Guia do usuário da nuvem privada virtual*.
+ Para obter detalhes da API, consulte [GetFlowLogsIntegrationTemplate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-flow-logs-integration-template.html)em *Referência de AWS CLI Comandos*.
### `get-groups-for-capacity-reservation`
O código de exemplo a seguir mostra como usar `get-groups-for-capacity-reservation`.
**AWS CLI**
**Listar os grupos de recursos com uma reserva de capacidade**
O exemplo `get-groups-for-capacity-reservation` a seguir lista os grupos de recursos aos quais a Reserva de Capacidade especificada foi adicionada.
```
aws ec2 get-groups-for-capacity-reservation \
--capacity-reservation-id cr-1234abcd56EXAMPLE
```
Saída:
```
{
"CapacityReservationsGroup": [
{
"GroupArn": "arn:aws:resource-groups:us-west-2:123456789012:group/my-resource-group",
"OwnerId": "123456789012"
}
]
}
```
Consulte mais informações em [Grupos de Reserva de capacidade](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-cr-group.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [GetGroupsForCapacityReservation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-groups-for-capacity-reservation.html)em *Referência de AWS CLI Comandos*.
### `get-host-reservation-purchase-preview`
O código de exemplo a seguir mostra como usar `get-host-reservation-purchase-preview`.
**AWS CLI**
**Obter uma prévia da compra de uma reserva de host dedicado**
Este exemplo fornece uma prévia dos custos de uma Reserva de Host Dedicado especificada para o Host Dedicado especificado em sua conta.
Comando:
```
aws ec2 get-host-reservation-purchase-preview --offering-id hro-03f707bf363b6b324 --host-id-set h-013abcd2a00cbd123
```
Saída:
```
{
"TotalHourlyPrice": "1.499",
"Purchase": [
{
"HourlyPrice": "1.499",
"InstanceFamily": "m4",
"PaymentOption": "NoUpfront",
"HostIdSet": [
"h-013abcd2a00cbd123"
],
"UpfrontPrice": "0.000",
"Duration": 31536000
}
],
"TotalUpfrontPrice": "0.000"
}
```
+ Para obter detalhes da API, consulte [GetHostReservationPurchasePreview](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-host-reservation-purchase-preview.html)em *Referência de AWS CLI Comandos*.
### `get-image-block-public-access-state`
O código de exemplo a seguir mostra como usar `get-image-block-public-access-state`.
**AWS CLI**
**Para obter o estado de bloqueio de acesso público AMIs na região especificada**
O `get-image-block-public-access-state` exemplo a seguir obtém o estado de bloqueio de acesso público AMIs no nível da conta na região especificada.
```
aws ec2 get-image-block-public-access-state \
--region us-east-1
```
Saída:
```
{
"ImageBlockPublicAccessState": "block-new-sharing"
}
```
Para obter mais informações, consulte [Bloquear o acesso público ao seu AMIs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sharingamis-intro.html#block-public-access-to-amis) no Guia do *usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [GetImageBlockPublicAccessState](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-image-block-public-access-state.html)em *Referência de AWS CLI Comandos*.
### `get-instance-types-from-instance-requirements`
O código de exemplo a seguir mostra como usar `get-instance-types-from-instance-requirements`.
**AWS CLI**
**Pré-visualizar os tipos de instância que correspondem aos atributos especificados**
O exemplo `get-instance-types-from-instance-requirements` a seguir primeiro gera uma lista de todos os atributos possíveis que podem ser especificados usando o parâmetro `--generate-cli-skeleton` e salva a lista em um arquivo JSON. Em seguida, o arquivo JSON é usado para personalizar os atributos para os quais visualizar os tipos de instância correspondentes.
Para gerar todos os atributos possíveis e salvar a saída diretamente em um arquivo JSON, use o comando a seguir.
```
aws ec2 get-instance-types-from-instance-requirements \
--region us-east-1 \
--generate-cli-skeleton input > attributes.json
```
Saída:
```
{
"DryRun": true,
"ArchitectureTypes": [
"x86_64_mac"
],
"VirtualizationTypes": [
"paravirtual"
],
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 0
},
"MemoryMiB": {
"Min": 0,
"Max": 0
},
"CpuManufacturers": [
"intel"
],
"MemoryGiBPerVCpu": {
"Min": 0.0,
"Max": 0.0
},
"ExcludedInstanceTypes": [
""
],
"InstanceGenerations": [
"current"
],
"SpotMaxPricePercentageOverLowestPrice": 0,
"OnDemandMaxPricePercentageOverLowestPrice": 0,
"BareMetal": "included",
"BurstablePerformance": "excluded",
"RequireHibernateSupport": true,
"NetworkInterfaceCount": {
"Min": 0,
"Max": 0
},
"LocalStorage": "required",
"LocalStorageTypes": [
"hdd"
],
"TotalLocalStorageGB": {
"Min": 0.0,
"Max": 0.0
},
"BaselineEbsBandwidthMbps": {
"Min": 0,
"Max": 0
},
"AcceleratorTypes": [
"inference"
],
"AcceleratorCount": {
"Min": 0,
"Max": 0
},
"AcceleratorManufacturers": [
"xilinx"
],
"AcceleratorNames": [
"t4"
],
"AcceleratorTotalMemoryMiB": {
"Min": 0,
"Max": 0
}
},
"MaxResults": 0,
"NextToken": ""
}
```
Configurar o arquivo JSON. Você deve fornecer valores para `ArchitectureTypes`, `VirtualizationTypes`, `VCpuCount` e `MemoryMiB`. Você pode omitir os outros atributos. Quando omitidos, os valores padrão são usados. Para obter uma descrição de cada atributo e seus valores padrão, consulte get-instance-types-from -instance-requirements < - -requirements.html>. https://docs.aws.amazon.com/cli/ latest/reference/ec2/get instance-types-from-instance
Pré-visualizar os tipos de instância que têm os atributos especificados em `attributes.json`. Especifique o nome e o caminho para seu arquivo JSON usando o parâmetro `--cli-input-json`. Na solicitação a seguir, a saída é formatada como uma tabela.
```
aws ec2 get-instance-types-from-instance-requirements \
--cli-input-json file://attributes.json \
--output table
```
Conteúdo do arquivo `attributes.json`:
```
{
"ArchitectureTypes": [
"x86_64"
],
"VirtualizationTypes": [
"hvm"
],
"InstanceRequirements": {
"VCpuCount": {
"Min": 4,
"Max": 6
},
"MemoryMiB": {
"Min": 2048
},
"InstanceGenerations": [
"current"
]
}
}
```
Saída:
```
------------------------------------------
|GetInstanceTypesFromInstanceRequirements|
+----------------------------------------+
|| InstanceTypes ||
|+--------------------------------------+|
|| InstanceType ||
|+--------------------------------------+|
|| c4.xlarge ||
|| c5.xlarge ||
|| c5a.xlarge ||
|| c5ad.xlarge ||
|| c5d.xlarge ||
|| c5n.xlarge ||
|| d2.xlarge ||
...
```
Para obter mais informações sobre a seleção de tipo de instância baseada em atributos, consulte [Como funciona a seleção de tipo de instância baseada em atributos](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-attribute-based-instance-type-selection.html#ec2fleet-abs-how-it-works) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [GetInstanceTypesFromInstanceRequirements](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-instance-types-from-instance-requirements.html)em *Referência de AWS CLI Comandos*.
### `get-instance-uefi-data`
O código de exemplo a seguir mostra como usar `get-instance-uefi-data`.
**AWS CLI**
**Recuperar dados UEFI de uma instância**
O exemplo `get-instance-uefi-data` a seguir recupera dados UEFI de uma instância. Se a saída estiver vazia, a instância não conterá dados UEFI.
```
aws ec2 get-instance-uefi-data \
--instance-id i-0123456789example
```
Saída:
```
{
"InstanceId": "i-0123456789example",
"UefiData": "QU1aTlVFRkkf+uLXAAAAAHj5a7fZ9+3dBzxXb/.
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4L/J/AODshho="
}
```
Para obter mais informações, consulte [Inicialização segura UEFI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/uefi-secure-boot.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [GetInstanceUefiData](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-instance-uefi-data.html)em *Referência de AWS CLI Comandos*.
### `get-ipam-address-history`
O código de exemplo a seguir mostra como usar `get-ipam-address-history`.
**AWS CLI**
**Obter o histórico de um CIDR**
O exemplo `get-ipam-address-history` a seguir obtém o histórico de um CIDR.
(Linux):
```
aws ec2 get-ipam-address-history \
--cidr 10.0.0.0/16 \
--ipam-scope-id ipam-scope-02fc38cd4c48e7d38 \
--start-time 2021-12-08T01:00:00.000Z \
--end-time 2021-12-10T01:00:00.000Z
```
(Windows):
```
aws ec2 get-ipam-address-history ^
--cidr 10.0.0.0/16 ^
--ipam-scope-id ipam-scope-02fc38cd4c48e7d38 ^
--start-time 2021-12-08T01:00:00.000Z ^
--end-time 2021-12-10T01:00:00.000Z
```
Saída:
```
{
"HistoryRecords": [
{
"ResourceOwnerId": "123456789012",
"ResourceRegion": "us-west-1",
"ResourceType": "vpc",
"ResourceId": "vpc-06cbefa9ee907e1c0",
"ResourceCidr": "10.0.0.0/16",
"ResourceName": "Demo",
"ResourceComplianceStatus": "unmanaged",
"ResourceOverlapStatus": "overlapping",
"VpcId": "vpc-06cbefa9ee907e1c0",
"SampledStartTime": "2021-12-08T19:54:57.675000+00:00"
},
{
"ResourceOwnerId": "123456789012",
"ResourceRegion": "us-east-2",
"ResourceType": "vpc",
"ResourceId": "vpc-042702f474812c9ad",
"ResourceCidr": "10.0.0.0/16",
"ResourceName": "test",
"ResourceComplianceStatus": "unmanaged",
"ResourceOverlapStatus": "overlapping",
"VpcId": "vpc-042702f474812c9ad",
"SampledStartTime": "2021-12-08T19:54:59.019000+00:00"
},
{
"ResourceOwnerId": "123456789012",
"ResourceRegion": "us-east-2",
"ResourceType": "vpc",
"ResourceId": "vpc-042b8a44f64267d67",
"ResourceCidr": "10.0.0.0/16",
"ResourceName": "tester",
"ResourceComplianceStatus": "unmanaged",
"ResourceOverlapStatus": "overlapping",
"VpcId": "vpc-042b8a44f64267d67",
"SampledStartTime": "2021-12-08T19:54:59.019000+00:00"
}
]
}
```
Para obter mais informações, consulte [Exibir o histórico de endereços IP](https://docs.aws.amazon.com/vpc/latest/ipam/view-history-cidr-ipam.html) no *Guia do usuário IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [GetIpamAddressHistory](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ipam-address-history.html)em *Referência de AWS CLI Comandos*.
### `get-ipam-discovered-accounts`
O código de exemplo a seguir mostra como usar `get-ipam-discovered-accounts`.
**AWS CLI**
**Visualizar as contas descobertas por um IPAM**
Nesse cenário, você é um administrador delegado do IPAM que deseja visualizar as AWS contas que possuem recursos que o IPAM está descobrindo.
`--discovery-region` é a região operacional do IPAM na qual você deseja visualizar os status da conta monitorada. Por exemplo, se você tiver três regiões operacionais do IPAM, talvez queira fazer essa solicitação três vezes para ver as marcações de hora específicas para a descoberta em cada uma dessas regiões específicas.
O `get-ipam-discovered-accounts` exemplo a seguir lista as AWS contas que possuem recursos que o IPAM está descobrindo.
```
aws ec2 get-ipam-discovered-accounts \
--ipam-resource-discovery-id ipam-res-disco-0365d2977fc1672fe \
--discovery-region us-east-1
```
Saída:
```
{
"IpamDiscoveredAccounts": [
{
"AccountId": "149977607591",
"DiscoveryRegion": "us-east-1",
"LastAttemptedDiscoveryTime": "2024-02-09T19:04:31.379000+00:00",
"LastSuccessfulDiscoveryTime": "2024-02-09T19:04:31.379000+00:00"
}
]
}
```
Para obter mais informações, consulte [Integrar o IPAM com contas fora da sua organização](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam-outside-org.html) no *Guia do usuário do IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [GetIpamDiscoveredAccounts](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ipam-discovered-accounts.html)em *Referência de AWS CLI Comandos*.
### `get-ipam-discovered-public-addresses`
O código de exemplo a seguir mostra como usar `get-ipam-discovered-public-addresses`.
**AWS CLI**
**Visualizar endereços IP públicos descobertos**
Neste exemplo, você é um administrador delegado do IPAM e deseja visualizar os endereços IP dos recursos descobertos pelo IPAM. Você pode obter o ID de descoberta do recurso com [describe-ipam-resource-discoveries](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-ipam-resource-discoveries.html).
O exemplo `get-ipam-discovered-public-addresses` a seguir mostra os endereços IP públicos descobertos para uma descoberta de recursos.
```
aws ec2 get-ipam-discovered-public-addresses \
--ipam-resource-discovery-id ipam-res-disco-0f4ef577a9f37a162 \
--address-region us-east-1 \
--region us-east-1
```
Saída:
```
{
"IpamDiscoveredPublicAddresses": [
{
"IpamResourceDiscoveryId": "ipam-res-disco-0f4ef577a9f37a162",
"AddressRegion": "us-east-1",
"Address": "54.208.155.7",
"AddressOwnerId": "320805250157",
"AssociationStatus": "associated",
"AddressType": "ec2-public-ip",
"VpcId": "vpc-073b294916198ce49",
"SubnetId": "subnet-0b6c8a8839e9a4f15",
"NetworkInterfaceId": "eni-081c446b5284a5e06",
"NetworkInterfaceDescription": "",
"InstanceId": "i-07459a6fca5b35823",
"Tags": {},
"NetworkBorderGroup": "us-east-1c",
"SecurityGroups": [
{
"GroupName": "launch-wizard-2",
"GroupId": "sg-0a489dd6a65c244ce"
}
],
"SampleTime": "2024-04-05T15:13:59.228000+00:00"
},
{
"IpamResourceDiscoveryId": "ipam-res-disco-0f4ef577a9f37a162",
"AddressRegion": "us-east-1",
"Address": "44.201.251.218",
"AddressOwnerId": "470889052923",
"AssociationStatus": "associated",
"AddressType": "ec2-public-ip",
"VpcId": "vpc-6c31a611",
"SubnetId": "subnet-062f47608b99834b1",
"NetworkInterfaceId": "eni-024845359c2c3ae9b",
"NetworkInterfaceDescription": "",
"InstanceId": "i-04ef786d9c4e03f41",
"Tags": {},
"NetworkBorderGroup": "us-east-1a",
"SecurityGroups": [
{
"GroupName": "launch-wizard-32",
"GroupId": "sg-0ed1a426e96a68374"
}
],
"SampleTime": "2024-04-05T15:13:59.145000+00:00"
}
}
```
Para obter mais informações, consulte [Visualizar Insights de IP público](https://docs.aws.amazon.com/vpc/latest/ipam/view-public-ip-insights.html), no *Guia do usuário IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [GetIpamDiscoveredPublicAddresses](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ipam-discovered-public-addresses.html)em *Referência de AWS CLI Comandos*.
### `get-ipam-discovered-resource-cidrs`
O código de exemplo a seguir mostra como usar `get-ipam-discovered-resource-cidrs`.
**AWS CLI**
**Para ver o endereço IP CIDRs descoberto por um IPAM**
Neste exemplo, você é um administrador delegado do IPAM que deseja ver detalhes relacionados ao endereço CIDRs IP dos recursos que o IPAM está descobrindo.
Para concluir essa solicitação:
A descoberta de recursos que você escolher deve estar associada ao IPAM. `--resource-region` É a AWS região em que o recurso foi criado.
O exemplo `get-ipam-discovered-resource-cidrs` a seguir lista os endereços IP dos recursos que o IPAM está descobrindo.
```
aws ec2 get-ipam-discovered-resource-cidrs \
--ipam-resource-discovery-id ipam-res-disco-0365d2977fc1672fe \
--resource-region us-east-1
```
Saída:
```
{
{
"IpamDiscoveredResourceCidrs": [
{
"IpamResourceDiscoveryId": "ipam-res-disco-0365d2977fc1672fe",
"ResourceRegion": "us-east-1",
"ResourceId": "vpc-0c974c95ca7ceef4a",
"ResourceOwnerId": "149977607591",
"ResourceCidr": "172.31.0.0/16",
"ResourceType": "vpc",
"ResourceTags": [],
"IpUsage": 0.375,
"VpcId": "vpc-0c974c95ca7ceef4a",
"SampleTime": "2024-02-09T19:15:16.529000+00:00"
},
{
"IpamResourceDiscoveryId": "ipam-res-disco-0365d2977fc1672fe",
"ResourceRegion": "us-east-1",
"ResourceId": "subnet-07fe028119082a8c1",
"ResourceOwnerId": "149977607591",
"ResourceCidr": "172.31.0.0/20",
"ResourceType": "subnet",
"ResourceTags": [],
"IpUsage": 0.0012,
"VpcId": "vpc-0c974c95ca7ceef4a",
"SampleTime": "2024-02-09T19:15:16.529000+00:00"
},
{
"IpamResourceDiscoveryId": "ipam-res-disco-0365d2977fc1672fe",
"ResourceRegion": "us-east-1",
"ResourceId": "subnet-0a96893763984cc4e",
"ResourceOwnerId": "149977607591",
"ResourceCidr": "172.31.64.0/20",
"ResourceType": "subnet",
"ResourceTags": [],
"IpUsage": 0.0012,
"VpcId": "vpc-0c974c95ca7ceef4a",
"SampleTime": "2024-02-09T19:15:16.529000+00:00"
}
}
}
```
Para obter mais informações, consulte [Monitorar o uso CIDR por recurso](https://docs.aws.amazon.com/vpc/latest/ipam/monitor-cidr-compliance-ipam.html) no *Guia do usuário IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [GetIpamDiscoveredResourceCidrs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ipam-discovered-resource-cidrs.html)em *Referência de AWS CLI Comandos*.
### `get-ipam-pool-allocations`
O código de exemplo a seguir mostra como usar `get-ipam-pool-allocations`.
**AWS CLI**
**Para obter a CIDRs alocação de um pool IPAM**
O `get-ipam-pool-allocations` exemplo a seguir obtém a CIDRs alocação de um pool IPAM.
(Linux):
```
aws ec2 get-ipam-pool-allocations \
--ipam-pool-id ipam-pool-0533048da7d823723 \
--filters Name=ipam-pool-allocation-id,Values=ipam-pool-alloc-0e6186d73999e47389266a5d6991e6220
```
(Windows):
```
aws ec2 get-ipam-pool-allocations ^
--ipam-pool-id ipam-pool-0533048da7d823723 ^
--filters Name=ipam-pool-allocation-id,Values=ipam-pool-alloc-0e6186d73999e47389266a5d6991e6220
```
Saída:
```
{
"IpamPoolAllocations": [
{
"Cidr": "10.0.0.0/16",
"IpamPoolAllocationId": "ipam-pool-alloc-0e6186d73999e47389266a5d6991e6220",
"ResourceType": "custom",
"ResourceOwner": "123456789012"
}
]
}
```
+ Para obter detalhes da API, consulte [GetIpamPoolAllocations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ipam-pool-allocations.html)em *Referência de AWS CLI Comandos*.
### `get-ipam-pool-cidrs`
O código de exemplo a seguir mostra como usar `get-ipam-pool-cidrs`.
**AWS CLI**
**Para obter o CIDRs aprovisionamento em um pool IPAM**
O `get-ipam-pool-cidrs` exemplo a seguir fornece o CIDRs provisionamento para um pool IPAM.
(Linux):
```
aws ec2 get-ipam-pool-cidrs \
--ipam-pool-id ipam-pool-0533048da7d823723 \
--filters 'Name=cidr,Values=10.*'
```
(Windows):
```
aws ec2 get-ipam-pool-cidrs ^
--ipam-pool-id ipam-pool-0533048da7d823723 ^
--filters Name=cidr,Values=10.*
```
Saída:
```
{
"IpamPoolCidr": {
"Cidr": "10.0.0.0/24",
"State": "provisioned"
}
}
```
+ Para obter detalhes da API, consulte [GetIpamPoolCidrs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ipam-pool-cidrs.html)em *Referência de AWS CLI Comandos*.
### `get-ipam-resource-cidrs`
O código de exemplo a seguir mostra como usar `get-ipam-resource-cidrs`.
**AWS CLI**
**Para obter o CIDRs alocado para um recurso**
O `get-ipam-resource-cidrs` exemplo a seguir obtém o CIDRs alocado para um recurso.
(Linux):
```
aws ec2 get-ipam-resource-cidrs \
--ipam-scope-id ipam-scope-02fc38cd4c48e7d38 \
--filters Name=management-state,Values=unmanaged
```
(Windows):
```
aws ec2 get-ipam-resource-cidrs ^
--ipam-scope-id ipam-scope-02fc38cd4c48e7d38 ^
--filters Name=management-state,Values=unmanaged
```
Saída:
```
{
"IpamResourceCidrs": [
{
"IpamId": "ipam-08440e7a3acde3908",
"IpamScopeId": "ipam-scope-02fc38cd4c48e7d38",
"ResourceRegion": "us-east-2",
"ResourceOwnerId": "123456789012",
"ResourceId": "vpc-621b8709",
"ResourceName": "Default AWS VPC",
"ResourceCidr": "172.33.0.0/16",
"ResourceType": "vpc",
"ResourceTags": [
{
"Key": "Environment",
"Value": "Test"
},
{
"Key": "Name",
"Value": "Default AWS VPC"
}
],
"IpUsage": 0.0039,
"ComplianceStatus": "unmanaged",
"ManagementState": "unmanaged",
"OverlapStatus": "nonoverlapping",
"VpcId": "vpc-621b8709"
}
]
}
```
Para obter mais informações, consulte [Monitorar o uso CIDR por recurso](https://docs.aws.amazon.com/vpc/latest/ipam/monitor-cidr-compliance-ipam.html) no *Guia do usuário IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [GetIpamResourceCidrs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ipam-resource-cidrs.html)em *Referência de AWS CLI Comandos*.
### `get-launch-template-data`
O código de exemplo a seguir mostra como usar `get-launch-template-data`.
**AWS CLI**
**Obter dados da instância de um modelo de execução**
Este exemplo obtém dados sobre a instância especificada e usa a opção `--query` para retornar o conteúdo `LaunchTemplateData`. É possível usar o resultado como base para criar um novo modelo de execução ou uma versão de modelo de execução.
Comando:
```
aws ec2 get-launch-template-data --instance-id i-0123d646e8048babc --query 'LaunchTemplateData'
```
Saída:
```
{
"Monitoring": {},
"ImageId": "ami-8c1be5f6",
"BlockDeviceMappings": [
{
"DeviceName": "/dev/xvda",
"Ebs": {
"DeleteOnTermination": true
}
}
],
"EbsOptimized": false,
"Placement": {
"Tenancy": "default",
"GroupName": "",
"AvailabilityZone": "us-east-1a"
},
"InstanceType": "t2.micro",
"NetworkInterfaces": [
{
"Description": "",
"NetworkInterfaceId": "eni-35306abc",
"PrivateIpAddresses": [
{
"Primary": true,
"PrivateIpAddress": "10.0.0.72"
}
],
"SubnetId": "subnet-7b16de0c",
"Groups": [
"sg-7c227019"
],
"Ipv6Addresses": [
{
"Ipv6Address": "2001:db8:1234:1a00::123"
}
],
"PrivateIpAddress": "10.0.0.72"
}
]
}
```
+ Para obter detalhes da API, consulte [GetLaunchTemplateData](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-launch-template-data.html)em *Referência de AWS CLI Comandos*.
### `get-managed-prefix-list-associations`
O código de exemplo a seguir mostra como usar `get-managed-prefix-list-associations`.
**AWS CLI**
**Obter associações de listas de prefixos**
O exemplo `get-managed-prefix-list-associations` a seguir obtém os recursos associados à lista de prefixos especificada.
```
aws ec2 get-managed-prefix-list-associations \
--prefix-list-id pl-0123456abcabcabc1
```
Saída:
```
{
"PrefixListAssociations": [
{
"ResourceId": "sg-0abc123456abc12345",
"ResourceOwner": "123456789012"
}
]
}
```
Para obter mais informações, consulte [Listas de prefixos gerenciados](https://docs.aws.amazon.com/vpc/latest/userguide/managed-prefix-lists.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [GetManagedPrefixListAssociations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-managed-prefix-list-associations.html)em *Referência de AWS CLI Comandos*.
### `get-managed-prefix-list-entries`
O código de exemplo a seguir mostra como usar `get-managed-prefix-list-entries`.
**AWS CLI**
**Obter as entradas da lista de prefixos**
O `get-managed-prefix-list-entries` a seguir obtém as entradas para a lista de prefixos especificada.
```
aws ec2 get-managed-prefix-list-entries \
--prefix-list-id pl-0123456abcabcabc1
```
Saída:
```
{
"Entries": [
{
"Cidr": "10.0.0.0/16",
"Description": "vpc-a"
},
{
"Cidr": "10.2.0.0/16",
"Description": "vpc-b"
}
]
}
```
Para obter mais informações, consulte [Listas de prefixos gerenciados](https://docs.aws.amazon.com/vpc/latest/userguide/managed-prefix-lists.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [GetManagedPrefixListEntries](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-managed-prefix-list-entries.html)em *Referência de AWS CLI Comandos*.
### `get-network-insights-access-scope-analysis-findings`
O código de exemplo a seguir mostra como usar `get-network-insights-access-scope-analysis-findings`.
**AWS CLI**
**Obter as descobertas da análise do escopo de acesso do Network Insights**
O `get-network-insights-access-scope-analysis-findings` exemplo a seguir obtém os resultados da análise de escopo selecionada em sua AWS conta.
```
aws ec2 get-network-insights-access-scope-analysis-findings \
--region us-east-1 \
--network-insights-access-scope-analysis-id nis \
--nis-123456789111
```
Saída:
```
{
"NetworkInsightsAccessScopeAnalysisId": "nisa-123456789222",
"AnalysisFindings": [
{
"NetworkInsightsAccessScopeAnalysisId": "nisa-123456789222",
"NetworkInsightsAccessScopeId": "nis-123456789111",
"FindingComponents": [
{
"SequenceNumber": 1,
"Component": {
"Id": "eni-02e3d42d5cceca67d",
"Arn": "arn:aws:ec2:us-east-1:936459623503:network-interface/eni-02e3d32d9cceca17d"
},
"OutboundHeader": {
"DestinationAddresses": [
"0.0.0.0/5",
"11.0.0.0/8",
"12.0.0.0/6",
"128.0.0.0/3",
"16.0.0.0/4",
"160.0.0.0/5",
"168.0.0.0/6",
"172.0.0.0/12"
"8.0.0.0/7"
],
"DestinationPortRanges": [
{
"From": 0,
"To": 65535
}
],
"Protocol": "6",
"SourceAddresses": [
"10.0.2.253/32"
],
"SourcePortRanges": [
{
"From": 0,
"To": 65535
}
]
}, [etc]
]
}
}
]
}
```
Para obter mais informações, consulte [Introdução ao Network Access Analyzer usando a AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli.html) no Guia *do Network Access* Analyzer.
+ Para obter detalhes da API, consulte [GetNetworkInsightsAccessScopeAnalysisFindings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-network-insights-access-scope-analysis-findings.html)em *Referência de AWS CLI Comandos*.
### `get-network-insights-access-scope-content`
O código de exemplo a seguir mostra como usar `get-network-insights-access-scope-content`.
**AWS CLI**
**Para que o Network Insights acesse o conteúdo do escopo**
O `get-network-insights-access-scope-content` exemplo a seguir obtém o conteúdo da ID de análise de escopo selecionada em sua AWS conta.
```
aws ec2 get-network-insights-access-scope-content \
--region us-east-1 \
--network-insights-access-scope-id nis-123456789222
```
Saída:
```
{
"NetworkInsightsAccessScopeContent": {
"NetworkInsightsAccessScopeId": "nis-123456789222",
"MatchPaths": [
{
"Source": {
"ResourceStatement": {
"ResourceTypes": [
"AWS::EC2::NetworkInterface"
]
}
},
"Destination": {
"ResourceStatement": {
"ResourceTypes": [
"AWS::EC2::InternetGateway"
]
}
}
}
]
}
}
```
Para obter mais informações, consulte [Introdução ao Network Access Analyzer usando a AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli.html) no Guia *do Network Access* Analyzer.
+ Para obter detalhes da API, consulte [GetNetworkInsightsAccessScopeContent](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-network-insights-access-scope-content.html)em *Referência de AWS CLI Comandos*.
### `get-password-data`
O código de exemplo a seguir mostra como usar `get-password-data`.
**AWS CLI**
**Obter a senha criptografada**
Este exemplo obtém a senha criptografada.
Comando:
```
aws ec2 get-password-data --instance-id i-1234567890abcdef0
```
Saída:
```
{
"InstanceId": "i-1234567890abcdef0",
"Timestamp": "2013-08-07T22:18:38.000Z",
"PasswordData": "gSlJFq+VpcZXqy+iktxMF6NyxQ4qCrT4+gaOuNOenX1MmgXPTj7XEXAMPLE
UQ+YeFfb+L1U4C4AKv652Ux1iRB3CPTYP7WmU3TUnhsuBd+p6LVk7T2lKUml6OXbk6WPW1VYYm/TRPB1
e1DQ7PY4an/DgZT4mwcpRFigzhniQgDDeO1InvSDcwoUTwNs0Y1S8ouri2W4n5GNlriM3Q0AnNVelVz/
53TkDtxbNoU606M1gK9zUWSxqEgwvbV2j8c5rP0WCuaMWSFl4ziDu4bd7q+4RSyi8NUsVWnKZ4aEZffu
DPGzKrF5yLlf3etP2L4ZR6CvG7K1hx7VKOQVN32Dajw=="
}
```
**Obter a senha descriptografada**
Este exemplo obtém a senha descriptografada.
Comando:
```
aws ec2 get-password-data --instance-id i-1234567890abcdef0 --priv-launch-key C:\Keys\MyKeyPair.pem
```
Saída:
```
{
"InstanceId": "i-1234567890abcdef0",
"Timestamp": "2013-08-30T23:18:05.000Z",
"PasswordData": "&ViJ652e*u"
}
```
+ Para obter detalhes da API, consulte [GetPasswordData](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-password-data.html)em *Referência de AWS CLI Comandos*.
### `get-reserved-instances-exchange-quote`
O código de exemplo a seguir mostra como usar `get-reserved-instances-exchange-quote`.
**AWS CLI**
**Obter uma cotação para trocar uma Instância Reservada Conversível**
Este exemplo obtém as informações de troca para as Instâncias Reservadas Conversíveis especificadas.
Comando:
```
aws ec2 get-reserved-instances-exchange-quote --reserved-instance-ids 7b8750c3-397e-4da4-bbcb-a45ebexample --target-configurations OfferingId=6fea5434-b379-434c-b07b-a7abexample
```
Saída:
```
{
"CurrencyCode": "USD",
"ReservedInstanceValueSet": [
{
"ReservedInstanceId": "7b8750c3-397e-4da4-bbcb-a45ebexample",
"ReservationValue": {
"RemainingUpfrontValue": "0.000000",
"HourlyPrice": "0.027800",
"RemainingTotalValue": "730.556200"
}
}
],
"PaymentDue": "424.983828",
"TargetConfigurationValueSet": [
{
"TargetConfiguration": {
"InstanceCount": 5,
"OfferingId": "6fea5434-b379-434c-b07b-a7abexample"
},
"ReservationValue": {
"RemainingUpfrontValue": "424.983828",
"HourlyPrice": "0.016000",
"RemainingTotalValue": "845.447828"
}
}
],
"IsValidExchange": true,
"OutputReservedInstancesWillExpireAt": "2020-10-01T13:03:39Z",
"ReservedInstanceValueRollup": {
"RemainingUpfrontValue": "0.000000",
"HourlyPrice": "0.027800",
"RemainingTotalValue": "730.556200"
},
"TargetConfigurationValueRollup": {
"RemainingUpfrontValue": "424.983828",
"HourlyPrice": "0.016000",
"RemainingTotalValue": "845.447828"
}
}
```
+ Para obter detalhes da API, consulte [GetReservedInstancesExchangeQuote](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-reserved-instances-exchange-quote.html)em *Referência de AWS CLI Comandos*.
### `get-security-groups-for-vpc`
O código de exemplo a seguir mostra como usar `get-security-groups-for-vpc`.
**AWS CLI**
**Visualizar grupos de segurança que podem ser associados a interfaces de rede em uma VPC especificada.**
O exemplo `get-security-groups-for-vpc` a seguir mostra os grupos de segurança que podem ser associados às interfaces de rede na VPC.
```
aws ec2 get-security-groups-for-vpc \
--vpc-id vpc-6c31a611 \
--region us-east-1
```
Saída:
```
{
"SecurityGroupForVpcs": [
{
"Description": "launch-wizard-36 created 2022-08-29T15:59:35.338Z",
"GroupName": "launch-wizard-36",
"OwnerId": "470889052923",
"GroupId": "sg-007e0c3027ee885f5",
"Tags": [],
"PrimaryVpcId": "vpc-6c31a611"
},
{
"Description": "launch-wizard-18 created 2024-01-19T20:22:27.527Z",
"GroupName": "launch-wizard-18",
"OwnerId": "470889052923",
"GroupId": "sg-0147193bef51c9eef",
"Tags": [],
"PrimaryVpcId": "vpc-6c31a611"
}
}
```
+ Para obter detalhes da API, consulte [GetSecurityGroupsForVpc](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-security-groups-for-vpc.html)em *Referência de AWS CLI Comandos*.
### `get-serial-console-access-status`
O código de exemplo a seguir mostra como usar `get-serial-console-access-status`.
**AWS CLI**
**Visualizar o status do acesso da conta ao console de série**
O exemplo `get-serial-console-access-status` a seguir determina se o acesso ao console de série está habilitado para sua conta.
```
aws ec2 get-serial-console-access-status
```
Saída:
```
{
"SerialConsoleAccessEnabled": true
}
```
Para obter mais informações, consulte [Console de Série do EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-serial-console.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [GetSerialConsoleAccessStatus](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-serial-console-access-status.html)em *Referência de AWS CLI Comandos*.
### `get-snapshot-block-public-access-state`
O código de exemplo a seguir mostra como usar `get-snapshot-block-public-access-state`.
**AWS CLI**
**Obter o status atual do bloqueio do acesso público para snapshots**
O exemplo `get-snapshot-block-public-access-state` a seguir mostra o estado atual do bloqueio do acesso público aos snapshots.
```
aws ec2 get-snapshot-block-public-access-state
```
Saída:
```
{
"State": "block-all-sharing"
}
```
Para obter mais informações, consulte [Bloquear acesso público aos snapshots](https://docs.aws.amazon.com/ebs/latest/userguide/block-public-access-snapshots.html) no *Guia do usuário do Amazon EBS*.
+ Para obter detalhes da API, consulte [GetSnapshotBlockPublicAccessState](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-snapshot-block-public-access-state.html)em *Referência de AWS CLI Comandos*.
### `get-spot-placement-scores`
O código de exemplo a seguir mostra como usar `get-spot-placement-scores`.
**AWS CLI**
**Calcular a pontuação de posicionamento de Spot para requisitos especificados**
O exemplo `get-spot-placement-scores` a seguir gera primeiro uma lista de todos os parâmetros possíveis que podem ser especificados para a configuração da pontuação de posicionamento de Spot usando o parâmetro `--generate-cli-skeleton` e salva a lista em um arquivo JSON. Em seguida, o arquivo JSON é usado para configurar os requisitos a serem usados para calcular a pontuação de posicionamento Spot.
Gerar todos os parâmetros possíveis que podem ser especificados para a configuração da pontuação de posicionamento Spot e salvar a saída diretamente em um arquivo JSON.
```
aws ec2 get-spot-placement-scores \
--region us-east-1 \
--generate-cli-skeleton input > attributes.json
```
Saída:
```
{
"InstanceTypes": [
""
],
"TargetCapacity": 0,
"TargetCapacityUnitType": "vcpu",
"SingleAvailabilityZone": true,
"RegionNames": [
""
],
"InstanceRequirementsWithMetadata": {
"ArchitectureTypes": [
"x86_64_mac"
],
"VirtualizationTypes": [
"hvm"
],
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 0
},
"MemoryMiB": {
"Min": 0,
"Max": 0
},
"CpuManufacturers": [
"amd"
],
"MemoryGiBPerVCpu": {
"Min": 0.0,
"Max": 0.0
},
"ExcludedInstanceTypes": [
""
],
"InstanceGenerations": [
"previous"
],
"SpotMaxPricePercentageOverLowestPrice": 0,
"OnDemandMaxPricePercentageOverLowestPrice": 0,
"BareMetal": "excluded",
"BurstablePerformance": "excluded",
"RequireHibernateSupport": true,
"NetworkInterfaceCount": {
"Min": 0,
"Max": 0
},
"LocalStorage": "included",
"LocalStorageTypes": [
"hdd"
],
"TotalLocalStorageGB": {
"Min": 0.0,
"Max": 0.0
},
"BaselineEbsBandwidthMbps": {
"Min": 0,
"Max": 0
},
"AcceleratorTypes": [
"fpga"
],
"AcceleratorCount": {
"Min": 0,
"Max": 0
},
"AcceleratorManufacturers": [
"amd"
],
"AcceleratorNames": [
"vu9p"
],
"AcceleratorTotalMemoryMiB": {
"Min": 0,
"Max": 0
}
}
},
"DryRun": true,
"MaxResults": 0,
"NextToken": ""
}
```
Configurar o arquivo JSON. Você deve fornecer um valor para `TargetCapacity`: Para obter uma descrição de cada parâmetro e seus valores padrão, consulte Calcular a pontuação de posicionamento spot (AWS CLI) . calculate-sps-cli
Calcule uma pontuação de posicionamento Spot para os requisitos especificados em `attributes.json`. Especifique o nome e o caminho para seu arquivo JSON usando o parâmetro `--cli-input-json`.
```
aws ec2 get-spot-placement-scores \
--region us-east-1 \
--cli-input-json file://attributes.json
```
Saída se `SingleAvailabilityZone` estiver definido como `false` ou omitido (se omitido, o padrão é `false`). Uma lista pontuada de regiões é retornada.
```
"Recommendation": [
{
"Region": "us-east-1",
"Score": 7
},
{
"Region": "us-west-1",
"Score": 5
},
...
```
Saída se `SingleAvailabilityZone` estiver definido como `true`. Uma lista SingleAvailability pontuada de zonas é retornada.
```
"Recommendation": [
{
"Region": "us-east-1",
"AvailabilityZoneId": "use1-az1"
"Score": 8
},
{
"Region": "us-east-1",
"AvailabilityZoneId": "usw2-az3"
"Score": 6
},
...
```
Para obter mais informações sobre o cálculo de uma pontuação de posicionamento Spot, e para exemplos de configurações, consulte [Calcular uma pontuação de posicionamento Spot](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-placement-score.html#work-with-spot-placement-score) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [GetSpotPlacementScores](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-spot-placement-scores.html)em *Referência de AWS CLI Comandos*.
### `get-subnet-cidr-reservations`
O código de exemplo a seguir mostra como usar `get-subnet-cidr-reservations`.
**AWS CLI**
**Obter informações sobre uma reserva CIDR de sub-rede**
O exemplo `get-subnet-cidr-reservations` a seguir mostra as informações da reserva de sub-rede CIDR especificada.
```
aws ec2 get-subnet-cidr-reservations \
--subnet-id subnet-03c51e2e6cEXAMPLE
```
Saída:
```
{
"SubnetIpv4CidrReservations": [
{
"SubnetCidrReservationId": "scr-044f977c4eEXAMPLE",
"SubnetId": "subnet-03c51e2e6cEXAMPLE",
"Cidr": "10.1.0.16/28",
"ReservationType": "prefix",
"OwnerId": "123456789012"
}
],
"SubnetIpv6CidrReservations": []
}
```
Para obter mais informações, consulte [Comportamento do endereçamento IP para sua sub-rede](https://docs.aws.amazon.com/vpc/latest/userguide/subnet-cidr-reservation.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [GetSubnetCidrReservations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-subnet-cidr-reservations.html)em *Referência de AWS CLI Comandos*.
### `get-transit-gateway-attachment-propagations`
O código de exemplo a seguir mostra como usar `get-transit-gateway-attachment-propagations`.
**AWS CLI**
**Listar as tabelas de rotas para as quais o anexo de recurso especificado propaga rotas**
O exemplo `get-transit-gateway-attachment-propagations` a seguir lista as tabelas de rotas para as quais o anexo de recurso especificado propaga rotas.
```
aws ec2 get-transit-gateway-attachment-propagations \
--transit-gateway-attachment-id tgw-attach-09fbd47ddfEXAMPLE
```
Saída:
```
{
"TransitGatewayAttachmentPropagations": [
{
"TransitGatewayRouteTableId": "tgw-rtb-0882c61b97EXAMPLE",
"State": "enabled"
}
]
}
```
Para obter mais informações, consulte [Tabelas de rota do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [GetTransitGatewayAttachmentPropagations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-transit-gateway-attachment-propagations.html)em *Referência de AWS CLI Comandos*.
### `get-transit-gateway-multicast-domain-associations`
O código de exemplo a seguir mostra como usar `get-transit-gateway-multicast-domain-associations`.
**AWS CLI**
**Visualizar informações sobre as associações de um domínio multicast de gateway de trânsito**
O exemplo `get-transit-gateway-multicast-domain-associations` a seguir retorna as associações para o domínio multicast especificado.
```
aws ec2 get-transit-gateway-multicast-domain-associations \
--transit-gateway-multicast-domain-id tgw-mcast-domain-0c4905cef7EXAMPLE
```
Saída:
```
{
"MulticastDomainAssociations": [
{
"TransitGatewayAttachmentId": "tgw-attach-028c1dd0f8EXAMPLE",
"ResourceId": "vpc-01128d2c24EXAMPLE",
"ResourceType": "vpc",
"Subnet": {
"SubnetId": "subnet-000de86e3bEXAMPLE",
"State": "associated"
}
},
{
"TransitGatewayAttachmentId": "tgw-attach-070e571cd1EXAMPLE",
"ResourceId": "vpc-7EXAMPLE",
"ResourceType": "vpc",
"Subnet": {
"SubnetId": "subnet-4EXAMPLE",
"State": "associated"
}
},
{
"TransitGatewayAttachmentId": "tgw-attach-070e571cd1EXAMPLE",
"ResourceId": "vpc-7EXAMPLE",
"ResourceType": "vpc",
"Subnet": {
"SubnetId": "subnet-5EXAMPLE",
"State": "associated"
}
},
{
"TransitGatewayAttachmentId": "tgw-attach-070e571cd1EXAMPLE",
"ResourceId": "vpc-7EXAMPLE",
"ResourceType": "vpc",
"Subnet": {
"SubnetId": "subnet-aEXAMPLE",
"State": "associated"
}
},
{
"TransitGatewayAttachmentId": "tgw-attach-070e571cd1EXAMPLE",
"ResourceId": "vpc-7EXAMPLE",
"ResourceType": "vpc",
"Subnet": {
"SubnetId": "subnet-fEXAMPLE",
"State": "associated"
}
}
]
}
```
Consulte mais informações em [Multicast domains](https://docs.aws.amazon.com/vpc/latest/tgw/multicast-domains-about.html) no *Guia do Transit Gateway*.
+ Para obter detalhes da API, consulte [GetTransitGatewayMulticastDomainAssociations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-transit-gateway-multicast-domain-associations.html)em *Referência de AWS CLI Comandos*.
### `get-transit-gateway-prefix-list-references`
O código de exemplo a seguir mostra como usar `get-transit-gateway-prefix-list-references`.
**AWS CLI**
**Obter referências a uma lista de prefixos na tabela de rotas do gateway de trânsito**
O exemplo `get-transit-gateway-prefix-list-references` a seguir obtém as referências da lista de prefixos para a tabela de rotas do Gateway de Trânsito especificada e filtra pelo ID de uma lista de prefixos específica.
```
aws ec2 get-transit-gateway-prefix-list-references \
--transit-gateway-route-table-id tgw-rtb-0123456789abcd123 \
--filters Name=prefix-list-id,Values=pl-11111122222222333
```
Saída:
```
{
"TransitGatewayPrefixListReferences": [
{
"TransitGatewayRouteTableId": "tgw-rtb-0123456789abcd123",
"PrefixListId": "pl-11111122222222333",
"PrefixListOwnerId": "123456789012",
"State": "available",
"Blackhole": false,
"TransitGatewayAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-aabbccddaabbccaab",
"ResourceType": "vpc",
"ResourceId": "vpc-112233445566aabbc"
}
}
]
}
```
Para obter mais informações, consulte [Referências de lista de prefixos](https://docs.aws.amazon.com/vpc/latest/tgw/create-prefix-list-reference.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [GetTransitGatewayPrefixListReferences](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-transit-gateway-prefix-list-references.html)em *Referência de AWS CLI Comandos*.
### `get-transit-gateway-route-table-associations`
O código de exemplo a seguir mostra como usar `get-transit-gateway-route-table-associations`.
**AWS CLI**
**Obter informações sobre as associações para a tabela de rotas do gateway de trânsito**
O exemplo `get-transit-gateway-route-table-associations` a seguir exibe informações sobre as associações para as tabelas de rotas de gateway de trânsito especificadas.
```
aws ec2 get-transit-gateway-route-table-associations \
--transit-gateway-route-table-id tgw-rtb-0a823edbdeEXAMPLE
```
Saída:
```
{
"Associations": [
{
"TransitGatewayAttachmentId": "tgw-attach-09b52ccdb5EXAMPLE",
"ResourceId": "vpc-4d7de228",
"ResourceType": "vpc",
"State": "associating"
}
]
}
```
Para obter mais informações, consulte [Tabelas de rota do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html#associate-tgw-route-table) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [GetTransitGatewayRouteTableAssociations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-transit-gateway-route-table-associations.html)em *Referência de AWS CLI Comandos*.
### `get-transit-gateway-route-table-propagations`
O código de exemplo a seguir mostra como usar `get-transit-gateway-route-table-propagations`.
**AWS CLI**
**Exibir informações sobre as propagações para a tabela de rotas do gateway de trânsito especificado**
O exemplo `get-transit-gateway-route-table-propagations` a seguir retorna as propagações da tabela de rotas para a tabela de rotas especificada.
```
aws ec2 get-transit-gateway-route-table-propagations \
--transit-gateway-route-table-id tgw-rtb-002573ed1eEXAMPLE
```
Saída:
```
{
"TransitGatewayRouteTablePropagations": [
{
"TransitGatewayAttachmentId": "tgw-attach-01f8100bc7EXAMPLE",
"ResourceId": "vpc-3EXAMPLE",
"ResourceType": "vpc",
"State": "enabled"
},
{
"TransitGatewayAttachmentId": "tgw-attach-08e0bc912cEXAMPLE",
"ResourceId": "11460968-4ac1-4fd3-bdb2-00599EXAMPLE",
"ResourceType": "direct-connect-gateway",
"State": "enabled"
},
{
"TransitGatewayAttachmentId": "tgw-attach-0a89069f57EXAMPLE",
"ResourceId": "8384da05-13ce-4a91-aada-5a1baEXAMPLE",
"ResourceType": "direct-connect-gateway",
"State": "enabled"
}
]
}
```
Para obter mais informações, consulte [Tabelas de rota do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [GetTransitGatewayRouteTablePropagations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-transit-gateway-route-table-propagations.html)em *Referência de AWS CLI Comandos*.
### `get-verified-access-endpoint-policy`
O código de exemplo a seguir mostra como usar `get-verified-access-endpoint-policy`.
**AWS CLI**
**Obter a política de acesso verificado de um endpoint**
O exemplo `get-verified-access-endpoint-policy` a seguir obtém a política de acesso verificado do endpoint especificado.
```
aws ec2 get-verified-access-endpoint-policy \
--verified-access-endpoint-id vae-066fac616d4d546f2
```
Saída:
```
{
"PolicyEnabled": true,
"PolicyDocument": "permit(principal,action,resource)\nwhen {\n context.identity.groups.contains(\"finance\") &&\n context.identity.email_verified == true\n};"
}
```
Para obter mais informações, consulte [Políticas de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/auth-policies.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [GetVerifiedAccessEndpointPolicy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-verified-access-endpoint-policy.html)em *Referência de AWS CLI Comandos*.
### `get-verified-access-group-policy`
O código de exemplo a seguir mostra como usar `get-verified-access-group-policy`.
**AWS CLI**
**Obter a política de acesso verificado de um grupo**
O exemplo `get-verified-access-group-policy` a seguir obtém a política de acesso verificado do grupo especificado.
```
aws ec2 get-verified-access-group-policy \
--verified-access-group-id vagr-0dbe967baf14b7235
```
Saída:
```
{
"PolicyEnabled": true,
"PolicyDocument": "permit(principal,action,resource)\nwhen {\n context.identity.groups.contains(\"finance\") &&\n context.identity.email_verified == true\n};"
}
```
Para obter mais informações, consulte [Grupos de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-groups.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [GetVerifiedAccessGroupPolicy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-verified-access-group-policy.html)em *Referência de AWS CLI Comandos*.
### `get-vpn-connection-device-sample-configuration`
O código de exemplo a seguir mostra como usar `get-vpn-connection-device-sample-configuration`.
**AWS CLI**
**Fazer download do arquivo de amostra de configuração**
O exemplo `get-vpn-connection-device-sample-configuration` a seguir faz download do arquivo de configuração de amostra especificado. Para listar os dispositivos de gateway com um arquivo de configuração de amostra, chame o comando `get-vpn-connection-device-types`.
```
aws ec2 get-vpn-connection-device-sample-configuration \
--vpn-connection-id vpn-123456789abc01234 \
--vpn-connection-device-type-id 5fb390ba
```
Saída:
```
{
"VpnConnectionDeviceSampleConfiguration": "contents-of-the-sample-configuration-file"
}
```
Para obter mais informações, consulte [Baixar o arquivo de configuração](https://docs.aws.amazon.com/vpn/latest/s2svpn/SetUpVPNConnections.html#vpn-download-config) no *Guia do usuário da AWS Site-to-Site VPN*.
+ Para obter detalhes da API, consulte [GetVpnConnectionDeviceSampleConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-vpn-connection-device-sample-configuration.html)em *Referência de AWS CLI Comandos*.
### `get-vpn-connection-device-types`
O código de exemplo a seguir mostra como usar `get-vpn-connection-device-types`.
**AWS CLI**
**Listar dispositivos de gateway com um arquivo de configuração de amostra**
O exemplo `get-vpn-connection-device-types` a seguir lista os dispositivos de gateway da Palo Alto Networks que têm exemplos de arquivos de configuração.
```
aws ec2 get-vpn-connection-device-types \
--query "VpnConnectionDeviceTypes[?Vendor==`Palo Alto Networks`]"
```
Saída:
```
[
{
"VpnConnectionDeviceTypeId": "754a6372",
"Vendor": "Palo Alto Networks",
"Platform": "PA Series",
"Software": "PANOS 4.1.2+"
},
{
"VpnConnectionDeviceTypeId": "9612cbed",
"Vendor": "Palo Alto Networks",
"Platform": "PA Series",
"Software": "PANOS 4.1.2+ (GUI)"
},
{
"VpnConnectionDeviceTypeId": "5fb390ba",
"Vendor": "Palo Alto Networks",
"Platform": "PA Series",
"Software": "PANOS 7.0+"
}
]
```
Para obter mais informações, consulte [Baixar o arquivo de configuração](https://docs.aws.amazon.com/vpn/latest/s2svpn/SetUpVPNConnections.html#vpn-download-config) no *Guia do usuário da AWS Site-to-Site VPN*.
+ Para obter detalhes da API, consulte [GetVpnConnectionDeviceTypes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-vpn-connection-device-types.html)em *Referência de AWS CLI Comandos*.
### `import-client-vpn-client-certificate-revocation-list`
O código de exemplo a seguir mostra como usar `import-client-vpn-client-certificate-revocation-list`.
**AWS CLI**
**Importar uma lista de revogação de certificados de cliente**
O exemplo `import-client-vpn-client-certificate-revocation-list` a seguir importa uma lista de revogação de certificados de cliente para o endpoint do Client VPN especificando a localização do arquivo no computador local.
```
aws ec2 import-client-vpn-client-certificate-revocation-list \
--certificate-revocation-list file:///path/to/crl.pem \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde
```
Saída:
```
{
"Return": true
}
```
Para obter mais informações, consulte [Listas de revogação de certificados de cliente](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-certificates.html) no *Guia do administrador do AWS Client VPN*.
+ Para obter detalhes da API, consulte [ImportClientVpnClientCertificateRevocationList](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/import-client-vpn-client-certificate-revocation-list.html)em *Referência de AWS CLI Comandos*.
### `import-image`
O código de exemplo a seguir mostra como usar `import-image`.
**AWS CLI**
**Importar um arquivo de imagem da VM como uma AMI**
O exemplo `import-image` a seguir importa o OVA especificado.
```
aws ec2 import-image \
--disk-containers Format=ova,UserBucket="{S3Bucket=my-import-bucket,S3Key=vms/my-server-vm.ova}"
```
Saída:
```
{
"ImportTaskId": "import-ami-1234567890abcdef0",
"Progress": "2",
"SnapshotDetails": [
{
"DiskImageSize": 0.0,
"Format": "ova",
"UserBucket": {
"S3Bucket": "my-import-bucket",
"S3Key": "vms/my-server-vm.ova"
}
}
],
"Status": "active",
"StatusMessage": "pending"
}
```
+ Para obter detalhes da API, consulte [ImportImage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/import-image.html)em *Referência de AWS CLI Comandos*.
### `import-key-pair`
O código de exemplo a seguir mostra como usar `import-key-pair`.
**AWS CLI**
**Importar uma chave pública**
Primeiro, gere um par de chaves com uma ferramenta de sua escolha. Por exemplo, use este comando ssh-keygen:
Comando:
```
ssh-keygen -t rsa -C "my-key" -f ~/.ssh/my-key
```
Saída:
```
Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/ec2-user/.ssh/my-key.
Your public key has been saved in /home/ec2-user/.ssh/my-key.pub.
...
```
Este exemplo de comando importa a chave pública especificada.
Comando:
```
aws ec2 import-key-pair --key-name "my-key" --public-key-material fileb://~/.ssh/my-key.pub
```
Saída:
```
{
"KeyName": "my-key",
"KeyFingerprint": "1f:51:ae:28:bf:89:e9:d8:1f:25:5d:37:2d:7d:b8:ca"
}
```
+ Para obter detalhes da API, consulte [ImportKeyPair](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/import-key-pair.html)em *Referência de AWS CLI Comandos*.
### `import-snapshot`
O código de exemplo a seguir mostra como usar `import-snapshot`.
**AWS CLI**
**Importar um snapshot**
O exemplo `import-snapshot` a seguir importa o disco especificado como um snapshot.
```
aws ec2 import-snapshot \
--description "My server VMDK" \
--disk-container Format=VMDK,UserBucket={'S3Bucket=my-import-bucket,S3Key=vms/my-server-vm.vmdk'}
```
Saída:
```
{
"Description": "My server VMDK",
"ImportTaskId": "import-snap-1234567890abcdef0",
"SnapshotTaskDetail": {
"Description": "My server VMDK",
"DiskImageSize": "0.0",
"Format": "VMDK",
"Progress": "3",
"Status": "active",
"StatusMessage": "pending"
"UserBucket": {
"S3Bucket": "my-import-bucket",
"S3Key": "vms/my-server-vm.vmdk"
}
}
}
```
+ Para obter detalhes da API, consulte [ImportSnapshot](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/import-snapshot.html)em *Referência de AWS CLI Comandos*.
### `list-images-in-recycle-bin`
O código de exemplo a seguir mostra como usar `list-images-in-recycle-bin`.
**AWS CLI**
**Listar as imagens na Lixeira**
O exemplo `list-images-in-recycle-bin` a seguir lista todas as imagens que estão atualmente retidas na Lixeira.
```
aws ec2 list-images-in-recycle-bin
```
Saída:
```
{
"Images": [
{
"RecycleBinEnterTime": "2022-03-14T15:35:08.000Z",
"Description": "Monthly AMI One",
"RecycleBinExitTime": "2022-03-15T15:35:08.000Z",
"Name": "AMI_01",
"ImageId": "ami-0111222333444abcd"
}
]
}
```
Para obter mais informações, consulte [Recuperação AMIs excluída da lixeira no Guia](https://docs.aws.amazon.com/ebs/latest/userguide/recycle-bin-working-with-amis.html) do *usuário do Amazon EBS*.
+ Para obter detalhes da API, consulte [ListImagesInRecycleBin](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/list-images-in-recycle-bin.html)em *Referência de AWS CLI Comandos*.
### `list-snapshots-in-recycle-bin`
O código de exemplo a seguir mostra como usar `list-snapshots-in-recycle-bin`.
**AWS CLI**
**Exibir snapshots na lixeira**
O exemplo `list-snapshots-in-recycle-bin` a seguir lista informações sobre snapshots na Lixeira, incluindo o ID do snapshot, uma descrição do snapshot, o ID do volume do qual o snapshot foi criado, a data e a hora em que o snapshot foi excluído e entrou na Lixeira e a data e a hora em que o período de retenção expira.
```
aws ec2 list-snapshots-in-recycle-bin \
--snapshot-id snap-01234567890abcdef
```
Saída:
```
{
"SnapshotRecycleBinInfo": [
{
"Description": "Monthly data backup snapshot",
"RecycleBinEnterTime": "2022-12-01T13:00:00.000Z",
"RecycleBinExitTime": "2022-12-15T13:00:00.000Z",
"VolumeId": "vol-abcdef09876543210",
"SnapshotId": "snap-01234567890abcdef"
}
]
}
```
Consulte mais informações sobre a Lixeira em [Recover deleted snapshots from the Recycle Bin](https://docs.aws.amazon.com/ebs/latest/userguide/recycle-bin-working-with-snaps.html) no *Manual do usuário do Amazon EBS*.
+ Para obter detalhes da API, consulte [ListSnapshotsInRecycleBin](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/list-snapshots-in-recycle-bin.html)em *Referência de AWS CLI Comandos*.
### `lock-snapshot`
O código de exemplo a seguir mostra como usar `lock-snapshot`.
**AWS CLI**
**Exemplo 1: bloquear um snapshot no modo de governança**
O exemplo `lock-snapshot` a seguir bloqueia o snapshot especificado no modo de governança.
```
aws ec2 lock-snapshot \
--snapshot-id snap-0b5e733b4a8df6e0d \
--lock-mode governance \
--lock-duration 365
```
Saída:
```
{
"SnapshotId": "snap-0b5e733b4a8df6e0d",
"LockState": "governance",
"LockDuration": 365,
"LockCreatedOn": "2024-05-05T00:56:06.208000+00:00",
"LockExpiresOn": "2025-05-05T00:56:06.208000+00:00",
"LockDurationStartTime": "2024-05-05T00:56:06.208000+00:00"
}
```
Para obter mais informações, consulte [Bloqueio de snapshots](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-snapshot-lock.html) no *Guia do usuário do Amazon EBS*.
**Exemplo 2: bloquear um snapshot no modo de conformidade**
O exemplo `lock-snapshot` a seguir bloqueia o snapshot especificado no modo de conformidade.
```
aws ec2 lock-snapshot \
--snapshot-id snap-0163a8524c5b9901f \
--lock-mode compliance \
--cool-off-period 24 \
--lock-duration 365
```
Saída:
```
{
"SnapshotId": "snap-0b5e733b4a8df6e0d",
"LockState": "compliance-cooloff",
"LockDuration": 365,
"CoolOffPeriod": 24,
"CoolOffPeriodExpiresOn": "2024-05-06T01:02:20.527000+00:00",
"LockCreatedOn": "2024-05-05T01:02:20.527000+00:00",
"LockExpiresOn": "2025-05-05T01:02:20.527000+00:00",
"LockDurationStartTime": "2024-05-05T01:02:20.527000+00:00"
}
```
Para obter mais informações, consulte [Bloqueio de snapshots](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-snapshot-lock.html) no *Guia do usuário do Amazon EBS*.
+ Para obter detalhes da API, consulte [LockSnapshot](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/lock-snapshot.html)em *Referência de AWS CLI Comandos*.
### `modify-address-attribute`
O código de exemplo a seguir mostra como usar `modify-address-attribute`.
**AWS CLI**
**Modificar o atributo do nome de domínio associado a um endereço IP elástico**
Os exemplos `modify-address-attribute` a seguir modificam o atributo de nome de domínio de um endereço IP elástico.
Linux
```
aws ec2 modify-address-attribute \
--allocation-id eipalloc-abcdef01234567890 \
--domain-name example.com
```
Windows:
```
aws ec2 modify-address-attribute ^
--allocation-id eipalloc-abcdef01234567890 ^
--domain-name example.com
```
Saída:
```
{
"Addresses": [
{
"PublicIp": "192.0.2.0",
"AllocationId": "eipalloc-abcdef01234567890",
"PtrRecord": "example.net."
"PtrRecordUpdate": {
"Value": "example.com.",
"Status": "PENDING"
}
]
}
```
Para monitorar a alteração pendente e visualizar os atributos modificados de um endereço IP elástico, consulte a Referência [describe-addresses-attribute](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-addresses-attribute.html)de *Comandos da AWS CLI*.
+ Para obter detalhes da API, consulte [ModifyAddressAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-address-attribute.html)em *Referência de AWS CLI Comandos*.
### `modify-availability-zone-group`
O código de exemplo a seguir mostra como usar `modify-availability-zone-group`.
**AWS CLI**
**Habilitar um grupo de zonas**
O exemplo `modify-availability-zone-group` a seguir habilita o grupo de zonas especificado.
```
aws ec2 modify-availability-zone-group \
--group-name us-west-2-lax-1 \
--opt-in-status opted-in
```
Saída:
```
{
"Return": true
}
```
Para obter mais informações, consulte [Regiões e zonas](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [ModifyAvailabilityZoneGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-availability-zone-group.html)em *Referência de AWS CLI Comandos*.
### `modify-capacity-reservation-fleet`
O código de exemplo a seguir mostra como usar `modify-capacity-reservation-fleet`.
**AWS CLI**
**Exemplo 1: modificar a capacidade total de destino de uma Frota de Reserva de Capacidade**
O exemplo `modify-capacity-reservation-fleet` a seguir modifica a capacidade total de destino da Frota de Reserva de Capacidade especificada. Ao modificar a capacidade total de destino de uma frota de reserva de capacidade, a frota cria automaticamente novas reservas de capacidade ou modifica ou cancela as reservas de capacidade existentes na frota para atender à nova capacidade total de destino. Não é possível tentar fazer modificações adicionais em uma frota enquanto ela estiver no estado `modifying`.
```
aws ec2 modify-capacity-reservation-fleet \
--capacity-reservation-fleet-id crf-01234567890abcedf \
--total-target-capacity 160
```
Saída:
```
{
"Return": true
}
```
**Exemplo 2: modificar a data de término de uma frota de reserva de capacidade**
O exemplo `modify-capacity-reservation-fleet` a seguir modifica a data final da Frota de Reserva de Capacidade especificada. Quando você modifica a data de término da frota, as datas de término de todas as reservas de capacidade individuais são atualizadas de maneira adequada. Não é possível tentar fazer modificações adicionais em uma frota enquanto ela estiver no estado `modifying`.
```
aws ec2 modify-capacity-reservation-fleet \
--capacity-reservation-fleet-id crf-01234567890abcedf \
--end-date 2022-07-04T23:59:59.000Z
```
Saída:
```
{
"Return": true
}
```
Para obter mais informações sobre as Frotas de Reserva de Capacidade, consulte [Frotas de reserva de capacidade](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cr-fleets.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [ModifyCapacityReservationFleet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-capacity-reservation-fleet.html)em *Referência de AWS CLI Comandos*.
### `modify-capacity-reservation`
O código de exemplo a seguir mostra como usar `modify-capacity-reservation`.
**AWS CLI**
**Exemplo 1: alterar o número de instâncias reservadas por uma reserva de capacidade existente**
O exemplo `modify-capacity-reservation` a seguir altera o número de instâncias para as quais a reserva de capacidade reserva a capacidade.
```
aws ec2 modify-capacity-reservation \
--capacity-reservation-id cr-1234abcd56EXAMPLE \
--instance-count 5
```
Saída:
```
{
"Return": true
}
```
Consulte mais informações em [Modify a Capacity Reservation](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservations-modify.html) no *Manual do usuário do Amazon EC2*.
**Exemplo 2: alterar a data e a hora de término de uma reserva de capacidade existente**
O exemplo `modify-capacity-reservation` a seguir modifica uma reserva de capacidade existente para terminar na data e na hora especificadas.
```
aws ec2 modify-capacity-reservation \
--capacity-reservation-id cr-1234abcd56EXAMPLE \
--end-date-type limited \
--end-date 2019-08-31T23:59:59Z
```
Consulte mais informações em [Modify a Capacity Reservation](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservations-modify.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [ModifyCapacityReservation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-capacity-reservation.html)em *Referência de AWS CLI Comandos*.
### `modify-client-vpn-endpoint`
O código de exemplo a seguir mostra como usar `modify-client-vpn-endpoint`.
**AWS CLI**
**Modificar um endpoint do Client VPN**
O exemplo `modify-client-vpn-endpoint` a seguir ativa o registro em log da conexão do cliente para o endpoint de Client VPN especificado.
```
aws ec2 modify-client-vpn-endpoint \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde \
--connection-log-options Enabled=true,CloudwatchLogGroup=ClientVPNLogs
```
Saída:
```
{
"Return": true
}
```
Para obter mais informações, consulte [Endpoints de Client VPN](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-endpoints.html) no *Guia do administrador do Cliente VPN da AWS *.
+ Para obter detalhes da API, consulte [ModifyClientVpnEndpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-client-vpn-endpoint.html)em *Referência de AWS CLI Comandos*.
### `modify-default-credit-specification`
O código de exemplo a seguir mostra como usar `modify-default-credit-specification`.
**AWS CLI**
**Modificar a opção de crédito padrão**
O exemplo `modify-default-credit-specification` a seguir modifica a opção de crédito padrão para instâncias T2.
```
aws ec2 modify-default-credit-specification \
--instance-family t2 \
--cpu-credits unlimited
```
Saída:
```
{
"InstanceFamilyCreditSpecification": {
"InstanceFamily": "t2",
"CpuCredits": "unlimited"
}
}
```
+ Para obter detalhes da API, consulte [ModifyDefaultCreditSpecification](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-default-credit-specification.html)em *Referência de AWS CLI Comandos*.
### `modify-ebs-default-kms-key-id`
O código de exemplo a seguir mostra como usar `modify-ebs-default-kms-key-id`.
**AWS CLI**
**Definir a CMK padrão para criptografia do EBS**
O `modify-ebs-default-kms-key-id` exemplo a seguir define a CMK especificada como a CMK padrão para criptografia do EBS para sua AWS conta na região atual.
```
aws ec2 modify-ebs-default-kms-key-id \
--kms-key-id alias/my-cmk
```
Saída:
```
{
"KmsKeyId": "arn:aws:kms:us-west-2:123456789012:key/0ea3fef3-80a7-4778-9d8c-1c0c6EXAMPLE"
}
```
+ Para obter detalhes da API, consulte [ModifyEbsDefaultKmsKeyId](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-ebs-default-kms-key-id.html)em *Referência de AWS CLI Comandos*.
### `modify-fleet`
O código de exemplo a seguir mostra como usar `modify-fleet`.
**AWS CLI**
**Escalar uma frota EC2**
O exemplo `modify-fleet` a seguir modifica a capacidade de destino da Frota EC2 especificada. Se o valor especificado for maior do que a capacidade atual, a Frota EC2 executará instâncias adicionais. Se o valor especificado for menor que a capacidade atual, a Frota EC2 cancela todas as solicitações abertas e, se a política de encerramento for `terminate`, a frota EC2 encerrará todas as instâncias que excederem a nova capacidade de destino.
```
aws ec2 modify-fleet \
--fleet-ids fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE \
--target-capacity-specification TotalTargetCapacity=5
```
Saída:
```
{
"Return": true
}
```
Consulte mais informações em [Trabalhar com uma frota do EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [ModifyFleet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-fleet.html)em *Referência de AWS CLI Comandos*.
### `modify-fpga-image-attribute`
O código de exemplo a seguir mostra como usar `modify-fpga-image-attribute`.
**AWS CLI**
**Modificar os atributos de uma imagem do Amazon FPGA**
Este exemplo adiciona permissões de carregamento para o ID da conta `123456789012` para a AFI especificada.
Comando:
```
aws ec2 modify-fpga-image-attribute --attribute loadPermission --fpga-image-id afi-0d123e123bfc85abc --load-permission Add=[{UserId=123456789012}]
```
Saída:
```
{
"FpgaImageAttribute": {
"FpgaImageId": "afi-0d123e123bfc85abc",
"LoadPermissions": [
{
"UserId": "123456789012"
}
]
}
}
```
+ Para obter detalhes da API, consulte [ModifyFpgaImageAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-fpga-image-attribute.html)em *Referência de AWS CLI Comandos*.
### `modify-hosts`
O código de exemplo a seguir mostra como usar `modify-hosts`.
**AWS CLI**
**Exemplo 1: habilitar o posicionamento automático para um Host Dedicado**
O exemplo `modify-hosts` a seguir habilita o posicionamento automático de um Host dedicado, para que ele aceite todas as execuções de instâncias não direcionadas que correspondam à configuração do tipo de instância.
```
aws ec2 modify-hosts \
--host-id h-06c2f189b4EXAMPLE \
--auto-placement on
```
Saída:
```
{
"Successful": [
"h-06c2f189b4EXAMPLE"
],
"Unsuccessful": []
}
```
Consulte mais informações em [Modificar a configuração de posicionamento automático para um host dedicado](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/modify-host-auto-placement.html) no *Manual do usuário do Amazon EC2*.
**Exemplo 2: habilitar a recuperação de host para um host dedicado**
O exemplo `modify-hosts` a seguir habilita a recuperação de host para o Host Dedicado especificado.
```
aws ec2 modify-hosts \
--host-id h-06c2f189b4EXAMPLE \
--host-recovery on
```
Saída:
```
{
"Successful": [
"h-06c2f189b4EXAMPLE"
],
"Unsuccessful": []
}
```
Consulte mais informações em [Modificar a configuração de posicionamento automático para um host dedicado](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/modify-host-auto-placement.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [ModifyHosts](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-hosts.html)em *Referência de AWS CLI Comandos*.
### `modify-id-format`
O código de exemplo a seguir mostra como usar `modify-id-format`.
**AWS CLI**
**Habilitar o formato de ID mais longo para um recurso**
O exemplo `modify-id-format` a seguir ativa o formato de ID mais longo para o tipo de recurso `instance`.
```
aws ec2 modify-id-format \
--resource instance \
--use-long-ids
```
**Desativar o formato de ID mais longo para um recurso**
O exemplo `modify-id-format` a seguir desativa o formato de ID mais longo para o tipo de recurso `instance`.
```
aws ec2 modify-id-format \
--resource instance \
--no-use-long-ids
```
O exemplo `modify-id-format` a seguir habilita o formato mais longo de ID para todos os tipos de recursos compatíveis que estejam no período de inclusão.
```
aws ec2 modify-id-format \
--resource all-current \
--use-long-ids
```
+ Para obter detalhes da API, consulte [ModifyIdFormat](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-id-format.html)em *Referência de AWS CLI Comandos*.
### `modify-identity-id-format`
O código de exemplo a seguir mostra como usar `modify-identity-id-format`.
**AWS CLI**
**Para permitir que uma função do IAM seja usada IDs por mais tempo em um recurso**
O `modify-identity-id-format` exemplo a seguir permite que a função do IAM `EC2Role` em sua AWS conta use o formato de ID longo para o tipo de `instance` recurso.
```
aws ec2 modify-identity-id-format \
--principal-arn arn:aws:iam::123456789012:role/EC2Role \
--resource instance \
--use-long-ids
```
**Para permitir que um usuário do IAM use IDs por mais tempo um recurso**
O `modify-identity-id-format` exemplo a seguir permite que o usuário do IAM `AdminUser` em sua AWS conta use o formato de ID mais longo para o tipo de `volume` recurso.
```
aws ec2 modify-identity-id-format \
--principal-arn arn:aws:iam::123456789012:user/AdminUser \
--resource volume \
--use-long-ids
```
O `modify-identity-id-format` exemplo a seguir permite que o usuário do IAM `AdminUser` em sua AWS conta use o formato de ID mais longo para todos os tipos de recursos compatíveis que estão dentro do período de inscrição.
```
aws ec2 modify-identity-id-format \
--principal-arn arn:aws:iam::123456789012:user/AdminUser \
--resource all-current \
--use-long-ids
```
+ Para obter detalhes da API, consulte [ModifyIdentityIdFormat](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-identity-id-format.html)em *Referência de AWS CLI Comandos*.
### `modify-image-attribute`
O código de exemplo a seguir mostra como usar `modify-image-attribute`.
**AWS CLI**
**Exemplo 1: tornar uma AMI pública**
O exemplo `modify-instance-attribute` a seguir torna pública a AMI especificada.
```
aws ec2 modify-image-attribute \
--image-id ami-5731123e \
--launch-permission "Add=[{Group=all}]"
```
Este comando não produz saída.
**Exemplo 2: tornar uma AMI privada**
O exemplo `modify-instance-attribute` a seguir torna a AMI especificada privada.
```
aws ec2 modify-image-attribute \
--image-id ami-5731123e \
--launch-permission "Remove=[{Group=all}]"
```
Este comando não produz saída.
**Exemplo 3: para conceder permissão de lançamento a uma AWS conta**
O `modify-instance-attribute` exemplo a seguir concede permissões de lançamento à AWS conta especificada.
```
aws ec2 modify-image-attribute \
--image-id ami-5731123e \
--launch-permission "Add=[{UserId=123456789012}]"
```
Este comando não produz saída.
**Exemplo 4: Para remover a permissão de lançamento de uma AWS conta**
O `modify-instance-attribute` exemplo a seguir remove as permissões de lançamento da AWS conta especificada.
```
aws ec2 modify-image-attribute \
--image-id ami-5731123e \
--launch-permission "Remove=[{UserId=123456789012}]"
```
+ Para obter detalhes da API, consulte [ModifyImageAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-image-attribute.html)em *Referência de AWS CLI Comandos*.
### `modify-instance-attribute`
O código de exemplo a seguir mostra como usar `modify-instance-attribute`.
**AWS CLI**
**Exemplo 1: modificar o tipo de instância**
O exemplo `modify-instance-attribute` a seguir modifica o tipo de instância da instância especificada. A instância deve estar no estado `stopped`.
```
aws ec2 modify-instance-attribute \
--instance-id i-1234567890abcdef0 \
--instance-type "{\"Value\": \"m1.small\"}"
```
Este comando não produz saída.
**Exemplo 2: habilitar a rede aprimorada em uma instância**
O exemplo `modify-instance-attribute` a seguir ativa a rede aprimorada para a instância especificada. A instância deve estar no estado `stopped`.
```
aws ec2 modify-instance-attribute \
--instance-id i-1234567890abcdef0 \
--sriov-net-support simple
```
Este comando não produz saída.
**Exemplo 3: Para modificar o sourceDestCheck atributo**
O exemplo `modify-instance-attribute` a seguir define o atributo `sourceDestCheck` para a instância especificada para `true`. A instância deve estar em uma VPC.
```
aws ec2 modify-instance-attribute --instance-id i-1234567890abcdef0 --source-dest-check "{\"Value\": true}"
```
Este comando não produz saída.
**Exemplo 4: Para modificar o deleteOnTermination atributo do volume raiz**
O exemplo `modify-instance-attribute` a seguir define o atributo `deleteOnTermination` para o volume raiz da instância especificada com suporte do Amazon EBS para `false`. Por padrão, esse atributo é `true` para o volume raiz.
Comando:
```
aws ec2 modify-instance-attribute \
--instance-id i-1234567890abcdef0 \
--block-device-mappings "[{\"DeviceName\": \"/dev/sda1\",\"Ebs\":{\"DeleteOnTermination\":false}}]"
```
Este comando não produz saída.
**Exemplo 5: modificar os dados do usuário anexados a uma instância**
O `modify-instance-attribute` exemplo a seguir adiciona o conteúdo do arquivo `UserData.txt` como UserData o da instância especificada.
Conteúdo do arquivo `UserData.txt` original:
```
#!/bin/bash
yum update -y
service httpd start
chkconfig httpd on
```
O conteúdo do arquivo deve ser codificado em base64. O primeiro comando converte o arquivo de texto em base64 e o salva como um novo arquivo.
Versão Linux/macOS do comando:
```
base64 UserData.txt > UserData.base64.txt
```
Este comando não produz saída.
Versão Windows do comando:
```
certutil -encode UserData.txt tmp.b64 && findstr /v /c:- tmp.b64 > UserData.base64.txt
```
Saída:
```
Input Length = 67
Output Length = 152
CertUtil: -encode command completed successfully.
```
Agora você pode referenciar esse arquivo no comando CLI a seguir:
```
aws ec2 modify-instance-attribute \
--instance-id=i-09b5a14dbca622e76 \
--attribute userData --value file://UserData.base64.txt
```
Este comando não produz saída.
Para obter mais informações, consulte [Dados do usuário e a AWS CLI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html#user-data-api-cli) no Guia do usuário do *EC2*.
+ Para obter detalhes da API, consulte [ModifyInstanceAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-instance-attribute.html)em *Referência de AWS CLI Comandos*.
### `modify-instance-capacity-reservation-attributes`
O código de exemplo a seguir mostra como usar `modify-instance-capacity-reservation-attributes`.
**AWS CLI**
**Exemplo 1: modificar as configurações de segmentação da reserva de capacidade de uma instância**
O exemplo `modify-instance-capacity-reservation-attributes` a seguir modifica uma instância interrompida para ter como destino uma Reserva de capacidade específica.
```
aws ec2 modify-instance-capacity-reservation-attributes \
--instance-id i-EXAMPLE8765abcd4e \
--capacity-reservation-specification 'CapacityReservationTarget={CapacityReservationId= cr-1234abcd56EXAMPLE }'
```
Saída:
```
{
"Return": true
}
```
Consulte mais informações em [Modificar as configurações de reserva de capacidade da instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservations-modify-instance.html) no *Manual do usuário do Amazon EC2*.
**Exemplo 2: modificar as configurações de segmentação da reserva de capacidade de uma instância**
O exemplo `modify-instance-capacity-reservation-attributes` a seguir modifica uma instância interrompida direcionada à reserva de capacidade especificada para execução em qualquer reserva de capacidade que tenha atributos correspondentes (por exemplo, tipo de instância, plataforma, Zona de Disponibilidade) e critérios de correspondência de instância em aberto.
```
aws ec2 modify-instance-capacity-reservation-attributes \
--instance-id i-EXAMPLE8765abcd4e \
--capacity-reservation-specification 'CapacityReservationPreference=open'
```
Saída:
```
{
"Return": true
}
```
Consulte mais informações em [Modificar as configurações de reserva de capacidade da instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservations-modify-instance.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [ModifyInstanceCapacityReservationAttributes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-instance-capacity-reservation-attributes.html)em *Referência de AWS CLI Comandos*.
### `modify-instance-credit-specification`
O código de exemplo a seguir mostra como usar `modify-instance-credit-specification`.
**AWS CLI**
**Modificar a opção de crédito para uso de CPU de uma instância**
Este exemplo modifica a opção de crédito para uso da CPU da instância especificada na região especificada para “ilimitado”. As opções de crédito válidas são “padrão” e “ilimitado”.
Comando:
```
aws ec2 modify-instance-credit-specification --instance-credit-specification "InstanceId=i-1234567890abcdef0,CpuCredits=unlimited"
```
Saída:
```
{
"SuccessfulInstanceCreditSpecifications": [
{
"InstanceId": "i-1234567890abcdef0"
}
],
"UnsuccessfulInstanceCreditSpecifications": []
}
```
+ Para obter detalhes da API, consulte [ModifyInstanceCreditSpecification](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-instance-credit-specification.html)em *Referência de AWS CLI Comandos*.
### `modify-instance-event-start-time`
O código de exemplo a seguir mostra como usar `modify-instance-event-start-time`.
**AWS CLI**
**Modificar o horário de início do evento para uma instância**
O comando `modify-instance-event-start-time` a seguir mostra como modificar a hora de início do evento para a instância especificada. Especifique o ID do evento usando o parâmetro `--instance-event-id`. Especifique a nova data e hora usando o parâmetro `--not-before`.
```
aws ec2 modify-instance-event-start-time --instance-id i-1234567890abcdef0 --instance-event-id instance-event-0abcdef1234567890 --not-before 2019-03-25T10:00:00.000
```
Saída:
```
"Event": {
"InstanceEventId": "instance-event-0abcdef1234567890",
"Code": "system-reboot",
"Description": "scheduled reboot",
"NotAfter": "2019-03-25T12:00:00.000Z",
"NotBefore": "2019-03-25T10:00:00.000Z",
"NotBeforeDeadline": "2019-04-22T21:00:00.000Z"
}
```
Para obter mais informações, consulte Trabalhar com instâncias programadas para reinicialização no *Guia do usuário do Amazon Elastic Compute Cloud*
+ Para obter detalhes da API, consulte [ModifyInstanceEventStartTime](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-instance-event-start-time.html)em *Referência de AWS CLI Comandos*.
### `modify-instance-event-window`
O código de exemplo a seguir mostra como usar `modify-instance-event-window`.
**AWS CLI**
**Exemplo 1: modificar o intervalo de tempo de uma janela de eventos**
O exemplo `modify-instance-event-window` a seguir modifica o intervalo de tempo de uma janela de eventos. Especifique o`time-range`Parâmetro para modificar o intervalo de tempo. Você também deve especificar o parâmetro `cron-expression`.
```
aws ec2 modify-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890
--time-range StartWeekDay=monday,StartHour=2,EndWeekDay=wednesday,EndHour=8
```
Saída:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"TimeRanges": [
{
"StartWeekDay": "monday",
"StartHour": 2,
"EndWeekDay": "wednesday",
"EndHour": 8
}
],
"Name": "myEventWindowName",
"AssociationTarget": {
"InstanceIds": [
"i-0abcdef1234567890",
"i-0be35f9acb8ba01f0"
],
"Tags": [],
"DedicatedHostIds": []
},
"State": "creating",
"Tags": [
{
"Key": "K1",
"Value": "V1"
}
]
}
}
```
Para restrições da janela de eventos, consulte [Considerações](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) na seção Eventos Programados do *Guia do usuário do Amazon EC2*.
**Exemplo 2: modificar um conjunto de intervalos de tempo para uma janela de eventos**
O exemplo `modify-instance-event-window` a seguir modifica o intervalo de tempo de uma janela de eventos. Especifique o`time-range`Parâmetro para modificar o intervalo de tempo. Você também deve especificar o parâmetro `cron-expression`.
```
aws ec2 modify-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890 \
--time-range '[{"StartWeekDay": "monday", "StartHour": 2, "EndWeekDay": "wednesday", "EndHour": 8},
{"StartWeekDay": "thursday", "StartHour": 2, "EndWeekDay": "friday", "EndHour": 8}]'
```
Saída:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"TimeRanges": [
{
"StartWeekDay": "monday",
"StartHour": 2,
"EndWeekDay": "wednesday",
"EndHour": 8
},
{
"StartWeekDay": "thursday",
"StartHour": 2,
"EndWeekDay": "friday",
"EndHour": 8
}
],
"Name": "myEventWindowName",
"AssociationTarget": {
"InstanceIds": [
"i-0abcdef1234567890",
"i-0be35f9acb8ba01f0"
],
"Tags": [],
"DedicatedHostIds": []
},
"State": "creating",
"Tags": [
{
"Key": "K1",
"Value": "V1"
}
]
}
}
```
Para restrições da janela de eventos, consulte [Considerações](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) na seção Eventos Programados do *Guia do usuário do Amazon EC2*.
**Exemplo 3: modificar a expressão cron de uma janela de eventos**
O exemplo `modify-instance-event-window` a seguir modifica a expressão cron de uma janela de eventos. Especifique o`cron-expression`para modificar a expressão cron. Você também deve especificar o parâmetro `time-range`.
```
aws ec2 modify-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890 \
--cron-expression "* 21-23 * * 2,3"
```
Saída:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"AssociationTarget": {
"InstanceIds": [
"i-0abcdef1234567890",
"i-0be35f9acb8ba01f0"
],
"Tags": [],
"DedicatedHostIds": []
},
"State": "creating",
"Tags": [
{
"Key": "K1",
"Value": "V1"
}
]
}
}
```
Para restrições da janela de eventos, consulte [Considerações](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) na seção Eventos Programados do *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [ModifyInstanceEventWindow](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-instance-event-window.html)em *Referência de AWS CLI Comandos*.
### `modify-instance-maintenance-options`
O código de exemplo a seguir mostra como usar `modify-instance-maintenance-options`.
**AWS CLI**
**Exemplo 1: desativar o comportamento de recuperação de uma instância**
O exemplo `modify-instance-maintenance-options` a seguir desabilita a recuperação automática simplificada de uma instância em execução ou interrompida.
```
aws ec2 modify-instance-maintenance-options \
--instance-id i-0abcdef1234567890 \
--auto-recovery disabled
```
Saída:
```
{
"InstanceId": "i-0abcdef1234567890",
"AutoRecovery": "disabled"
}
```
Consulte mais informações em [Configurar a recuperação automática simplificada](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-configuration-recovery.html) no *Manual do usuário do Amazon EC2*.
**Exemplo 2: definir o comportamento de recuperação de uma instância como padrão**
O exemplo `modify-instance-maintenance-options` a seguir define o comportamento de recuperação automática como padrão, o que permite a recuperação automática simplificada para tipos de instância compatíveis.
```
aws ec2 modify-instance-maintenance-options \
--instance-id i-0abcdef1234567890 \
--auto-recovery default
```
Saída:
```
{
"InstanceId": "i-0abcdef1234567890",
"AutoRecovery": "default"
}
```
Consulte mais informações em [Configurar a recuperação automática simplificada](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-configuration-recovery.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [ModifyInstanceMaintenanceOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-instance-maintenance-options.html)em *Referência de AWS CLI Comandos*.
### `modify-instance-metadata-options`
O código de exemplo a seguir mostra como usar `modify-instance-metadata-options`.
**AWS CLI**
**Exemplo 1: Para habilitar IMDSv2**
O `modify-instance-metadata-options` exemplo a seguir configura o uso de IMDSv2 na instância especificada.
```
aws ec2 modify-instance-metadata-options \
--instance-id i-1234567898abcdef0 \
--http-tokens required \
--http-endpoint enabled
```
Saída:
```
{
"InstanceId": "i-1234567898abcdef0",
"InstanceMetadataOptions": {
"State": "pending",
"HttpTokens": "required",
"HttpPutResponseHopLimit": 1,
"HttpEndpoint": "enabled"
}
}
```
Para mais informações, consulte [Metadados da instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) no *Manual do usuário do Amazon EC2*.
**Exemplo 2: desativar os metadados da instância**
O exemplo `modify-instance-metadata-options` a seguir desativa o uso de todas as versões dos metadados da instância na instância especificada.
```
aws ec2 modify-instance-metadata-options \
--instance-id i-1234567898abcdef0 \
--http-endpoint disabled
```
Saída:
```
{
"InstanceId": "i-1234567898abcdef0",
"InstanceMetadataOptions": {
"State": "pending",
"HttpTokens": "required",
"HttpPutResponseHopLimit": 1,
"HttpEndpoint": "disabled"
}
}
```
Para mais informações, consulte [Metadados da instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) no *Manual do usuário do Amazon EC2*.
**Exemplo 3: Para habilitar o IPv6 endpoint de metadados da instância para sua instância**
O `modify-instance-metadata-options` exemplo a seguir mostra como ativar o IPv6 endpoint para o serviço de metadados da instância. Por padrão, o IPv6 endpoint está desativado. Isso é verdade mesmo se você tiver iniciado uma instância em uma IPv6 sub-rede somente. O IPv6 endpoint do IMDS só pode ser acessado em instâncias criadas no Sistema Nitro.
```
aws ec2 modify-instance-metadata-options \
--instance-id i-1234567898abcdef0 \
--http-protocol-ipv6 enabled \
--http-endpoint enabled
```
Saída:
```
{
"InstanceId": "i-1234567898abcdef0",
"InstanceMetadataOptions": {
"State": "pending",
"HttpTokens": "required",
"HttpPutResponseHopLimit": 1,
"HttpEndpoint": "enabled",
HttpProtocolIpv6": "enabled"
}
}
```
Para mais informações, consulte [Metadados da instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [ModifyInstanceMetadataOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-instance-metadata-options.html)em *Referência de AWS CLI Comandos*.
### `modify-instance-placement`
O código de exemplo a seguir mostra como usar `modify-instance-placement`.
**AWS CLI**
**Exemplo 1: remover a afinidade de uma instância com um host dedicado**
O exemplo `modify-instance-placement` a seguir remove a afinidade de uma instância com um Host dedicado e habilita esse host para execução em qualquer Host dedicado disponível na conta que ofereça suporte ao seu tipo de instância.
```
aws ec2 modify-instance-placement \
--instance-id i-0e6ddf6187EXAMPLE \
--affinity default
```
Saída:
```
{
"Return": true
}
```
**Exemplo 2: estabelecer afinidade entre uma instância e o host dedicado especificado**
O exemplo `modify-instance-placement` a seguir estabelece uma relação de execução entre uma instância e um Host Dedicado. A instância só pode ser executada no Host Dedicado especificado.
```
aws ec2 modify-instance-placement \
--instance-id i-0e6ddf6187EXAMPLE \
--affinity host \
--host-id i-0e6ddf6187EXAMPLE
```
Saída:
```
{
"Return": true
}
```
**Exemplo 3: mover uma instância para um grupo de posicionamento**
O exemplo `modify-instance-placement` a seguir move uma instância para um grupo de posicionamento, interrompe a instância, modifica o posicionamento da instância e, em seguida, reinicia a instância.
```
aws ec2 stop-instances \
--instance-ids i-0123a456700123456
aws ec2 modify-instance-placement \
--instance-id i-0123a456700123456 \
--group-name MySpreadGroup
aws ec2 start-instances \
--instance-ids i-0123a456700123456
```
**Exemplo 4: remover uma instância de um grupo de posicionamento**
O exemplo `modify-instance-placement` a seguir remove uma instância de um grupo de posicionamento interrompendo a instância, modificando o posicionamento da instância e depois reiniciando a instância. O exemplo a seguir especifica uma string vazia ("") para o nome do grupo de posicionamento para indicar que a instância não deve estar localizada em um grupo de posicionamento.
Interromper a instância:
```
aws ec2 stop-instances \
--instance-ids i-0123a456700123456
```
Modificar o posicionamento (prompt de comando do Windows):
```
aws ec2 modify-instance-placement \
--instance-id i-0123a456700123456 \
--group-name ""
```
Modifique o posicionamento (Windows PowerShell, Linux e macOS):
```
aws ec2 modify-instance-placement `
--instance-id i-0123a456700123456 `
--group-name ''
```
Reinicie a instância:
```
aws ec2 start-instances \
--instance-ids i-0123a456700123456
```
Saída:
```
{
"Return": true
}
```
Consulte mais informações em [Modificar a locação e a afinidade de host dedicado](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/moving-instances-dedicated-hosts.html) no *Manual do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [ModifyInstancePlacement](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-instance-placement.html)em *Referência de AWS CLI Comandos*.
### `modify-ipam-pool`
O código de exemplo a seguir mostra como usar `modify-ipam-pool`.
**AWS CLI**
**Modificar um pool IPAM**
O exemplo `modify-ipam-pool` a seguir modifica um pool IPAM.
(Linux):
```
aws ec2 modify-ipam-pool \
--ipam-pool-id ipam-pool-0533048da7d823723 \
--add-allocation-resource-tags "Key=Owner,Value=Build Team" \
--clear-allocation-default-netmask-length \
--allocation-min-netmask-length 14
```
(Windows):
```
aws ec2 modify-ipam-pool ^
--ipam-pool-id ipam-pool-0533048da7d823723 ^
--add-allocation-resource-tags "Key=Owner,Value=Build Team" ^
--clear-allocation-default-netmask-length ^
--allocation-min-netmask-length 14
```
Saída:
```
{
"IpamPool": {
"OwnerId": "123456789012",
"IpamPoolId": "ipam-pool-0533048da7d823723",
"IpamPoolArn": "arn:aws:ec2::123456789012:ipam-pool/ipam-pool-0533048da7d823723",
"IpamScopeArn": "arn:aws:ec2::123456789012:ipam-scope/ipam-scope-02fc38cd4c48e7d38",
"IpamScopeType": "private",
"IpamArn": "arn:aws:ec2::123456789012:ipam/ipam-08440e7a3acde3908",
"IpamRegion": "us-east-1",
"Locale": "None",
"PoolDepth": 1,
"State": "modify-complete",
"AutoImport": true,
"AddressFamily": "ipv4",
"AllocationMinNetmaskLength": 14,
"AllocationMaxNetmaskLength": 26,
"AllocationResourceTags": [
{
"Key": "Environment",
"Value": "Preprod"
},
{
"Key": "Owner",
"Value": "Build Team"
}
]
}
}
```
Para obter mais informações, consulte [Editar um pool](https://docs.aws.amazon.com/vpc/latest/ipam/mod-pool-ipam.html) no *Guia do usuário do IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [ModifyIpamPool](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-ipam-pool.html)em *Referência de AWS CLI Comandos*.
### `modify-ipam-resource-cidr`
O código de exemplo a seguir mostra como usar `modify-ipam-resource-cidr`.
**AWS CLI**
**Modificar o CIDR alocado a um recurso**
O exemplo `modify-ipam-resource-cidr` a seguir modifica um CIDR de recurso.
(Linux):
```
aws ec2 modify-ipam-resource-cidr \
--current-ipam-scope-id ipam-scope-02fc38cd4c48e7d38 \
--destination-ipam-scope-id ipam-scope-0da34c61fd189a141 \
--resource-id vpc-010e1791024eb0af9 \
--resource-cidr 10.0.1.0/24 \
--resource-region us-east-1 \
--monitored
```
(Windows):
```
aws ec2 modify-ipam-resource-cidr ^
--current-ipam-scope-id ipam-scope-02fc38cd4c48e7d38 ^
--destination-ipam-scope-id ipam-scope-0da34c61fd189a141 ^
--resource-id vpc-010e1791024eb0af9 ^
--resource-cidr 10.0.1.0/24 ^
--resource-region us-east-1 ^
--monitored
```
Saída:
```
{
"IpamResourceCidr": {
"IpamId": "ipam-08440e7a3acde3908",
"IpamScopeId": "ipam-scope-0da34c61fd189a141",
"IpamPoolId": "ipam-pool-0533048da7d823723",
"ResourceRegion": "us-east-1",
"ResourceOwnerId": "123456789012",
"ResourceId": "vpc-010e1791024eb0af9",
"ResourceCidr": "10.0.1.0/24",
"ResourceType": "vpc",
"ResourceTags": [
{
"Key": "Environment",
"Value": "Preprod"
},
{
"Key": "Owner",
"Value": "Build Team"
}
],
"IpUsage": 0.0,
"ComplianceStatus": "noncompliant",
"ManagementState": "managed",
"OverlapStatus": "overlapping",
"VpcId": "vpc-010e1791024eb0af9"
}
}
```
Para obter mais informações sobre movimentação de recursos, consulte [Movimentar recursos CIDRs entre escopos](https://docs.aws.amazon.com/vpc/latest/ipam/move-resource-ipam.html) no Guia do usuário *IPAM da Amazon VPC*.
Para obter mais informações sobre a alteração dos estados de monitoramento, consulte [Alterar o estado de monitoramento do recurso CIDRs](https://docs.aws.amazon.com/vpc/latest/ipam/change-monitoring-state-ipam.html) no Guia do *usuário IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [ModifyIpamResourceCidr](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-ipam-resource-cidr.html)em *Referência de AWS CLI Comandos*.
### `modify-ipam-resource-discovery`
O código de exemplo a seguir mostra como usar `modify-ipam-resource-discovery`.
**AWS CLI**
**Modificar as regiões operacionais de uma descoberta de recursos**
Neste exemplo, você é um administrador delegado do IPAM que deseja modificar as regiões operacionais de uma descoberta de recursos.
Para concluir essa solicitação:
Você não pode modificar uma descoberta de recursos padrão e deve ser o proprietário da descoberta do recurso. Você precisa da ID de descoberta do recurso, com a qual você pode obter. [describe-ipam-resource-discoveries](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-ipam-resource-discoveries.html)
O `modify-ipam-resource-discovery` exemplo a seguir modifica uma descoberta de recursos não padrão em sua AWS conta.
```
aws ec2 modify-ipam-resource-discovery \
--ipam-resource-discovery-id ipam-res-disco-0f4ef577a9f37a162 \
--add-operating-regions RegionName='us-west-1' \
--remove-operating-regions RegionName='us-east-2' \
--region us-east-1
```
Saída:
```
{
"IpamResourceDiscovery": {
"OwnerId": "149977607591",
"IpamResourceDiscoveryId": "ipam-res-disco-0365d2977fc1672fe",
"IpamResourceDiscoveryArn": "arn:aws:ec2::149977607591:ipam-resource-discovery/ipam-res-disco-0365d2977fc1672fe",
"IpamResourceDiscoveryRegion": "us-east-1",
"Description": "Example",
"OperatingRegions": [
{
"RegionName": "us-east-1"
},
{
"RegionName": "us-west-1"
}
],
"IsDefault": false,
"State": "modify-in-progress"
}
}
```
Para obter mais informações, consulte [Trabalhar com descobertas de recurso](https://docs.aws.amazon.com/vpc/latest/ipam/res-disc-work-with.html) no *Guia do usuário da Amazon VPC IPAM*.
+ Para obter detalhes da API, consulte [ModifyIpamResourceDiscovery](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-ipam-resource-discovery.html)em *Referência de AWS CLI Comandos*.
### `modify-ipam-scope`
O código de exemplo a seguir mostra como usar `modify-ipam-scope`.
**AWS CLI**
**Modificar a descrição de um escopo**
Nesse cenário, você é um administrador delegado do IPAM que deseja modificar a descrição de um escopo do IPAM.
Para concluir essa solicitação, você precisará do ID do escopo, com o qual você pode obter [describe-ipam-scopes](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-ipam-scopes.html).
O exemplo `modify-ipam-scope` a seguir atualiza a descrição do escopo.
```
aws ec2 modify-ipam-scope \
--ipam-scope-id ipam-scope-0d3539a30b57dcdd1 \
--description example \
--region us-east-1
```
Saída:
```
{
"IpamScope": {
"OwnerId": "320805250157",
"IpamScopeId": "ipam-scope-0d3539a30b57dcdd1",
"IpamScopeArn": "arn:aws:ec2::320805250157:ipam-scope/ipam-scope-0d3539a30b57dcdd1",
"IpamArn": "arn:aws:ec2::320805250157:ipam/ipam-005f921c17ebd5107",
"IpamRegion": "us-east-1",
"IpamScopeType": "public",
"IsDefault": true,
"Description": "example",
"PoolCount": 1,
"State": "modify-in-progress"
}
}
```
Para mais informações sobre escopos, consulte [Como o IPAM funciona](https://docs.aws.amazon.com/vpc/latest/ipam/how-it-works-ipam.html), no *Guia do usuário do Amazon VPC IPAM*.
+ Para obter detalhes da API, consulte [ModifyIpamScope](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-ipam-scope.html)em *Referência de AWS CLI Comandos*.
### `modify-ipam`
O código de exemplo a seguir mostra como usar `modify-ipam`.
**AWS CLI**
**Modificar um IPAM**
O exemplo `modify-ipam` a seguir modifica um IPAM adicionando uma região operacional.
(Linux):
```
aws ec2 modify-ipam \
--ipam-id ipam-08440e7a3acde3908 \
--add-operating-regions RegionName=us-west-2
```
(Windows):
```
aws ec2 modify-ipam ^
--ipam-id ipam-08440e7a3acde3908 ^
--add-operating-regions RegionName=us-west-2
```
Saída:
```
{
"Ipam": {
"OwnerId": "123456789012",
"IpamId": "ipam-08440e7a3acde3908",
"IpamArn": "arn:aws:ec2::123456789012:ipam/ipam-08440e7a3acde3908",
"IpamRegion": "us-east-1",
"PublicDefaultScopeId": "ipam-scope-0b9eed026396dbc16",
"PrivateDefaultScopeId": "ipam-scope-02fc38cd4c48e7d38",
"ScopeCount": 3,
"OperatingRegions": [
{
"RegionName": "us-east-1"
},
{
"RegionName": "us-east-2"
},
{
"RegionName": "us-west-1"
},
{
"RegionName": "us-west-2"
}
],
"State": "modify-in-progress"
}
}
```
+ Para obter detalhes da API, consulte [ModifyIpam](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-ipam.html)em *Referência de AWS CLI Comandos*.
### `modify-launch-template`
O código de exemplo a seguir mostra como usar `modify-launch-template`.
**AWS CLI**
**Alterar a versão do modelo de inicialização padrão**
Este exemplo especifica a versão 2 do modelo de execução especificado como a versão padrão.
Comando:
```
aws ec2 modify-launch-template --launch-template-id lt-0abcd290751193123 --default-version 2
```
Saída:
```
{
"LaunchTemplate": {
"LatestVersionNumber": 2,
"LaunchTemplateId": "lt-0abcd290751193123",
"LaunchTemplateName": "WebServers",
"DefaultVersionNumber": 2,
"CreatedBy": "arn:aws:iam::123456789012:root",
"CreateTime": "2017-12-01T13:35:46.000Z"
}
}
```
+ Para obter detalhes da API, consulte [ModifyLaunchTemplate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-launch-template.html)em *Referência de AWS CLI Comandos*.
### `modify-managed-prefix-list`
O código de exemplo a seguir mostra como usar `modify-managed-prefix-list`.
**AWS CLI**
**Modificar uma lista de prefixos**
O exemplo `modify-managed-prefix-list` a seguir adiciona uma entrada à lista de prefixos especificada.
```
aws ec2 modify-managed-prefix-list \
--prefix-list-id pl-0123456abcabcabc1 \
--add-entries Cidr=10.1.0.0/16,Description=vpc-c \
--current-version 1
```
Saída:
```
{
"PrefixList": {
"PrefixListId": "pl-0123456abcabcabc1",
"AddressFamily": "IPv4",
"State": "modify-in-progress",
"PrefixListArn": "arn:aws:ec2:us-west-2:123456789012:prefix-list/pl-0123456abcabcabc1",
"PrefixListName": "vpc-cidrs",
"MaxEntries": 10,
"Version": 1,
"OwnerId": "123456789012"
}
}
```
Para obter mais informações, consulte [Listas de prefixos gerenciados](https://docs.aws.amazon.com/vpc/latest/userguide/managed-prefix-lists.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [ModifyManagedPrefixList](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-managed-prefix-list.html)em *Referência de AWS CLI Comandos*.
### `modify-network-interface-attribute`
O código de exemplo a seguir mostra como usar `modify-network-interface-attribute`.
**AWS CLI**
**Modificar o atributo de anexo de uma interface de rede**
Este exemplo de comando modifica o atributo `attachment` da interface de rede especificada.
Comando:
```
aws ec2 modify-network-interface-attribute --network-interface-id eni-686ea200 --attachment AttachmentId=eni-attach-43348162,DeleteOnTermination=false
```
**Modificar o atributo de descrição de uma interface de rede**
Este exemplo de comando modifica o atributo `description` da interface de rede especificada.
Comando:
```
aws ec2 modify-network-interface-attribute --network-interface-id eni-686ea200 --description "My description"
```
**Modificar o atributo groupSet de uma interface de rede**
Este exemplo de comando modifica o atributo `groupSet` da interface de rede especificada.
Comando:
```
aws ec2 modify-network-interface-attribute --network-interface-id eni-686ea200 --groups sg-903004f8 sg-1a2b3c4d
```
**Para modificar o sourceDestCheck atributo de uma interface de rede**
Este exemplo de comando modifica o atributo `sourceDestCheck` da interface de rede especificada.
Comando:
```
aws ec2 modify-network-interface-attribute --network-interface-id eni-686ea200 --no-source-dest-check
```
+ Para obter detalhes da API, consulte [ModifyNetworkInterfaceAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-network-interface-attribute.html)em *Referência de AWS CLI Comandos*.
### `modify-private-dns-name-options`
O código de exemplo a seguir mostra como usar `modify-private-dns-name-options`.
**AWS CLI**
**Modificar as opções para nomes de host de instância.**
O exemplo `modify-private-dns-name-options` a seguir desabilita a opção de responder a consultas ao DNS para nomes de host da instância com registros A do DNS.
```
aws ec2 modify-private-dns-name-options \
--instance-id i-1234567890abcdef0 \
--no-enable-resource-name-dns-a-record
```
Saída:
```
{
"Return": true
}
```
Para obter mais informações, consulte [Tipos de nomes do host de instâncias do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [ModifyPrivateDnsNameOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-private-dns-name-options.html)em *Referência de AWS CLI Comandos*.
### `modify-reserved-instances`
O código de exemplo a seguir mostra como usar `modify-reserved-instances`.
**AWS CLI**
**Modificar instâncias reservadas**
Esse exemplo de comando move uma instância reservada para outra zona de disponibilidade na mesma região.
Comando:
```
aws ec2 modify-reserved-instances --reserved-instances-ids b847fa93-e282-4f55-b59a-1342f5bd7c02 --target-configurations AvailabilityZone=us-west-1c,Platform=EC2-Classic,InstanceCount=10
```
Saída:
```
{
"ReservedInstancesModificationId": "rimod-d3ed4335-b1d3-4de6-ab31-0f13aaf46687"
}
```
**Modificar a plataforma de rede das Instâncias Reservadas**
Este exemplo de comando converte Instâncias Reservadas do EC2-Classic em EC2-VPC.
Comando:
```
aws ec2 modify-reserved-instances --reserved-instances-ids f127bd27-edb7-44c9-a0eb-0d7e09259af0 --target-configurations AvailabilityZone=us-west-1c,Platform=EC2-VPC,InstanceCount=5
```
Saída:
```
{
"ReservedInstancesModificationId": "rimod-82fa9020-668f-4fb6-945d-61537009d291"
}
```
Para obter mais informações, consulte Modificar Instâncias Reservadas no *Guia do usuário do Amazon EC2*.
**Modificar o tamanho de instância de instâncias reservadas**
Este exemplo de comando modifica uma instância reservada que tem 10 instâncias m1.small em us-west-1c para que 8 Linux/UNIX instâncias m1.small se tornem 2 instâncias m1.large e as 2 m1.small restantes se tornem 1 instância m1.medium na mesma zona de disponibilidade. Comando:
```
aws ec2 modify-reserved-instances --reserved-instances-ids 1ba8e2e3-3556-4264-949e-63ee671405a9 --target-configurations AvailabilityZone=us-west-1c,Platform=EC2-Classic,InstanceCount=2,InstanceType=m1.large AvailabilityZone=us-west-1c,Platform=EC2-Classic,InstanceCount=1,InstanceType=m1.medium
```
Saída:
```
{
"ReservedInstancesModificationId": "rimod-acc5f240-080d-4717-b3e3-1c6b11fa00b6"
}
```
Para obter mais informações, consulte Modificar o tamanho da instância de suas reservas no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [ModifyReservedInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-reserved-instances.html)em *Referência de AWS CLI Comandos*.
### `modify-security-group-rules`
O código de exemplo a seguir mostra como usar `modify-security-group-rules`.
**AWS CLI**
**Para modificar as regras de um grupo de segurança para atualizar a descrição da regra, o protocolo IP e o intervalo de CidrIpv 4 endereços**
O `modify-security-group-rules` exemplo a seguir atualiza a descrição, o protocolo IP e o intervalo IPV4 CIDR de uma regra de grupo de segurança especificada. Use o parâmetro `security-group-rules` para inserir as atualizações para as regras do grupo de segurança especificado. `-1` especifica todos os protocolos.
```
aws ec2 modify-security-group-rules \
--group-id sg-1234567890abcdef0 \
--security-group-rules SecurityGroupRuleId=sgr-abcdef01234567890,SecurityGroupRule='{Description=test,IpProtocol=-1,CidrIpv4=0.0.0.0/0}'
```
Saída:
```
{
"Return": true
}
```
Para obter mais informações sobre regras de grupo de segurança, consulte [Regras de grupo de segurança](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules.html) no *Guia do usuário da Amazon EC2*.
+ Para obter detalhes da API, consulte [ModifySecurityGroupRules](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-security-group-rules.html)em *Referência de AWS CLI Comandos*.
### `modify-snapshot-attribute`
O código de exemplo a seguir mostra como usar `modify-snapshot-attribute`.
**AWS CLI**
**Exemplo 1: modificar um atributo de snapshot**
O exemplo `modify-snapshot-attribute` a seguir atualiza o atributo `createVolumePermission` do snapshot especificado, removendo as permissões de volume do usuário especificado.
```
aws ec2 modify-snapshot-attribute \
--snapshot-id snap-1234567890abcdef0 \
--attribute createVolumePermission \
--operation-type remove \
--user-ids 123456789012
```
**Exemplo 2: tornar público um snapshot**
O exemplo `modify-snapshot-attribute` a seguir torna público o snapshot especificado.
```
aws ec2 modify-snapshot-attribute \
--snapshot-id snap-1234567890abcdef0 \
--attribute createVolumePermission \
--operation-type add \
--group-names all
```
+ Para obter detalhes da API, consulte [ModifySnapshotAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-snapshot-attribute.html)em *Referência de AWS CLI Comandos*.
### `modify-snapshot-tier`
O código de exemplo a seguir mostra como usar `modify-snapshot-tier`.
**AWS CLI**
**Como arquivar um snapshot**
O exemplo `modify-snapshot-tier` a seguir arquiva o snapshot especificado. O parâmetro de resposta `TieringStartTime` indica a data e hora em que o processo de arquivamento foi iniciado, no formato de hora UTC (AAAA-MM-DDTHH:MM:SSZ).
```
aws ec2 modify-snapshot-tier \
--snapshot-id snap-01234567890abcedf \
--storage-tier archive
```
Saída:
```
{
"SnapshotId": "snap-01234567890abcedf",
"TieringStartTime": "2021-09-15T16:44:37.574Z"
}
```
Consulte mais informações sobre o arquivamento de snapshots em [Archive Amazon EBS snapshots](https://docs.aws.amazon.com/ebs/latest/userguide/snapshot-archive.html) no *Guia do usuário do Amazon EBS*.
+ Para obter detalhes da API, consulte [ModifySnapshotTier](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-snapshot-tier.html)em *Referência de AWS CLI Comandos*.
### `modify-spot-fleet-request`
O código de exemplo a seguir mostra como usar `modify-spot-fleet-request`.
**AWS CLI**
**Modificar uma solicitação de frota spot**
Este comando de exemplo atualiza a capacidade de destino da solicitação de frota Spot especificada.
Comando:
```
aws ec2 modify-spot-fleet-request --target-capacity 20 --spot-fleet-request-id sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE
```
Saída:
```
{
"Return": true
}
```
Este exemplo de comando diminui a capacidade de destino da frota Spot especificada sem encerrar qualquer instância Spot como resultado.
Comando:
```
aws ec2 modify-spot-fleet-request --target-capacity 10 --excess-capacity-termination-policy NoTermination --spot-fleet-request-ids sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE
```
Saída:
```
{
"Return": true
}
```
+ Para obter detalhes da API, consulte [ModifySpotFleetRequest](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-spot-fleet-request.html)em *Referência de AWS CLI Comandos*.
### `modify-subnet-attribute`
O código de exemplo a seguir mostra como usar `modify-subnet-attribute`.
**AWS CLI**
**Para alterar o comportamento de IPv4 endereçamento público de uma sub-rede**
Este exemplo modifica a subnet-1a2b3c4d para especificar que todas as instâncias executadas nessa sub-rede recebam um endereço público. IPv4 Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 modify-subnet-attribute --subnet-id subnet-1a2b3c4d --map-public-ip-on-launch
```
**Para alterar o comportamento de IPv6 endereçamento de uma sub-rede**
Este exemplo modifica a subnet-1a2b3c4d para especificar que todas as instâncias executadas nessa sub-rede recebam um endereço do intervalo da sub-rede. IPv6
Comando:
```
aws ec2 modify-subnet-attribute --subnet-id subnet-1a2b3c4d --assign-ipv6-address-on-creation
```
Para obter mais informações, consulte Endereço IP na VPC no *Guia do usuário da Nuvem privada virtual AWS *.
+ Para obter detalhes da API, consulte [ModifySubnetAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-subnet-attribute.html)em *Referência de AWS CLI Comandos*.
### `modify-traffic-mirror-filter-network-services`
O código de exemplo a seguir mostra como usar `modify-traffic-mirror-filter-network-services`.
**AWS CLI**
**Adicionar serviços de rede a um filtro de espelhamento de tráfego**
O exemplo `modify-traffic-mirror-filter-network-services` a seguir adiciona os serviços de rede Amazon DNS ao filtro especificado.
```
aws ec2 modify-traffic-mirror-filter-network-services \
--traffic-mirror-filter-id tmf-04812ff784EXAMPLE \
--add-network-service amazon-dns
```
Saída:
```
{
"TrafficMirrorFilter": {
"Tags": [
{
"Key": "Name",
"Value": "Production"
}
],
"EgressFilterRules": [],
"NetworkServices": [
"amazon-dns"
],
"TrafficMirrorFilterId": "tmf-04812ff784EXAMPLE",
"IngressFilterRules": [
{
"SourceCidrBlock": "0.0.0.0/0",
"RuleNumber": 1,
"DestinationCidrBlock": "0.0.0.0/0",
"Description": "TCP Rule",
"Protocol": 6,
"TrafficDirection": "ingress",
"TrafficMirrorFilterId": "tmf-04812ff784EXAMPLE",
"RuleAction": "accept",
"TrafficMirrorFilterRuleId": "tmf-04812ff784EXAMPLE"
}
]
}
}
```
Para obter mais informações, consulte [Modificar serviços de rede do filtro de espelhamento de tráfego](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-filter.html#modify-traffic-mirroring-filter-network-services) do *Guia de espelhamento de tráfego da AWS *.
+ Para obter detalhes da API, consulte [ModifyTrafficMirrorFilterNetworkServices](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-traffic-mirror-filter-network-services.html)em *Referência de AWS CLI Comandos*.
### `modify-traffic-mirror-filter-rule`
O código de exemplo a seguir mostra como usar `modify-traffic-mirror-filter-rule`.
**AWS CLI**
**Modificar uma regra de filtro de espelhamento de tráfego**
O exemplo `modify-traffic-mirror-filter-rule` a seguir modifica a descrição da regra de filtro de espelhamento de tráfego especificada.
```
aws ec2 modify-traffic-mirror-filter-rule \
--traffic-mirror-filter-rule-id tmfr-0ca76e0e08EXAMPLE \
--description "TCP Rule"
```
Saída:
```
{
"TrafficMirrorFilterRule": {
"TrafficMirrorFilterRuleId": "tmfr-0ca76e0e08EXAMPLE",
"TrafficMirrorFilterId": "tmf-0293f26e86EXAMPLE",
"TrafficDirection": "ingress",
"RuleNumber": 100,
"RuleAction": "accept",
"Protocol": 6,
"DestinationCidrBlock": "10.0.0.0/24",
"SourceCidrBlock": "10.0.0.0/24",
"Description": "TCP Rule"
}
}
```
Para obter mais informações, consulte [Modificar suas regras de filtro de espelhamento de tráfego](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-filter.html#modify-traffic-mirroring-filter-rules) no *Guia de espelhamento de tráfego da AWS *.
+ Para obter detalhes da API, consulte [ModifyTrafficMirrorFilterRule](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-traffic-mirror-filter-rule.html)em *Referência de AWS CLI Comandos*.
### `modify-traffic-mirror-session`
O código de exemplo a seguir mostra como usar `modify-traffic-mirror-session`.
**AWS CLI**
**Modificar uma sessão de espelhamento de tráfego**
O exemplo `modify-traffic-mirror-session` a seguir altera a descrição da sessão do espelhamento de tráfego e o número de pacotes a serem espelhados.
```
aws ec2 modify-traffic-mirror-session \
--description "Change packet length" \
--traffic-mirror-session-id tms-08a33b1214EXAMPLE \
--remove-fields "packet-length"
```
Saída:
```
{
"TrafficMirrorSession": {
"TrafficMirrorSessionId": "tms-08a33b1214EXAMPLE",
"TrafficMirrorTargetId": "tmt-07f75d8feeEXAMPLE",
"TrafficMirrorFilterId": "tmf-04812ff784EXAMPLE",
"NetworkInterfaceId": "eni-070203f901EXAMPLE",
"OwnerId": "111122223333",
"SessionNumber": 1,
"VirtualNetworkId": 7159709,
"Description": "Change packet length",
"Tags": []
}
}
```
Para obter mais informações, consulte [Modificar sessão de espelhamento de tráfego](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-session.html#modify-traffic-mirroring-session) no *Guia de espelhamento de tráfego*.
+ Para obter detalhes da API, consulte [ModifyTrafficMirrorSession](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-traffic-mirror-session.html)em *Referência de AWS CLI Comandos*.
### `modify-transit-gateway-prefix-list-reference`
O código de exemplo a seguir mostra como usar `modify-transit-gateway-prefix-list-reference`.
**AWS CLI**
**Modificar uma referência da lista de prefixos**
O exemplo `modify-transit-gateway-prefix-list-reference` a seguir modifica a referência da lista de prefixos na tabela de rotas especificada alterando o anexo para o qual o tráfego é roteado.
```
aws ec2 modify-transit-gateway-prefix-list-reference \
--transit-gateway-route-table-id tgw-rtb-0123456789abcd123 \
--prefix-list-id pl-11111122222222333 \
--transit-gateway-attachment-id tgw-attach-aabbccddaabbccaab
```
Saída:
```
{
"TransitGatewayPrefixListReference": {
"TransitGatewayRouteTableId": "tgw-rtb-0123456789abcd123",
"PrefixListId": "pl-11111122222222333",
"PrefixListOwnerId": "123456789012",
"State": "modifying",
"Blackhole": false,
"TransitGatewayAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-aabbccddaabbccaab",
"ResourceType": "vpc",
"ResourceId": "vpc-112233445566aabbc"
}
}
}
```
Para obter mais informações, consulte [Referências de lista de prefixos](https://docs.aws.amazon.com/vpc/latest/tgw/create-prefix-list-reference.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [ModifyTransitGatewayPrefixListReference](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-transit-gateway-prefix-list-reference.html)em *Referência de AWS CLI Comandos*.
### `modify-transit-gateway-vpc-attachment`
O código de exemplo a seguir mostra como usar `modify-transit-gateway-vpc-attachment`.
**AWS CLI**
**Modificar um anexo VPC do gateway de trânsito**
O exemplo `modify-transit-gateway-vpc-attachment` a seguir adiciona uma sub-rede ao anexo VPC do gateway de trânsito especificado.
```
aws ec2 modify-transit-gateway-vpc-attachment \
--transit-gateway-attachment-id tgw-attach-09fbd47ddfEXAMPLE \
--add-subnet-ids subnet-0e51f45802EXAMPLE
```
Saída:
```
{
"TransitGatewayVpcAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-09fbd47ddfEXAMPLE",
"TransitGatewayId": "tgw-0560315ccfEXAMPLE",
"VpcId": "vpc-5eccc927",
"VpcOwnerId": "111122223333",
"State": "modifying",
"SubnetIds": [
"subnet-0e51f45802EXAMPLE",
"subnet-1EXAMPLE"
],
"CreationTime": "2019-08-08T16:47:38.000Z",
"Options": {
"DnsSupport": "enable",
"Ipv6Support": "disable"
}
}
}
```
Para obter mais informações, consulte [Anexos do gateway de trânsito para uma VPC](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [ModifyTransitGatewayVpcAttachment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-transit-gateway-vpc-attachment.html)em *Referência de AWS CLI Comandos*.
### `modify-transit-gateway`
O código de exemplo a seguir mostra como usar `modify-transit-gateway`.
**AWS CLI**
**Modificar um gateway de trânsito**
O exemplo `modify-transit-gateway` a seguir modifica o gateway de trânsito especificado ativando o suporte ECMP para anexos VPN.
```
aws ec2 modify-transit-gateway \
--transit-gateway-id tgw-111111222222aaaaa \
--options VpnEcmpSupport=enable
```
Saída:
```
{
"TransitGateway": {
"TransitGatewayId": "tgw-111111222222aaaaa",
"TransitGatewayArn": "64512",
"State": "modifying",
"OwnerId": "123456789012",
"CreationTime": "2020-04-30T08:41:37.000Z",
"Options": {
"AmazonSideAsn": 64512,
"AutoAcceptSharedAttachments": "disable",
"DefaultRouteTableAssociation": "enable",
"AssociationDefaultRouteTableId": "tgw-rtb-0123456789abcd123",
"DefaultRouteTablePropagation": "enable",
"PropagationDefaultRouteTableId": "tgw-rtb-0123456789abcd123",
"VpnEcmpSupport": "enable",
"DnsSupport": "enable"
}
}
}
```
Para obter mais informações, consulte [Gateways de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-transit-gateways.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [ModifyTransitGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-transit-gateway.html)em *Referência de AWS CLI Comandos*.
### `modify-verified-access-endpoint-policy`
O código de exemplo a seguir mostra como usar `modify-verified-access-endpoint-policy`.
**AWS CLI**
**Configurar a política de acesso verificado para um endpoint**
O exemplo `modify-verified-access-endpoint-policy` a seguir adiciona a política de acesso verificado especificada ao endpoint de acesso verificado especificado.
```
aws ec2 modify-verified-access-endpoint-policy \
--verified-access-endpoint-id vae-066fac616d4d546f2 \
--policy-enabled \
--policy-document file://policy.txt
```
Conteúdo de `policy.txt`:
```
permit(principal,action,resource)
when {
context.identity.groups.contains("finance") &&
context.identity.email.verified == true
};
```
Saída:
```
{
"PolicyEnabled": true,
"PolicyDocument": "permit(principal,action,resource)\nwhen {\n context.identity.groups.contains(\"finance\") &&\n context.identity.email_verified == true\n};"
}
```
Para obter mais informações, consulte [Políticas de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/auth-policies.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [ModifyVerifiedAccessEndpointPolicy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-verified-access-endpoint-policy.html)em *Referência de AWS CLI Comandos*.
### `modify-verified-access-endpoint`
O código de exemplo a seguir mostra como usar `modify-verified-access-endpoint`.
**AWS CLI**
**Modificar a configuração de um endpoint do acesso verificado**
O exemplo `modify-verified-access-endpoint` a seguir adiciona a descrição especificada ao endpoint de acesso verificado especificado.
```
aws ec2 modify-verified-access-endpoint \
--verified-access-endpoint-id vae-066fac616d4d546f2 \
--description 'Testing Verified Access'
```
Saída:
```
{
"VerifiedAccessEndpoint": {
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"VerifiedAccessGroupId": "vagr-0dbe967baf14b7235",
"VerifiedAccessEndpointId": "vae-066fac616d4d546f2",
"ApplicationDomain": "example.com",
"EndpointType": "network-interface",
"AttachmentType": "vpc",
"DomainCertificateArn": "arn:aws:acm:us-east-2:123456789012:certificate/eb065ea0-26f9-4e75-a6ce-0a1a7EXAMPLE",
"EndpointDomain": "my-ava-app.edge-00c3372d53b1540bb.vai-0ce000c0b7643abea.prod.verified-access.us-east-2.amazonaws.com",
"SecurityGroupIds": [
"sg-004915970c4c8f13a"
],
"NetworkInterfaceOptions": {
"NetworkInterfaceId": "eni-0aec70418c8d87a0f",
"Protocol": "https",
"Port": 443
},
"Status": {
"Code": "updating"
},
"Description": "Testing Verified Access",
"CreationTime": "2023-08-25T20:54:43",
"LastUpdatedTime": "2023-08-25T22:46:32"
}
}
```
Para obter mais informações, consulte [Endpoints de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-endpoints.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [ModifyVerifiedAccessEndpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-verified-access-endpoint.html)em *Referência de AWS CLI Comandos*.
### `modify-verified-access-group-policy`
O código de exemplo a seguir mostra como usar `modify-verified-access-group-policy`.
**AWS CLI**
**Configurar uma política de acesso verificado para um grupo**
O exemplo `modify-verified-access-group-policy` a seguir adiciona a política de acesso verificado especificada ao grupo de acesso verificado especificado.
```
aws ec2 modify-verified-access-group-policy \
--verified-access-group-id vagr-0dbe967baf14b7235 \
--policy-enabled \
--policy-document file://policy.txt
```
Conteúdo de `policy.txt`:
```
permit(principal,action,resource)
when {
context.identity.groups.contains("finance") &&
context.identity.email.verified == true
};
```
Saída:
```
{
"PolicyEnabled": true,
"PolicyDocument": "permit(principal,action,resource)\nwhen {\n context.identity.groups.contains(\"finance\") &&\n context.identity.email_verified == true\n};"
}
```
Para obter mais informações, consulte [Grupos de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-groups.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [ModifyVerifiedAccessGroupPolicy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-verified-access-group-policy.html)em *Referência de AWS CLI Comandos*.
### `modify-verified-access-group`
O código de exemplo a seguir mostra como usar `modify-verified-access-group`.
**AWS CLI**
**Modificar a configuração de um grupo de acesso verificado**
O exemplo `modify-verified-access-group` a seguir adiciona a descrição especificada ao grupo de acesso verificado especificado.
```
aws ec2 modify-verified-access-group \
--verified-access-group-id vagr-0dbe967baf14b7235 \
--description "Testing Verified Access"
```
Saída:
```
{
"VerifiedAccessGroup": {
"VerifiedAccessGroupId": "vagr-0dbe967baf14b7235",
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"Description": "Testing Verified Access",
"Owner": "123456789012",
"VerifiedAccessGroupArn": "arn:aws:ec2:us-east-2:123456789012:verified-access-group/vagr-0dbe967baf14b7235",
"CreationTime": "2023-08-25T19:55:19",
"LastUpdatedTime": "2023-08-25T22:17:25"
}
}
```
Para obter mais informações, consulte [Grupos de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-groups.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [ModifyVerifiedAccessGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-verified-access-group.html)em *Referência de AWS CLI Comandos*.
### `modify-verified-access-instance-logging-configuration`
O código de exemplo a seguir mostra como usar `modify-verified-access-instance-logging-configuration`.
**AWS CLI**
**Habilitar o registro em uma instância de acesso verificado**
O exemplo `modify-verified-access-instance-logging-configuration` a seguir habilita o log de acesso para a instância especificada do acesso verificado. Os registros serão entregues ao grupo de CloudWatch registros de registros especificado.
```
aws ec2 modify-verified-access-instance-logging-configuration \
--verified-access-instance-id vai-0ce000c0b7643abea \
--access-logs CloudWatchLogs={Enabled=true,LogGroup=my-log-group}
```
Saída:
```
{
"LoggingConfiguration": {
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"AccessLogs": {
"S3": {
"Enabled": false
},
"CloudWatchLogs": {
"Enabled": true,
"DeliveryStatus": {
"Code": "success"
},
"LogGroup": "my-log-group"
},
"KinesisDataFirehose": {
"Enabled": false
},
"LogVersion": "ocsf-1.0.0-rc.2",
"IncludeTrustContext": false
}
}
}
```
Para obter mais informações, consulte [Logs do acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/access-logs.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [ModifyVerifiedAccessInstanceLoggingConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-verified-access-instance-logging-configuration.html)em *Referência de AWS CLI Comandos*.
### `modify-verified-access-instance`
O código de exemplo a seguir mostra como usar `modify-verified-access-instance`.
**AWS CLI**
**Modificar a configuração da instância de acesso verificado**
O exemplo `modify-verified-access-instance` a seguir adiciona a descrição especificada à instância de acesso verificado especificada.
```
aws ec2 modify-verified-access-instance \
--verified-access-instance-id vai-0ce000c0b7643abea \
--description "Testing Verified Access"
```
Saída:
```
{
"VerifiedAccessInstance": {
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"Description": "Testing Verified Access",
"VerifiedAccessTrustProviders": [
{
"VerifiedAccessTrustProviderId": "vatp-0bb32de759a3e19e7",
"TrustProviderType": "user",
"UserTrustProviderType": "iam-identity-center"
}
],
"CreationTime": "2023-08-25T18:27:56",
"LastUpdatedTime": "2023-08-25T22:41:04"
}
}
```
Para obter mais informações, consulte [Instâncias de acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-instances.html) no *Guia do usuário do acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [ModifyVerifiedAccessInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-verified-access-instance.html)em *Referência de AWS CLI Comandos*.
### `modify-verified-access-trust-provider`
O código de exemplo a seguir mostra como usar `modify-verified-access-trust-provider`.
**AWS CLI**
**Modificar a configuração de um provedor confiável de acesso verificado**
O exemplo `modify-verified-access-trust-provider` a seguir adiciona a descrição especificada ao provedor confiável especificado do acesso verificado.
```
aws ec2 modify-verified-access-trust-provider \
--verified-access-trust-provider-id vatp-0bb32de759a3e19e7 \
--description "Testing Verified Access"
```
Saída:
```
{
"VerifiedAccessTrustProvider": {
"VerifiedAccessTrustProviderId": "vatp-0bb32de759a3e19e7",
"Description": "Testing Verified Access",
"TrustProviderType": "user",
"UserTrustProviderType": "iam-identity-center",
"PolicyReferenceName": "idc",
"CreationTime": "2023-08-25T19:00:38",
"LastUpdatedTime": "2023-08-25T19:18:21"
}
}
```
Para obter mais informações, consulte [Provedores confiáveis para acesso verificado](https://docs.aws.amazon.com/verified-access/latest/ug/trust-providers.html) no *Guia do usuário de acesso verificado da AWS *.
+ Para obter detalhes da API, consulte [ModifyVerifiedAccessTrustProvider](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-verified-access-trust-provider.html)em *Referência de AWS CLI Comandos*.
### `modify-volume-attribute`
O código de exemplo a seguir mostra como usar `modify-volume-attribute`.
**AWS CLI**
**Modificar um atributo de volume**
Este exemplo define o atributo `autoEnableIo` do volume com o ID `vol-1234567890abcdef0` como `true`. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 modify-volume-attribute --volume-id vol-1234567890abcdef0 --auto-enable-io
```
+ Para obter detalhes da API, consulte [ModifyVolumeAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-volume-attribute.html)em *Referência de AWS CLI Comandos*.
### `modify-volume`
O código de exemplo a seguir mostra como usar `modify-volume`.
**AWS CLI**
**Exemplo 1: modificar um volume alterando seu tamanho**
O exemplo `modify-volume` a seguir altera o tamanho do volume especificado para 150 GB.
Comando:
```
aws ec2 modify-volume --size 150 --volume-id vol-1234567890abcdef0
```
Saída:
```
{
"VolumeModification": {
"TargetSize": 150,
"TargetVolumeType": "io1",
"ModificationState": "modifying",
"VolumeId": " vol-1234567890abcdef0",
"TargetIops": 100,
"StartTime": "2019-05-17T11:27:19.000Z",
"Progress": 0,
"OriginalVolumeType": "io1",
"OriginalIops": 100,
"OriginalSize": 100
}
}
```
**Exemplo 2: modificar um volume alterando seu tipo, tamanho e valor de IOPS**
O exemplo `modify-volume` a seguir altera o tipo de volume para SSD de IOPS provisionadas, define a taxa de IOPS alvo como 10000 e define o tamanho do volume como 350 GB.
```
aws ec2 modify-volume \
--volume-type io1 \
--iops 10000 \
--size 350 \
--volume-id vol-1234567890abcdef0
```
Saída:
```
{
"VolumeModification": {
"TargetSize": 350,
"TargetVolumeType": "io1",
"ModificationState": "modifying",
"VolumeId": "vol-0721c1a9d08c93bf6",
"TargetIops": 10000,
"StartTime": "2019-05-17T11:38:57.000Z",
"Progress": 0,
"OriginalVolumeType": "gp2",
"OriginalIops": 150,
"OriginalSize": 50
}
}
```
+ Para obter detalhes da API, consulte [ModifyVolume](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-volume.html)em *Referência de AWS CLI Comandos*.
### `modify-vpc-attribute`
O código de exemplo a seguir mostra como usar `modify-vpc-attribute`.
**AWS CLI**
**Para modificar o enableDnsSupport atributo**
Este exemplo modifica o atributo `enableDnsSupport`. Esse atributo indica se a VPC conta com resolução de DNS habilitada. Se este atributo é `true`, o servidor de DNS da Amazon resolve os nomes de hosts DNS de suas instâncias para os endereços IP correspondentes; caso contrário, ele não resolve. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 modify-vpc-attribute --vpc-id vpc-a01106c2 --enable-dns-support "{\"Value\":false}"
```
**Para modificar o enableDnsHostnames atributo**
Este exemplo modifica o atributo `enableDnsHostnames`. Esse atributo indica se instâncias executadas na VPC obtêm nomes de host DNS. Se esse atributo é `true`, as instâncias na VPC obtêm os nomes de hosts DNS; caso contrário, isso não ocorrerá. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 modify-vpc-attribute --vpc-id vpc-a01106c2 --enable-dns-hostnames "{\"Value\":false}"
```
+ Para obter detalhes da API, consulte [ModifyVpcAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpc-attribute.html)em *Referência de AWS CLI Comandos*.
### `modify-vpc-endpoint-connection-notification`
O código de exemplo a seguir mostra como usar `modify-vpc-endpoint-connection-notification`.
**AWS CLI**
**Modificar uma notificação de conexão de endpoint**
Este exemplo altera o tópico do SNS para a notificação de conexão de endpoint especificada.
Comando:
```
aws ec2 modify-vpc-endpoint-connection-notification --connection-notification-id vpce-nfn-008776de7e03f5abc --connection-events Accept Reject --connection-notification-arn arn:aws:sns:us-east-2:123456789012:mytopic
```
Saída:
```
{
"ReturnValue": true
}
```
+ Para obter detalhes da API, consulte [ModifyVpcEndpointConnectionNotification](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpc-endpoint-connection-notification.html)em *Referência de AWS CLI Comandos*.
### `modify-vpc-endpoint-service-configuration`
O código de exemplo a seguir mostra como usar `modify-vpc-endpoint-service-configuration`.
**AWS CLI**
**Modificar uma configuração de serviço de endpoint**
Este exemplo altera o requisito de aceitação para o serviço de endpoint especificado.
Comando:
```
aws ec2 modify-vpc-endpoint-service-configuration --service-id vpce-svc-09222513e6e77dc86 --no-acceptance-required
```
Saída:
```
{
"ReturnValue": true
}
```
+ Para obter detalhes da API, consulte [ModifyVpcEndpointServiceConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpc-endpoint-service-configuration.html)em *Referência de AWS CLI Comandos*.
### `modify-vpc-endpoint-service-payer-responsibility`
O código de exemplo a seguir mostra como usar `modify-vpc-endpoint-service-payer-responsibility`.
**AWS CLI**
**Modificar a responsabilidade do pagador**
O exemplo `modify-vpc-endpoint-service-payer-responsibility` a seguir modifica a responsabilidade do pagador pelo serviço de endpoint especificado.
```
aws ec2 modify-vpc-endpoint-service-payer-responsibility \
--service-id vpce-svc-071afff70666e61e0 \
--payer-responsibility ServiceOwner
```
Este comando não produz saída.
+ Para obter detalhes da API, consulte [ModifyVpcEndpointServicePayerResponsibility](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpc-endpoint-service-payer-responsibility.html)em *Referência de AWS CLI Comandos*.
### `modify-vpc-endpoint-service-permissions`
O código de exemplo a seguir mostra como usar `modify-vpc-endpoint-service-permissions`.
**AWS CLI**
**Modificar as permissões de serviço endpoint**
Este exemplo adiciona permissão para que uma AWS conta se conecte ao serviço de endpoint especificado.
Comando:
```
aws ec2 modify-vpc-endpoint-service-permissions --service-id vpce-svc-03d5ebb7d9579a2b3 --add-allowed-principals '["arn:aws:iam::123456789012:root"]'
```
Saída:
```
{
"ReturnValue": true
}
```
Este exemplo adiciona permissão para que um usuário do IAM específico (`admin`) se conecte ao serviço de endpoint especificado.
Comando:
```
aws ec2 modify-vpc-endpoint-service-permissions --service-id vpce-svc-03d5ebb7d9579a2b3 --add-allowed-principals '["arn:aws:iam::123456789012:user/admin"]'
```
+ Para obter detalhes da API, consulte [ModifyVpcEndpointServicePermissions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpc-endpoint-service-permissions.html)em *Referência de AWS CLI Comandos*.
### `modify-vpc-endpoint`
O código de exemplo a seguir mostra como usar `modify-vpc-endpoint`.
**AWS CLI**
**Modificar um endpoint do gateway**
Este exemplo modifica o endpoint do gateway `vpce-1a2b3c4d` associando a tabela de rotas `rtb-aaa222bb` ao endpoint e redefinindo o documento de política.
Comando:
```
aws ec2 modify-vpc-endpoint --vpc-endpoint-id vpce-1a2b3c4d --add-route-table-ids rtb-aaa222bb --reset-policy
```
Saída:
```
{
"Return": true
}
```
**Modificar um endpoint de interface**
Este exemplo modifica o endpoint da interface `vpce-0fe5b17a0707d6fa5` adicionando uma sub-rede `subnet-d6fcaa8d` ao endpoint.
Comando:
```
aws ec2 modify-vpc-endpoint --vpc-endpoint-id vpce-0fe5b17a0707d6fa5 --add-subnet-id subnet-d6fcaa8d
```
Saída:
```
{
"Return": true
}
```
+ Para obter detalhes da API, consulte [ModifyVpcEndpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpc-endpoint.html)em *Referência de AWS CLI Comandos*.
### `modify-vpc-peering-connection-options`
O código de exemplo a seguir mostra como usar `modify-vpc-peering-connection-options`.
**AWS CLI**
**Para habilitar a comunicação por meio de uma conexão de emparelhamento VPC a partir da sua conexão local ClassicLink **
Neste exemplo, para conexão de emparelhamento`pcx-aaaabbb`, o proprietário da VPC solicitante modifica as opções de conexão de emparelhamento de VPC para permitir que uma conexão ClassicLink local se comunique com a VPC de mesmo nível.
Comando:
```
aws ec2 modify-vpc-peering-connection-options --vpc-peering-connection-id pcx-aaaabbbb --requester-peering-connection-options AllowEgressFromLocalClassicLinkToRemoteVpc=true
```
Saída:
```
{
"RequesterPeeringConnectionOptions": {
"AllowEgressFromLocalClassicLinkToRemoteVpc": true
}
}
```
**Para habilitar a comunicação por meio de uma conexão de emparelhamento de VPC de sua VPC local para uma conexão remota ClassicLink **
Neste exemplo, o proprietário da VPC aceitadora modifica as opções de conexão de emparelhamento da VPC para permitir que a VPC local se comunique com a conexão na VPC de mesmo nível. ClassicLink
Comando:
```
aws ec2 modify-vpc-peering-connection-options --vpc-peering-connection-id pcx-aaaabbbb --accepter-peering-connection-options AllowEgressFromLocalVpcToRemoteClassicLink=true
```
Saída:
```
{
"AccepterPeeringConnectionOptions": {
"AllowEgressFromLocalVpcToRemoteClassicLink": true
}
}
```
**Habilitar um suporte de resolução DNS para a conexão de emparelhamento da VPC**
Neste exemplo, o proprietário da VPC solicitante modifica as opções de conexão de emparelhamento da VPC para `pcx-aaaabbbb` para habilitar a VPC local a solucionar nomes de hosts DNS públicos para endereços IP privados quando em consultas provenientes de instâncias na VPC emparelhada.
Comando:
```
aws ec2 modify-vpc-peering-connection-options --vpc-peering-connection-id pcx-aaaabbbb --requester-peering-connection-options AllowDnsResolutionFromRemoteVpc=true
```
Saída:
```
{
"RequesterPeeringConnectionOptions": {
"AllowDnsResolutionFromRemoteVpc": true
}
}
```
+ Para obter detalhes da API, consulte [ModifyVpcPeeringConnectionOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpc-peering-connection-options.html)em *Referência de AWS CLI Comandos*.
### `modify-vpc-tenancy`
O código de exemplo a seguir mostra como usar `modify-vpc-tenancy`.
**AWS CLI**
**Modificar a locação de uma VPC**
Este exemplo modifica a locação da VPC `vpc-1a2b3c4d` para `default`.
Comando:
```
aws ec2 modify-vpc-tenancy --vpc-id vpc-1a2b3c4d --instance-tenancy default
```
Saída:
```
{
"Return": true
}
```
+ Para obter detalhes da API, consulte [ModifyVpcTenancy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpc-tenancy.html)em *Referência de AWS CLI Comandos*.
### `modify-vpn-connection-options`
O código de exemplo a seguir mostra como usar `modify-vpn-connection-options`.
**AWS CLI**
**Modificar as opções de conexão da VPN**
O `modify-vpn-connection-options` exemplo a seguir modifica o IPv4 CIDR local no lado do gateway do cliente da conexão VPN especificada.
```
aws ec2 modify-vpn-connection-options \
--vpn-connection-id vpn-1122334455aabbccd \
--local-ipv4-network-cidr 10.0.0.0/16
```
Saída:
```
{
"VpnConnections": [
{
"CustomerGatewayConfiguration": "...configuration information...",
"CustomerGatewayId": "cgw-01234567abcde1234",
"Category": "VPN",
"State": "modifying",
"Type": "ipsec.1",
"VpnConnectionId": "vpn-1122334455aabbccd",
"TransitGatewayId": "tgw-00112233445566aab",
"Options": {
"EnableAcceleration": false,
"StaticRoutesOnly": true,
"LocalIpv4NetworkCidr": "10.0.0.0/16",
"RemoteIpv4NetworkCidr": "0.0.0.0/0",
"TunnelInsideIpVersion": "ipv4"
},
"Routes": [],
"Tags": [
{
"Key": "Name",
"Value": "CanadaVPN"
}
],
"VgwTelemetry": [
{
"AcceptedRouteCount": 0,
"LastStatusChange": "2020-07-29T10:35:11.000Z",
"OutsideIpAddress": "203.0.113.3",
"Status": "DOWN",
"StatusMessage": ""
},
{
"AcceptedRouteCount": 0,
"LastStatusChange": "2020-09-02T09:09:33.000Z",
"OutsideIpAddress": "203.0.113.5",
"Status": "UP",
"StatusMessage": ""
}
]
}
]
}
```
Para obter mais informações, consulte [Modificando as opções de conexão Site-to-Site VPN](https://docs.aws.amazon.com/vpn/latest/s2svpn/modify-vpn-connection-options.html) no *Guia do usuário da AWS Site-to-Site VPN*.
+ Para obter detalhes da API, consulte [ModifyVpnConnectionOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpn-connection-options.html)em *Referência de AWS CLI Comandos*.
### `modify-vpn-connection`
O código de exemplo a seguir mostra como usar `modify-vpn-connection`.
**AWS CLI**
**Modificar uma conexão VPN**
O exemplo `modify-vpn-connection` a seguir altera o gateway de destino da conexão VPN `vpn-12345678901234567` para o gateway privado virtual `vgw-11223344556677889`:
```
aws ec2 modify-vpn-connection \
--vpn-connection-id vpn-12345678901234567 \
--vpn-gateway-id vgw-11223344556677889
```
Saída:
```
{
"VpnConnection": {
"CustomerGatewayConfiguration": "...configuration information...",
"CustomerGatewayId": "cgw-aabbccddee1122334",
"Category": "VPN",
"State": "modifying",
"Type": "ipsec.1",
"VpnConnectionId": "vpn-12345678901234567",
"VpnGatewayId": "vgw-11223344556677889",
"Options": {
"StaticRoutesOnly": false
},
"VgwTelemetry": [
{
"AcceptedRouteCount": 0,
"LastStatusChange": "2019-07-17T07:34:00.000Z",
"OutsideIpAddress": "18.210.3.222",
"Status": "DOWN",
"StatusMessage": "IPSEC IS DOWN"
},
{
"AcceptedRouteCount": 0,
"LastStatusChange": "2019-07-20T21:20:16.000Z",
"OutsideIpAddress": "34.193.129.33",
"Status": "DOWN",
"StatusMessage": "IPSEC IS DOWN"
}
]
}
}
```
+ Para obter detalhes da API, consulte [ModifyVpnConnection](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpn-connection.html)em *Referência de AWS CLI Comandos*.
### `modify-vpn-tunnel-certificate`
O código de exemplo a seguir mostra como usar `modify-vpn-tunnel-certificate`.
**AWS CLI**
**Rotacionar um certificado de túnel de VPN**
O exemplo `modify-vpn-tunnel-certificate` a seguir rotaciona o certificado para o túnel especificado para uma conexão VPN
```
aws ec2 modify-vpn-tunnel-certificate \
--vpn-tunnel-outside-ip-address 203.0.113.17 \
--vpn-connection-id vpn-12345678901234567
```
Saída:
```
{
"VpnConnection": {
"CustomerGatewayConfiguration": ...configuration information...,
"CustomerGatewayId": "cgw-aabbccddee1122334",
"Category": "VPN",
"State": "modifying",
"Type": "ipsec.1",
"VpnConnectionId": "vpn-12345678901234567",
"VpnGatewayId": "vgw-11223344556677889",
"Options": {
"StaticRoutesOnly": false
},
"VgwTelemetry": [
{
"AcceptedRouteCount": 0,
"LastStatusChange": "2019-09-11T17:27:14.000Z",
"OutsideIpAddress": "203.0.113.17",
"Status": "DOWN",
"StatusMessage": "IPSEC IS DOWN",
"CertificateArn": "arn:aws:acm:us-east-1:123456789101:certificate/c544d8ce-20b8-4fff-98b0-example"
},
{
"AcceptedRouteCount": 0,
"LastStatusChange": "2019-09-11T17:26:47.000Z",
"OutsideIpAddress": "203.0.114.18",
"Status": "DOWN",
"StatusMessage": "IPSEC IS DOWN",
"CertificateArn": "arn:aws:acm:us-east-1:123456789101:certificate/5ab64566-761b-4ad3-b259-example"
}
]
}
}
```
+ Para obter detalhes da API, consulte [ModifyVpnTunnelCertificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpn-tunnel-certificate.html)em *Referência de AWS CLI Comandos*.
### `modify-vpn-tunnel-options`
O código de exemplo a seguir mostra como usar `modify-vpn-tunnel-options`.
**AWS CLI**
**Modificar as opções de túnel de uma conexão VPN**
O exemplo `modify-vpn-tunnel-options` a seguir atualiza os grupos Diffie-Hellman permitidos para o túnel especificado e a conexão VPN.
```
aws ec2 modify-vpn-tunnel-options \
--vpn-connection-id vpn-12345678901234567 \
--vpn-tunnel-outside-ip-address 203.0.113.17 \
--tunnel-options Phase1DHGroupNumbers=[{Value=14},{Value=15},{Value=16},{Value=17},{Value=18}],Phase2DHGroupNumbers=[{Value=14},{Value=15},{Value=16},{Value=17},{Value=18}]
```
Saída:
```
{
"VpnConnection": {
"CustomerGatewayConfiguration": "...configuration information...",
"CustomerGatewayId": "cgw-aabbccddee1122334",
"Category": "VPN",
"State": "available",
"Type": "ipsec.1",
"VpnConnectionId": "vpn-12345678901234567",
"VpnGatewayId": "vgw-11223344556677889",
"Options": {
"StaticRoutesOnly": false,
"TunnelOptions": [
{
"OutsideIpAddress": "203.0.113.17",
"Phase1DHGroupNumbers": [
{
"Value": 14
},
{
"Value": 15
},
{
"Value": 16
},
{
"Value": 17
},
{
"Value": 18
}
],
"Phase2DHGroupNumbers": [
{
"Value": 14
},
{
"Value": 15
},
{
"Value": 16
},
{
"Value": 17
},
{
"Value": 18
}
]
},
{
"OutsideIpAddress": "203.0.114.19"
}
]
},
"VgwTelemetry": [
{
"AcceptedRouteCount": 0,
"LastStatusChange": "2019-09-10T21:56:54.000Z",
"OutsideIpAddress": "203.0.113.17",
"Status": "DOWN",
"StatusMessage": "IPSEC IS DOWN"
},
{
"AcceptedRouteCount": 0,
"LastStatusChange": "2019-09-10T21:56:43.000Z",
"OutsideIpAddress": "203.0.114.19",
"Status": "DOWN",
"StatusMessage": "IPSEC IS DOWN"
}
]
}
}
```
+ Para obter detalhes da API, consulte [ModifyVpnTunnelOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpn-tunnel-options.html)em *Referência de AWS CLI Comandos*.
### `monitor-instances`
O código de exemplo a seguir mostra como usar `monitor-instances`.
**AWS CLI**
**Para habilitar o monitoramento detalhado de uma instância**
Este exemplo de comando habilita o monitoramento detalhado da instância especificada.
Comando:
```
aws ec2 monitor-instances --instance-ids i-1234567890abcdef0
```
Saída:
```
{
"InstanceMonitorings": [
{
"InstanceId": "i-1234567890abcdef0",
"Monitoring": {
"State": "pending"
}
}
]
}
```
+ Para obter detalhes da API, consulte [MonitorInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/monitor-instances.html)em *Referência de AWS CLI Comandos*.
### `move-address-to-vpc`
O código de exemplo a seguir mostra como usar `move-address-to-vpc`.
**AWS CLI**
**Mover um endereço para EC2-VPC**
Este exemplo move o endereço IP elástico 54.123.4.56 para a plataforma EC2-VPC.
Comando:
```
aws ec2 move-address-to-vpc --public-ip 54.123.4.56
```
Saída:
```
{
"Status": "MoveInProgress"
}
```
+ Para obter detalhes da API, consulte [MoveAddressToVpc](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/move-address-to-vpc.html)em *Referência de AWS CLI Comandos*.
### `move-byoip-cidr-to-ipam`
O código de exemplo a seguir mostra como usar `move-byoip-cidr-to-ipam`.
**AWS CLI**
**Transferir um CIDR BYOIP para o IPAM**
O exemplo `move-byoip-cidr-to-ipam` a seguir transfere um CIDR BYOIP para o IPAM.
(Linux):
```
aws ec2 move-byoip-cidr-to-ipam \
--region us-west-2 \
--ipam-pool-id ipam-pool-0a03d430ca3f5c035 \
--ipam-pool-owner 111111111111 \
--cidr 130.137.249.0/24
```
(Windows):
```
aws ec2 move-byoip-cidr-to-ipam ^
--region us-west-2 ^
--ipam-pool-id ipam-pool-0a03d430ca3f5c035 ^
--ipam-pool-owner 111111111111 ^
--cidr 130.137.249.0/24
```
Saída:
```
{
"ByoipCidr": {
"Cidr": "130.137.249.0/24",
"State": "pending-transfer"
}
}
```
Para obter mais informações, consulte [Tutorial: Transferir um IPv4 CIDR BYOIP existente para IPAM no Guia do usuário IPAM](https://docs.aws.amazon.com/vpc/latest/ipam/tutorials-byoip-ipam-transfer-ipv4.html) da Amazon *VPC*.
+ Para obter detalhes da API, consulte [MoveByoipCidrToIpam](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/move-byoip-cidr-to-ipam.html)em *Referência de AWS CLI Comandos*.
### `network-insights-access-scope`
O código de exemplo a seguir mostra como usar `network-insights-access-scope`.
**AWS CLI**
**Criar escopos de acesso do Network Insights**
O `create-network-insights-access-scope` exemplo a seguir cria um escopo de acesso ao Network Insights em sua AWS conta.
```
aws ec2 create-network-insights-access-scope \
--cli-input-json file://access-scope-file.json
```
Conteúdo de `access-scope-file.json`:
```
{
{
"MatchPaths": [
{
"Source": {
"ResourceStatement": {
"Resources": [
"vpc-abcd12e3"
]
}
}
}
],
"ExcludePaths": [
{
"Source": {
"ResourceStatement": {
"ResourceTypes": [
"AWS::EC2::InternetGateway"
]
}
}
}
]
}
}
```
Saída:
```
{
"NetworkInsightsAccessScopeAnalysisId": "nisa-123456789111"
}{
"NetworkInsightsAccessScope": {
"NetworkInsightsAccessScopeId": "nis-123456789222",
"NetworkInsightsAccessScopeArn": "arn:aws:ec2:us-east-1:123456789222:network-insights-access-scope/nis-123456789222",
"CreatedDate": "2022-01-25T19:20:28.796000+00:00",
"UpdatedDate": "2022-01-25T19:20:28.797000+00:00"
},
"NetworkInsightsAccessScopeContent": {
"NetworkInsightsAccessScopeId": "nis-04c0c0fbca737c404",
"MatchPaths": [
{
"Source": {
"ResourceStatement": {
"Resources": [
"vpc-abcd12e3"
]
}
}
}
],
"ExcludePaths": [
{
"Source": {
"ResourceStatement": {
"ResourceTypes": [
"AWS::EC2::InternetGateway"
]
}
}
}
]
}
}
```
Para obter mais informações, consulte [Introdução ao Network Access Analyzer usando a AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli-naa.html) no Guia *do Network Access* Analyzer.
+ Para obter detalhes da API, consulte [NetworkInsightsAccessScope](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/network-insights-access-scope.html)em *Referência de AWS CLI Comandos*.
### `provision-byoip-cidr`
O código de exemplo a seguir mostra como usar `provision-byoip-cidr`.
**AWS CLI**
**Provisionar um intervalo de endereços**
O `provision-byoip-cidr` exemplo a seguir provisiona um intervalo de endereços IP públicos para uso com AWS.
```
aws ec2 provision-byoip-cidr \
--cidr 203.0.113.25/24 \
--cidr-authorization-context Message="$text_message",Signature="$signed_message"
```
Saída:
```
{
"ByoipCidr": {
"Cidr": "203.0.113.25/24",
"State": "pending-provision"
}
}
```
Para obter mais informações sobre a criação de cadeias de mensagens para o contexto de autorização, consulte [Traga seus próprios endereços IP](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [ProvisionByoipCidr](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/provision-byoip-cidr.html)em *Referência de AWS CLI Comandos*.
### `provision-ipam-pool-cidr`
O código de exemplo a seguir mostra como usar `provision-ipam-pool-cidr`.
**AWS CLI**
**Provisionar um CIDR para um pool do IPAM**
O exemplo `provision-ipam-pool-cidr` a seguir provisiona um CIDR para um grupo do IPAM.
(Linux):
```
aws ec2 provision-ipam-pool-cidr \
--ipam-pool-id ipam-pool-0533048da7d823723 \
--cidr 10.0.0.0/24
```
(Windows):
```
aws ec2 provision-ipam-pool-cidr ^
--ipam-pool-id ipam-pool-0533048da7d823723 ^
--cidr 10.0.0.0/24
```
Saída:
```
{
"IpamPoolCidr": {
"Cidr": "10.0.0.0/24",
"State": "pending-provision"
}
}
```
Para obter mais informações, consulte [ CIDRs Provisionar para um pool](https://docs.aws.amazon.com/vpc/latest/ipam/prov-cidr-ipam.html) no Guia do *usuário IPAM da Amazon VPC*.
+ Para obter detalhes da API, consulte [ProvisionIpamPoolCidr](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/provision-ipam-pool-cidr.html)em *Referência de AWS CLI Comandos*.
### `purchase-host-reservation`
O código de exemplo a seguir mostra como usar `purchase-host-reservation`.
**AWS CLI**
**Comprar uma reserva de host dedicado**
Este exemplo compra a oferta de Reserva de Host Dedicado especificada para o Host Dedicado especificado em sua conta.
Comando:
```
aws ec2 purchase-host-reservation --offering-id hro-03f707bf363b6b324 --host-id-set h-013abcd2a00cbd123
```
Saída:
```
{
"TotalHourlyPrice": "1.499",
"Purchase": [
{
"HourlyPrice": "1.499",
"InstanceFamily": "m4",
"PaymentOption": "NoUpfront",
"HostIdSet": [
"h-013abcd2a00cbd123"
],
"HostReservationId": "hr-0d418a3a4ffc669ae",
"UpfrontPrice": "0.000",
"Duration": 31536000
}
],
"TotalUpfrontPrice": "0.000"
}
```
+ Para obter detalhes da API, consulte [PurchaseHostReservation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/purchase-host-reservation.html)em *Referência de AWS CLI Comandos*.
### `purchase-reserved-instances-offering`
O código de exemplo a seguir mostra como usar `purchase-reserved-instances-offering`.
**AWS CLI**
**Comprar uma oferta de instância reservada**
Este exemplo de comando ilustra a compra de uma oferta de Instâncias Reservadas, especificando o ID da oferta e a contagem de instâncias.
Comando:
```
aws ec2 purchase-reserved-instances-offering --reserved-instances-offering-id ec06327e-dd07-46ee-9398-75b5fexample --instance-count 3
```
Saída:
```
{
"ReservedInstancesId": "af9f760e-6f91-4559-85f7-4980eexample"
}
```
+ Para obter detalhes da API, consulte [PurchaseReservedInstancesOffering](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/purchase-reserved-instances-offering.html)em *Referência de AWS CLI Comandos*.
### `purchase-scheduled-instances`
O código de exemplo a seguir mostra como usar `purchase-scheduled-instances`.
**AWS CLI**
**Comprar uma instância programada**
Este exemplo compra uma Instância Programada.
Comando:
```
aws ec2 purchase-scheduled-instances --purchase-requests file://purchase-request.json
```
Purchase-request.json:
```
[
{
"PurchaseToken": "eyJ2IjoiMSIsInMiOjEsImMiOi...",
"InstanceCount": 1
}
]
```
Saída:
```
{
"ScheduledInstanceSet": [
{
"AvailabilityZone": "us-west-2b",
"ScheduledInstanceId": "sci-1234-1234-1234-1234-123456789012",
"HourlyPrice": "0.095",
"CreateDate": "2016-01-25T21:43:38.612Z",
"Recurrence": {
"OccurrenceDaySet": [
1
],
"Interval": 1,
"Frequency": "Weekly",
"OccurrenceRelativeToEnd": false,
"OccurrenceUnit": ""
},
"Platform": "Linux/UNIX",
"TermEndDate": "2017-01-31T09:00:00Z",
"InstanceCount": 1,
"SlotDurationInHours": 32,
"TermStartDate": "2016-01-31T09:00:00Z",
"NetworkPlatform": "EC2-VPC",
"TotalScheduledInstanceHours": 1696,
"NextSlotStartTime": "2016-01-31T09:00:00Z",
"InstanceType": "c4.large"
}
]
}
```
+ Para obter detalhes da API, consulte [PurchaseScheduledInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/purchase-scheduled-instances.html)em *Referência de AWS CLI Comandos*.
### `reboot-instances`
O código de exemplo a seguir mostra como usar `reboot-instances`.
**AWS CLI**
**Para reinicializar uma instância do Amazon EC2**
Este exemplo reinicia a instância especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 reboot-instances --instance-ids i-1234567890abcdef5
```
Para obter mais informações, consulte Reinicializar a instância no *Guia do usuário do Amazon Elastic Compute Cloud*.
+ Para obter detalhes da API, consulte [RebootInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reboot-instances.html)em *Referência de AWS CLI Comandos*.
### `register-image`
O código de exemplo a seguir mostra como usar `register-image`.
**AWS CLI**
**Exemplo 1: registrar uma AMI usando um arquivo de manifesto**
O exemplo `register-image` a seguir registra uma AMI usando o arquivo de manifesto especificado no Amazon S3.
```
aws ec2 register-image \
--name my-image \
--image-location amzn-s3-demo-bucket/myimage/image.manifest.xml
```
Saída:
```
{
"ImageId": "ami-1234567890EXAMPLE"
}
```
Para obter mais informações, consulte [Imagens de máquina da Amazon (AMIs)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) no *Guia do usuário do Amazon EC2*.
**Exemplo 2: registrar uma AMI usando um snapshot de um dispositivo raiz**
O exemplo `register-image` a seguir registra uma AMI usando o snapshot especificado de um volume raiz do EBS como um dispositivo `/dev/xvda`. O mapeamento de dispositivos de blocos também inclui um volume EBS vazio de 100 GiB como dispositivo `/dev/xvdf`.
```
aws ec2 register-image \
--name my-image \
--root-device-name /dev/xvda \
--block-device-mappings DeviceName=/dev/xvda,Ebs={SnapshotId=snap-0db2cf683925d191f} DeviceName=/dev/xvdf,Ebs={VolumeSize=100}
```
Saída:
```
{
"ImageId": "ami-1a2b3c4d5eEXAMPLE"
}
```
Para obter mais informações, consulte [Imagens de máquina da Amazon (AMIs)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [RegisterImage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/register-image.html)em *Referência de AWS CLI Comandos*.
### `register-instance-event-notification-attributes`
O código de exemplo a seguir mostra como usar `register-instance-event-notification-attributes`.
**AWS CLI**
**Exemplo 1: incluir todas as tags em notificações de eventos**
O exemplo `register-instance-event-notification-attributes` a seguir inclui todas as tags em notificações de eventos.
```
aws ec2 register-instance-event-notification-attributes \
--instance-tag-attribute IncludeAllTagsOfInstance=true
```
Saída:
```
{
"InstanceTagAttribute": {
"InstanceTagKeys": [],
"IncludeAllTagsOfInstance": true
}
}
```
Para obter mais informações, consulte [Eventos programados para sua instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html) no *Guia do usuário do Amazon EC2 para instâncias do Linux*.
**Exemplo 2: incluir tags específicas em notificações de eventos**
O exemplo `register-instance-event-notification-attributes` a seguir inclui as tags especificadas nas notificações de eventos. Não é possível especificar tags se `IncludeAllTagsOfInstance` for `true`.
```
aws ec2 register-instance-event-notification-attributes \
--instance-tag-attribute InstanceTagKeys="tag-key1","tag-key2"
```
Saída:
```
{
"InstanceTagAttribute": {
"InstanceTagKeys": [
"tag-key1",
"tag-key2"
],
"IncludeAllTagsOfInstance": false
}
}
```
Para obter mais informações, consulte [Eventos programados para sua instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html) no *Guia do usuário do Amazon EC2 para instâncias do Linux*.
+ Para obter detalhes da API, consulte [RegisterInstanceEventNotificationAttributes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/register-instance-event-notification-attributes.html)em *Referência de AWS CLI Comandos*.
### `register-transit-gateway-multicase-group-sources`
O código de exemplo a seguir mostra como usar `register-transit-gateway-multicase-group-sources`.
**AWS CLI**
**Registrar uma origem em um grupo de multicast do gateway de trânsito.**
O exemplo `register-transit-gateway-multicast-group-sources` a seguir registra a origem do grupo de interface de rede especificado com um grupo multicast.
```
aws ec2 register-transit-gateway-multicast-group-sources \
--transit-gateway-multicast-domain-id tgw-mcast-domain-0c4905cef79d6e597 \
--group-ip-address 224.0.1.0 \
--network-interface-ids eni-07f290fc3c090cbae
```
Saída:
```
{
"RegisteredMulticastGroupSources": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-0c4905cef79d6e597",
"RegisteredNetworkInterfaceIds": [
"eni-07f290fc3c090cbae"
],
"GroupIpAddress": "224.0.1.0"
}
}
```
Para obter mais informações, consulte [Registrar fontes com um grupo multicast](https://docs.aws.amazon.com/vpc/latest/tgw/working-with-multicast.html#add-source-multicast-group) no *Guia do usuário de Gateways de trânsito da AWS *.
+ Para obter detalhes da API, consulte [RegisterTransitGatewayMulticaseGroupSources](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/register-transit-gateway-multicase-group-sources.html)em *Referência de AWS CLI Comandos*.
### `register-transit-gateway-multicast-group-members`
O código de exemplo a seguir mostra como usar `register-transit-gateway-multicast-group-members`.
**AWS CLI**
**Visualizar informações sobre as associações de um domínio multicast de gateway de trânsito**
O exemplo `register-transit-gateway-multicast-group-members` a seguir retorna as associações para o domínio multicast especificado.
```
aws ec2 register-transit-gateway-multicast-group-members \
--transit-gateway-multicast-domain-id tgw-mcast-domain-0c4905cef79d6e597 \
--group-ip-address 224.0.1.0 \
--network-interface-ids eni-0e246d32695012e81
```
Saída:
```
{
"RegisteredMulticastGroupMembers": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-0c4905cef79d6e597",
"RegisteredNetworkInterfaceIds": [
"eni-0e246d32695012e81"
],
"GroupIpAddress": "224.0.1.0"
}
}
```
Consulte mais informações em [Multicast domains](https://docs.aws.amazon.com/vpc/latest/tgw/multicast-domains-about.html) no *Guia do usuário do Transit Gateway*.
+ Para obter detalhes da API, consulte [RegisterTransitGatewayMulticastGroupMembers](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/register-transit-gateway-multicast-group-members.html)em *Referência de AWS CLI Comandos*.
### `register-transit-gateway-multicast-group-sources`
O código de exemplo a seguir mostra como usar `register-transit-gateway-multicast-group-sources`.
**AWS CLI**
**Registrar uma origem em um grupo de multicast do gateway de trânsito.**
O exemplo `register-transit-gateway-multicast-group-sources` a seguir registra a origem do grupo de interface de rede especificado com um grupo multicast.
```
aws ec2 register-transit-gateway-multicast-group-sources \
--transit-gateway-multicast-domain-id tgw-mcast-domain-0c4905cef79d6e597 \
--group-ip-address 224.0.1.0 \
--network-interface-ids eni-07f290fc3c090cbae
```
Saída:
```
{
"RegisteredMulticastGroupSources": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-0c4905cef79d6e597",
"RegisteredNetworkInterfaceIds": [
"eni-07f290fc3c090cbae"
],
"GroupIpAddress": "224.0.1.0"
}
}
```
Consulte mais informações em [Multicast domains](https://docs.aws.amazon.com/vpc/latest/tgw/multicast-domains-about.html) no *Guia do Transit Gateway*.
+ Para obter detalhes da API, consulte [RegisterTransitGatewayMulticastGroupSources](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/register-transit-gateway-multicast-group-sources.html)em *Referência de AWS CLI Comandos*.
### `reject-transit-gateway-peering-attachment`
O código de exemplo a seguir mostra como usar `reject-transit-gateway-peering-attachment`.
**AWS CLI**
**Rejeitar um anexo de emparelhamento do gateway de trânsito**
O exemplo `reject-transit-gateway-peering-attachment` a seguir rejeita a solicitação de anexo de emparelhamento do gateway de trânsito especificada. O parâmetro `--region` especifica a região na qual o gateway de trânsito do aceitante está localizado.
```
aws ec2 reject-transit-gateway-peering-attachment \
--transit-gateway-attachment-id tgw-attach-4455667788aabbccd \
--region us-east-2
```
Saída:
```
{
"TransitGatewayPeeringAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-4455667788aabbccd",
"RequesterTgwInfo": {
"TransitGatewayId": "tgw-123abc05e04123abc",
"OwnerId": "123456789012",
"Region": "us-west-2"
},
"AccepterTgwInfo": {
"TransitGatewayId": "tgw-11223344aabbcc112",
"OwnerId": "123456789012",
"Region": "us-east-2"
},
"State": "rejecting",
"CreationTime": "2019-12-09T11:50:31.000Z"
}
}
```
Para obter mais informações, consulte [Anexos de pareamento do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-peering.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [RejectTransitGatewayPeeringAttachment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reject-transit-gateway-peering-attachment.html)em *Referência de AWS CLI Comandos*.
### `reject-transit-gateway-vpc-attachment`
O código de exemplo a seguir mostra como usar `reject-transit-gateway-vpc-attachment`.
**AWS CLI**
**Rejeitar um anexo de emparelhamento do gateway da VPC**
O exemplo `reject-transit-gateway-vpc-attachment` a seguir rejeita o anexo da VPC do gateway de trânsito especificado.
```
aws ec2 reject-transit-gateway-vpc-attachment \
--transit-gateway-attachment-id tgw-attach-0a34fe6b4fEXAMPLE
```
Saída:
```
{
"TransitGatewayVpcAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-0a34fe6b4fEXAMPLE",
"TransitGatewayId": "tgw-0262a0e521EXAMPLE",
"VpcId": "vpc-07e8ffd50fEXAMPLE",
"VpcOwnerId": "111122223333",
"State": "pending",
"SubnetIds": [
"subnet-0752213d59EXAMPLE"
],
"CreationTime": "2019-07-10T17:33:46.000Z",
"Options": {
"DnsSupport": "enable",
"Ipv6Support": "disable"
}
}
}
```
Para obter mais informações, consulte [Anexos do gateway de trânsito para uma VPC](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [RejectTransitGatewayVpcAttachment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reject-transit-gateway-vpc-attachment.html)em *Referência de AWS CLI Comandos*.
### `reject-transit-gateway-vpc-attachments`
O código de exemplo a seguir mostra como usar `reject-transit-gateway-vpc-attachments`.
**AWS CLI**
**Rejeitar um anexo de emparelhamento do gateway da VPC**
O exemplo `reject-transit-gateway-vpc-attachment` a seguir rejeita o anexo da VPC do gateway de trânsito especificado.
```
aws ec2 reject-transit-gateway-vpc-attachment \
--transit-gateway-attachment-id tgw-attach-0a34fe6b4fEXAMPLE
```
Saída:
```
{
"TransitGatewayVpcAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-0a34fe6b4fEXAMPLE",
"TransitGatewayId": "tgw-0262a0e521EXAMPLE",
"VpcId": "vpc-07e8ffd50fEXAMPLE",
"VpcOwnerId": "111122223333",
"State": "pending",
"SubnetIds": [
"subnet-0752213d59EXAMPLE"
],
"CreationTime": "2019-07-10T17:33:46.000Z",
"Options": {
"DnsSupport": "enable",
"Ipv6Support": "disable"
}
}
}
```
Para obter mais informações, consulte [Anexos do gateway de trânsito para uma VPC](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [RejectTransitGatewayVpcAttachments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reject-transit-gateway-vpc-attachments.html)em *Referência de AWS CLI Comandos*.
### `reject-vpc-endpoint-connections`
O código de exemplo a seguir mostra como usar `reject-vpc-endpoint-connections`.
**AWS CLI**
**Rejeitar uma solicitação de conexão de endpoint**
Este exemplo rejeita a solicitação de conexão de endpoint especificada para o serviço de endpoint especificado.
Comando:
```
aws ec2 reject-vpc-endpoint-connections --service-id vpce-svc-03d5ebb7d9579a2b3 --vpc-endpoint-ids vpce-0c1308d7312217abc
```
Saída:
```
{
"Unsuccessful": []
}
```
+ Para obter detalhes da API, consulte [RejectVpcEndpointConnections](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reject-vpc-endpoint-connections.html)em *Referência de AWS CLI Comandos*.
### `reject-vpc-peering-connection`
O código de exemplo a seguir mostra como usar `reject-vpc-peering-connection`.
**AWS CLI**
**Rejeitar uma conexão de emparelhamento da VPC**
Este exemplo rejeita a solicitação de conexão de emparelhamento da VPC especificada.
Comando:
```
aws ec2 reject-vpc-peering-connection --vpc-peering-connection-id pcx-1a2b3c4d
```
Saída:
```
{
"Return": true
}
```
+ Para obter detalhes da API, consulte [RejectVpcPeeringConnection](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reject-vpc-peering-connection.html)em *Referência de AWS CLI Comandos*.
### `release-address`
O código de exemplo a seguir mostra como usar `release-address`.
**AWS CLI**
**Para liberar um endereço IP elástico do EC2-Classic**
Este exemplo libera um endereço IP elástico para usar com instâncias no EC2-Classic. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 release-address --public-ip 198.51.100.0
```
**Para liberar um endereço IP elástico para o EC2-VPC**
Este exemplo libera um endereço IP elástico para usar com instâncias em uma VPC. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 release-address --allocation-id eipalloc-64d5890a
```
+ Para obter detalhes da API, consulte [ReleaseAddress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/release-address.html)em *Referência de AWS CLI Comandos*.
### `release-hosts`
O código de exemplo a seguir mostra como usar `release-hosts`.
**AWS CLI**
**Liberar um host dedicado da sua conta**
Liberar um host dedicado da sua conta. As instâncias que estão no host devem ser interrompidas ou encerradas antes que o host possa ser liberado.
Comando:
```
aws ec2 release-hosts --host-id=h-0029d6e3cacf1b3da
```
Saída:
```
{
"Successful": [
"h-0029d6e3cacf1b3da"
],
"Unsuccessful": []
}
```
+ Para obter detalhes da API, consulte [ReleaseHosts](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/release-hosts.html)em *Referência de AWS CLI Comandos*.
### `release-ipam-pool-allocation`
O código de exemplo a seguir mostra como usar `release-ipam-pool-allocation`.
**AWS CLI**
**Liberar uma alocação de pool IPAM**
Neste exemplo, você é um administrador delegado do IPAM que tentou excluir um pool do IPAM, mas recebeu um erro informando que você não pode excluir o pool enquanto o pool tem alocações. Você está usando esse comando para liberar uma alocação de pool.
Observe o seguinte:
Você só pode usar esse comando para alocações personalizadas. Para remover uma alocação para um recurso sem excluir o recurso, defina seu estado monitorado como falso usando [modify-ipam-resource-cidr](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-ipam-resource-cidr.html).Para concluir essa solicitação, você precisará do ID do pool IPAM, com o qual você pode obter. [describe-ipam-pools](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-ipam-pools.html) Você também precisará do ID de alocação, que pode ser obtido com [get-ipam-pool-allocations](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-ipam-pool-allocations.html).Se não quiser remover as alocações uma por uma, você pode usar o `--cascade option` ao excluir um pool IPAM para liberar automaticamente todas as alocações no pool antes de excluí-las. Há vários pré-requisitos antes de executar esse comando. Para obter mais informações, consulte [Liberar uma alocação](https://docs.aws.amazon.com/vpc/latest/ipam/release-alloc-ipam.html) no *Guia do usuário IPAM da Amazon VPC*. O `--region` em que você executa esse comando deve ser o local do pool IPAM onde está a alocação.
O exemplo `release-ipam-pool-allocation` a seguir libera uma alocação de pool IPAM.
```
aws ec2 release-ipam-pool-allocation \
--ipam-pool-id ipam-pool-07bdd12d7c94e4693 \
--cidr 10.0.0.0/23 \
--ipam-pool-allocation-id ipam-pool-alloc-0e66a1f730da54791b99465b79e7d1e89 \
--region us-west-1
```
Saída:
```
{
"Success": true
}
```
Depois de liberar uma alocação, talvez você queira [delete-ipam-pool](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-ipam-pool.html)executá-la.
+ Para obter detalhes da API, consulte [ReleaseIpamPoolAllocation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/release-ipam-pool-allocation.html)em *Referência de AWS CLI Comandos*.
### `replace-iam-instance-profile-association`
O código de exemplo a seguir mostra como usar `replace-iam-instance-profile-association`.
**AWS CLI**
**Para substituir um perfil de instância do IAM de uma instância**
Este exemplo substitui o perfil de instância do IAM representado pela associação `iip-assoc-060bae234aac2e7fa` pelo perfil de instância do IAM chamado `AdminRole`.
```
aws ec2 replace-iam-instance-profile-association \
--iam-instance-profile Name=AdminRole \
--association-id iip-assoc-060bae234aac2e7fa
```
Saída:
```
{
"IamInstanceProfileAssociation": {
"InstanceId": "i-087711ddaf98f9489",
"State": "associating",
"AssociationId": "iip-assoc-0b215292fab192820",
"IamInstanceProfile": {
"Id": "AIPAJLNLDX3AMYZNWYYAY",
"Arn": "arn:aws:iam::123456789012:instance-profile/AdminRole"
}
}
}
```
+ Para obter detalhes da API, consulte [ReplaceIamInstanceProfileAssociation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/replace-iam-instance-profile-association.html)em *Referência de AWS CLI Comandos*.
### `replace-network-acl-association`
O código de exemplo a seguir mostra como usar `replace-network-acl-association`.
**AWS CLI**
**Substituir a ACL de rede associada a uma sub-rede**
Este exemplo associa a ACL de rede especificada à sub-rede da associação de ACL de rede especificada.
Comando:
```
aws ec2 replace-network-acl-association --association-id aclassoc-e5b95c8c --network-acl-id acl-5fb85d36
```
Saída:
```
{
"NewAssociationId": "aclassoc-3999875b"
}
```
+ Para obter detalhes da API, consulte [ReplaceNetworkAclAssociation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/replace-network-acl-association.html)em *Referência de AWS CLI Comandos*.
### `replace-network-acl-entry`
O código de exemplo a seguir mostra como usar `replace-network-acl-entry`.
**AWS CLI**
**Substituir uma entrada de ACL de rede**
Este exemplo substitui uma entrada para a rede ACL especificada. A nova regra 100 permite o tráfego de entrada de 203.0.113.12/24 na porta UDP 53 (DNS) em qualquer sub-rede associada.
Comando:
```
aws ec2 replace-network-acl-entry --network-acl-id acl-5fb85d36 --ingress --rule-number 100 --protocol udp --port-range From=53,To=53 --cidr-block 203.0.113.12/24 --rule-action allow
```
+ Para obter detalhes da API, consulte [ReplaceNetworkAclEntry](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/replace-network-acl-entry.html)em *Referência de AWS CLI Comandos*.
### `replace-route-table-association`
O código de exemplo a seguir mostra como usar `replace-route-table-association`.
**AWS CLI**
**Substituir uma tabela de rotas associada a uma sub-rede**
Este exemplo associa a tabela de rotas especificada à sub-rede para a associação da tabela de rotas especificada.
Comando:
```
aws ec2 replace-route-table-association --association-id rtbassoc-781d0d1a --route-table-id rtb-22574640
```
Saída:
```
{
"NewAssociationId": "rtbassoc-3a1f0f58"
}
```
+ Para obter detalhes da API, consulte [ReplaceRouteTableAssociation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/replace-route-table-association.html)em *Referência de AWS CLI Comandos*.
### `replace-route`
O código de exemplo a seguir mostra como usar `replace-route`.
**AWS CLI**
**Substituir uma rota**
Este exemplo substitui a rota especificada na tabela de rotas especificada. A nova rota corresponde ao CIDR especificado e envia o tráfego para o gateway privado virtual especificado. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 replace-route --route-table-id rtb-22574640 --destination-cidr-block 10.0.0.0/16 --gateway-id vgw-9a4cacf3
```
+ Para obter detalhes da API, consulte [ReplaceRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/replace-route.html)em *Referência de AWS CLI Comandos*.
### `replace-transit-gateway-route`
O código de exemplo a seguir mostra como usar `replace-transit-gateway-route`.
**AWS CLI**
**Substituir a rota especificada na tabela de rotas do gateway de trânsito especificada**
O exemplo `replace-transit-gateway-route` a seguir substitui a rota na tabela de rotas de gateway de trânsito especificada.
```
aws ec2 replace-transit-gateway-route \
--destination-cidr-block 10.0.2.0/24 \
--transit-gateway-attachment-id tgw-attach-09b52ccdb5EXAMPLE \
--transit-gateway-route-table-id tgw-rtb-0a823edbdeEXAMPLE
```
Saída:
```
{
"Route": {
"DestinationCidrBlock": "10.0.2.0/24",
"TransitGatewayAttachments": [
{
"ResourceId": "vpc-4EXAMPLE",
"TransitGatewayAttachmentId": "tgw-attach-09b52ccdb5EXAMPLE",
"ResourceType": "vpc"
}
],
"Type": "static",
"State": "active"
}
}
```
Para obter mais informações, consulte [Tabelas de rota do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [ReplaceTransitGatewayRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/replace-transit-gateway-route.html)em *Referência de AWS CLI Comandos*.
### `report-instance-status`
O código de exemplo a seguir mostra como usar `report-instance-status`.
**AWS CLI**
**Reportar feedback de status de uma instância**
Este exemplo de comando reporta um feedback de status para a instância especificada.
Comando:
```
aws ec2 report-instance-status --instances i-1234567890abcdef0 --status impaired --reason-codes unresponsive
```
+ Para obter detalhes da API, consulte [ReportInstanceStatus](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/report-instance-status.html)em *Referência de AWS CLI Comandos*.
### `request-spot-fleet`
O código de exemplo a seguir mostra como usar `request-spot-fleet`.
**AWS CLI**
**Solicitar uma frota Spot na sub-rede com o menor preço**
Esse exemplo de comando cria uma solicitação de frota Spot com duas especificações de lançamento que diferem somente por sub-rede. A frota Spot lança as instâncias na sub-rede especificada de menor preço. Se as instâncias forem executadas em uma VPC padrão, elas receberão um endereço IP público por padrão. Se as instâncias forem executadas em uma VPC não padrão, elas não receberão um endereço IP público por padrão.
Observe que você não pode especificar sub-redes diferentes da mesma zona de disponibilidade em uma solicitação de frota spot.
Comando:
```
aws ec2 request-spot-fleet --spot-fleet-request-config file://config.json
```
Config.json:
```
{
"SpotPrice": "0.04",
"TargetCapacity": 2,
"IamFleetRole": "arn:aws:iam::123456789012:role/my-spot-fleet-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"KeyName": "my-key-pair",
"SecurityGroups": [
{
"GroupId": "sg-1a2b3c4d"
}
],
"InstanceType": "m3.medium",
"SubnetId": "subnet-1a2b3c4d, subnet-3c4d5e6f",
"IamInstanceProfile": {
"Arn": "arn:aws:iam::123456789012:instance-profile/my-iam-role"
}
}
]
}
```
Saída:
```
{
"SpotFleetRequestId": "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE"
}
```
**Solicitar uma frota Spot na zona de disponibilidade com o menor preço**
Esse exemplo de comando cria uma solicitação de frota Spot com duas especificações de lançamento que diferem somente por Zona de Disponibilidade. A frota Spot lança as instâncias na Zona de Disponibilidade especificada de menor preço. Se sua conta oferece suporte somente ao EC2-VPC, o Amazon EC2 executará as instâncias Spot na sub-rede padrão da Zona de Disponibilidade. Se sua conta oferece suporte ao EC2-Classic, o Amazon EC2 executará as instâncias no EC2-Classic na Zona de Disponibilidade.
Comando:
```
aws ec2 request-spot-fleet --spot-fleet-request-config file://config.json
```
Config.json:
```
{
"SpotPrice": "0.04",
"TargetCapacity": 2,
"IamFleetRole": "arn:aws:iam::123456789012:role/my-spot-fleet-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"KeyName": "my-key-pair",
"SecurityGroups": [
{
"GroupId": "sg-1a2b3c4d"
}
],
"InstanceType": "m3.medium",
"Placement": {
"AvailabilityZone": "us-west-2a, us-west-2b"
},
"IamInstanceProfile": {
"Arn": "arn:aws:iam::123456789012:instance-profile/my-iam-role"
}
}
]
}
```
**Lançar instâncias spot em uma sub-rede e atribuir a elas endereços IP públicos**
Este comando de exemplo atribui endereços IP públicos a instâncias lançadas em uma VPC não padrão. Observe que, ao especificar uma interface de rede, você deve incluir o ID da sub-rede e o ID do grupo de segurança usando a interface de rede.
Comando:
```
aws ec2 request-spot-fleet --spot-fleet-request-config file://config.json
```
Config.json:
```
{
"SpotPrice": "0.04",
"TargetCapacity": 2,
"IamFleetRole": "arn:aws:iam::123456789012:role/my-spot-fleet-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"KeyName": "my-key-pair",
"InstanceType": "m3.medium",
"NetworkInterfaces": [
{
"DeviceIndex": 0,
"SubnetId": "subnet-1a2b3c4d",
"Groups": [ "sg-1a2b3c4d" ],
"AssociatePublicIpAddress": true
}
],
"IamInstanceProfile": {
"Arn": "arn:aws:iam::880185128111:instance-profile/my-iam-role"
}
}
]
}
```
**Solicitar uma frota Spot usando a estratégia de alocação diversificada**
Esse exemplo de comando cria uma solicitação de frota Spot que executa 30 instâncias usando a estratégia de alocação diversificada. As especificações de lançamento variam de acordo com o tipo de instância. A frota spot distribui as instâncias pelas especificações de execução, de modo que haja 10 instâncias de cada tipo.
Comando:
```
aws ec2 request-spot-fleet --spot-fleet-request-config file://config.json
```
Config.json:
```
{
"SpotPrice": "0.70",
"TargetCapacity": 30,
"AllocationStrategy": "diversified",
"IamFleetRole": "arn:aws:iam::123456789012:role/my-spot-fleet-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "c4.2xlarge",
"SubnetId": "subnet-1a2b3c4d"
},
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "m3.2xlarge",
"SubnetId": "subnet-1a2b3c4d"
},
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "r3.2xlarge",
"SubnetId": "subnet-1a2b3c4d"
}
]
}
```
Para obter mais informações, consulte Solicitações de frota Spot no *Guia do usuário do Amazon Elastic Compute Cloud*.
+ Para obter detalhes da API, consulte [RequestSpotFleet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/request-spot-fleet.html)em *Referência de AWS CLI Comandos*.
### `request-spot-instances`
O código de exemplo a seguir mostra como usar `request-spot-instances`.
**AWS CLI**
**Solicitar Instâncias spot**
Este exemplo de comando cria uma solicitação única de Instância Spot para cinco instâncias na Zona de Disponibilidade especificada. Se sua conta oferece suporte somente ao EC2-VPC, o Amazon EC2 executará as instâncias na sub-rede especificada da Zona de Disponibilidade. Se sua conta oferece suporte ao EC2-Classic, o Amazon EC2 executará as instâncias no EC2-Classic na Zona de Disponibilidade especificada.
Comando:
```
aws ec2 request-spot-instances --spot-price "0.03" --instance-count 5 --type "one-time" --launch-specification file://specification.json
```
Specification.json:
```
{
"ImageId": "ami-1a2b3c4d",
"KeyName": "my-key-pair",
"SecurityGroupIds": [ "sg-1a2b3c4d" ],
"InstanceType": "m3.medium",
"Placement": {
"AvailabilityZone": "us-west-2a"
},
"IamInstanceProfile": {
"Arn": "arn:aws:iam::123456789012:instance-profile/my-iam-role"
}
}
```
Saída:
```
{
"SpotInstanceRequests": [
{
"Status": {
"UpdateTime": "2014-03-25T20:54:21.000Z",
"Code": "pending-evaluation",
"Message": "Your Spot request has been submitted for review, and is pending evaluation."
},
"ProductDescription": "Linux/UNIX",
"SpotInstanceRequestId": "sir-df6f405d",
"State": "open",
"LaunchSpecification": {
"Placement": {
"AvailabilityZone": "us-west-2a"
},
"ImageId": "ami-1a2b3c4d",
"KeyName": "my-key-pair",
"SecurityGroups": [
{
"GroupName": "my-security-group",
"GroupId": "sg-1a2b3c4d"
}
],
"Monitoring": {
"Enabled": false
},
"IamInstanceProfile": {
"Arn": "arn:aws:iam::123456789012:instance-profile/my-iam-role"
},
"InstanceType": "m3.medium"
},
"Type": "one-time",
"CreateTime": "2014-03-25T20:54:20.000Z",
"SpotPrice": "0.050000"
},
...
]
}
```
Este exemplo de comando cria uma solicitação única de Instância Spot para cinco instâncias na sub-rede especificada. O Amazon EC2 executa as instâncias na sub-rede especificada. Se a VPC não for padrão, as instâncias não receberão um endereço IP público por padrão.
Comando:
```
aws ec2 request-spot-instances --spot-price "0.050" --instance-count 5 --type "one-time" --launch-specification file://specification.json
```
Specification.json:
```
{
"ImageId": "ami-1a2b3c4d",
"SecurityGroupIds": [ "sg-1a2b3c4d" ],
"InstanceType": "m3.medium",
"SubnetId": "subnet-1a2b3c4d",
"IamInstanceProfile": {
"Arn": "arn:aws:iam::123456789012:instance-profile/my-iam-role"
}
}
```
Saída:
```
{
"SpotInstanceRequests": [
{
"Status": {
"UpdateTime": "2014-03-25T22:21:58.000Z",
"Code": "pending-evaluation",
"Message": "Your Spot request has been submitted for review, and is pending evaluation."
},
"ProductDescription": "Linux/UNIX",
"SpotInstanceRequestId": "sir-df6f405d",
"State": "open",
"LaunchSpecification": {
"Placement": {
"AvailabilityZone": "us-west-2a"
}
"ImageId": "ami-1a2b3c4d"
"SecurityGroups": [
{
"GroupName": "my-security-group",
"GroupID": "sg-1a2b3c4d"
}
]
"SubnetId": "subnet-1a2b3c4d",
"Monitoring": {
"Enabled": false
},
"IamInstanceProfile": {
"Arn": "arn:aws:iam::123456789012:instance-profile/my-iam-role"
},
"InstanceType": "m3.medium",
},
"Type": "one-time",
"CreateTime": "2014-03-25T22:21:58.000Z",
"SpotPrice": "0.050000"
},
...
]
}
```
Este exemplo atribui um endereço IP público às Instâncias Spot que você lança em uma VPC não padrão. Observe que, ao especificar uma interface de rede, você deve incluir o ID da sub-rede e o ID do grupo de segurança usando a interface de rede.
Comando:
```
aws ec2 request-spot-instances --spot-price "0.050" --instance-count 1 --type "one-time" --launch-specification file://specification.json
```
Specification.json:
```
{
"ImageId": "ami-1a2b3c4d",
"KeyName": "my-key-pair",
"InstanceType": "m3.medium",
"NetworkInterfaces": [
{
"DeviceIndex": 0,
"SubnetId": "subnet-1a2b3c4d",
"Groups": [ "sg-1a2b3c4d" ],
"AssociatePublicIpAddress": true
}
],
"IamInstanceProfile": {
"Arn": "arn:aws:iam::123456789012:instance-profile/my-iam-role"
}
}
```
+ Para obter detalhes da API, consulte [RequestSpotInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/request-spot-instances.html)em *Referência de AWS CLI Comandos*.
### `reset-address-attribute`
O código de exemplo a seguir mostra como usar `reset-address-attribute`.
**AWS CLI**
**Redefinir o atributo do nome de domínio associado a um endereço IP elástico**
Os exemplos `reset-address-attribute` a seguir redefinem o atributo de nome de domínio de um endereço IP elástico.
Linux
```
aws ec2 reset-address-attribute \
--allocation-id eipalloc-abcdef01234567890 \
--attribute domain-name
```
Windows:
```
aws ec2 reset-address-attribute ^
--allocation-id eipalloc-abcdef01234567890 ^
--attribute domain-name
```
Saída:
```
{
"Addresses": [
{
"PublicIp": "192.0.2.0",
"AllocationId": "eipalloc-abcdef01234567890",
"PtrRecord": "example.com."
"PtrRecordUpdate": {
"Value": "example.net.",
"Status": "PENDING"
}
]
}
```
Para monitorar a alteração pendente, consulte [describe-addresses-attribute](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-addresses-attribute.html)na Referência de *Comandos da AWS CLI*.
+ Para obter detalhes da API, consulte [ResetAddressAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reset-address-attribute.html)em *Referência de AWS CLI Comandos*.
### `reset-ebs-default-kms-key-id`
O código de exemplo a seguir mostra como usar `reset-ebs-default-kms-key-id`.
**AWS CLI**
**Redefinir sua CMK padrão para criptografia EBS**
O `reset-ebs-default-kms-key-id` exemplo a seguir redefine a CMK padrão para criptografia do EBS para sua AWS conta na região atual.
```
aws ec2 reset-ebs-default-kms-key-id
```
Saída:
```
{
"KmsKeyId": "arn:aws:kms:us-west-2:123456789012:key/8c5b2c63-b9bc-45a3-a87a-5513eEXAMPLE"
}
```
+ Para obter detalhes da API, consulte [ResetEbsDefaultKmsKeyId](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reset-ebs-default-kms-key-id.html)em *Referência de AWS CLI Comandos*.
### `reset-fpga-image-attribute`
O código de exemplo a seguir mostra como usar `reset-fpga-image-attribute`.
**AWS CLI**
**Redefinir os atributos de uma imagem do Amazon FPGA**
Este exemplo redefine as permissões de carga para a AFI especificada.
Comando:
```
aws ec2 reset-fpga-image-attribute --fpga-image-id afi-0d123e123bfc85abc --attribute loadPermission
```
Saída:
```
{
"Return": true
}
```
+ Para obter detalhes da API, consulte [ResetFpgaImageAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reset-fpga-image-attribute.html)em *Referência de AWS CLI Comandos*.
### `reset-image-attribute`
O código de exemplo a seguir mostra como usar `reset-image-attribute`.
**AWS CLI**
**Redefinir o atributo launchPermission**
Este exemplo redefine o atributo `launchPermission` da AMI especificada para seu valor padrão. Por padrão, AMIs são privados. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 reset-image-attribute --image-id ami-5731123e --attribute launchPermission
```
+ Para obter detalhes da API, consulte [ResetImageAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reset-image-attribute.html)em *Referência de AWS CLI Comandos*.
### `reset-instance-attribute`
O código de exemplo a seguir mostra como usar `reset-instance-attribute`.
**AWS CLI**
**Para redefinir o sourceDestCheck atributo**
Este exemplo redefine o atributo `sourceDestCheck` da instância especificada. A instância deve estar em uma VPC. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 reset-instance-attribute --instance-id i-1234567890abcdef0 --attribute sourceDestCheck
```
**Redefinir o atributo kernel**
Este exemplo redefine o atributo `kernel` da instância especificada. A instância deve estar no estado `stopped`. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 reset-instance-attribute --instance-id i-1234567890abcdef0 --attribute kernel
```
**Redefinir o atributo ramdisk**
Este exemplo redefine o atributo `ramdisk` da instância especificada. A instância deve estar no estado `stopped`. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 reset-instance-attribute --instance-id i-1234567890abcdef0 --attribute ramdisk
```
+ Para obter detalhes da API, consulte [ResetInstanceAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reset-instance-attribute.html)em *Referência de AWS CLI Comandos*.
### `reset-network-interface-attribute`
O código de exemplo a seguir mostra como usar `reset-network-interface-attribute`.
**AWS CLI**
**Redefinir um atributo da interface de rede**
O `reset-network-interface-attribute` exemplo a seguir redefine o valor do atributo de source/destination verificação para`true`.
```
aws ec2 reset-network-interface-attribute \
--network-interface-id eni-686ea200 \
--source-dest-check
```
Este comando não produz saída.
+ Para obter detalhes da API, consulte [ResetNetworkInterfaceAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reset-network-interface-attribute.html)em *Referência de AWS CLI Comandos*.
### `reset-snapshot-attribute`
O código de exemplo a seguir mostra como usar `reset-snapshot-attribute`.
**AWS CLI**
**Redefinir um atributo de snapshot**
Este exemplo redefine as permissões de criação de volume para o snapshot `snap-1234567890abcdef0`. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 reset-snapshot-attribute --snapshot-id snap-1234567890abcdef0 --attribute createVolumePermission
```
+ Para obter detalhes da API, consulte [ResetSnapshotAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reset-snapshot-attribute.html)em *Referência de AWS CLI Comandos*.
### `restore-address-to-classic`
O código de exemplo a seguir mostra como usar `restore-address-to-classic`.
**AWS CLI**
**Restaurar um endereço para EC2-Classic**
Este exemplo restaura o endereço IP elástico 198.51.100.0 na plataforma EC2-Classic.
Comando:
```
aws ec2 restore-address-to-classic --public-ip 198.51.100.0
```
Saída:
```
{
"Status": "MoveInProgress",
"PublicIp": "198.51.100.0"
}
```
+ Para obter detalhes da API, consulte [RestoreAddressToClassic](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/restore-address-to-classic.html)em *Referência de AWS CLI Comandos*.
### `restore-image-from-recycle-bin`
O código de exemplo a seguir mostra como usar `restore-image-from-recycle-bin`.
**AWS CLI**
**Restaurar uma imagem da Lixeira**
O exemplo `restore-image-from-recycle-bin` a seguir restaura a AMI ami-0111222333444abcd da Lixeira.
```
aws ec2 restore-image-from-recycle-bin \
--image-id ami-0111222333444abcd
```
Saída:
```
{
"Return": true
}
```
Para obter mais informações, consulte [Recuperação AMIs excluída da lixeira no Guia](https://docs.aws.amazon.com/ebs/latest/userguide/recycle-bin-working-with-amis.html) do *usuário do Amazon EBS*.
+ Para obter detalhes da API, consulte [RestoreImageFromRecycleBin](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/restore-image-from-recycle-bin.html)em *Referência de AWS CLI Comandos*.
### `restore-managed-prefix-list-version`
O código de exemplo a seguir mostra como usar `restore-managed-prefix-list-version`.
**AWS CLI**
us-west-2\$1\$1Restaurar uma versão da lista de prefixos\$1\$1
O `restore-managed-prefix-list-version` a seguir restaura as entradas da versão 1 da lista de prefixos especificada.
```
aws ec2 restore-managed-prefix-list-version \
--prefix-list-id pl-0123456abcabcabc1 \
--current-version 2 \
--previous-version 1
```
Saída:
```
{
"PrefixList": {
"PrefixListId": "pl-0123456abcabcabc1",
"AddressFamily": "IPv4",
"State": "restore-in-progress",
"PrefixListArn": "arn:aws:ec2:us-west-2:123456789012:prefix-list/pl-0123456abcabcabc1",
"PrefixListName": "vpc-cidrs",
"MaxEntries": 10,
"Version": 2,
"OwnerId": "123456789012"
}
}
```
Para obter mais informações, consulte [Listas de prefixos gerenciados](https://docs.aws.amazon.com/vpc/latest/userguide/managed-prefix-lists.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [RestoreManagedPrefixListVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/restore-managed-prefix-list-version.html)em *Referência de AWS CLI Comandos*.
### `restore-snapshot-from-recycle-bin`
O código de exemplo a seguir mostra como usar `restore-snapshot-from-recycle-bin`.
**AWS CLI**
**Restaurar os snapshots da lixeira**
O exemplo `restore-snapshot-from-recycle-bin` a seguir restaura o snapshot da Lixeira. Quando você restaura um snapshot da lixeira, ele fica imediatamente disponível para uso e é removido da lixeira. É possível usar um snapshot restaurado como usa qualquer outro snapshot em sua conta.
```
aws ec2 restore-snapshot-from-recycle-bin \
--snapshot-id snap-01234567890abcdef
```
Este comando não produz saída.
Consulte mais informações sobre a Lixeira em [Recover deleted snapshots from the Recycle Bin](https://docs.aws.amazon.com/ebs/latest/userguide/recycle-bin-working-with-snaps.html) no *Manual do usuário do Amazon EBS*.
+ Para obter detalhes da API, consulte [RestoreSnapshotFromRecycleBin](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/restore-snapshot-from-recycle-bin.html)em *Referência de AWS CLI Comandos*.
### `restore-snapshot-tier`
O código de exemplo a seguir mostra como usar `restore-snapshot-tier`.
**AWS CLI**
**Exemplo 1: restaurar permanentemente um snapshot arquivado**
O exemplo `restore-snapshot-tier` a seguir restaura permanentemente o snapshot especificado. Especifique `--snapshot-id` e inclua a opção `permanent-restore`.
```
aws ec2 restore-snapshot-tier \
--snapshot-id snap-01234567890abcedf \
--permanent-restore
```
Saída:
```
{
"SnapshotId": "snap-01234567890abcedf",
"IsPermanentRestore": true
}
```
Consulte mais informações sobre o arquivamento de snapshots em [Archive Amazon EBS snapshots](https://docs.aws.amazon.com/ebs/latest/userguide/snapshot-archive.html) no *Guia do usuário do Amazon EBS*.
**Exemplo 2: restaurar temporariamente um snapshot arquivado**
O exemplo `restore-snapshot-tier` a seguir restaura temporariamente o snapshot especificado. Omita a opção `--permanent-restore`. Especifique `--snapshot-id` e, para `temporary-restore-days`, especifique o número de dias pelos quais restaurar o snapshot. `temporary-restore-days` deve ser especificado em dias. O intervalo permitido é de `1` a `180`. Se você não especificar um valor, o padrão de `1` dia será adotado.
```
aws ec2 restore-snapshot-tier \
--snapshot-id snap-01234567890abcedf \
--temporary-restore-days 5
```
Saída:
```
{
"SnapshotId": "snap-01234567890abcedf",
"RestoreDuration": 5,
"IsPermanentRestore": false
}
```
Consulte mais informações sobre o arquivamento de snapshots em [Archive Amazon EBS snapshots](https://docs.aws.amazon.com/ebs/latest/userguide/snapshot-archive.html) no *Guia do usuário do Amazon EBS*.
**Exemplo 3: modificar o período de restauração**
O exemplo `restore-snapshot-tier` a seguir altera o período de restauração do snapshot especificado para `10` dias.
```
aws ec2 restore-snapshot-tier \
--snapshot-id snap-01234567890abcedf
--temporary-restore-days 10
```
Saída:
```
{
"SnapshotId": "snap-01234567890abcedf",
"RestoreDuration": 10,
"IsPermanentRestore": false
}
```
Consulte mais informações sobre o arquivamento de snapshots em [Archive Amazon EBS snapshots](https://docs.aws.amazon.com/ebs/latest/userguide/snapshot-archive.html) no *Guia do usuário do Amazon EBS*.
**Exemplo 4: modificar o tipo de restauração**
O exemplo `restore-snapshot-tier` a seguir altera o tipo de restauração para o snapshot especificado de temporária para permanente.
```
aws ec2 restore-snapshot-tier \
--snapshot-id snap-01234567890abcedf
--permanent-restore
```
Saída:
```
{
"SnapshotId": "snap-01234567890abcedf",
"IsPermanentRestore": true
}
```
Consulte mais informações sobre o arquivamento de snapshots em [Archive Amazon EBS snapshots](https://docs.aws.amazon.com/ebs/latest/userguide/snapshot-archive.html) no *Guia do usuário do Amazon EBS*.
+ Para obter detalhes da API, consulte [RestoreSnapshotTier](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/restore-snapshot-tier.html)em *Referência de AWS CLI Comandos*.
### `revoke-client-vpn-ingress`
O código de exemplo a seguir mostra como usar `revoke-client-vpn-ingress`.
**AWS CLI**
**Revogar uma regra de autorização de um endpoint do Client VPN**
O exemplo `revoke-client-vpn-ingress` a seguir revoga uma regra de acesso à Internet (`0.0.0.0/0`) para todos os grupos.
```
aws ec2 revoke-client-vpn-ingress \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde \
--target-network-cidr 0.0.0.0/0 --revoke-all-groups
```
Saída:
```
{
"Status": {
"Code": "revoking"
}
}
```
Para obter mais informações, consulte [Regras de autorização](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-rules.html) no *Guia do administrador do Cliente VPN da AWS *.
+ Para obter detalhes da API, consulte [RevokeClientVpnIngress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/revoke-client-vpn-ingress.html)em *Referência de AWS CLI Comandos*.
### `revoke-security-group-egress`
O código de exemplo a seguir mostra como usar `revoke-security-group-egress`.
**AWS CLI**
**Exemplo 1: remover a regra que permite tráfego de saída para um intervalo de endereços específico**
O comando de exemplo `revoke-security-group-egress` a seguir remove a regra que concede acesso aos intervalos de endereços especificados na porta TCP 80.
```
aws ec2 revoke-security-group-egress \
--group-id sg-026c12253ce15eff7 \
--ip-permissions [{IpProtocol=tcp,FromPort=80,ToPort=80,IpRanges=[{CidrIp=10.0.0.0/16}]
```
Este comando não produz saída.
Para obter mais informações, consulte [Grupos de segurança](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html) no *Manual do usuário da Amazon EC2*.
**Exemplo 2: remover a regra que permite tráfego de saída para um grupo de segurança específico**
O comando de exemplo `revoke-security-group-egress` a seguir remove a regra que concede acesso ao grupo de segurança especificado na porta TCP 80.
```
aws ec2 revoke-security-group-egress \
--group-id sg-026c12253ce15eff7 \
--ip-permissions '[{"IpProtocol": "tcp", "FromPort": 443, "ToPort": 443,"UserIdGroupPairs": [{"GroupId": "sg-06df23a01ff2df86d"}]}]'
```
Este comando não produz saída.
Para obter mais informações, consulte [Grupos de segurança](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html) no *Manual do usuário da Amazon EC2*.
+ Para obter detalhes da API, consulte [RevokeSecurityGroupEgress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/revoke-security-group-egress.html)em *Referência de AWS CLI Comandos*.
### `revoke-security-group-ingress`
O código de exemplo a seguir mostra como usar `revoke-security-group-ingress`.
**AWS CLI**
**Exemplo 1: remover uma regra de um grupo de segurança**
O exemplo `revoke-security-group-ingress` a seguir remove o acesso à porta TCP 22 para o intervalo de endereços `203.0.113.0/24` do grupo de segurança especificado para uma VPC padrão.
```
aws ec2 revoke-security-group-ingress \
--group-name mySecurityGroup
--protocol tcp \
--port 22 \
--cidr 203.0.113.0/24
```
Se for bem-sucedido, esse comando não gerará nenhum resultado.
Para obter mais informações, consulte [Grupos de segurança](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html) no *Manual do usuário da Amazon EC2*.
**Exemplo 2: remover uma regra usando o conjunto de permissões de IP**
O exemplo `revoke-security-group-ingress` a seguir usa o parâmetro `ip-permissions` para remover uma regra de entrada que permite a mensagem do ICMP `Destination Unreachable: Fragmentation Needed and Don't Fragment was Set` (Tipo 3, Código 4).
```
aws ec2 revoke-security-group-ingress \
--group-id sg-026c12253ce15eff7 \
--ip-permissions IpProtocol=icmp,FromPort=3,ToPort=4,IpRanges=[{CidrIp=0.0.0.0/0}]
```
Se for bem-sucedido, esse comando não gerará nenhum resultado.
Para obter mais informações, consulte [Grupos de segurança](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html) no *Manual do usuário da Amazon EC2*.
+ Para obter detalhes da API, consulte [RevokeSecurityGroupIngress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/revoke-security-group-ingress.html)em *Referência de AWS CLI Comandos*.
### `run-instances`
O código de exemplo a seguir mostra como usar `run-instances`.
**AWS CLI**
**Exemplo 1: executar uma instância em uma sub-rede padrão**
O exemplo `run-instances` a seguir executa uma única instância do tipo `t2.micro` na sub-rede padrão da região atual e a associa à sub-rede padrão da VPC padrão da região. O par de chaves é opcional se você não planeja se conectar à instância usando SSH (Linux) ou RDP (Windows).
```
aws ec2 run-instances \
--image-id ami-0abcdef1234567890 \
--instance-type t2.micro \
--key-name MyKeyPair
```
Saída:
```
{
"Instances": [
{
"AmiLaunchIndex": 0,
"ImageId": "ami-0abcdef1234567890",
"InstanceId": "i-1231231230abcdef0",
"InstanceType": "t2.micro",
"KeyName": "MyKeyPair",
"LaunchTime": "2018-05-10T08:05:20.000Z",
"Monitoring": {
"State": "disabled"
},
"Placement": {
"AvailabilityZone": "us-east-2a",
"GroupName": "",
"Tenancy": "default"
},
"PrivateDnsName": "ip-10-0-0-157.us-east-2.compute.internal",
"PrivateIpAddress": "10.0.0.157",
"ProductCodes": [],
"PublicDnsName": "",
"State": {
"Code": 0,
"Name": "pending"
},
"StateTransitionReason": "",
"SubnetId": "subnet-04a636d18e83cfacb",
"VpcId": "vpc-1234567890abcdef0",
"Architecture": "x86_64",
"BlockDeviceMappings": [],
"ClientToken": "",
"EbsOptimized": false,
"Hypervisor": "xen",
"NetworkInterfaces": [
{
"Attachment": {
"AttachTime": "2018-05-10T08:05:20.000Z",
"AttachmentId": "eni-attach-0e325c07e928a0405",
"DeleteOnTermination": true,
"DeviceIndex": 0,
"Status": "attaching"
},
"Description": "",
"Groups": [
{
"GroupName": "MySecurityGroup",
"GroupId": "sg-0598c7d356eba48d7"
}
],
"Ipv6Addresses": [],
"MacAddress": "0a:ab:58:e0:67:e2",
"NetworkInterfaceId": "eni-0c0a29997760baee7",
"OwnerId": "123456789012",
"PrivateDnsName": "ip-10-0-0-157.us-east-2.compute.internal",
"PrivateIpAddress": "10.0.0.157",
"PrivateIpAddresses": [
{
"Primary": true,
"PrivateDnsName": "ip-10-0-0-157.us-east-2.compute.internal",
"PrivateIpAddress": "10.0.0.157"
}
],
"SourceDestCheck": true,
"Status": "in-use",
"SubnetId": "subnet-04a636d18e83cfacb",
"VpcId": "vpc-1234567890abcdef0",
"InterfaceType": "interface"
}
],
"RootDeviceName": "/dev/xvda",
"RootDeviceType": "ebs",
"SecurityGroups": [
{
"GroupName": "MySecurityGroup",
"GroupId": "sg-0598c7d356eba48d7"
}
],
"SourceDestCheck": true,
"StateReason": {
"Code": "pending",
"Message": "pending"
},
"Tags": [],
"VirtualizationType": "hvm",
"CpuOptions": {
"CoreCount": 1,
"ThreadsPerCore": 1
},
"CapacityReservationSpecification": {
"CapacityReservationPreference": "open"
},
"MetadataOptions": {
"State": "pending",
"HttpTokens": "optional",
"HttpPutResponseHopLimit": 1,
"HttpEndpoint": "enabled"
}
}
],
"OwnerId": "123456789012",
"ReservationId": "r-02a3f596d91211712"
}
```
**Exemplo 2: para executar uma instância em uma sub-rede não padrão e adicionar um endereço IP público**
O exemplo `run-instances` a seguir solicita um endereço IP público para uma instância que você está executando em uma sub-rede não padrão. A instância está associada ao grupo de segurança especificado.
```
aws ec2 run-instances \
--image-id ami-0abcdef1234567890 \
--instance-type t2.micro \
--subnet-id subnet-08fc749671b2d077c \
--security-group-ids sg-0b0384b66d7d692f9 \
--associate-public-ip-address \
--key-name MyKeyPair
```
Para obter um exemplo da saída de `run-instances`, consulte o Exemplo 1.
**Exemplo 3: executar uma instância com volumes adicionais**
O exemplo `run-instances` a seguir usa um mapeamento de dispositivos de blocos, especificado em mapping.json, para anexar volumes adicionais na execução. Um mapeamento de dispositivos de blocos pode especificar volumes do EBS, volumes de armazenamento de instância ou tanto volumes do EBS quanto volumes de armazenamento de instância.
```
aws ec2 run-instances \
--image-id ami-0abcdef1234567890 \
--instance-type t2.micro \
--subnet-id subnet-08fc749671b2d077c \
--security-group-ids sg-0b0384b66d7d692f9 \
--key-name MyKeyPair \
--block-device-mappings file://mapping.json
```
Conteúdo de `mapping.json`. Este exemplo adiciona `/dev/sdh` como um volume vazio do EBS com um tamanho de 100 GiB.
```
[
{
"DeviceName": "/dev/sdh",
"Ebs": {
"VolumeSize": 100
}
}
]
```
Conteúdo de `mapping.json`. Este exemplo adiciona `ephemeral1` como um volume de armazenamento de instância.
```
[
{
"DeviceName": "/dev/sdc",
"VirtualName": "ephemeral1"
}
]
```
Para obter um exemplo da saída de `run-instances`, consulte o Exemplo 1.
Para obter mais informações sobre mapeamentos de dispositivos de blocos, consulte [Mapeamento de dispositivos de blocos](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html) no *Guia do usuário do Amazon EC2*.
**Exemplo 4: executar uma instância e adicionar tags na criação**
O exemplo `run-instances` a seguir adiciona uma tag com uma chave de `webserver` e um valor de `production` à instância. O comando também aplica uma tag com uma chave de `cost-center` e um valor de `cc123` a qualquer volume do EBS criado (neste caso, o volume do dispositivo raiz).
```
aws ec2 run-instances \
--image-id ami-0abcdef1234567890 \
--instance-type t2.micro \
--count 1 \
--subnet-id subnet-08fc749671b2d077c \
--key-name MyKeyPair \
--security-group-ids sg-0b0384b66d7d692f9 \
--tag-specifications 'ResourceType=instance,Tags=[{Key=webserver,Value=production}]' 'ResourceType=volume,Tags=[{Key=cost-center,Value=cc123}]'
```
Para obter um exemplo da saída de `run-instances`, consulte o Exemplo 1.
**Exemplo 5: executar uma instância com dados do usuário**
O exemplo `run-instances` a seguir passa dados do usuário em um arquivo chamado `my_script.txt` que contém um script de configuração para a sua instância. O script é executado na inicialização.
```
aws ec2 run-instances \
--image-id ami-0abcdef1234567890 \
--instance-type t2.micro \
--count 1 \
--subnet-id subnet-08fc749671b2d077c \
--key-name MyKeyPair \
--security-group-ids sg-0b0384b66d7d692f9 \
--user-data file://my_script.txt
```
Para obter um exemplo da saída de `run-instances`, consulte o Exemplo 1.
Para obter mais informações sobre dados do usuário da instância, consulte [Trabalho com dados do usuário da instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-add-user-data.html) no *Guia do usuário do Amazon EC2*.
**Exemplo 6: executar uma instância de desempenho expansível**
O exemplo `run-instances` a seguir executa uma instância t2.micro com a opção de crédito `unlimited`. Ao executar uma instância T2, se você não especificar a `--credit-specification`, o padrão é a opção de crédito `standard`. Ao executar uma instância T3, o padrão é a opção de crédito `unlimited`.
```
aws ec2 run-instances \
--image-id ami-0abcdef1234567890 \
--instance-type t2.micro \
--count 1 \
--subnet-id subnet-08fc749671b2d077c \
--key-name MyKeyPair \
--security-group-ids sg-0b0384b66d7d692f9 \
--credit-specification CpuCredits=unlimited
```
Para obter um exemplo da saída de `run-instances`, consulte o Exemplo 1.
Para obter mais informações sobre instâncias de desempenho expansível, consulte [Instâncias de desempenho expansível](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [RunInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/run-instances.html)em *Referência de AWS CLI Comandos*.
### `run-scheduled-instances`
O código de exemplo a seguir mostra como usar `run-scheduled-instances`.
**AWS CLI**
**Executar uma instância programada**
Este exemplo inicia a Instância Programada especificada em uma VPC.
Comando:
```
aws ec2 run-scheduled-instances --scheduled-instance-id sci-1234-1234-1234-1234-123456789012 --instance-count 1 --launch-specification file://launch-specification.json
```
Launch-specification.json:
```
{
"ImageId": "ami-12345678",
"KeyName": "my-key-pair",
"InstanceType": "c4.large",
"NetworkInterfaces": [
{
"DeviceIndex": 0,
"SubnetId": "subnet-12345678",
"AssociatePublicIpAddress": true,
"Groups": ["sg-12345678"]
}
],
"IamInstanceProfile": {
"Name": "my-iam-role"
}
}
```
Saída:
```
{
"InstanceIdSet": [
"i-1234567890abcdef0"
]
}
```
Este exemplo lança a Instância Programada especificada no EC2-Classic.
Comando:
```
aws ec2 run-scheduled-instances --scheduled-instance-id sci-1234-1234-1234-1234-123456789012 --instance-count 1 --launch-specification file://launch-specification.json
```
Launch-specification.json:
```
{
"ImageId": "ami-12345678",
"KeyName": "my-key-pair",
"SecurityGroupIds": ["sg-12345678"],
"InstanceType": "c4.large",
"Placement": {
"AvailabilityZone": "us-west-2b"
}
"IamInstanceProfile": {
"Name": "my-iam-role"
}
}
```
Saída:
```
{
"InstanceIdSet": [
"i-1234567890abcdef0"
]
}
```
+ Para obter detalhes da API, consulte [RunScheduledInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/run-scheduled-instances.html)em *Referência de AWS CLI Comandos*.
### `search-local-gateway-routes`
O código de exemplo a seguir mostra como usar `search-local-gateway-routes`.
**AWS CLI**
**Pesquisar rotas em uma tabela de rotas de gateway local**
O exemplo `search-local-gateway-routes` a seguir pesquisa rotas estáticas na tabela de rotas do gateway local especificada na tabela de rotas do gateway local.
```
aws ec2 search-local-gateway-routes \
--local-gateway-route-table-id lgw-rtb-059615ef7dEXAMPLE \
--filters "Name=type,Values=static"
```
Saída:
```
{
"Route": {
"DestinationCidrBlock": "0.0.0.0/0",
"LocalGatewayVirtualInterfaceGroupId": "lgw-vif-grp-07145b276bEXAMPLE",
"Type": "static",
"State": "deleted",
"LocalGatewayRouteTableId": "lgw-rtb-059615ef7EXAMPLE"
}
}
```
+ Para obter detalhes da API, consulte [SearchLocalGatewayRoutes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/search-local-gateway-routes.html)em *Referência de AWS CLI Comandos*.
### `search-transit-gateway-multicast-groups`
O código de exemplo a seguir mostra como usar `search-transit-gateway-multicast-groups`.
**AWS CLI**
**Pesquisar um ou mais grupos multicast do gateway de trânsito e retornar as informações de associação ao grupo**
O exemplo `search-transit-gateway-multicast-groups` a seguir retorna a associação do grupo multicast especificado.
```
aws ec2 search-transit-gateway-multicast-groups \
--transit-gateway-multicast-domain-id tgw-mcast-domain-000fb24d04EXAMPLE
```
Saída:
```
{
"MulticastGroups": [
{
"GroupIpAddress": "224.0.1.0",
"TransitGatewayAttachmentId": "tgw-attach-0372e72386EXAMPLE",
"SubnetId": "subnet-0187aff814EXAMPLE",
"ResourceId": "vpc-0065acced4EXAMPLE",
"ResourceType": "vpc",
"NetworkInterfaceId": "eni-03847706f6EXAMPLE",
"GroupMember": false,
"GroupSource": true,
"SourceType": "static"
}
]
}
```
Consulte mais informações em [Multicast on transit gateways](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-multicast-overview.html) no *Guia do usuário do Transit Gateway*.
+ Para obter detalhes da API, consulte [SearchTransitGatewayMulticastGroups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/search-transit-gateway-multicast-groups.html)em *Referência de AWS CLI Comandos*.
### `search-transit-gateway-routes`
O código de exemplo a seguir mostra como usar `search-transit-gateway-routes`.
**AWS CLI**
**Procurar rotas na tabela de rotas do gateway de trânsito especificada**
O exemplo `search-transit-gateway-routes` a seguir retorna todas as rotas do tipo `static` na tabela de rotas especificada.
```
aws ec2 search-transit-gateway-routes \
--transit-gateway-route-table-id tgw-rtb-0a823edbdeEXAMPLE \
--filters "Name=type,Values=static"
```
Saída:
```
{
"Routes": [
{
"DestinationCidrBlock": "10.0.2.0/24",
"TransitGatewayAttachments": [
{
"ResourceId": "vpc-4EXAMPLE",
"TransitGatewayAttachmentId": "tgw-attach-09b52ccdb5EXAMPLE",
"ResourceType": "vpc"
}
],
"Type": "static",
"State": "active"
},
{
"DestinationCidrBlock": "10.1.0.0/24",
"TransitGatewayAttachments": [
{
"ResourceId": "vpc-4EXAMPLE",
"TransitGatewayAttachmentId": "tgw-attach-09b52ccdb5EXAMPLE",
"ResourceType": "vpc"
}
],
"Type": "static",
"State": "active"
}
],
"AdditionalRoutesAvailable": false
}
```
Para obter mais informações, consulte [Tabelas de rota do gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html) no *Guia de gateways de trânsito*.
+ Para obter detalhes da API, consulte [SearchTransitGatewayRoutes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/search-transit-gateway-routes.html)em *Referência de AWS CLI Comandos*.
### `send-diagnostic-interrupt`
O código de exemplo a seguir mostra como usar `send-diagnostic-interrupt`.
**AWS CLI**
**Enviar uma interrupção para diagnóstico**
O exemplo `send-diagnostic-interrupt` a seguir envia uma interrupção de diagnóstico para a instância especificada.
```
aws ec2 send-diagnostic-interrupt \
--instance-id i-1234567890abcdef0
```
Este comando não produz saída.
+ Para obter detalhes da API, consulte [SendDiagnosticInterrupt](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/send-diagnostic-interrupt.html)em *Referência de AWS CLI Comandos*.
### `start-instances`
O código de exemplo a seguir mostra como usar `start-instances`.
**AWS CLI**
**Para iniciar uma instância do Amazon EC2**
Este exemplo inicia a instância especificada com o Amazon EBS.
Comando:
```
aws ec2 start-instances --instance-ids i-1234567890abcdef0
```
Saída:
```
{
"StartingInstances": [
{
"InstanceId": "i-1234567890abcdef0",
"CurrentState": {
"Code": 0,
"Name": "pending"
},
"PreviousState": {
"Code": 80,
"Name": "stopped"
}
}
]
}
```
Para obter mais informações, consulte Interromper e iniciar sua instância no *Guia do usuário do Amazon Elastic Compute Cloud*.
+ Para obter detalhes da API, consulte [StartInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/start-instances.html)em *Referência de AWS CLI Comandos*.
### `start-network-insights-access-scope-analysis`
O código de exemplo a seguir mostra como usar `start-network-insights-access-scope-analysis`.
**AWS CLI**
**Iniciar uma análise do escopo de acesso do Network Insights**
O `start-network-insights-access-scope-analysis` exemplo a seguir inicia a análise do escopo em sua AWS conta.
```
aws ec2 start-network-insights-access-scope-analysis \
--region us-east-1 \
--network-insights-access-scope-id nis-123456789111
```
Saída:
```
{
"NetworkInsightsAccessScopeAnalysis": {
"NetworkInsightsAccessScopeAnalysisId": "nisa-123456789222",
"NetworkInsightsAccessScopeAnalysisArn": "arn:aws:ec2:us-east-1:123456789012:network-insights-access-scope-analysis/nisa-123456789222",
"NetworkInsightsAccessScopeId": "nis-123456789111",
"Status": "running",
"StartDate": "2022-01-26T00:47:06.814000+00:00"
}
}
```
Para obter mais informações, consulte [Introdução ao Network Access Analyzer usando a AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli.html) no Guia *do Network Access* Analyzer.
+ Para obter detalhes da API, consulte [StartNetworkInsightsAccessScopeAnalysis](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/start-network-insights-access-scope-analysis.html)em *Referência de AWS CLI Comandos*.
### `start-network-insights-analysis`
O código de exemplo a seguir mostra como usar `start-network-insights-analysis`.
**AWS CLI**
**Analisar um caminho**
O exemplo `start-network-insights-analysis` a seguir analisa o caminho entre a origem e o destino. Para visualizar os resultados da análise do caminho, use o comando `describe-network-insights-analyses`.
```
aws ec2 start-network-insights-analysis \
--network-insights-path-id nip-0b26f224f1d131fa8
```
Saída:
```
{
"NetworkInsightsAnalysis": {
"NetworkInsightsAnalysisId": "nia-02207aa13eb480c7a",
"NetworkInsightsAnalysisArn": "arn:aws:ec2:us-east-1:123456789012:network-insights-analysis/nia-02207aa13eb480c7a",
"NetworkInsightsPathId": "nip-0b26f224f1d131fa8",
"StartDate": "2021-01-20T22:58:37.495Z",
"Status": "running"
}
}
```
Para obter mais informações, consulte [Introdução ao uso da AWS CLI](https://docs.aws.amazon.com/vpc/latest/reachability/getting-started-cli.html) no Guia do *Reachability Analyzer*.
+ Para obter detalhes da API, consulte [StartNetworkInsightsAnalysis](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/start-network-insights-analysis.html)em *Referência de AWS CLI Comandos*.
### `start-vpc-endpoint-service-private-dns-verification`
O código de exemplo a seguir mostra como usar `start-vpc-endpoint-service-private-dns-verification`.
**AWS CLI**
**Iniciar o processo de verificação de DNS**
O exemplo `start-vpc-endpoint-service-private-dns-verification` a seguir inicia o processo de verificação de DNS para o serviço de endpoint especificado.
```
aws ec2 start-vpc-endpoint-service-private-dns-verification \
--service-id vpce-svc-071afff70666e61e0
```
Este comando não produz saída.
Para obter mais informações, consulte [Gerenciar nomes DNS](https://docs.aws.amazon.com/vpc/latest/privatelink/manage-dns-names.html) no *Guia do AWS PrivateLink usuário*.
+ Para obter detalhes da API, consulte [StartVpcEndpointServicePrivateDnsVerification](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/start-vpc-endpoint-service-private-dns-verification.html)em *Referência de AWS CLI Comandos*.
### `stop-instances`
O código de exemplo a seguir mostra como usar `stop-instances`.
**AWS CLI**
**Exemplo 1: interromper uma instância do Amazon EC2**
O exemplo `stop-instances` a seguir interrompe a instância especificada com o Amazon EBS.
```
aws ec2 stop-instances \
--instance-ids i-1234567890abcdef0
```
Saída:
```
{
"StoppingInstances": [
{
"InstanceId": "i-1234567890abcdef0",
"CurrentState": {
"Code": 64,
"Name": "stopping"
},
"PreviousState": {
"Code": 16,
"Name": "running"
}
}
]
}
```
Para obter mais informações, consulte [Interromper e iniciar sua instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Stop_Start.html) no *Guia do usuário do Amazon Elastic Compute Cloud*.
**Exemplo 2: hibernar uma instância do Amazon EC2**
O exemplo `stop-instances` a seguir hiberna uma instância com o Amazon EBS se ela estiver habilitada para isso e atender aos pré-requisitos de hibernação. Depois de colocar a instância em hibernação, ela é interrompida.
```
aws ec2 stop-instances \
--instance-ids i-1234567890abcdef0 \
--hibernate
```
Saída:
```
{
"StoppingInstances": [
{
"CurrentState": {
"Code": 64,
"Name": "stopping"
},
"InstanceId": "i-1234567890abcdef0",
"PreviousState": {
"Code": 16,
"Name": "running"
}
}
]
}
```
Para obter mais informações, consulte [Colocar em hibernação uma instância sob demanda do Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html) no *Guia do usuário do Amazon Elastic Cloud Compute*.
+ Para obter detalhes da API, consulte [StopInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/stop-instances.html)em *Referência de AWS CLI Comandos*.
### `terminate-client-vpn-connections`
O código de exemplo a seguir mostra como usar `terminate-client-vpn-connections`.
**AWS CLI**
**Encerrar uma conexão com um endpoint do Client VPN**
O exemplo `terminate-client-vpn-connections` a seguir encerra a conexão especificada com o endpoint do Client VPN.
```
aws ec2 terminate-client-vpn-connections \
--client-vpn-endpoint-id vpn-endpoint-123456789123abcde \
--connection-id cvpn-connection-04edd76f5201e0cb8
```
Saída:
```
{
"ClientVpnEndpointId": "vpn-endpoint-123456789123abcde",
"ConnectionStatuses": [
{
"ConnectionId": "cvpn-connection-04edd76f5201e0cb8",
"PreviousStatus": {
"Code": "active"
},
"CurrentStatus": {
"Code": "terminating"
}
}
]
}
```
Para obter mais informações, consulte [Conexões do cliente](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-connections.html) no *Guia do administrador do AWS Client VPN*.
+ Para obter detalhes da API, consulte [TerminateClientVpnConnections](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/terminate-client-vpn-connections.html)em *Referência de AWS CLI Comandos*.
### `terminate-instances`
O código de exemplo a seguir mostra como usar `terminate-instances`.
**AWS CLI**
**Para encerrar uma instância do Amazon EC2**
Este exemplo encerra a instância especificada.
Comando:
```
aws ec2 terminate-instances --instance-ids i-1234567890abcdef0
```
Saída:
```
{
"TerminatingInstances": [
{
"InstanceId": "i-1234567890abcdef0",
"CurrentState": {
"Code": 32,
"Name": "shutting-down"
},
"PreviousState": {
"Code": 16,
"Name": "running"
}
}
]
}
```
Para obter mais informações, consulte Using Amazon EC2 Instances no *Guia do usuário da AWS Command Line Interface*.
+ Para obter detalhes da API, consulte [TerminateInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/terminate-instances.html)em *Referência de AWS CLI Comandos*.
### `unassign-ipv6-addresses`
O código de exemplo a seguir mostra como usar `unassign-ipv6-addresses`.
**AWS CLI**
**Para cancelar a atribuição de um IPv6 endereço de uma interface de rede**
Este exemplo cancela a atribuição do IPv6 endereço especificado da interface de rede especificada.
Comando:
```
aws ec2 unassign-ipv6-addresses --ipv6-addresses 2001:db8:1234:1a00:3304:8879:34cf:4071 --network-interface-id eni-23c49b68
```
Saída:
```
{
"NetworkInterfaceId": "eni-23c49b68",
"UnassignedIpv6Addresses": [
"2001:db8:1234:1a00:3304:8879:34cf:4071"
]
}
```
+ Para obter detalhes da API, consulte [UnassignIpv6Addresses](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/unassign-ipv6-addresses.html) in *AWS CLI Command Reference*.
### `unassign-private-ip-addresses`
O código de exemplo a seguir mostra como usar `unassign-private-ip-addresses`.
**AWS CLI**
**Cancelar a atribuição de um endereço IP privado secundário de uma interface de rede**
Este exemplo cancela a atribuição do endereço IP privado especificado da interface de rede especificada. Se o comando for bem-sucedido, nenhuma saída será retornada.
Comando:
```
aws ec2 unassign-private-ip-addresses --network-interface-id eni-e5aa89a3 --private-ip-addresses 10.0.0.82
```
+ Para obter detalhes da API, consulte [UnassignPrivateIpAddresses](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/unassign-private-ip-addresses.html)em *Referência de AWS CLI Comandos*.
### `unassign-private-nat-gateway-address`
O código de exemplo a seguir mostra como usar `unassign-private-nat-gateway-address`.
**AWS CLI**
**Cancelar a atribuição de um endereço IP privado do seu gateway NAT privado**
O exemplo `unassign-private-nat-gateway-address` a seguir cancela a atribuição do endereço IP especificado do gateway NAT privado especificado.
```
aws ec2 unassign-private-nat-gateway-address \
--nat-gateway-id nat-1234567890abcdef0 \
--private-ip-addresses 10.0.20.197
```
Saída:
```
{
"NatGatewayId": "nat-0ee3edd182361f662",
"NatGatewayAddresses": [
{
"NetworkInterfaceId": "eni-0065a61b324d1897a",
"PrivateIp": "10.0.20.197",
"IsPrimary": false,
"Status": "unassigning"
}
]
}
```
Para obter mais informações, consulte [Gateways NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) no *Guia do usuário da Amazon VPC*.
+ Para obter detalhes da API, consulte [UnassignPrivateNatGatewayAddress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/unassign-private-nat-gateway-address.html)em *Referência de AWS CLI Comandos*.
### `unlock-snapshot`
O código de exemplo a seguir mostra como usar `unlock-snapshot`.
**AWS CLI**
**Desbloquear um snapshot**
O exemplo `unlock-snapshot` a seguir desbloqueia o snapshot especificado.
```
aws ec2 unlock-snapshot \
--snapshot-id snap-0b5e733b4a8df6e0d
```
Saída:
```
{
"SnapshotId": "snap-0b5e733b4a8df6e0d"
}
```
Para obter mais informações, consulte [Bloqueio de snapshots](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-snapshot-lock.html) no *Guia do usuário do Amazon EBS*.
+ Para obter detalhes da API, consulte [UnlockSnapshot](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/unlock-snapshot.html)em *Referência de AWS CLI Comandos*.
### `unmonitor-instances`
O código de exemplo a seguir mostra como usar `unmonitor-instances`.
**AWS CLI**
**Para desabilitar o monitoramento detalhado de uma instância**
Este exemplo de comando desabilita o monitoramento detalhado da instância especificada.
Comando:
```
aws ec2 unmonitor-instances --instance-ids i-1234567890abcdef0
```
Saída:
```
{
"InstanceMonitorings": [
{
"InstanceId": "i-1234567890abcdef0",
"Monitoring": {
"State": "disabling"
}
}
]
}
```
+ Para obter detalhes da API, consulte [UnmonitorInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/unmonitor-instances.html)em *Referência de AWS CLI Comandos*.
### `update-security-group-rule-descriptions-egress`
O código de exemplo a seguir mostra como usar `update-security-group-rule-descriptions-egress`.
**AWS CLI**
**Atualizar a descrição de uma regra de saída de grupo de segurança**
O `update-security-group-rule-descriptions-egress` exemplo a seguir atualiza a descrição da regra do grupo de segurança para a porta e o intervalo de IPv4 endereços especificados. A descrição '`Outbound HTTP access to server 2`' substitui qualquer descrição existente para a regra.
```
aws ec2 update-security-group-rule-descriptions-egress \
--group-id sg-02f0d35a850ba727f \
--ip-permissions IpProtocol=tcp,FromPort=80,ToPort=80,IpRanges=[{CidrIp=203.0.113.0/24,Description="Outbound HTTP access to server 2"}]
```
Saída:
```
{
"Return": true
}
```
Consulte mais informações em [Regras de grupo de segurança](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html#security-group-rules) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [UpdateSecurityGroupRuleDescriptionsEgress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/update-security-group-rule-descriptions-egress.html)em *Referência de AWS CLI Comandos*.
### `update-security-group-rule-descriptions-ingress`
O código de exemplo a seguir mostra como usar `update-security-group-rule-descriptions-ingress`.
**AWS CLI**
**Exemplo 1: atualizar a descrição de uma regra de grupo de segurança de entrada com uma fonte CIDR**
O `update-security-group-rule-descriptions-ingress` exemplo a seguir atualiza a descrição da regra do grupo de segurança para a porta e o intervalo de IPv4 endereços especificados. A descrição '`SSH access from ABC office`' substitui qualquer descrição existente para a regra.
```
aws ec2 update-security-group-rule-descriptions-ingress \
--group-id sg-02f0d35a850ba727f \
--ip-permissions IpProtocol=tcp,FromPort=22,ToPort=22,IpRanges='[{CidrIp=203.0.113.0/16,Description="SSH access from corpnet"}]'
```
Saída:
```
{
"Return": true
}
```
Consulte mais informações em [Regras de grupo de segurança](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html#security-group-rules) no *Guia do usuário do Amazon EC2*.
**Exemplo 2: atualizar a descrição de uma regra de grupo de segurança de entrada com uma fonte de lista de prefixos**
O exemplo `update-security-group-rule-descriptions-ingress` a seguir atualiza a descrição da regra do grupo de segurança para a porta especificada e a lista de prefixos. A descrição '`SSH access from ABC office`' substitui qualquer descrição existente para a regra.
```
aws ec2 update-security-group-rule-descriptions-ingress \
--group-id sg-02f0d35a850ba727f \
--ip-permissions IpProtocol=tcp,FromPort=22,ToPort=22,PrefixListIds='[{PrefixListId=pl-12345678,Description="SSH access from corpnet"}]'
```
Saída:
```
{
"Return": true
}
```
Consulte mais informações em [Regras de grupo de segurança](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html#security-group-rules) no *Guia do usuário do Amazon EC2*.
+ Para obter detalhes da API, consulte [UpdateSecurityGroupRuleDescriptionsIngress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/update-security-group-rule-descriptions-ingress.html)em *Referência de AWS CLI Comandos*.
### `withdraw-byoip-cidr`
O código de exemplo a seguir mostra como usar `withdraw-byoip-cidr`.
**AWS CLI**
**Parar de anunciar um intervalo de endereços**
O exemplo `withdraw-byoip-cidr` a seguir interrompe o anúncio do intervalo de endereços especificado.
```
aws ec2 withdraw-byoip-cidr
--cidr 203.0.113.25/24
```
Saída:
```
{
"ByoipCidr": {
"Cidr": "203.0.113.25/24",
"StatusMessage": "ipv4pool-ec2-1234567890abcdef0",
"State": "advertised"
}
}
```
+ Para obter detalhes da API, consulte [WithdrawByoipCidr](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/withdraw-byoip-cidr.html)em *Referência de AWS CLI Comandos*.