Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esempi di utilizzo di Amazon EC2 AWS CLI
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando Amazon EC2. AWS Command Line Interface
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `accept-address-transfer`
Il seguente esempio di codice mostra come usare`accept-address-transfer`.
**AWS CLI**
**Come accettare il trasferimento di un indirizzo IP elastico nell’account**
L’esempio `accept-address-transfer` seguente accetta il trasferimento dell’indirizzo IP elastico specificato nell’account.
```
aws ec2 accept-address-transfer \
--address 100.21.184.216
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Trasferimento degli indirizzi IP elastici](https://docs.aws.amazon.com/vpc/latest/userguide/WorkWithEIPs.html#transfer-EIPs-intro) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [AcceptAddressTransfer AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/accept-address-transfer.html)*Command Reference*.
### `accept-reserved-instances-exchange-quote`
Il seguente esempio di codice mostra come utilizzare`accept-reserved-instances-exchange-quote`.
**AWS CLI**
**Come eseguire uno scambio di istanze riservate modificabili**
Questo esempio esegue uno scambio delle istanze riservate modificabili specificate.
Comando:
```
aws ec2 accept-reserved-instances-exchange-quote --reserved-instance-ids 7b8750c3-397e-4da4-bbcb-a45ebexample --target-configurations OfferingId=b747b472-423c-48f3-8cee-679bcexample
```
Output:
```
{
"ExchangeId": "riex-e68ed3c1-8bc8-4c17-af77-811afexample"
}
```
+ Per i dettagli sull'API, consulta [AcceptReservedInstancesExchangeQuote AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/accept-reserved-instances-exchange-quote.html)*Command Reference*.
### `accept-transit-gateway-peering-attachment`
Il seguente esempio di codice mostra come utilizzare`accept-transit-gateway-peering-attachment`.
**AWS CLI**
**Come accettare un accessorio di peering del gateway di transito**
L’esempio `accept-transit-gateway-peering-attachment` seguente accetta l’accessorio di peering del gateway di transito specificato. Il parametro `--region` specifica la Regione in cui si trova il gateway di transito accettante.
```
aws ec2 accept-transit-gateway-peering-attachment \
--transit-gateway-attachment-id tgw-attach-4455667788aabbccd \
--region us-east-2
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Accessori di peering del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-peering.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [AcceptTransitGatewayPeeringAttachment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/accept-transit-gateway-peering-attachment.html)*Command Reference*.
### `accept-transit-gateway-vpc-attachment`
Il seguente esempio di codice mostra come utilizzare`accept-transit-gateway-vpc-attachment`.
**AWS CLI**
**Come accettare una richiesta per collegare un VPC a un gateway di transito.**
L’esempio `accept-transit-gateway-vpc-attachment` seguente accetta il collegamento specificato forte della richiesta.
```
aws ec2 accept-transit-gateway-vpc-attachment \
--transit-gateway-attachment-id tgw-attach-0a34fe6b4fEXAMPLE
```
Output:
```
{
"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"
}
}
}
```
Per ulteriori informazioni, consulta [Collegamenti del gateway di transito alla VPN a un VPC](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [AcceptTransitGatewayVpcAttachment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/accept-transit-gateway-vpc-attachment.html)*Command Reference*.
### `accept-vpc-endpoint-connections`
Il seguente esempio di codice mostra come utilizzare`accept-vpc-endpoint-connections`.
**AWS CLI**
**Come accettare le richieste di connessione endpoint dell’interfaccia**
Questo esempio accetta la richiesta di connessione endpoint specificata per il servizio endpoint specificato.
Comando:
```
aws ec2 accept-vpc-endpoint-connections --service-id vpce-svc-03d5ebb7d9579a2b3 --vpc-endpoint-ids vpce-0c1308d7312217abc
```
Output:
```
{
"Unsuccessful": []
}
```
+ Per i dettagli sull'API, consulta [AcceptVpcEndpointConnections AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/accept-vpc-endpoint-connections.html)*Command Reference*.
### `accept-vpc-peering-connection`
Il seguente esempio di codice mostra come utilizzare`accept-vpc-peering-connection`.
**AWS CLI**
**Come accettare una connessione peering VPC**
Questo esempio accetta la richiesta di connessione peering VPC specificata.
Comando:
```
aws ec2 accept-vpc-peering-connection --vpc-peering-connection-id pcx-1a2b3c4d
```
Output:
```
{
"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"
}
}
}
```
+ Per i dettagli sull'API, consulta [AcceptVpcPeeringConnection AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/accept-vpc-peering-connection.html)*Command Reference*.
### `advertise-byoip-cidr`
Il seguente esempio di codice mostra come utilizzare`advertise-byoip-cidr`.
**AWS CLI**
**Come pubblicizzare un intervallo di indirizzi**
L'`advertise-byoip-cidr`esempio seguente pubblicizza l'intervallo di IPv4 indirizzi pubblici specificato.
```
aws ec2 advertise-byoip-cidr \
--cidr 203.0.113.25/24
```
Output:
```
{
"ByoipCidr": {
"Cidr": "203.0.113.25/24",
"StatusMessage": "ipv4pool-ec2-1234567890abcdef0",
"State": "provisioned"
}
}
```
+ Per i dettagli sull'API, vedere [AdvertiseByoipCidr](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/advertise-byoip-cidr.html)in *AWS CLI Command Reference.*
### `allocate-address`
Il seguente esempio di codice mostra come utilizzare`allocate-address`.
**AWS CLI**
**Esempio 1: come allocare un indirizzo IP elastico dal pool di indirizzi Amazon**
Nell’esempio di `allocate-address` seguente viene allocato un indirizzo IP elastico. Amazon EC2 seleziona l’indirizzo dal pool di indirizzi Amazon.
```
aws ec2 allocate-address
```
Output:
```
{
"PublicIp": "70.224.234.241",
"AllocationId": "eipalloc-01435ba59eEXAMPLE",
"PublicIpv4Pool": "amazon",
"NetworkBorderGroup": "us-west-2",
"Domain": "vpc"
}
```
Per ulteriori informazioni, consulta [Indirizzi IP elastici](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come allocare un indirizzo IP elastico e associarlo a un gruppo di confine di rete**
Nell’esempio di `allocate-address` seguente viene allocato un indirizzo IP elastico e viene associato al gruppo di confine di rete specificato.
```
aws ec2 allocate-address \
--network-border-group us-west-2-lax-1
```
Output:
```
{
"PublicIp": "70.224.234.241",
"AllocationId": "eipalloc-e03dd489ceEXAMPLE",
"PublicIpv4Pool": "amazon",
"NetworkBorderGroup": "us-west-2-lax-1",
"Domain": "vpc"
}
```
Per ulteriori informazioni, consulta [Indirizzi IP elastici](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 3: come allocare un indirizzo IP elastico da un pool di indirizzi proprietario**
Nell’esempio di `allocate-address` seguente viene allocato un indirizzo IP elastico da un pool di indirizzi trasferito sull’account Amazon Web Services. Amazon EC2 seleziona l’indirizzo da tale pool di indirizzi.
```
aws ec2 allocate-address \
--public-ipv4-pool ipv4pool-ec2-1234567890abcdef0
```
Output:
```
{
"AllocationId": "eipalloc-02463d08ceEXAMPLE",
"NetworkBorderGroup": "us-west-2",
"CustomerOwnedIp": "18.218.95.81",
"CustomerOwnedIpv4Pool": "ipv4pool-ec2-1234567890abcdef0",
"Domain": "vpc"
"NetworkBorderGroup": "us-west-2",
}
```
Per ulteriori informazioni, consulta [Indirizzi IP elastici](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 4: come allocare un indirizzo IP elastico dal pool IPAM**
L’esempio `allocate-address` seguente alloca un indirizzo IP elastico /32 specifico a un pool Gestione indirizzi IP (IPAM) di Amazon VPC.
```
aws ec2 allocate-address \
--region us-east-1 \
--ipam-pool-id ipam-pool-1234567890abcdef0 \
--address 192.0.2.0
```
Output:
```
{
"PublicIp": "192.0.2.0",
"AllocationId": "eipalloc-abcdef01234567890",
"PublicIpv4Pool": "ipam-pool-1234567890abcdef0",
"NetworkBorderGroup": "us-east-1",
"Domain": "vpc"
}
```
Per ulteriori informazioni, consulta [Assegnare indirizzi IP elastici sequenziali da un pool IPAM](https://docs.aws.amazon.com/vpc/latest/ipam/tutorials-eip-pool.html) nella *Guida per l’utente di Amazon VPC IPAM*.
+ Per i dettagli sull'API, consulta [AllocateAddress AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/allocate-address.html)*Command Reference*.
### `allocate-hosts`
Il seguente esempio di codice mostra come utilizzare`allocate-hosts`.
**AWS CLI**
**Esempio 1: come allocare un host dedicato**
L’esempio `allocate-hosts` seguente alloca un unico host dedicato nella zona di disponibilità `eu-west-1a`, dove è possibile avviare le istanze `m5.large`. Per impostazione predefinita, l’host dedicato accetta solo l’avvio di istanze di destinazione e non supporta il ripristino dell’host.
```
aws ec2 allocate-hosts \
--instance-type m5.large \
--availability-zone eu-west-1a \
--quantity 1
```
Output:
```
{
"HostIds": [
"h-07879acf49EXAMPLE"
]
}
```
**Esempio 2: come allocare un host dedicato con posizionamento automatico e ripristino dell’host abilitati**
L’esempio `allocate-hosts` seguente alloca un unico host dedicato nella zona di disponibilità `eu-west-1a` con posizionamento automatico e ripristino dell’host abilitati.
```
aws ec2 allocate-hosts \
--instance-type m5.large \
--availability-zone eu-west-1a \
--auto-placement on \
--host-recovery on \
--quantity 1
```
Output:
```
{
"HostIds": [
"h-07879acf49EXAMPLE"
]
}
```
**Esempio 3: come allocare un host dedicato con tag**
L’esempio `allocate-hosts` seguente alloca un unico host dedicato e applica un tag con una chiave denominata `purpose` e il valore `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}'
```
Output:
```
{
"HostIds": [
"h-07879acf49EXAMPLE"
]
}
```
Per ulteriori informazioni, consulta [Allocazione di un host dedicato](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-hosts-allocating.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [AllocateHosts AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/allocate-hosts.html)*Command Reference*.
### `allocate-ipam-pool-cidr`
Il seguente esempio di codice mostra come utilizzare`allocate-ipam-pool-cidr`.
**AWS CLI**
**Come allocare un CIDR da un pool IPAM**
L’esempio `allocate-ipam-pool-cidr` seguente alloca un CIDR da un pool 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
```
Output:
```
{
"IpamPoolAllocation": {
"Cidr": "10.0.0.0/24",
"IpamPoolAllocationId": "ipam-pool-alloc-018ecc28043b54ba38e2cd99943cebfbd",
"ResourceType": "custom",
"ResourceOwner": "123456789012"
}
}
```
Per ulteriori informazioni, consulta [Allocare manualmente un CIDR a un pool per riservare lo spazio degli indirizzi IP](https://docs.aws.amazon.com/vpc/latest/ipam/manually-allocate-ipam.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta [AllocateIpamPoolCidr AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/allocate-ipam-pool-cidr.html)*Command Reference*.
### `apply-security-groups-to-client-vpn-target-network`
Il seguente esempio di codice mostra come utilizzare`apply-security-groups-to-client-vpn-target-network`.
**AWS CLI**
**Come applicare gruppi di sicurezza a una rete di destinazione per un endpoint VPN Client**
L’esempio `apply-security-groups-to-client-vpn-target-network` seguente applica il gruppo di sicurezza `sg-01f6e627a89f4db32` all’associazione tra la rete di destinazione specificata e l’endpoint VPN Client.
```
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
```
Output:
```
{
"SecurityGroupIds": [
"sg-01f6e627a89f4db32"
]
}
```
Per ulteriori informazioni, consulta [Reti target](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-target.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [ApplySecurityGroupsToClientVpnTargetNetwork AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/apply-security-groups-to-client-vpn-target-network.html)*Command Reference*.
### `assign-ipv6-addresses`
Il seguente esempio di codice mostra come utilizzare`assign-ipv6-addresses`.
**AWS CLI**
**Per assegnare IPv6 indirizzi specifici a un'interfaccia di rete**
Questo esempio assegna IPv6 gli indirizzi specificati all'interfaccia di rete specificata.
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
```
Output:
```
{
"AssignedIpv6Addresses": [
"2001:db8:1234:1a00:3304:8879:34cf:4071",
"2001:db8:1234:1a00:9691:9503:25ad:1761"
],
"NetworkInterfaceId": "eni-38664473"
}
```
**Per assegnare IPv6 gli indirizzi selezionati da Amazon a un'interfaccia di rete**
Questo esempio assegna due IPv6 indirizzi all'interfaccia di rete specificata. Amazon assegna automaticamente questi IPv6 indirizzi dagli IPv6 indirizzi disponibili nell'intervallo di blocchi IPv6 CIDR della sottorete.
Comando:
```
aws ec2 assign-ipv6-addresses --network-interface-id eni-38664473 --ipv6-address-count 2
```
Output:
```
{
"AssignedIpv6Addresses": [
"2001:db8:1234:1a00:3304:8879:34cf:4071",
"2001:db8:1234:1a00:9691:9503:25ad:1761"
],
"NetworkInterfaceId": "eni-38664473"
}
```
+ *Per i dettagli sull'API, consulta [AssignIpv6Addresses](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/assign-ipv6-addresses.html) in Command Reference.AWS CLI *
### `assign-private-ip-addresses`
Il seguente esempio di codice mostra come utilizzare`assign-private-ip-addresses`.
**AWS CLI**
**Come assegnare un indirizzo IP privato secondario specifico a un’interfaccia di rete**
Questo esempio assegna l’indirizzo IP privato secondario specificato all’interfaccia di rete specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 assign-private-ip-addresses --network-interface-id eni-e5aa89a3 --private-ip-addresses 10.0.0.82
```
**Come assegnare indirizzi IP privati secondari selezionati da Amazon EC2 a un’interfaccia di rete**
Questo esempio assegna due indirizzi IP privati secondari all’interfaccia di rete specificata. Amazon EC2 assegna automaticamente questi indirizzi IP dagli indirizzi IP disponibili nell’intervallo CIDR della sottorete a cui è associata l’interfaccia di rete. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 assign-private-ip-addresses --network-interface-id eni-e5aa89a3 --secondary-private-ip-address-count 2
```
+ Per i dettagli sull'API, consulta [AssignPrivateIpAddresses AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/assign-private-ip-addresses.html)*Command Reference*.
### `assign-private-nat-gateway-address`
Il seguente esempio di codice mostra come utilizzare`assign-private-nat-gateway-address`.
**AWS CLI**
**Come assegnare indirizzi IP privati al gateway NAT privato**
L’esempio `assign-private-nat-gateway-address` seguente assegna due indirizzi IP privati al gateway NAT privato specificato.
```
aws ec2 assign-private-nat-gateway-address \
--nat-gateway-id nat-1234567890abcdef0 \
--private-ip-address-count 2
```
Output:
```
{
"NatGatewayId": "nat-1234567890abcdef0",
"NatGatewayAddresses": [
{
"NetworkInterfaceId": "eni-0065a61b324d1897a",
"IsPrimary": false,
"Status": "assigning"
},
{
"NetworkInterfaceId": "eni-0065a61b324d1897a",
"IsPrimary": false,
"Status": "assigning"
}
]
}
```
Per ulteriori informazioni, consulta [Gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [AssignPrivateNatGatewayAddress AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/assign-private-nat-gateway-address.html)*Command Reference*.
### `associate-address`
Il seguente esempio di codice mostra come utilizzare`associate-address`.
**AWS CLI**
**Esempio 1: come associare un indirizzo IP elastico a un’istanza**
L’esempio `associate-address` seguente associa un indirizzo IP elastico all’istanza EC2 specificata.
```
aws ec2 associate-address \
--instance-id i-0b263919b6498b123 \
--allocation-id eipalloc-64d5890a
```
Output:
```
{
"AssociationId": "eipassoc-2bebb745"
}
```
**Esempio 2: come associare un indirizzo IP elastico a un’interfaccia di rete**
L’esempio `associate-address` seguente associa l’indirizzo IP elastico specificato all’interfaccia di rete specificata.
```
aws ec2 associate-address
--allocation-id eipalloc-64d5890a \
--network-interface-id eni-1a2b3c4d
```
Output:
```
{
"AssociationId": "eipassoc-2bebb745"
}
```
**Esempio 3: come associare un indirizzo IP elastico a un indirizzo IP privato**
L’esempio `associate-address` seguente associa l’indirizzo IP elastico specificato all’indirizzo IP privato specificato nell’interfaccia di rete specificata.
```
aws ec2 associate-address \
--allocation-id eipalloc-64d5890a \
--network-interface-id eni-1a2b3c4d \
--private-ip-address 10.0.0.85
```
Output:
```
{
"AssociationId": "eipassoc-2bebb745"
}
```
Per ulteriori informazioni, consulta [Indirizzi IP elastici](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [AssociateAddress AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-address.html)*Command Reference*.
### `associate-client-vpn-target-network`
Il seguente esempio di codice mostra come utilizzare`associate-client-vpn-target-network`.
**AWS CLI**
**Come associare una rete di destinazione a un endpoint VPN Client**
L’esempio `associate-client-vpn-target-network` seguente associa una sottorete a un endpoint VPN Client.
```
aws ec2 associate-client-vpn-target-network \
--subnet-id subnet-0123456789abcabca \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde
```
Output:
```
{
"AssociationId": "cvpn-assoc-12312312312312312",
"Status": {
"Code": "associating"
}
}
```
Per ulteriori informazioni, consulta [Reti target](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-target.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [AssociateClientVpnTargetNetwork AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-client-vpn-target-network.html)*Command Reference*.
### `associate-dhcp-options`
Il seguente esempio di codice mostra come utilizzare`associate-dhcp-options`.
**AWS CLI**
**Come associare un set di opzioni DHCP al VPC in uso**
Questo esempio associa il set di opzioni DHCP specificato al VPC specificato. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 associate-dhcp-options --dhcp-options-id dopt-d9070ebb --vpc-id vpc-a01106c2
```
**Come associare il set di opzioni DHCP predefinito al VPC in uso**
Nell’esempio seguente viene associato il set di opzioni DHCP predefinite al VPC specificato. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 associate-dhcp-options --dhcp-options-id default --vpc-id vpc-a01106c2
```
+ Per i dettagli sull'API, consulta [AssociateDhcpOptions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-dhcp-options.html)*Command Reference*.
### `associate-iam-instance-profile`
Il seguente esempio di codice mostra come utilizzare`associate-iam-instance-profile`.
**AWS CLI**
**Come associare un profilo dell’istanza IAM a un’istanza**
Questo esempio associa un profilo dell’istanza IAM denominata `admin-role` all’istanza `i-123456789abcde123`.
Comando:
```
aws ec2 associate-iam-instance-profile --instance-id i-123456789abcde123 --iam-instance-profile Name=admin-role
```
Output:
```
{
"IamInstanceProfileAssociation": {
"InstanceId": "i-123456789abcde123",
"State": "associating",
"AssociationId": "iip-assoc-0e7736511a163c209",
"IamInstanceProfile": {
"Id": "AIPAJBLK7RKJKWDXVHIEC",
"Arn": "arn:aws:iam::123456789012:instance-profile/admin-role"
}
}
}
```
+ Per i dettagli sull'API, consulta [AssociateIamInstanceProfile AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-iam-instance-profile.html)*Command Reference*.
### `associate-instance-event-window`
Il seguente esempio di codice mostra come utilizzare`associate-instance-event-window`.
**AWS CLI**
**Esempio 1: come associare una o più istanze a una finestra di eventi**
L’esempio `associate-instance-event-window` seguente associa una o più istanze a una finestra di eventi.
```
aws ec2 associate-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890 \
--association-target "InstanceIds=i-1234567890abcdef0,i-0598c7d356eba48d7"
```
Output:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"AssociationTarget": {
"InstanceIds": [
"i-1234567890abcdef0",
"i-0598c7d356eba48d7"
],
"Tags": [],
"DedicatedHostIds": []
},
"State": "creating"
}
}
```
Per i vincoli relativi alla finestra di eventi, consulta [Considerazioni](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) nella sezione Eventi pianificati della *Guida per l’utente di Amazon EC2*.
**Esempio 2: come associare i tag di istanza a una finestra di eventi**
L’esempio `associate-instance-event-window` seguente associa i tag di istanza a una finestra di eventi. Immettere un parametro `instance-event-window-id` per specificare la finestra di eventi. Per associare i tag di istanza, specifica il parametro `association-target` e specifica uno o più tag per il valore del parametro.
```
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}]"
```
Output:
```
{
"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"
}
}
```
Per i vincoli relativi alla finestra di eventi, consulta [Considerazioni](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) nella sezione Eventi pianificati della *Guida per l’utente di Amazon EC2*.
**Esempio 3: come associare un host dedicato a una finestra di eventi**
L’esempio `associate-instance-event-window` seguente associa un host dedicato a una finestra di eventi. Immettere un parametro `instance-event-window-id` per specificare la finestra di eventi. Per associare un host dedicato, specificare il `--association-target` parametro e, per i valori dei parametri, specificare uno o più host dedicati IDs.
```
aws ec2 associate-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890 \
--association-target "DedicatedHostIds=h-029fa35a02b99801d"
```
Output:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"AssociationTarget": {
"InstanceIds": [],
"Tags": [],
"DedicatedHostIds": [
"h-029fa35a02b99801d"
]
},
"State": "creating"
}
}
```
Per i vincoli relativi alla finestra di eventi, consulta [Considerazioni](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) nella sezione Eventi pianificati della *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [AssociateInstanceEventWindow AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-instance-event-window.html)*Command Reference*.
### `associate-ipam-resource-discovery`
Il seguente esempio di codice mostra come utilizzare`associate-ipam-resource-discovery`.
**AWS CLI**
**Come associare un rilevamento delle risorse a un’IPAM**
In questo esempio, sei un amministratore delegato IPAM e un rilevamento delle risorse è stato creato e condiviso con te da un altro AWS account in modo da poter utilizzare IPAM per gestire e monitorare le risorse di CIDRs proprietà dell'altro account.
Nota
Per completare questa richiesta, avrai bisogno dell'ID di scoperta della risorsa che puoi utilizzare [describe-ipam-resource-discoveries](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-ipam-resource-discoveries.html)e dell'ID IPAM che puoi ottenere con [describe-ipams](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-ipams.html). L'individuazione delle risorse che stai associando deve essere stata prima condivisa con il tuo account utilizzando la AWS RAM. L'`--region`ID che inserisci deve corrispondere alla regione di origine dell'IPAM a cui la stai associando.
L’esempio `associate-ipam-resource-discovery` seguente associa un rilevamento di risorse a un’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
```
Output:
```
{
{
"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": []
}
}
}
```
Una volta associata l'individuazione di una risorsa, è possibile monitorare e and/or gestire gli indirizzi IP delle risorse create dagli altri account. Per ulteriori informazioni, consulta [Come integrare IPAM con account esterni alla tua organizzazione](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam-outside-org.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta [AssociateIpamResourceDiscovery AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-ipam-resource-discovery.html)*Command Reference*.
### `associate-nat-gateway-address`
Il seguente esempio di codice mostra come utilizzare`associate-nat-gateway-address`.
**AWS CLI**
**Come associare un indirizzo IP elastico a un gateway NAT pubblico**
L'`associate-nat-gateway-address`esempio seguente associa l'indirizzo IP elastico specificato al gateway NAT pubblico specificato. AWS assegna automaticamente un indirizzo privato secondario. IPv4
```
aws ec2 associate-nat-gateway-address \
--nat-gateway-id nat-1234567890abcdef0 \
--allocation-ids eipalloc-0be6ecac95EXAMPLE
```
Output:
```
{
"NatGatewayId": "nat-1234567890abcdef0",
"NatGatewayAddresses": [
{
"AllocationId": "eipalloc-0be6ecac95EXAMPLE",
"NetworkInterfaceId": "eni-09cc4b2558794f7f9",
"IsPrimary": false,
"Status": "associating"
}
]
}
```
Per ulteriori informazioni, consulta [Gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [AssociateNatGatewayAddress AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-nat-gateway-address.html)*Command Reference.*
### `associate-route-table`
Il seguente esempio di codice mostra come utilizzare`associate-route-table`.
**AWS CLI**
**Come associare una tabella di routing a una sottorete**
Questo esempio associa la tabella di routing specificata alla sottorete specificata.
Comando:
```
aws ec2 associate-route-table --route-table-id rtb-22574640 --subnet-id subnet-9d4a7b6c
```
Output:
```
{
"AssociationId": "rtbassoc-781d0d1a"
}
```
+ Per i dettagli sull'API, consulta [AssociateRouteTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-route-table.html)*Command Reference*.
### `associate-security-group-vpc`
Il seguente esempio di codice mostra come utilizzare`associate-security-group-vpc`.
**AWS CLI**
**Come associare un gruppo di sicurezza a un altro VPC**
L’esempio `associate-security-group-vpc` seguente associa il gruppo di sicurezza specificato al VPC specificato.
```
aws ec2 associate-security-group-vpc \
--group-id sg-04dbb43907d3f8a78 \
--vpc-id vpc-0bf4c2739bc05a694
```
Output:
```
{
"State": "associating"
}
```
Per ulteriori informazioni, consulta [Associare gruppi di sicurezza a più](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-assoc.html) gruppi VPCs nella *Amazon VPC User Guide*.
+ Per i dettagli sull'API, consulta [AssociateSecurityGroupVpc AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-security-group-vpc.html)*Command Reference.*
### `associate-subnet-cidr-block`
Il seguente esempio di codice mostra come utilizzare`associate-subnet-cidr-block`.
**AWS CLI**
**Per associare un blocco IPv6 CIDR a una sottorete**
Questo esempio associa un blocco IPv6 CIDR alla sottorete specificata.
Comando:
```
aws ec2 associate-subnet-cidr-block --subnet-id subnet-5f46ec3b --ipv6-cidr-block 2001:db8:1234:1a00::/64
```
Output:
```
{
"SubnetId": "subnet-5f46ec3b",
"Ipv6CidrBlockAssociation": {
"Ipv6CidrBlock": "2001:db8:1234:1a00::/64",
"AssociationId": "subnet-cidr-assoc-3aa54053",
"Ipv6CidrBlockState": {
"State": "associating"
}
}
}
```
+ *Per i dettagli sull'API, vedere [AssociateSubnetCidrBlock](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-subnet-cidr-block.html)in AWS CLI Command Reference.*
### `associate-transit-gateway-multicast-domain`
Il seguente esempio di codice mostra come utilizzare`associate-transit-gateway-multicast-domain`.
**AWS CLI**
**Come associare un gateway di transito a un dominio multicast (trasmissione uno a molti)**
L’esempio `associate-transit-gateway-multicast-domain` seguente associa la sottorete e l’allegato specificati al dominio multicast (trasmissione uno a molti) specificato.
```
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
```
Output:
```
{
"Associations": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-0c4905cef79d6e597",
"TransitGatewayAttachmentId": "tgw-attach-028c1dd0f8f5cbe8e",
"ResourceId": "vpc-01128d2c240c09bd5",
"ResourceType": "vpc",
"Subnets": [
{
"SubnetId": "subnet-000de86e3b49c932a",
"State": "associating"
}
]
}
}
```
Per ulteriori informazioni, consulta [Domini multicast (trasmissione uno a molti)](https://docs.aws.amazon.com/vpc/latest/tgw/multicast-domains-about.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [AssociateTransitGatewayMulticastDomain AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-transit-gateway-multicast-domain.html)*Command Reference*.
### `associate-transit-gateway-route-table`
Il seguente esempio di codice mostra come utilizzare`associate-transit-gateway-route-table`.
**AWS CLI**
**Come associare una tabella di routing del gateway di transito a un collegamento del gateway di transito alla VPN**
L’esempio seguente associa la tabella di routing del gateway di transito specificata al collegamento VPC specificato.
```
aws ec2 associate-transit-gateway-route-table \
--transit-gateway-route-table-id tgw-rtb-002573ed1eEXAMPLE \
--transit-gateway-attachment-id tgw-attach-0b5968d3b6EXAMPLE
```
Output:
```
{
"Association": {
"TransitGatewayRouteTableId": "tgw-rtb-002573ed1eEXAMPLE",
"TransitGatewayAttachmentId": "tgw-attach-0b5968d3b6EXAMPLE",
"ResourceId": "vpc-0065acced4EXAMPLE",
"ResourceType": "vpc",
"State": "associating"
}
}
```
Per ulteriori informazioni, consulta [Associare una tabella di routing di un gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html#associate-tgw-route-table) nella *Guida di AWS Transit Gateway*.
+ Per i dettagli sull'API, consulta [AssociateTransitGatewayRouteTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-transit-gateway-route-table.html)*Command Reference*.
### `associate-vpc-cidr-block`
Il seguente esempio di codice mostra come utilizzare`associate-vpc-cidr-block`.
**AWS CLI**
**Esempio 1: associare un blocco IPv6 CIDR fornito da Amazon a un VPC**
L'`associate-vpc-cidr-block`esempio seguente associa un blocco IPv6 CIDR al VPC specificato. :
```
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
```
Output:
```
{
"Ipv6CidrBlockAssociation": {
"AssociationId": "vpc-cidr-assoc-0838ce7d9dEXAMPLE",
"Ipv6CidrBlockState": {
"State": "associating"
},
"NetworkBorderGroup": "us-west-2-lax-1"
},
"VpcId": "vpc-8EXAMPLE"
}
```
**Esempio 2:Per associare un blocco IPv4 CIDR aggiuntivo a un VPC**
L'`associate-vpc-cidr-block`esempio seguente associa il blocco IPv4 CIDR al `10.2.0.0/16` VPC specificato.
```
aws ec2 associate-vpc-cidr-block \
--vpc-id vpc-1EXAMPLE \
--cidr-block 10.2.0.0/16
```
Output:
```
{
"CidrBlockAssociation": {
"AssociationId": "vpc-cidr-assoc-2EXAMPLE",
"CidrBlock": "10.2.0.0/16",
"CidrBlockState": {
"State": "associating"
}
},
"VpcId": "vpc-1EXAMPLE"
}
```
+ *Per i dettagli sull'API, vedere [AssociateVpcCidrBlock](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/associate-vpc-cidr-block.html)in AWS CLI Command Reference.*
### `attach-classic-link-vpc`
Il seguente esempio di codice mostra come utilizzare`attach-classic-link-vpc`.
**AWS CLI**
**Come collegare (allegare) un’istanza EC2-Classic a un VPC**
Questo esempio collega l’istanza i-1234567890abcdef0 al VPC vpc-88888888 tramite il gruppo di sicurezza VPC sg-12312312.
Comando:
```
aws ec2 attach-classic-link-vpc --instance-id i-1234567890abcdef0 --vpc-id vpc-88888888 --groups sg-12312312
```
Output:
```
{
"Return": true
}
```
+ Per i dettagli sull'API, consulta [AttachClassicLinkVpc AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/attach-classic-link-vpc.html)*Command Reference*.
### `attach-internet-gateway`
Il seguente esempio di codice mostra come utilizzare`attach-internet-gateway`.
**AWS CLI**
**Come collegare un gateway internet al VPC**
L’esempio `attach-internet-gateway` seguente collega il gateway Internet specificato al VPC specificato.
```
aws ec2 attach-internet-gateway \
--internet-gateway-id igw-0d0fb496b3EXAMPLE \
--vpc-id vpc-0a60eb65b4EXAMPLE
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Gateway Internet](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [AttachInternetGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/attach-internet-gateway.html)*Command Reference*.
### `attach-network-interface`
Il seguente esempio di codice mostra come utilizzare`attach-network-interface`.
**AWS CLI**
**Esempio 1: come collegare un’interfaccia di rete a un’istanza**
L’esempio `attach-network-interface` seguente collega l’interfaccia di rete specificata all’istanza specificata.
```
aws ec2 attach-network-interface \
--network-interface-id eni-0dc56a8d4640ad10a \
--instance-id i-1234567890abcdef0 \
--device-index 1
```
Output:
```
{
"AttachmentId": "eni-attach-01a8fc87363f07cf9"
}
```
Per ulteriori informazioni, consulta [Interfacce di rete elastiche](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come collegare un’interfaccia di rete a un’istanza con più schede di rete**
L’esempio `attach-network-interface` seguente collega l’interfaccia di rete specificata all’istanza e alla scheda di specificate.
```
aws ec2 attach-network-interface \
--network-interface-id eni-07483b1897541ad83 \
--instance-id i-01234567890abcdef \
--network-card-index 1 \
--device-index 1
```
Output:
```
{
"AttachmentId": "eni-attach-0fbd7ee87a88cd06c"
}
```
Per ulteriori informazioni, consulta [Interfacce di rete elastiche](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [AttachNetworkInterface AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/attach-network-interface.html)*Command Reference*.
### `attach-verified-access-trust-provider`
Il seguente esempio di codice mostra come utilizzare`attach-verified-access-trust-provider`.
**AWS CLI**
**Come collegare un provider di attendibilità a un’istanza**
L’esempio `attach-verified-access-trust-provider` seguente collega il provider di attendibilità di accesso verificato specificato all’istanza di accesso verificato specificata.
```
aws ec2 attach-verified-access-trust-provider \
--verified-access-instance-id vai-0ce000c0b7643abea \
--verified-access-trust-provider-id vatp-0bb32de759a3e19e7
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Istanze di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-instances.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [AttachVerifiedAccessTrustProvider AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/attach-verified-access-trust-provider.html)*Command Reference*.
### `attach-volume`
Il seguente esempio di codice mostra come utilizzare`attach-volume`.
**AWS CLI**
**Come collegare un volume a un’istanza**
Questo esempio collega un volume (`vol-1234567890abcdef0`) a un’istanza (`i-01474ef662b89480`) come `/dev/sdf`.
Comando:
```
aws ec2 attach-volume --volume-id vol-1234567890abcdef0 --instance-id i-01474ef662b89480 --device /dev/sdf
```
Output:
```
{
"AttachTime": "YYYY-MM-DDTHH:MM:SS.000Z",
"InstanceId": "i-01474ef662b89480",
"VolumeId": "vol-1234567890abcdef0",
"State": "attaching",
"Device": "/dev/sdf"
}
```
+ Per i dettagli sull'API, consulta [AttachVolume AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/attach-volume.html)*Command Reference*.
### `attach-vpn-gateway`
Il seguente esempio di codice mostra come utilizzare`attach-vpn-gateway`.
**AWS CLI**
**Come collegare un gateway privato virtuale a un VPC**
L’esempio `attach-vpn-gateway` seguente collega il gateway privato virtuale specificato al VPC specificato.
```
aws ec2 attach-vpn-gateway \
--vpn-gateway-id vgw-9a4cacf3 \
--vpc-id vpc-a01106c2
```
Output:
```
{
"VpcAttachment": {
"State": "attaching",
"VpcId": "vpc-a01106c2"
}
}
```
+ Per i dettagli sull'API, consulta [AttachVpnGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/attach-vpn-gateway.html)*Command Reference*.
### `authorize-client-vpn-ingress`
Il seguente esempio di codice mostra come utilizzare`authorize-client-vpn-ingress`.
**AWS CLI**
**Come aggiungere una regola di autorizzazione a un endpoint VPN Client**
L’esempio `authorize-client-vpn-ingress` seguente aggiunge una regola di autorizzazione che concede a tutti i client l’accesso 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
```
Output:
```
{
"Status": {
"Code": "authorizing"
}
}
```
Per ulteriori informazioni, consulta [Regole di autorizzazione](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-rules.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [AuthorizeClientVpnIngress AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/authorize-client-vpn-ingress.html)*Command Reference*.
### `authorize-security-group-egress`
Il seguente esempio di codice mostra come utilizzare`authorize-security-group-egress`.
**AWS CLI**
**Esempio 1: come aggiungere una regola che consenta il traffico in uscita verso un intervallo di indirizzi specifico**
L’esempio `authorize-security-group-egress` seguente aggiunge una regola che concede l’accesso agli intervalli di indirizzi specificati sulla 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}]'
```
Output:
```
{
"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"
}
]
}
```
**Esempio 2: come aggiungere una regola che consenta il traffico in uscita verso un gruppo di sicurezza specifico**
L’esempio `authorize-security-group-egress` seguente aggiunge una regola che concede l’accesso al gruppo di sicurezza specificato sulla 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}]'
```
Output:
```
{
"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"
}
}
]
}
```
Per ulteriori informazioni, consulta [Gruppi di sicurezza](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-security-groups.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [AuthorizeSecurityGroupEgress AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/authorize-security-group-egress.html)*Command Reference*.
### `authorize-security-group-ingress`
Il seguente esempio di codice mostra come utilizzare`authorize-security-group-ingress`.
**AWS CLI**
**Esempio 1: come aggiungere una regola che consenta il traffico SSH in entrata**
Nell’esempio di `authorize-security-group-ingress` seguente viene aggiunta una regola che consente il traffico in entrata nella porta TCP 22 (SSH).
```
aws ec2 authorize-security-group-ingress \
--group-id sg-1234567890abcdef0 \
--protocol tcp \
--port 22 \
--cidr 203.0.113.0/24
```
Output:
```
{
"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"
}
]
}
```
**Esempio 2: come aggiungere una regola che consenta il traffico HTTP in entrata da un altro gruppo di sicurezza**
Nell’esempio di `authorize-security-group-ingress` seguente viene aggiunta una regola che consente l’accesso in entrata alla porta TCP 80 dal gruppo di sicurezza di origine `sg-1a2b3c4d`. Il gruppo di origine deve trovarsi nello stesso VPC o in un VPC peer (richiede una connessione peering VPC). Il traffico in entrata è autorizzato in base agli indirizzi IP privati delle istanze associate al gruppo di sicurezza di origine (e non in base all’indirizzo IP elastico o pubblico).
```
aws ec2 authorize-security-group-ingress \
--group-id sg-1234567890abcdef0 \
--protocol tcp \
--port 80 \
--source-group sg-1a2b3c4d
```
Output:
```
{
"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"
}
}
]
}
```
**Esempio 3: come aggiungere più regole nella stessa chiamata**
Nell’esempio di `authorize-security-group-ingress` seguente viene utilizzato il parametro `ip-permissions` per aggiungere due regole in entrata, una che consenta l’accesso in entrata sulla porta TCP 3389 (RDP) e l’altra che consenta ping/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}]'
```
Output:
```
{
"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"
}
]
}
```
**Esempio 4: come aggiungere una regola per il traffico ICMP**
L’esempio `authorize-security-group-ingress` seguente utilizza il parametro `ip-permissions` per aggiungere una regola in entrata che consenta il messaggio ICMP `Destination Unreachable: Fragmentation Needed and Don't Fragment was Set` (tipo 3, codice 4) da qualsiasi luogo.
```
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}]'
```
Output:
```
{
"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"
}
]
}
```
**Esempio 5: aggiungere una regola per il IPv6 traffico**
L'`authorize-security-group-ingress`esempio seguente utilizza il `ip-permissions` parametro per aggiungere una regola in entrata che consente l'accesso SSH (porta 22) dall' IPv6 intervallo. `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}]'
```
Output:
```
{
"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"
}
]
}
```
**Esempio 6: per aggiungere una regola per il traffico ICMPv6 **
L'`authorize-security-group-ingress`esempio seguente utilizza il `ip-permissions` parametro per aggiungere una regola in entrata che consente il ICMPv6 traffico da qualsiasi luogo.
```
aws ec2 authorize-security-group-ingress \
--group-id sg-1234567890abcdef0 \
--ip-permissions 'IpProtocol=icmpv6,Ipv6Ranges=[{CidrIpv6=::/0}]'
```
Output:
```
{
"Return": true,
"SecurityGroupRules": [
{
"SecurityGroupRuleId": "sgr-04b612d9363ab6327",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "123456789012",
"IsEgress": false,
"IpProtocol": "icmpv6",
"FromPort": -1,
"ToPort": -1,
"CidrIpv6": "::/0"
}
]
}
```
**Esempio 7: aggiungere una regola con una descrizione**
L'`authorize-security-group-ingress`esempio seguente utilizza il `ip-permissions` parametro per aggiungere una regola in entrata che consente il traffico RDP dall'intervallo di indirizzi specificato IPv4 . La regola include una descrizione per consentirne l’identificazione in un secondo momento.
```
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'}]'
```
Output:
```
{
"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"
}
]
}
```
**Esempio 8: come aggiungere una regola in entrata che utilizza un elenco di prefissi**
L’esempio `authorize-security-group-ingress` seguente utilizza il parametro `ip-permissions` per aggiungere una regola in entrata che consenta tutto il traffico per gli intervalli CIDR nell’elenco di prefissi specificato.
```
aws ec2 authorize-security-group-ingress \
--group-id sg-04a351bfe432d4e71 \
--ip-permissions 'IpProtocol=all,PrefixListIds=[{PrefixListId=pl-002dc3ec097de1514}]'
```
Output:
```
{
"Return": true,
"SecurityGroupRules": [
{
"SecurityGroupRuleId": "sgr-09c74b32f677c6c7c",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "123456789012",
"IsEgress": false,
"IpProtocol": "-1",
"FromPort": -1,
"ToPort": -1,
"PrefixListId": "pl-0721453c7ac4ec009"
}
]
}
```
Per ulteriori informazioni, consulta [Gruppi di sicurezza](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-security-groups.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [AuthorizeSecurityGroupIngress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/authorize-security-group-ingress.html)Reference*.
### `bundle-instance`
Il seguente esempio di codice mostra come utilizzare`bundle-instance`.
**AWS CLI**
**Come creare il bundle di un’istanza**
Questo esempio crea il bundle dell’istanza `i-1234567890abcdef0` in un bucket denominato `bundletasks`. Prima di specificare i valori per la chiave di accesso IDs, consulta e segui le indicazioni contenute nelle migliori pratiche per la gestione delle chiavi di AWS accesso.
Comando:
```
aws ec2 bundle-instance --instance-id i-1234567890abcdef0 --bucket bundletasks --prefix winami --owner-akid AK12AJEXAMPLE --owner-sak example123example
```
Output:
```
{
"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"
}
}
```
+ Per i dettagli sull'API, consulta [BundleInstance AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/bundle-instance.html)*Command Reference*.
### `cancel-bundle-task`
Il seguente esempio di codice mostra come utilizzare`cancel-bundle-task`.
**AWS CLI**
**Come annullare un’attività bundle**
Questo esempio annulla l’attività bundle `bun-2a4e041c`.
Comando:
```
aws ec2 cancel-bundle-task --bundle-id bun-2a4e041c
```
Output:
```
{
"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"
}
}
```
+ Per i dettagli sull'API, consulta [CancelBundleTask AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-bundle-task.html)*Command Reference*.
### `cancel-capacity-reservation-fleets`
Il seguente esempio di codice mostra come utilizzare`cancel-capacity-reservation-fleets`.
**AWS CLI**
**Come annullare un parco di prenotazione della capacità**
L’esempio `cancel-capacity-reservation-fleets` seguente annulla il parco di prenotazione della capacità specificata e la capacità che viene riservata. Quando annulli un parco istanze, il suo stato cambia in `cancelled` e non può più creare nuove prenotazioni di capacità. Inoltre, tutte le singole prenotazioni di capacità nel parco istanze vengono annullate e le istanze precedentemente in esecuzione nella capacità riservata continuano a funzionare normalmente in capacità condivisa.
```
aws ec2 cancel-capacity-reservation-fleets \
--capacity-reservation-fleet-ids crf-abcdef01234567890
```
Output:
```
{
"SuccessfulFleetCancellations": [
{
"CurrentFleetState": "cancelling",
"PreviousFleetState": "active",
"CapacityReservationFleetId": "crf-abcdef01234567890"
}
],
"FailedFleetCancellations": []
}
```
Per ulteriori informazioni sui parchi di prenotazione della capacità, consulta [Parchi prenotazione della capacità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cr-fleets.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [CancelCapacityReservationFleets AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-capacity-reservation-fleets.html)*Command Reference*.
### `cancel-capacity-reservation`
Il seguente esempio di codice mostra come utilizzare`cancel-capacity-reservation`.
**AWS CLI**
**Come annullare una prenotazione della capacità**
L’esempio `cancel-capacity-reservation` seguente annulla la prenotazione della capacità specificata.
```
aws ec2 cancel-capacity-reservation \
--capacity-reservation-id cr-1234abcd56EXAMPLE
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni, consulta [Annullamento di una prenotazione della capacità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservations-release.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [CancelCapacityReservation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-capacity-reservation.html)*Command Reference*.
### `cancel-conversion-task`
Il seguente esempio di codice mostra come utilizzare`cancel-conversion-task`.
**AWS CLI**
**Come annullare una conversione attiva di un’istanza o di un volume**
Questo esempio annulla il caricamento associato all'ID dell'attività import-i-fh 95npoc. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 cancel-conversion-task --conversion-task-id import-i-fh95npoc
```
+ *Per i dettagli sull'API, consulta [CancelConversionTask](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-conversion-task.html)Command Reference.AWS CLI *
### `cancel-export-task`
Il seguente esempio di codice mostra come utilizzare`cancel-export-task`.
**AWS CLI**
**Come annullare un’attività di esportazione attiva**
Questo esempio annulla un'attività di esportazione attiva con l'ID attività export-i-fgelt 0i7. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 cancel-export-task --export-task-id export-i-fgelt0i7
```
+ *Per i dettagli sull'API, consulta Command [CancelExportTask](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-export-task.html)Reference AWS CLI .*
### `cancel-image-launch-permission`
Il seguente esempio di codice mostra come utilizzare`cancel-image-launch-permission`.
**AWS CLI**
**Come annullare un’AMI condivisa con l’account Amazon Web Services**
L’esempio `cancel-image-launch-permission` seguente rimuove l’account dalle autorizzazione di avvio dell’AMI specificata:
```
aws ec2 cancel-image-launch-permission \
--image-id ami-0123456789example \
--region us-east-1
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni, consulta [Annullamento della condivisione di un’AMI con l’account Amazon Web Services](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cancel-sharing-an-AMI.html#cancel-image-launch-permission) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [CancelImageLaunchPermission AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-image-launch-permission.html)*Command Reference*.
### `cancel-import-task`
Il seguente esempio di codice mostra come utilizzare`cancel-import-task`.
**AWS CLI**
**Come annullare un’attività di importazione**
L’esempio `cancel-import-task` seguente annulla l’attività di importazione di immagini specificata.
```
aws ec2 cancel-import-task \
--import-task-id import-ami-1234567890abcdef0
```
Output:
```
{
"ImportTaskId": "import-ami-1234567890abcdef0",
"PreviousState": "active",
"State": "deleting"
}
```
+ Per i dettagli sull'API, consulta [CancelImportTask AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-import-task.html)*Command Reference*.
### `cancel-reserved-instances-listing`
Il seguente esempio di codice mostra come utilizzare`cancel-reserved-instances-listing`.
**AWS CLI**
**Come annullare un elenco di istanze riservate**
L’esempio `cancel-reserved-instances-listing` seguente annulla l’elenco di istanze riservate specificato.
```
aws ec2 cancel-reserved-instances-listing \
--reserved-instances-listing-id 5ec28771-05ff-4b9b-aa31-9e57dexample
```
+ Per i dettagli sull'API, consulta [CancelReservedInstancesListing AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-reserved-instances-listing.html)*Command Reference*.
### `cancel-spot-fleet-requests`
Il seguente esempio di codice mostra come utilizzare`cancel-spot-fleet-requests`.
**AWS CLI**
**Esempio 1: come annullare una richiesta del parco istanze spot e terminare le istanze associate**
L’esempio `cancel-spot-fleet-requests` seguente annulla una richiesta del parco istanze spot e termina le istanze on demand e le istanze spot associate.
```
aws ec2 cancel-spot-fleet-requests \
--spot-fleet-request-ids sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE \
--terminate-instances
```
Output:
```
{
"SuccessfulFleetRequests": [
{
"SpotFleetRequestId": "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE",
"CurrentSpotFleetRequestState": "cancelled_terminating",
"PreviousSpotFleetRequestState": "active"
}
],
"UnsuccessfulFleetRequests": []
}
```
**Esempio 2: come annullare una richiesta del parco istanze spot senza terminare le istanze associate**
L’esempio `cancel-spot-fleet-requests` seguente annulla una richiesta del parco istanze spot senza terminare le istanze on demand e le istanze spot associate.
```
aws ec2 cancel-spot-fleet-requests \
--spot-fleet-request-ids sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE \
--no-terminate-instances
```
Output:
```
{
"SuccessfulFleetRequests": [
{
"SpotFleetRequestId": "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE",
"CurrentSpotFleetRequestState": "cancelled_running",
"PreviousSpotFleetRequestState": "active"
}
],
"UnsuccessfulFleetRequests": []
}
```
Per ulteriori informazioni, consulta [Annullare una richiesta di parco istanze spot](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cancel-spot-fleet.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [CancelSpotFleetRequests AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-spot-fleet-requests.html)*Command Reference*.
### `cancel-spot-instance-requests`
Il seguente esempio di codice mostra come utilizzare`cancel-spot-instance-requests`.
**AWS CLI**
**Come annullare le richieste di istanze spot**
Questo comando di esempio annulla una richiesta di istanza spot.
Comando:
```
aws ec2 cancel-spot-instance-requests --spot-instance-request-ids sir-08b93456
```
Output:
```
{
"CancelledSpotInstanceRequests": [
{
"State": "cancelled",
"SpotInstanceRequestId": "sir-08b93456"
}
]
}
```
+ Per i dettagli sull'API, consulta [CancelSpotInstanceRequests AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/cancel-spot-instance-requests.html)*Command Reference*.
### `confirm-product-instance`
Il seguente esempio di codice mostra come utilizzare`confirm-product-instance`.
**AWS CLI**
**Come confermare l’istanza del prodotto**
Questo esempio determina se il codice prodotto specificato è associato all’istanza specificata.
Comando:
```
aws ec2 confirm-product-instance --product-code 774F4FF8 --instance-id i-1234567890abcdef0
```
Output:
```
{
"OwnerId": "123456789012"
}
```
+ Per i dettagli sull'API, consulta [ConfirmProductInstance AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/confirm-product-instance.html)*Command Reference*.
### `copy-fpga-image`
Il seguente esempio di codice mostra come utilizzare`copy-fpga-image`.
**AWS CLI**
**Come copiare un’immagine FPGA di Amazon (AFI)**
Questo esempio copia l’AFI specificata dalla regione `us-east-1` alla regione corrente (`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
```
Output:
```
{
"FpgaImageId": "afi-06b12350a123fbabc"
}
```
+ Per i dettagli sull'API, consulta [CopyFpgaImage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/copy-fpga-image.html)*Command Reference*.
### `copy-image`
Il seguente esempio di codice mostra come utilizzare`copy-image`.
**AWS CLI**
**Esempio 1: come copiare un’AMI in un’altra Regione**
L’esempio `copy-image` seguente copia l’AMI specificata dalla Regione `us-west-2` alla Regione `us-east-1` e aggiunge una breve descrizione.
```
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."
```
Output:
```
{
"ImageId": "ami-0123456789abcdefg"
}
```
Per ulteriori informazioni, consulta [Copiare un’AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/CopyingAMIs.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come copiare un’AMI in un’altra Regione e crittografare lo snapshot di supporto**
Il comando `copy-image` seguente copia l’AMI specificata dalla Regione `us-west-2` nella Regione corrente ed esegue la crittografia dello snapshot di supporto utilizzando la chiave KMS specificata.
```
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
```
Output:
```
{
"ImageId": "ami-0123456789abcdefg"
}
```
Per ulteriori informazioni, consulta [Copiare un’AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/CopyingAMIs.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 3: come includere i tag AMI definiti dall’utente durante la copia di un’AMI**
Il comando `copy-image` seguente utilizza il parametro `--copy-image-tags` per copiare i tag AMI definiti dall’utente durante la copia dell’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
```
Output:
```
{
"ImageId": "ami-0123456789abcdefg"
}
```
Per ulteriori informazioni, consulta [Copiare un’AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/CopyingAMIs.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [CopyImage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/copy-image.html)*Command Reference*.
### `copy-snapshot`
Il seguente esempio di codice mostra come utilizzare`copy-snapshot`.
**AWS CLI**
**Esempio 1: come copiare uno snapshot in un’altra Regione**
L’esempio `copy-snapshot` seguente copia lo snapshot specificato dalla Regione `us-west-2` nella Regione `us-east-1` e aggiunge una breve descrizione.
```
aws ec2 copy-snapshot \
--region us-east-1 \
--source-region us-west-2 \
--source-snapshot-id snap-066877671789bd71b \
--description 'This is my copied snapshot.'
```
Output:
```
{
"SnapshotId": "snap-066877671789bd71b"
}
```
**Esempio 2: copiare uno snapshot non crittografato e crittografare il nuovo snapshot**
Il comando `copy-snapshot` seguente copia lo snapshot non crittografato specificato dalla Regione `us-west-2` nella Regione corrente ed esegue la crittografia del nuovo snapshot utilizzando la chiave KMS specificata.
```
aws ec2 copy-snapshot \
--source-region us-west-2 \
--source-snapshot-id snap-066877671789bd71b \
--encrypted \
--kms-key-id alias/my-kms-key
```
Output:
```
{
"SnapshotId": "snap-066877671789bd71b"
}
```
Per ulteriori informazioni, consulta [Copia di uno snapshot Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-copy-snapshot.html) nella *Guida per l’utente di Amazon EBS*.
+ Per i dettagli sull'API, consulta [CopySnapshot AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/copy-snapshot.html)*Command Reference*.
### `create-capacity-reservation-fleet`
Il seguente esempio di codice mostra come utilizzare`create-capacity-reservation-fleet`.
**AWS CLI**
**Come creare un parco di prenotazione della capacità**
L’esempio `create-capacity-reservation-fleet` seguente crea un parco di prenotazione della capacità per il tipo di istanza specificato nella richiesta, fino alla capacità di destinazione totale specificata. Il numero di istanze per le quali il parco istanze di prenotazione della capacità prenota quest’ultima dipende dalla capacità target totale e dai pesi del tipo di istanza specificati nella richiesta. Specifica i tipi di istanza da utilizzare e una priorità per ciascuno dei tipi di istanza designati.
```
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
```
Contenuto di `instanceTypeSpecification.json`:
```
[
{
"InstanceType": "m5.xlarge",
"InstancePlatform": "Linux/UNIX",
"Weight": 3.0,
"AvailabilityZone":"us-east-1a",
"EbsOptimized": true,
"Priority" : 1
}
]
```
Output:
```
{
"Status": "submitted",
"TotalFulfilledCapacity": 0.0,
"CapacityReservationFleetId": "crf-abcdef01234567890",
"TotalTargetCapacity": 24
}
```
Per ulteriori informazioni sui parchi di prenotazione della capacità, consulta [Parchi prenotazione della capacità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cr-fleets.html) nella *Guida per l’utente di Amazon EC2*.
Per ulteriori informazioni sul peso del tipo di istanza e sulla capacità target totale, consulta [Peso del tipo di istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#instance-weight) e [Capacità target totale](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#target-capacity) nella *Guida per l’utente di Amazon EC2*.
Per ulteriori informazioni sulla designazione della priorità per tipi di istanza specificati, consulta [Strategia di allocazione](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#allocation-strategy) e [Priorità del tipo di istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#instance-priority) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [CreateCapacityReservationFleet AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-capacity-reservation-fleet.html)*Command Reference*.
### `create-capacity-reservation`
Il seguente esempio di codice mostra come utilizzare`create-capacity-reservation`.
**AWS CLI**
**Esempio 1: come creare una prenotazione della capacità**
L'`create-capacity-reservation`esempio seguente crea una prenotazione di capacità nella zona di `eu-west-1a` disponibilità, nella quale è possibile avviare tre `t2.medium` istanze che eseguono un sistema Linux/Unix operativo. Per impostazione predefinita, la prenotazione della capacità viene creata con criteri di corrispondenza delle istanze aperte e senza il supporto dell’archiviazione temporanea e rimane attiva finché non viene annullata manualmente.
```
aws ec2 create-capacity-reservation \
--availability-zone eu-west-1a \
--instance-type t2.medium \
--instance-platform Linux/UNIX \
--instance-count 3
```
Output:
```
{
"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"
}
}
```
**Esempio 2: come creare una prenotazione della capacità che termini automaticamente a una data/ora specificata**
L'`create-capacity-reservation`esempio seguente crea una prenotazione di capacità nella zona di `eu-west-1a` disponibilità, nella quale è possibile avviare tre `m5.large` istanze che eseguono un Linux/Unix sistema operativo. Questa prenotazione della capacità termina automaticamente il 31/08/2019 alle 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
```
Output:
```
{
"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"
}
}
```
**Esempio 3: come creare una prenotazione della capacità che accetta solo avvii di istanze mirate**
L’esempio `create-capacity-reservation` seguente crea una prenotazione della capacità che accetta solo avvii di istanze di destinazione.
```
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
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Creazione di una prenotazione della capacità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservations-using.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [CreateCapacityReservation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-capacity-reservation.html)*Command Reference.*
### `create-carrier-gateway`
Il seguente esempio di codice mostra come utilizzare`create-carrier-gateway`.
**AWS CLI**
**Come creare un gateway carrier**
L’esempio `create-carrier-gateway` seguente crea un gateway carrier per il VPC specificato.
```
aws ec2 create-carrier-gateway \
--vpc-id vpc-0c529aEXAMPLE1111
```
Output:
```
{
"CarrierGateway": {
"CarrierGatewayId": "cagw-0465cdEXAMPLE1111",
"VpcId": "vpc-0c529aEXAMPLE1111",
"State": "pending",
"OwnerId": "123456789012"
}
}
```
Per ulteriori informazioni, consulta [Gateway carrier](https://docs.aws.amazon.com/wavelength/latest/developerguide/carrier-gateways.html) nella *Guida per l’utente di AWS Wavelength*.
+ Per i dettagli sull'API, consulta [CreateCarrierGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-carrier-gateway.html)*Command Reference*.
### `create-client-vpn-endpoint`
Il seguente esempio di codice mostra come utilizzare`create-client-vpn-endpoint`.
**AWS CLI**
**Come creare un endpoint Client VPN**
L’esempio `create-client-vpn-endpoint` seguente crea un endpoint VPN Client che utilizza l’autenticazione reciproca e specifica un valore per l’intervallo CIDR del client.
```
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
```
Output:
```
{
"ClientVpnEndpointId": "cvpn-endpoint-123456789123abcde",
"Status": {
"Code": "pending-associate"
},
"DnsName": "cvpn-endpoint-123456789123abcde.prod.clientvpn.ap-south-1.amazonaws.com"
}
```
Per ulteriori informazioni, consulta [Endpoint Client VPN](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-endpoints.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [CreateClientVpnEndpoint AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-client-vpn-endpoint.html)*Command Reference*.
### `create-client-vpn-route`
Il seguente esempio di codice mostra come utilizzare`create-client-vpn-route`.
**AWS CLI**
**Come creare una route per l’endpoint VPN Client**
L’esempio `create-client-vpn-route` seguente aggiunge una route a internet (`0.0.0.0/0`) per la sottorete specificata dell’endpoint VPN Client.
```
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
```
Output:
```
{
"Status": {
"Code": "creating"
}
}
```
Per ulteriori informazioni, consulta [Route](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-routes.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [CreateClientVpnRoute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-client-vpn-route.html)*Command Reference*.
### `create-coip-cidr`
Il seguente esempio di codice mostra come utilizzare`create-coip-cidr`.
**AWS CLI**
**Come creare un intervallo di indirizzi IP di proprietà del cliente (CoIP)**
L’esempio `create-coip-cidr` seguente crea l’intervallo specificato di indirizzi CoIP nel pool CoIP specificato.
```
aws ec2 create-coip-cidr \
--cidr 15.0.0.0/24 \
--coip-pool-id ipv4pool-coip-1234567890abcdefg
```
Output:
```
{
"CoipCidr": {
"Cidr": "15.0.0.0/24",
"CoipPoolId": "ipv4pool-coip-1234567890abcdefg",
"LocalGatewayRouteTableId": "lgw-rtb-abcdefg1234567890"
}
}
```
Per ulteriori informazioni, consulta [Indirizzi IP di proprietà del cliente](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#ip-addressing) nella *Guida per l’utente di AWS Outposts*.
+ Per i dettagli sull'API, consulta [CreateCoipCidr AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-coip-cidr.html)*Command Reference*.
### `create-coip-pool`
Il seguente esempio di codice mostra come utilizzare`create-coip-pool`.
**AWS CLI**
**Come creare un pool di indirizzi IP di proprietà del cliente (CoIP)**
L’esempio `create-coip-pool` seguente crea un pool CoIP per gli indirizzi CoIP nella tabella di routing del gateway locale specificata.
```
aws ec2 create-coip-pool \
--local-gateway-route-table-id lgw-rtb-abcdefg1234567890
```
Output:
```
{
"CoipPool": {
"PoolId": "ipv4pool-coip-1234567890abcdefg",
"LocalGatewayRouteTableId": "lgw-rtb-abcdefg1234567890",
"PoolArn": "arn:aws:ec2:us-west-2:123456789012:coip-pool/ipv4pool-coip-1234567890abcdefg"
}
}
```
Per ulteriori informazioni, consulta [Indirizzi IP di proprietà del cliente](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#ip-addressing) nella *Guida per l’utente di AWS Outposts*.
+ Per i dettagli sull'API, consulta [CreateCoipPool AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-coip-pool.html)*Command Reference*.
### `create-customer-gateway`
Il seguente esempio di codice mostra come utilizzare`create-customer-gateway`.
**AWS CLI**
**Come creare un gateway del cliente**
Questo esempio crea un gateway del cliente con l’indirizzo IP specificato per la relativa interfaccia esterna.
Comando:
```
aws ec2 create-customer-gateway --type ipsec.1 --public-ip 12.1.2.3 --bgp-asn 65534
```
Output:
```
{
"CustomerGateway": {
"CustomerGatewayId": "cgw-0e11f167",
"IpAddress": "12.1.2.3",
"State": "available",
"Type": "ipsec.1",
"BgpAsn": "65534"
}
}
```
+ Per i dettagli sull'API, consulta [CreateCustomerGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-customer-gateway.html)*Command Reference*.
### `create-default-subnet`
Il seguente esempio di codice mostra come utilizzare`create-default-subnet`.
**AWS CLI**
**Come creare una sottorete predefinita**
Questo esempio crea una sottorete predefinita nella zona di disponibilità `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
}
}
```
+ Per i dettagli sull'API, consulta [CreateDefaultSubnet AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-default-subnet.html)*Command Reference*.
### `create-default-vpc`
Il seguente esempio di codice mostra come utilizzare`create-default-vpc`.
**AWS CLI**
**Come creare un VPC predefinito**
Questo esempio crea un VPC predefinito.
Comando:
```
aws ec2 create-default-vpc
```
Output:
```
{
"Vpc": {
"VpcId": "vpc-8eaae5ea",
"InstanceTenancy": "default",
"Tags": [],
"Ipv6CidrBlockAssociationSet": [],
"State": "pending",
"DhcpOptionsId": "dopt-af0c32c6",
"CidrBlock": "172.31.0.0/16",
"IsDefault": true
}
}
```
+ Per i dettagli sull'API, consulta [CreateDefaultVpc AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-default-vpc.html)*Command Reference*.
### `create-dhcp-options`
Il seguente esempio di codice mostra come utilizzare`create-dhcp-options`.
**AWS CLI**
**Come creare un set di opzioni DHCP**
L’esempio `create-dhcp-options` seguente crea un set di opzioni DHCP che specifica il nome di dominio, i server dei nomi di dominio e il tipo di nodo 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"
```
Output:
```
{
"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"
}
}
```
+ Per i dettagli sull'API, consulta [CreateDhcpOptions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-dhcp-options.html)*Command Reference*.
### `create-egress-only-internet-gateway`
Il seguente esempio di codice mostra come utilizzare`create-egress-only-internet-gateway`.
**AWS CLI**
**Come creare un gateway Internet di sola uscita**
Questo esempio crea un gateway Internet di sola uscita per il VPC specificato.
Comando:
```
aws ec2 create-egress-only-internet-gateway --vpc-id vpc-0c62a468
```
Output:
```
{
"EgressOnlyInternetGateway": {
"EgressOnlyInternetGatewayId": "eigw-015e0e244e24dfe8a",
"Attachments": [
{
"State": "attached",
"VpcId": "vpc-0c62a468"
}
]
}
}
```
+ Per i dettagli sull'API, consulta [CreateEgressOnlyInternetGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-egress-only-internet-gateway.html)*Command Reference*.
### `create-fleet`
Il seguente esempio di codice mostra come utilizzare`create-fleet`.
**AWS CLI**
**Esempio 1: come creare un parco EC2 che avvii le istanze spot come modello di acquisto predefinito**
L’esempio `create-fleet` seguente crea un parco EC2 utilizzando i parametri minimi richiesti per avviare un parco: un modello di avvio, una capacità di destinazione e un’opzione d’acquisto predefinita. Il modello di avvio viene identificato dall’ID e dal numero di versione del modello di avvio. La capacità di destinazione per il parco è di 2 istanze e il modello d’acquisto predefinito è `spot`; ne consegue che il parco avvia 2 istanze spot.
Durante la creazione di un parco EC2, utilizzare un file JSON per specificare le informazioni sulle istanze da avviare.
```
aws ec2 create-fleet \
--cli-input-json file://file_name.json
```
Contenuto del file\$1name.json:
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-0e8c754449b27161c",
"Version": "1"
}
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 2,
"DefaultTargetCapacityType": "spot"
}
}
```
Output:
```
{
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE"
}
```
**Esempio 2: come creare un parco EC2 che avvii istanze on demand come modello di acquisto predefinito**
L’esempio `create-fleet` seguente crea un parco EC2 utilizzando i parametri minimi richiesti per avviare un parco: un modello di avvio, una capacità di destinazione e un’opzione d’acquisto predefinita. Il modello di avvio viene identificato dall’ID e dal numero di versione del modello di avvio. La capacità di destinazione per il parco è di 2 istanze e l’opzione d’acquisto predefinita è `on-demand`; ne consegue che il parco avvia 2 istanze on demand.
Durante la creazione di un parco EC2, utilizzare un file JSON per specificare le informazioni sulle istanze da avviare.
```
aws ec2 create-fleet \
--cli-input-json file://file_name.json
```
Contenuto del file\$1name.json:
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-0e8c754449b27161c",
"Version": "1"
}
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 2,
"DefaultTargetCapacityType": "on-demand"
}
}
```
Output:
```
{
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE"
}
```
**Esempio 3: come creare un parco EC2 che avvia istanze on demand come capacità primaria**
L’esempio `create-fleet` seguente crea un parco EC2 che specifica la capacità di destinazione totale di 2 istanze per il parco e una capacità di destinazione di 1 istanza on demand. Il modello di acquisto predefinito è `spot`. Il parco avvia 1 istanza on demand come indicato, ma deve avviare un’altra istanza per soddisfare la capacità di destinazione totale. L’opzione di acquisto per la differenza viene calcolata come `TotalTargetCapacity` – `OnDemandTargetCapacity` = `DefaultTargetCapacityType`, ne consegue che il parco avvia 1 istanza spot.
Durante la creazione di un parco EC2, utilizzare un file JSON per specificare le informazioni sulle istanze da avviare.
```
aws ec2 create-fleet \
--cli-input-json file://file_name.json
```
Contenuto del file\$1name.json:
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-0e8c754449b27161c",
"Version": "1"
}
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 2,
"OnDemandTargetCapacity":1,
"DefaultTargetCapacityType": "spot"
}
}
```
Output:
```
{
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE"
}
```
**Esempio 4: come creare un parco EC2 che avvii istanze spot utilizzando la strategia di allocazione al prezzo più basso**
Se non è indicata la strategia di allocazione per le istanze spot, viene utilizzata la strategia di allocazione predefinita, ovvero `lowest-price`. L’esempio `create-fleet` seguente crea un parco EC2 utilizzando la strategia di allocazione `lowest-price`. Le tre specifiche di avvio, che sostituiscono il modello di avvio, hanno tipi di istanza diversi ma capacità ponderata e sottorete uguali. La capacità di destinazione totale è di 2 istanze e il modello d’acquisto predefinito è `spot`. Il parco EC2 avvia 2 istanze spot utilizzando il tipo di istanza della specifica di avvio con il prezzo più basso.
Durante la creazione di un parco EC2, utilizzare un file JSON per specificare le informazioni sulle istanze da avviare.
```
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"
}
}
```
Output:
```
{
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE"
}
```
+ Per i dettagli sull'API, consulta [CreateFleet AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-fleet.html)*Command Reference*.
### `create-flow-logs`
Il seguente esempio di codice mostra come utilizzare`create-flow-logs`.
**AWS CLI**
**Esempio 1: come creare un log di flusso**
L’esempio `create-flow-logs` seguente crea un log di flusso che acquisisce tutto il traffico rifiutato per l’interfaccia di rete specificata. I log di flusso vengono consegnati a un gruppo di log in CloudWatch Logs utilizzando le autorizzazioni nel ruolo IAM specificato.
```
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
```
Output:
```
{
"ClientToken": "so0eNA2uSHUNlHI0S2cJ305GuIX1CezaRdGtexample",
"FlowLogIds": [
"fl-12345678901234567"
],
"Unsuccessful": []
}
```
Per ulteriori informazioni, consulta [Log di flusso VPC](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html) nella *Guida per l’utente di Amazon VPC*.
**Esempio 2: come creare un log di flusso con un formato personalizzato**
L’esempio `create-flow-logs` seguente crea un log di flusso che acquisisce tutto il traffico per il VPC specificato e consegna i log di flusso a un bucket Amazon S3. Il parametro `--log-format` specifica un formato personalizzato per i record di log di flusso. Per eseguire questo comando in Windows, modifica le virgolette singole (‘’) in virgolette doppie (“”).
```
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}'
```
Per ulteriori informazioni, consulta [Log di flusso VPC](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html) nella *Guida per l’utente di Amazon VPC*.
**Esempio 3: come creare un log di flusso con un intervallo di aggregazione massimo di un minuto**
L’esempio `create-flow-logs` seguente crea un log di flusso che acquisisce tutto il traffico per il VPC specificato e consegna i log di flusso a un bucket Amazon S3. Il parametro `--max-aggregation-interval` specifica un intervallo di aggregazione massimo di 60 secondi (1 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
```
Per ulteriori informazioni, consulta [Log di flusso VPC](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html) nella *Guida per l’utente di Amazon VPC*.
+ *Per i dettagli sull'API, consulta Command [CreateFlowLogs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-flow-logs.html)Reference AWS CLI .*
### `create-fpga-image`
Il seguente esempio di codice mostra come utilizzare`create-fpga-image`.
**AWS CLI**
**Come creare un’immagine FPGA di Amazon (AFI)**
Questo esempio crea un’AFI dal tarball specificato nel bucket specificato.
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
```
Output:
```
{
"FpgaImageId": "afi-0d123e123bfc85abc",
"FpgaImageGlobalId": "agfi-123cb27b5e84a0abc"
}
```
+ Per i dettagli sull'API, consulta [CreateFpgaImage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-fpga-image.html)*Command Reference*.
### `create-image`
Il seguente esempio di codice mostra come utilizzare`create-image`.
**AWS CLI**
**Esempio 1: come creare un’AMI da un’istanza supportata da Amazon EBS**
L’esempio `create-image` seguente crea un’AMI dall’istanza specificata.
```
aws ec2 create-image \
--instance-id i-1234567890abcdef0 \
--name "My server" \
--description "An AMI for my server"
```
Output:
```
{
"ImageId": "ami-abcdef01234567890"
}
```
Per ulteriori informazioni sulla specifica di una mappatura dei dispositivi a blocchi, consulta [Specificare una mappatura dei dispositivi a blocchi di un’AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html#create-ami-bdm) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come creare un’AMI da un’istanza supportata da Amazon EBS senza riavvio**
L’esempio `create-image` seguente crea un’AMI e imposta il parametro --no-reboot in modo che l’istanza non venga riavviata prima della creazione dell’immagine.
```
aws ec2 create-image \
--instance-id i-1234567890abcdef0 \
--name "My server" \
--no-reboot
```
Output:
```
{
"ImageId": "ami-abcdef01234567890"
}
```
Per ulteriori informazioni sulla specifica di una mappatura dei dispositivi a blocchi, consulta [Specificare una mappatura dei dispositivi a blocchi di un’AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html#create-ami-bdm) nella *Guida per l’utente di Amazon EC2*.
**Esempio 3: come assegnare tag a un’AMI e agli snapshot durante la creazione**
L’esempio `create-image` seguente crea un’AMI e assegna all’AMI e agli snapshot lo stesso 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}]"
```
Output:
```
{
"ImageId": "ami-abcdef01234567890"
}
```
Per ulteriori informazioni sul tagging delle risorse durante la creazione, consulta [Aggiunta di tag alla creazione di risorse](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-on-create-examples) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [CreateImage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-image.html)*Command Reference*.
### `create-instance-connect-endpoint`
Il seguente esempio di codice mostra come utilizzare`create-instance-connect-endpoint`.
**AWS CLI**
**Come creare un endpoint EC2 Instance Connect**
L’esempio `create-instance-connect-endpoint` seguente crea un endpoint EC2 Instance Connect nella sottorete specificata.
```
aws ec2 create-instance-connect-endpoint \
--region us-east-1 \
--subnet-id subnet-0123456789example
```
Output:
```
{
"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"
}
```
Per ulteriori informazioni, consulta [Creazione di un endpoint EC2 Instance Connect](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-ec2-instance-connect-endpoints.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [CreateInstanceConnectEndpoint AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-instance-connect-endpoint.html)*Command Reference*.
### `create-instance-event-window`
Il seguente esempio di codice mostra come utilizzare`create-instance-event-window`.
**AWS CLI**
**Esempio 1: come creare una finestra di eventi con un intervallo temporale**
L’esempio `create-instance-event-window` seguente crea una finestra di eventi con un intervallo temporale. Non è possibile specificare anche il parametro `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
```
Output:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"TimeRanges": [
{
"StartWeekDay": "monday",
"StartHour": 2,
"EndWeekDay": "wednesday",
"EndHour": 8
}
],
"Name": "myEventWindowName",
"State": "creating",
"Tags": [
{
"Key": "K1",
"Value": "V1"
}
]
}
}
```
Per i vincoli relativi alla finestra di eventi, consulta [Considerazioni](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) nella sezione Eventi pianificati della *Guida per l’utente di Amazon EC2*.
**Esempio 2: come creare una finestra di eventi con un’espressione Cron**
L’esempio `create-instance-event-window` seguente crea una finestra di eventi con un’espressione Cron. Non è possibile specificare anche il parametro `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
```
Output:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"State": "creating",
"Tags": [
{
"Key": "K1",
"Value": "V1"
}
]
}
}
```
Per i vincoli relativi alla finestra di eventi, consulta [Considerazioni](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) nella sezione Eventi pianificati della *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [CreateInstanceEventWindow AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-instance-event-window.html)*Command Reference*.
### `create-instance-export-task`
Il seguente esempio di codice mostra come utilizzare`create-instance-export-task`.
**AWS CLI**
**Come esportare un’istanza**
Questo comando di esempio crea un’attività per esportare l’istanza i-1234567890abcdef0 nel bucket Amazon S3 myexportbucket.
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
```
Output:
```
{
"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"
}
}
```
+ Per i dettagli sull'API, consulta [CreateInstanceExportTask AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-instance-export-task.html)*Command Reference*.
### `create-internet-gateway`
Il seguente esempio di codice mostra come utilizzare`create-internet-gateway`.
**AWS CLI**
**Come creare un gateway Internet**
L’esempio `create-internet-gateway` seguente crea un gateway Internet con il tag `Name=my-igw`.
```
aws ec2 create-internet-gateway \
--tag-specifications ResourceType=internet-gateway,Tags=[{Key=Name,Value=my-igw}]
```
Output:
```
{
"InternetGateway": {
"Attachments": [],
"InternetGatewayId": "igw-0d0fb496b3994d755",
"OwnerId": "123456789012",
"Tags": [
{
"Key": "Name",
"Value": "my-igw"
}
]
}
}
```
Per ulteriori informazioni, consulta [Gateway Internet](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [CreateInternetGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-internet-gateway.html)*Command Reference*.
### `create-ipam-pool`
Il seguente esempio di codice mostra come utilizzare`create-ipam-pool`.
**AWS CLI**
**Come creare un pool IPAM**
L’esempio `create-ipam-pool` seguente crea un 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"}]
```
Output:
```
{
"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"
}
]
}
}
```
Per ulteriori informazioni, consulta [Pianificare il provisioning degli indirizzi IP](https://docs.aws.amazon.com/vpc/latest/ipam/planning-ipam.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta [CreateIpamPool AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-ipam-pool.html)*Command Reference*.
### `create-ipam-resource-discovery`
Il seguente esempio di codice mostra come utilizzare`create-ipam-resource-discovery`.
**AWS CLI**
**Come creare un’individuazione delle risorse**
In questo esempio, sei un amministratore IPAM delegato che desidera creare e condividere un'individuazione delle risorse con l'amministratore IPAM di un'altra AWS organizzazione in modo che l'amministratore dell'altra organizzazione possa gestire e monitorare gli indirizzi IP delle risorse dell'organizzazione.
Importante
Questo esempio include entrambe le opzioni `--region` e `--operating-regions` perché, sebbene siano facoltative, devono essere configurate in un modo particolare per integrare correttamente un rilevamento di risorse con un’IPAM. \$1 `--operating-regions` deve corrispondere alle Regioni in cui sono presenti risorse che devono essere rilevate dall’IPAM. Se ci sono Regioni in cui l’IPAM non deve gestire gli indirizzi IP (ad esempio per motivi di conformità), non includerle. \$1 `--region` deve corrispondere alla Regione di origine dell’IPAM a cui si desidera associarlo. È necessario creare il rilevamento di risorse nella stessa Regione in cui è stato creato l’IPAM. Ad esempio, se l’IPAM a cui ci si sta associando è stato creato in us-east-1, includere `--region us-east-1` nella richiesta. Entrambe le opzioni `--region` e `--operating-regions` sono predefinite nella Regione in cui si sta eseguendo il comando se non vengono specificate.
In questo esempio, le Regioni operative IPAM con cui si sta effettuando l’integrazione includono `us-west-1`, `us-west-2` e `ap-south-1`. Quando si crea il rilevamento di risorse, l’IPAM deve rilevare gli indirizzi IP delle risorse in `us-west-1` e `us-west-2` ma non in `ap-south-1`. Pertanto, nella richiesta viene incluso solo `--operating-regions RegionName='us-west-1' RegionName='us-west-2'`.
L’esempio `create-ipam-resource-discovery` seguente crea un rilevamento di risorse 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
```
Output:
```
{
"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"
}
]
}
```
Dopo aver creato un rilevamento delle risorse, potresti volerlo condividere con un altro amministratore delegato IPAM, cosa che puoi fare. [create-resource-share](https://docs.aws.amazon.com/cli/latest/reference/ram/create-resource-share.html) Per ulteriori informazioni, consulta [Come integrare IPAM con account esterni alla tua organizzazione](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam-outside-org.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [CreateIpamResourceDiscovery](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-ipam-resource-discovery.html)Reference*.
### `create-ipam-scope`
Il seguente esempio di codice mostra come utilizzare`create-ipam-scope`.
**AWS CLI**
**Come creare un ambito IPAM**
L’esempio `create-ipam-scope` seguente crea un ambito 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"}]
```
Output:
```
{
"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"
}
]
}
}
```
Per ulteriori informazioni, consulta [Creazione di ambiti aggiuntivi](https://docs.aws.amazon.com/vpc/latest/ipam/add-scope-ipam.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta [CreateIpamScope AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-ipam-scope.html)*Command Reference*.
### `create-ipam`
Il seguente esempio di codice mostra come utilizzare`create-ipam`.
**AWS CLI**
**Come creare un’IPAM**
L’esempio `create-ipam` seguente crea un’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}]
```
Output:
```
{
"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"
}
]
}
}
```
Per ulteriori informazioni, consulta [Creare un IPAM](https://docs.aws.amazon.com/vpc/latest/ipam/create-ipam.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta [CreateIpam AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-ipam.html)*Command Reference*.
### `create-key-pair`
Il seguente esempio di codice mostra come utilizzare`create-key-pair`.
**AWS CLI**
**Come creare una coppia di chiavi**
Nell’esempio seguente viene creata una coppia di chiavi denominata `MyKeyPair`.
Comando:
```
aws ec2 create-key-pair --key-name MyKeyPair
```
L’output è una versione ASCII della chiave privata e l’impronta della chiave. È necessario salvare la chiave in un file.
Per ulteriori informazioni, consulta Utilizzo delle coppie di chiavi nella *Guida per l’utente dell’Interfaccia a riga di comando AWS *.
+ Per i dettagli sull'API, consulta [CreateKeyPair AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-key-pair.html)*Command Reference*.
### `create-launch-template-version`
Il seguente esempio di codice mostra come utilizzare`create-launch-template-version`.
**AWS CLI**
**Come creare una versione del modello di avvio**
Questo esempio crea una nuova versione del modello di avvio basata sulla versione 1 del modello di avvio e specifica un ID AMI diverso.
Comando:
```
aws ec2 create-launch-template-version --launch-template-id lt-0abcd290751193123 --version-description WebVersion2 --source-version 1 --launch-template-data '{"ImageId":"ami-c998b6b2"}'
```
Output:
```
{
"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"
}
}
```
+ Per i dettagli sull'API, consulta [CreateLaunchTemplateVersion AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-launch-template-version.html)*Command Reference*.
### `create-launch-template`
Il seguente esempio di codice mostra come utilizzare`create-launch-template`.
**AWS CLI**
**Esempio 1: come creare un modello di avvio**
L'`create-launch-template`esempio seguente crea un modello di avvio che specifica la sottorete in cui avviare l'istanza, assegna un indirizzo IP pubblico e un IPv6 indirizzo all'istanza e crea un tag per l'istanza.
```
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"}]}]}'
```
Output:
```
{
"LaunchTemplate": {
"LatestVersionNumber": 1,
"LaunchTemplateId": "lt-01238c059e3466abc",
"LaunchTemplateName": "TemplateForWebServer",
"DefaultVersionNumber": 1,
"CreatedBy": "arn:aws:iam::123456789012:user/Bob",
"CreateTime": "2019-01-27T09:13:24.000Z"
}
}
```
Per ulteriori informazioni, consulta Avvio di istanze da un modello di avvio nella *Guida per l’utente di Amazon Elastic Compute Cloud*. Per informazioni sulla citazione di parametri in formato JSON, consulta Virgolette con stringhe nella *Guida per l’utente dell’Interfaccia a riga di comando AWS *.
**Esempio 2: come creare un modello di avvio per Amazon EC2 Auto Scaling**
Nell’esempio di `create-launch-template` seguente viene creato un modello di avvio con tag multipli e mappatura dei dispositivi a blocchi per specificare un volume EBS aggiuntivo quando viene avviata un’istanza. Specificare un valore per `Groups` che corrisponde ai gruppi di sicurezza per il VPC nel quale il gruppo Auto Scaling avvierà le istanze. Specificare il VPC e le sottoreti come proprietà del gruppo 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
```
Output:
```
{
"LaunchTemplate": {
"LatestVersionNumber": 1,
"LaunchTemplateId": "lt-0123c79c33a54e0abc",
"LaunchTemplateName": "TemplateForAutoScaling",
"DefaultVersionNumber": 1,
"CreatedBy": "arn:aws:iam::123456789012:user/Bob",
"CreateTime": "2019-04-30T18:16:06.000Z"
}
}
```
Per ulteriori informazioni, consulta Creazione di un modello di avvio per un gruppo Auto Scaling nella *Guida per l’utente di Amazon EC2 Auto Scaling*. Per informazioni sulla citazione di parametri in formato JSON, consulta Inserimento di stringhe tra virgolette nella *Guida per l’utente dell’Interfaccia a riga di comando AWS *.
**Esempio 3: come creare un modello di avvio che specifica la crittografia dei volumi EBS**
Nell’esempio di `create-launch-template` seguente viene creato un modello di avvio che include volumi EBS crittografati creati da uno snapshot non crittografato. Inoltre, vengono applicati i tag ai volumi durante la creazione. Se la crittografia predefinita è disabilitata, è necessario specificare l’opzione `"Encrypted"` come mostrato nel seguente esempio. Se si utilizza l’opzione `"KmsKeyId"` per specificare una CMK gestita dal cliente, è necessario specificare l’opzione `"Encrypted"` anche se la crittografia predefinita è abilitata.
```
aws ec2 create-launch-template \
--launch-template-name TemplateForEncryption \
--launch-template-data file://config.json
```
Contenuto di `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"
}
]
}
]
}
```
Output:
```
{
"LaunchTemplate": {
"LatestVersionNumber": 1,
"LaunchTemplateId": "lt-0d5bd51bcf8530abc",
"LaunchTemplateName": "TemplateForEncryption",
"DefaultVersionNumber": 1,
"CreatedBy": "arn:aws:iam::123456789012:user/Bob",
"CreateTime": "2020-01-07T19:08:36.000Z"
}
}
```
Per ulteriori informazioni, consulta Ripristino di un volume EBS da uno snapshot e Crittografia per impostazione predefinita nella *Guida per l’utente di Amazon Elastic Compute Cloud*.
+ *Per i dettagli sull'API, consulta Command [CreateLaunchTemplate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-launch-template.html)Reference AWS CLI .*
### `create-local-gateway-route-table-virtual-interface-group-association`
Il seguente esempio di codice mostra come utilizzare`create-local-gateway-route-table-virtual-interface-group-association`.
**AWS CLI**
**Per associare una tabella di routing del gateway locale a un gruppo di interfacce virtuali (VIFs)**
L’esempio `create-local-gateway-route-table-virtual-interface-group-association` seguente crea un’associazione tra la tabella di routing del gateway locale specificata e il gruppo 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
```
Output:
```
{
"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": []
}
}
```
Per ulteriori informazioni, consulta [Associazioni di gruppi VIF](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#vif-group-associations) nella *Guida per l’utente di AWS Outposts*.
+ Per i dettagli sull'API, vedere [CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-local-gateway-route-table-virtual-interface-group-association.html)in *AWS CLI Command Reference.*
### `create-local-gateway-route-table-vpc-association`
Il seguente esempio di codice mostra come utilizzare`create-local-gateway-route-table-vpc-association`.
**AWS CLI**
**Come associare un VPC a una tabella di routing**
L’esempio `create-local-gateway-route-table-vpc-association` seguente associa il VPC specificato alla tabella di routing del gateway locale specificata.
```
aws ec2 create-local-gateway-route-table-vpc-association \
--local-gateway-route-table-id lgw-rtb-059615ef7dEXAMPLE \
--vpc-id vpc-07ef66ac71EXAMPLE
```
Output:
```
{
"LocalGatewayRouteTableVpcAssociation": {
"LocalGatewayRouteTableVpcAssociationId": "lgw-vpc-assoc-0ee765bcc8EXAMPLE",
"LocalGatewayRouteTableId": "lgw-rtb-059615ef7dEXAMPLE",
"LocalGatewayId": "lgw-09b493aa7cEXAMPLE",
"VpcId": "vpc-07ef66ac71EXAMPLE",
"State": "associated"
}
}
```
+ Per i dettagli sull'API, consulta [CreateLocalGatewayRouteTableVpcAssociation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-local-gateway-route-table-vpc-association.html)*Command Reference*.
### `create-local-gateway-route-table`
Il seguente esempio di codice mostra come utilizzare`create-local-gateway-route-table`.
**AWS CLI**
**Come creare la tabella di routing del gateway locale**
L’esempio `create-local-gateway-route-table` seguente crea una tabella di routing del gateway locale con la modalità di routing VPC diretta.
```
aws ec2 create-local-gateway-route-table \
--local-gateway-id lgw-1a2b3c4d5e6f7g8h9 \
--mode direct-vpc-routing
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Tabelle di routing del gateway locale](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html) nella *Guida per l’utente di AWS Outposts*.
+ Per i dettagli sull'API, consulta [CreateLocalGatewayRouteTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-local-gateway-route-table.html)*Command Reference*.
### `create-local-gateway-route`
Il seguente esempio di codice mostra come utilizzare`create-local-gateway-route`.
**AWS CLI**
**Come creare una route statica per una tabella di routing del gateway locale**
L’esempio `create-local-gateway-route` seguente crea la route specificata nella tabella di routing del gateway locale specificata.
```
aws ec2 create-local-gateway-route \
--destination-cidr-block 0.0.0.0/0 \
--local-gateway-route-table-id lgw-rtb-059615ef7dEXAMPLE
```
Output:
```
{
"Route": {
"DestinationCidrBlock": "0.0.0.0/0",
"LocalGatewayVirtualInterfaceGroupId": "lgw-vif-grp-07145b276bEXAMPLE",
"Type": "static",
"State": "deleted",
"LocalGatewayRouteTableId": "lgw-rtb-059615ef7dEXAMPLE"
}
}
```
+ Per i dettagli sull'API, consulta [CreateLocalGatewayRoute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-local-gateway-route.html)*Command Reference*.
### `create-managed-prefix-list`
Il seguente esempio di codice mostra come utilizzare`create-managed-prefix-list`.
**AWS CLI**
**Come creare un elenco di prefissi**
L'`create-managed-prefix-list`esempio seguente crea un elenco di IPv4 prefissi con un massimo di 10 voci e crea 2 voci nell'elenco dei prefissi.
```
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
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Elenchi di prefissi gestiti](https://docs.aws.amazon.com/vpc/latest/userguide/managed-prefix-lists.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, vedere [CreateManagedPrefixList](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-managed-prefix-list.html)in *AWS CLI Command Reference*.
### `create-nat-gateway`
Il seguente esempio di codice mostra come utilizzare`create-nat-gateway`.
**AWS CLI**
**Esempio 1: come creare un gateway NAT pubblico**
L’esempio `create-nat-gateway` seguente crea un gateway NAT pubblico nella sottorete specificata e associa l’indirizzo IP elastico all’ID di allocazione specificato. Quando si crea un gateway NAT pubblico, occorre associare un indirizzo IP elastico.
```
aws ec2 create-nat-gateway \
--subnet-id subnet-0250c25a1fEXAMPLE \
--allocation-id eipalloc-09ad461b0dEXAMPLE
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) nella *Guida per l’utente di Amazon VPC*.
**Esempio 2: come creare un gateway NAT privato**
L’esempio `create-nat-gateway` seguente crea un gateway NAT privato nella sottorete specificata. Un gateway NAT privato non ha un indirizzo IP elastico associato.
```
aws ec2 create-nat-gateway \
--subnet-id subnet-0250c25a1fEXAMPLE \
--connectivity-type private
```
Output:
```
{
"NatGateway": {
"CreateTime": "2021-12-01T22:26:00.000Z",
"NatGatewayAddresses": [
{}
],
"NatGatewayId": "nat-011b568379EXAMPLE",
"State": "pending",
"SubnetId": "subnet-0250c25a1fEXAMPLE",
"VpcId": "vpc-0a60eb65b4EXAMPLE",
"ConnectivityType": "private"
}
}
```
Per ulteriori informazioni, consulta [Gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [CreateNatGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-nat-gateway.html)*Command Reference*.
### `create-network-acl-entry`
Il seguente esempio di codice mostra come utilizzare`create-network-acl-entry`.
**AWS CLI**
**Come creare una voce della lista di controllo degli accessi alla rete (ACL)**
Questo esempio crea una voce per la lista di controllo degli accessi alla rete (ACL) specificata. La regola consente il traffico in ingresso da qualsiasi IPv4 indirizzo (0.0.0.0/0) sulla porta UDP 53 (DNS) in qualsiasi sottorete associata. Se il comando va a buon fine, non viene restituito alcun output.
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
```
Questo esempio crea una regola per l'ACL di rete specificato che consente il traffico in ingresso da qualsiasi IPv6 indirizzo (:: /0) sulla 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
```
+ *Per i dettagli sull'API, vedere [CreateNetworkAclEntry](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-network-acl-entry.html)in Command Reference.AWS CLI *
### `create-network-acl`
Il seguente esempio di codice mostra come utilizzare`create-network-acl`.
**AWS CLI**
**Come creare una lista di controllo degli accessi alla rete**
Questo esempio crea una lista di controllo degli accessi alla rete per il VPC specificato.
Comando:
```
aws ec2 create-network-acl --vpc-id vpc-a01106c2
```
Output:
```
{
"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
}
}
```
+ Per i dettagli sull'API, consulta [CreateNetworkAcl AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-network-acl.html)*Command Reference*.
### `create-network-insights-access-scope`
Il seguente esempio di codice mostra come utilizzare`create-network-insights-access-scope`.
**AWS CLI**
**Come creare un ambito di accesso alla rete**
L’esempio `create-network-insights-access-scope` seguente crea un ambito di accesso alla rete.
```
aws ec2 create-network-insights-access-scope \
--cli-input-json file://access-scope-file.json
```
Contenuto di `access-scope-file.json`:
```
{
"MatchPaths": [
{
"Source": {
"ResourceStatement": {
"Resources": [
"vpc-abcd12e3"
]
}
}
}
],
"ExcludePaths": [
{
"Source": {
"ResourceStatement": {
"ResourceTypes": [
"AWS::EC2::InternetGateway"
]
}
}
}
]
}
```
Output:
```
{
"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"
]
}
}
}
]
}
}
```
Per ulteriori informazioni, consulta [Guida introduttiva a Network Access Analyzer utilizzando la AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli.html) *nella Guida Network Access* Analyzer.
+ *Per i dettagli sull'API, consulta Command [CreateNetworkInsightsAccessScope](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-network-insights-access-scope.html)Reference AWS CLI .*
### `create-network-insights-path`
Il seguente esempio di codice mostra come utilizzare`create-network-insights-path`.
**AWS CLI**
**Come creare un percorso**
L’esempio `create-network-insights-path` seguente crea un percorso. L’origine è il gateway Internet specificato e la destinazione è l’istanza EC2 specificata. Per determinare se la destinazione è raggiungibile utilizzando il protocollo e la porta specificati, analizza il percorso utilizzando il comando `start-network-insights-analysis`.
```
aws ec2 create-network-insights-path \
--source igw-0797cccdc9d73b0e5 \
--destination i-0495d385ad28331c7 \
--destination-port 22 \
--protocol TCP
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Guida introduttiva all'uso della AWS CLI](https://docs.aws.amazon.com/vpc/latest/reachability/getting-started-cli.html) nella Reachability *Analyzer Guide*.
+ *Per i dettagli sull'API, consulta Command [CreateNetworkInsightsPath](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-network-insights-path.html)Reference AWS CLI .*
### `create-network-interface-permission`
Il seguente esempio di codice mostra come utilizzare`create-network-interface-permission`.
**AWS CLI**
**Come creare l’autorizzazione di un’interfaccia di rete**
Questo esempio concede l’autorizzazione all’account `123456789012` per collegare l’interfaccia di rete `eni-1a2b3c4d` a un’istanza.
Comando:
```
aws ec2 create-network-interface-permission --network-interface-id eni-1a2b3c4d --aws-account-id 123456789012 --permission INSTANCE-ATTACH
```
Output:
```
{
"InterfacePermission": {
"PermissionState": {
"State": "GRANTED"
},
"NetworkInterfacePermissionId": "eni-perm-06fd19020ede149ea",
"NetworkInterfaceId": "eni-1a2b3c4d",
"Permission": "INSTANCE-ATTACH",
"AwsAccountId": "123456789012"
}
}
```
+ Per i dettagli sull'API, consulta [CreateNetworkInterfacePermission AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-network-interface-permission.html)*Command Reference*.
### `create-network-interface`
Il seguente esempio di codice mostra come utilizzare`create-network-interface`.
**AWS CLI**
**Esempio 1: specificare un IPv4 indirizzo per un'interfaccia di rete**
L'`create-network-interface`esempio seguente crea un'interfaccia di rete per la sottorete specificata con l' IPv4 indirizzo primario specificato.
```
aws ec2 create-network-interface \
--subnet-id subnet-00a24d0d67acf6333 \
--description "my network interface" \
--groups sg-09dfba7ed20cda78b \
--private-ip-address 10.0.8.17
```
Output:
```
{
"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"
}
}
```
**Esempio 2: creare un'interfaccia di rete con un IPv4 indirizzo e un IPv6 indirizzo**
L’esempio `create-network-interface` seguente crea un’interfaccia di rete per la sottorete specificata con un indirizzo IPv4 e un indirizzo IPv6 selezionati da Amazon EC2.
```
aws ec2 create-network-interface \
--subnet-id subnet-00a24d0d67acf6333 \
--description "my dual stack network interface" \
--ipv6-address-count 1 \
--groups sg-09dfba7ed20cda78b
```
Output:
```
{
"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"
}
}
```
**Esempio 3: come creare un’interfaccia di rete con opzioni di configurazione per il monitoraggio delle connessioni**
L’esempio `create-network-interface` seguente crea un’interfaccia di rete e configura i timeout di tracciamento delle connessioni inattive.
```
aws ec2 create-network-interface \
--subnet-id subnet-00a24d0d67acf6333 \
--groups sg-02e57dbcfe0331c1b \
--connection-tracking-specification TcpEstablishedTimeout=86400,UdpTimeout=60
```
Output:
```
{
"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"
}
}
```
**Esempio 4: come creare un Elastic Fabric Adapter**
L’esempio `create-network-interface` seguente crea un EFA.
```
aws ec2 create-network-interface \
--interface-type efa \
--subnet-id subnet-00a24d0d67acf6333 \
--description "my efa" \
--groups sg-02e57dbcfe0331c1b
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Interfacce di rete elastiche](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [CreateNetworkInterface AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-network-interface.html)*Command Reference*.
### `create-placement-group`
Il seguente esempio di codice mostra come utilizzare`create-placement-group`.
**AWS CLI**
**Come creare un gruppo di posizionamento**
Questo comando di esempio crea un gruppo di posizionamento con il nome specificato.
Comando:
```
aws ec2 create-placement-group --group-name my-cluster --strategy cluster
```
**Come creare un gruppo di posizionamento delle partizioni**
Questo comando di esempio crea un gruppo di posizionamento delle partizioni denominato `HDFS-Group-A` con cinque partizioni.
Comando:
```
aws ec2 create-placement-group --group-name HDFS-Group-A --strategy partition --partition-count 5
```
+ Per i dettagli sull'API, consulta [CreatePlacementGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-placement-group.html)*Command Reference*.
### `create-replace-root-volume-task`
Il seguente esempio di codice mostra come utilizzare`create-replace-root-volume-task`.
**AWS CLI**
**Esempio 1: come ripristinare un volume root allo stato di avvio iniziale**
L’esempio `create-replace-root-volume-task` seguente ripristina il volume root dell’istanza i-0123456789abcdefa allo stato di avvio iniziale.
```
aws ec2 create-replace-root-volume-task \
--instance-id i-0123456789abcdefa
```
Output:
```
{
"ReplaceRootVolumeTask":
{
"InstanceId": "i-0123456789abcdefa",
"ReplaceRootVolumeTaskId": "replacevol-0111122223333abcd",
"TaskState": "pending",
"StartTime": "2022-03-14T15:06:38Z",
"Tags": []
}
}
```
**Esempio 2: come ripristinare un volume root in uno snapshot specifico**
L’esempio `create-replace-root-volume-task` seguente ripristina il volume root dell’istanza i-0123456789abcdefa allo snapshot snap-0abcdef1234567890.
```
aws ec2 create-replace-root-volume-task \
--instance-id i-0123456789abcdefa \
--snapshot-id snap-0abcdef1234567890
```
Output:
```
{
"ReplaceRootVolumeTask":
{
"InstanceId": "i-0123456789abcdefa",
"ReplaceRootVolumeTaskId": "replacevol-0555566667777abcd",
"TaskState": "pending",
"StartTime": "2022-03-14T15:16:28Z",
"Tags": []
}
}
```
Per ulteriori informazioni, consulta [Sostituzione di un volume root](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/replace-root.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [CreateReplaceRootVolumeTask AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-replace-root-volume-task.html)*Command Reference*.
### `create-reserved-instances-listing`
Il seguente esempio di codice mostra come utilizzare`create-reserved-instances-listing`.
**AWS CLI**
**Come elencare un’istanza riservata nel Marketplace di istanze riservate**
L’esempio `create-reserved-instances-listing` seguente crea un elenco per l’istanza riservata specificata nel Marketplace di istanze riservate.
```
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
```
+ Per i dettagli sull'API, consulta [CreateReservedInstancesListing AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-reserved-instances-listing.html)*Command Reference*.
### `create-restore-image-task`
Il seguente esempio di codice mostra come utilizzare`create-restore-image-task`.
**AWS CLI**
**Come ripristinare un’AMI da un bucket S3**
L’esempio `create-restore-image-task` seguente ripristina un’AMI da un bucket S3. Utilizza i valori per `S3ObjectKey `` and ``Bucket` dall’output `describe-store-image-tasks`, specifica la chiave oggetto dell’AMI e il nome del bucket S3 in cui è stata copiata l’AMI e specifica il nome dell’AMI ripristinata. Il nome di questo account deve essere univoco nella regione. AMIs L’AMI ripristinata riceverà un nuovo ID AMI.
```
aws ec2 create-restore-image-task \
--object-key ami-1234567890abcdef0.bin \
--bucket my-ami-bucket \
--name 'New AMI Name'
```
Output:
```
{
"ImageId": "ami-0eab20fe36f83e1a8"
}
```
Per ulteriori informazioni, consulta [Archiviazione e ripristino di un’AMI utilizzando S3](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [CreateRestoreImageTask AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-restore-image-task.html)*Command Reference*.
### `create-route-table`
Il seguente esempio di codice mostra come utilizzare`create-route-table`.
**AWS CLI**
**Come creare una tabella di routing**
Nell’esempio seguente viene creata una tabella di routing per il VPC specificato.
Comando:
```
aws ec2 create-route-table --vpc-id vpc-a01106c2
```
Output:
```
{
"RouteTable": {
"Associations": [],
"RouteTableId": "rtb-22574640",
"VpcId": "vpc-a01106c2",
"PropagatingVgws": [],
"Tags": [],
"Routes": [
{
"GatewayId": "local",
"DestinationCidrBlock": "10.0.0.0/16",
"State": "active"
}
]
}
}
```
+ Per i dettagli sull'API, consulta [CreateRouteTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-route-table.html)*Command Reference*.
### `create-route`
Il seguente esempio di codice mostra come utilizzare`create-route`.
**AWS CLI**
**Come creare una route**
Questo esempio crea una route per la tabella di routing specificata. Il percorso corrisponde a tutto IPv4 il traffico (`0.0.0.0/0`) e lo indirizza verso il gateway Internet specificato. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 create-route --route-table-id rtb-22574640 --destination-cidr-block 0.0.0.0/0 --gateway-id igw-c0a643a9
```
Questo comando di esempio crea una route nella tabella di routing rtb-g8ff4ea2. Il percorso corrisponde al traffico per il blocco IPv4 CIDR 10.0.0.0/16 e lo indirizza alla connessione peering VPC, pcx-111aaa22. Questa route consente di indirizzare il traffico al VPC peer nella connessione peering VPC. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 create-route --route-table-id rtb-g8ff4ea2 --destination-cidr-block 10.0.0.0/16 --vpc-peering-connection-id pcx-1a2b3c4d
```
Questo esempio crea una route nella tabella di route specificata che corrisponde a tutto IPv6 il traffico () e la indirizza verso il gateway Internet di sola uscita specificato. `::/0`
Comando:
```
aws ec2 create-route --route-table-id rtb-dce620b8 --destination-ipv6-cidr-block ::/0 --egress-only-internet-gateway-id eigw-01eadbd45ecd7943f
```
+ *Per i dettagli sull'API, vedere [CreateRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-route.html)in AWS CLI Command Reference.*
### `create-security-group`
Il seguente esempio di codice mostra come utilizzare`create-security-group`.
**AWS CLI**
**Come creare un gruppo di sicurezza per EC2-Classic**
Nell’esempio seguente viene creato un gruppo di sicurezza denominato `MySecurityGroup`.
Comando:
```
aws ec2 create-security-group --group-name MySecurityGroup --description "My security group"
```
Output:
```
{
"GroupId": "sg-903004f8"
}
```
**Come creare un gruppo di sicurezza per EC2-VPC**
Nell’esempio seguente viene creato un gruppo di sicurezza denominato `MySecurityGroup` per il VPC specificato.
Comando:
```
aws ec2 create-security-group --group-name MySecurityGroup --description "My security group" --vpc-id vpc-1a2b3c4d
```
Output:
```
{
"GroupId": "sg-903004f8"
}
```
Per ulteriori informazioni, consulta Utilizzo dei gruppi di sicurezza nella *Guida per l’utente dell’Interfaccia a riga di comando AWS *.
+ Per i dettagli sull'API, consulta [CreateSecurityGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-security-group.html)*Command Reference*.
### `create-snapshot`
Il seguente esempio di codice mostra come utilizzare`create-snapshot`.
**AWS CLI**
**Come creare uno snapshot**
Questo comando di esempio crea uno snapshot del volume con l’ID volume `vol-1234567890abcdef0` e una breve descrizione per identificare lo snapshot.
Comando:
```
aws ec2 create-snapshot --volume-id vol-1234567890abcdef0 --description "This is my root volume snapshot"
```
Output:
```
{
"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"
}
```
**Come creare uno snapshot con tag**
Questo comando di esempio crea uno snapshot e applica due tag, ovvero 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}]'
```
Output:
```
{
"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"
}
```
+ Per i dettagli sull'API, consulta [CreateSnapshot AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-snapshot.html)*Command Reference*.
### `create-snapshots`
Il seguente esempio di codice mostra come utilizzare`create-snapshots`.
**AWS CLI**
**Esempio 1: come creare uno snapshot a più volumi**
L’esempio `create-snapshots` seguente crea gli snapshot di tutti i volumi collegati all’istanza specificata.
```
aws ec2 create-snapshots \
--instance-specification InstanceId=i-1234567890abcdef0 \
--description "This is snapshot of a volume from my-instance"
```
Output:
```
{
"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"
},
...
]
}
```
**Esempio 2: come creare uno snapshot a più volumi con tag dal volume di origine**
L’esempio `create-snapshots` seguente crea snapshot di tutti i volumi collegati all’istanza specificata e copia i tag da ciascun volume nello snapshot corrispondente.
```
aws ec2 create-snapshots \
--instance-specification InstanceId=i-1234567890abcdef0 \
--copy-tags-from-source volume \
--description "This is snapshot of a volume from my-instance"
```
Output:
```
{
"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"
}
...
]
}
```
**Esempio 3: come creare uno snapshot a più volumi che non includa il volume root**
L’esempio `create-snapshots` seguente crea uno snapshot di tutti i volumi collegati all’istanza specificata ad eccezione del volume root.
```
aws ec2 create-snapshots \
--instance-specification InstanceId=i-1234567890abcdef0,ExcludeBootVolume=true
```
Vedi l’esempio 1 per un output di esempio.
**Esempio 4: come creare uno snapshot a più volumi e aggiungere tag**
L’esempio `create-snapshots` seguente crea gli snapshot di tutti i volumi collegati all’istanza specificata e aggiunge due tag a ciascun snapshot.
```
aws ec2 create-snapshots \
--instance-specification InstanceId=i-1234567890abcdef0 \
--tag-specifications 'ResourceType=snapshot,Tags=[{Key=Name,Value=backup},{Key=costcenter,Value=123}]'
```
Vedi l’esempio 1 per un output di esempio.
+ Per i dettagli sull'API, consulta [CreateSnapshots AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-snapshots.html)*Command Reference*.
### `create-spot-datafeed-subscription`
Il seguente esempio di codice mostra come utilizzare`create-spot-datafeed-subscription`.
**AWS CLI**
**Come creare un feed di dati dell’istanza spot**
L’esempio `create-spot-datafeed-subscription` seguente crea un feed di dati dell’istanza spot.
```
aws ec2 create-spot-datafeed-subscription \
--bucket amzn-s3-demo-bucket \
--prefix spot-data-feed
```
Output:
```
{
"SpotDatafeedSubscription": {
"Bucket": "amzn-s3-demo-bucket",
"OwnerId": "123456789012",
"Prefix": "spot-data-feed",
"State": "Active"
}
}
```
Il feed di dati viene archiviato nel bucket Amazon S3 specificato. I nomi di file di questo feed di dati hanno il formato seguente.
```
amzn-s3-demo-bucket.s3.amazonaws.com/spot-data-feed/123456789012.YYYY-MM-DD-HH.n.abcd1234.gz
```
Per ulteriori informazioni, consulta [Feed di dati dell’istanza spot](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-data-feeds.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [CreateSpotDatafeedSubscription AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-spot-datafeed-subscription.html)*Command Reference*.
### `create-store-image-task`
Il seguente esempio di codice mostra come utilizzare`create-store-image-task`.
**AWS CLI**
**Come archiviare un’AMI in un bucket S3**
L’esempio `create-store-image-task` seguente archivia un’AMI in un bucket S3. Specificare l’ID AMI e il nome del bucket S3 in cui archiviare l’AMI.
```
aws ec2 create-store-image-task \
--image-id ami-1234567890abcdef0 \
--bucket my-ami-bucket
```
Output:
```
{
"ObjectKey": "ami-1234567890abcdef0.bin"
}
```
Per ulteriori informazioni, consulta [Archiviazione e ripristino di un’AMI utilizzando S3](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [CreateStoreImageTask AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-store-image-task.html)*Command Reference*.
### `create-subnet-cidr-reservation`
Il seguente esempio di codice mostra come utilizzare`create-subnet-cidr-reservation`.
**AWS CLI**
**Come creare una prenotazione CIDR della sottorete**
L’esempio `create-subnet-cidr-reservation` seguente crea una prenotazione CIDR della sottorete per la sottorete e l’intervallo CIDR specificati.
```
aws ec2 create-subnet-cidr-reservation \
--subnet-id subnet-03c51e2eEXAMPLE \
--reservation-type prefix \
--cidr 10.1.0.20/26
```
Output:
```
{
"SubnetCidrReservation": {
"SubnetCidrReservationId": "scr-044f977c4eEXAMPLE",
"SubnetId": "subnet-03c51e2e6cEXAMPLE",
"Cidr": "10.1.0.16/28",
"ReservationType": "prefix",
"OwnerId": "123456789012"
}
}
```
Per ulteriori informazioni, consulta [Prenotazioni della CIDR per la sottorete](https://docs.aws.amazon.com/vpc/latest/userguide/subnet-cidr-reservation.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [CreateSubnetCidrReservation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-subnet-cidr-reservation.html)*Command Reference*.
### `create-subnet`
Il seguente esempio di codice mostra come utilizzare`create-subnet`.
**AWS CLI**
**Esempio 1: creare una sottorete con solo un blocco IPv4 CIDR**
L'`create-subnet`esempio seguente crea una sottorete nel VPC specificato con il blocco CIDR IPv4 specificato.
```
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}]
```
Output:
```
{
"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"
}
}
```
**Esempio 2: creare una sottorete con entrambi i blocchi CIDR IPv4 IPv6 **
L'`create-subnet`esempio seguente crea una sottorete nel VPC specificato con i blocchi IPv4 specificati 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}]
```
Output:
```
{
"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"
}
}
```
**Esempio 3: creare una sottorete con solo un blocco CIDR IPv6 **
L'`create-subnet`esempio seguente crea una sottorete nel VPC specificato con il blocco CIDR IPv6 specificato.
```
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}]
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [VPCs e sottoreti](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html) nella Amazon *VPC* User Guide.
+ *Per i dettagli sull'API, consulta Command [CreateSubnet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-subnet.html)Reference AWS CLI .*
### `create-tags`
Il seguente esempio di codice mostra come utilizzare`create-tags`.
**AWS CLI**
**Esempio 1: come aggiungere un tag a una risorsa**
Nell’esempio di `create-tags` seguente viene aggiunto il tag `Stack=production` all’immagine specificata o sovrascritto un tag esistente per l’AMI in cui la chiave tag è `Stack`.
```
aws ec2 create-tags \
--resources ami-1234567890abcdef0 \
--tags Key=Stack,Value=production
```
Questo comando non produce alcun output.
**Esempio 2: come aggiungere tag a più risorse**
Nell’esempio di `create-tags` seguente vengono aggiunti (o sovrascritti) due tag per un’AMI e un’istanza. Uno dei tag ha una chiave (`webserver`), ma nessun valore (il valore è impostato su una stringa vuota). L’altro tag ha una chiave (`stack`) e un valore (`Production`).
```
aws ec2 create-tags \
--resources ami-1a2b3c4d i-1234567890abcdef0 \
--tags Key=webserver,Value= Key=stack,Value=Production
```
Questo comando non produce alcun output.
**Esempio 3: come aggiungere tag contenenti caratteri speciali**
L’esempio `create-tags` seguente aggiunge il tag `[Group]=test` a un’istanza. Le parentesi quadre ([ e ]) sono caratteri speciali per i quali occorre eseguire l’escape. Negli esempi seguenti viene utilizzato anche il carattere di continuazione della riga adeguato a ogni ambiente.
Se si utilizza Windows, racchiudere l’elemento con caratteri speciali tra virgolette doppie (“”), quindi anteporre ad ogni virgoletta doppia una barra rovesciata (\$1) come segue:
```
aws ec2 create-tags ^
--resources i-1234567890abcdef0 ^
--tags Key=\"[Group]\",Value=test
```
Se utilizzate Windows PowerShell, racchiudete l'elemento con caratteri speciali tra virgolette doppie («), fate precedere ogni virgoletta doppia da una barra rovesciata (\$1), quindi racchiudete l'intera struttura di chiavi e valori tra virgolette singole (') come segue.
```
aws ec2 create-tags `
--resources i-1234567890abcdef0 `
--tags 'Key=\"[Group]\",Value=test'
```
Se si utilizza Linux o OS X, racchiudere l’elemento contenente caratteri speciali con virgolette doppie (“”), quindi racchiudere l’intera struttura di chiave e valore tra virgolette singole (‘’), come segue:
```
aws ec2 create-tags \
--resources i-1234567890abcdef0 \
--tags 'Key="[Group]",Value=test'
```
Per ulteriori informazioni, consulta [Tagging delle risorse Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html) nella *Guida per l’utente di Amazon EC2*.
+ *Per i dettagli sull'API, consulta Command Reference. [CreateTags](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-tags.html)AWS CLI *
### `create-traffic-mirror-filter-rule`
Il seguente esempio di codice mostra come utilizzare`create-traffic-mirror-filter-rule`.
**AWS CLI**
**Come creare una regola di filtro per il traffico TCP in entrata**
L’esempio `create-traffic-mirror-filter-rule` seguente crea una regola che è possibile utilizzare per eseguire il mirroring di tutto il traffico TCP in entrata. Prima di eseguire questo comando, utilizza `create-traffic-mirror-filter` per creare il filtro di mirroring del traffico.
```
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
```
Output:
```
{
"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"
}
```
Per ulteriori informazioni, consulta [Creazione di un filtro di mirroring del traffico](https://docs.aws.amazon.com/vpc/latest/mirroring/create-traffic-mirroring-filter.html) nella *Guida di Mirroring del traffico*.
+ Per i dettagli sull'API, consulta [CreateTrafficMirrorFilterRule AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-traffic-mirror-filter-rule.html)*Command Reference*.
### `create-traffic-mirror-filter`
Il seguente esempio di codice mostra come utilizzare`create-traffic-mirror-filter`.
**AWS CLI**
**Come creare un filtro di mirroring del traffico**
L’esempio `create-traffic-mirror-filter` seguente crea un filtro di mirroring del traffico. Dopo aver creato il filtro, utilizza `create-traffic-mirror-filter-rule` per aggiungere regole.
```
aws ec2 create-traffic-mirror-filter \
--description 'TCP Filter'
```
Output:
```
{
"ClientToken": "28908518-100b-4987-8233-8c744EXAMPLE",
"TrafficMirrorFilter": {
"TrafficMirrorFilterId": "tmf-04812ff784EXAMPLE",
"Description": "TCP Filter",
"EgressFilterRules": [],
"IngressFilterRules": [],
"Tags": [],
"NetworkServices": []
}
}
```
Per ulteriori informazioni, consulta [Creazione di un filtro di mirroring del traffico](https://docs.aws.amazon.com/vpc/latest/mirroring/create-traffic-mirroring-filter.html) nella *Guida di Mirroring del traffico*.
+ Per i dettagli sull'API, consulta [CreateTrafficMirrorFilter AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-traffic-mirror-filter.html)*Command Reference*.
### `create-traffic-mirror-session`
Il seguente esempio di codice mostra come utilizzare`create-traffic-mirror-session`.
**AWS CLI**
**Come creare una sessione di mirroring del traffico**
Il comando `create-traffic-mirror-session` seguente crea una sessione di mirroring del traffico per l’origine e la destinazione specificate per 25 byte del pacchetto.
```
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
```
Output:
```
{
"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"
}
```
Per ulteriori informazioni, consulta [Creazione di un filtro del mirroring del traffico](https://docs.aws.amazon.com/vpc/latest/mirroring/create-traffic-mirroring-session.html) nella *Guida di Mirroring del traffico*.
+ Per i dettagli sull'API, consulta [CreateTrafficMirrorSession AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-traffic-mirror-session.html)*Command Reference*.
### `create-traffic-mirror-target`
Il seguente esempio di codice mostra come utilizzare`create-traffic-mirror-target`.
**AWS CLI**
**Come creare una destinazione di mirroring del traffico con un Network Load Balancer**
L’esempio `create-traffic-mirror-target` seguente crea una destinazione di mirroring del traffico di 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
```
Output:
```
{
"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"
}
```
**Come creare una destinazione di mirroring del traffico di rete**
L’esempio `create-traffic-mirror-target` seguente crea una destinazione di mirroring del traffico per l’interfaccia di rete.
```
aws ec2 create-traffic-mirror-target \
--description 'Network interface target' \
--network-interface-id eni-eni-01f6f631eEXAMPLE
```
Output:
```
{
"ClientToken": "5289a345-0358-4e62-93d5-47ef3061d65e",
"TrafficMirrorTarget": {
"Description": "Network interface target",
"NetworkInterfaceId": "eni-01f6f631eEXAMPLE",
"TrafficMirrorTargetId": "tmt-02dcdbe2abEXAMPLE",
"OwnerId": "111122223333",
"Type": "network-interface",
"Tags": []
}
}
```
Per ulteriori informazioni, consulta [Creazione di una destinazione di mirroring del traffico](https://docs.aws.amazon.com/vpc/latest/mirroring/create-traffic-mirroring-target.html) nella *Guida di Mirroring del traffico*.
+ Per i dettagli sull'API, consulta [CreateTrafficMirrorTarget AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-traffic-mirror-target.html)*Command Reference*.
### `create-transit-gateway-connect-peer`
Il seguente esempio di codice mostra come utilizzare`create-transit-gateway-connect-peer`.
**AWS CLI**
**Come creare un peer di Transit Gateway Connect**
L’esempio `create-transit-gateway-connect-peer` seguente crea un peer di Connect.
```
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
```
Output:
```
{
"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"
}
]
}
}
}
```
Per ulteriori informazioni, consulta [Collegamenti Transit gateway Connect e peer Connect](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [CreateTransitGatewayConnectPeer AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-connect-peer.html)*Command Reference*.
### `create-transit-gateway-connect`
Il seguente esempio di codice mostra come utilizzare`create-transit-gateway-connect`.
**AWS CLI**
**Come creare un collegamento per il Transit Gateway Connect**
L’esempio `create-transit-gateway-connect` seguente crea un collegamento Connect, con il protocollo “gre” per il collegamento specificato.
```
aws ec2 create-transit-gateway-connect \
--transport-transit-gateway-attachment-id tgw-attach-0a89069f57EXAMPLE \
--options "Protocol=gre"
```
Output:
```
{
"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"
}
}
}
```
Per ulteriori informazioni, consulta [Collegamenti Transit gateway Connect e peer Connect](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [CreateTransitGatewayConnect AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-connect.html)*Command Reference*.
### `create-transit-gateway-multicast-domain`
Il seguente esempio di codice mostra come utilizzare`create-transit-gateway-multicast-domain`.
**AWS CLI**
**Esempio 1: come creare un dominio multicast (trasmissione uno a molti) IGMP**
L’esempio `create-transit-gateway-multicast-domain` seguente crea un dominio multicast (trasmissione uno a molti) per il gateway di transito specificato. Con le fonti statiche disabilitate, tutte le istanze presenti nelle sottoreti associate al dominio multicast (trasmissione uno a molti) possono inviare traffico multicast (trasmissione uno a molti). Se almeno un membro utilizza il protocollo IGMP, è necessario abilitare il IGMPv2 supporto.
```
aws ec2 create-transit-gateway-multicast-domain \
--transit-gateway-id tgw-0bf0bffefaEXAMPLE \
--options StaticSourcesSupport=disable,Igmpv2Support=enable
```
Output:
```
{
"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"
}
}
```
**Esempio 2: come creare un dominio multicast (trasmissione uno a molti) statico**
L’esempio `create-transit-gateway-multicast-domain` seguente crea un dominio multicast (trasmissione uno a molti) per il gateway di transito specificato. Con le fonti statiche abilitate, è necessario aggiungere fonti staticamente.
```
aws ec2 create-transit-gateway-multicast-domain \
--transit-gateway-id tgw-0bf0bffefaEXAMPLE \
--options StaticSourcesSupport=enable,Igmpv2Support=disable
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Gestione dei domini multicast (trasmissione uno a molti)](https://docs.aws.amazon.com/vpc/latest/tgw/manage-domain.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, vedere [CreateTransitGatewayMulticastDomain](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-multicast-domain.html)in *AWS CLI Command Reference.*
### `create-transit-gateway-peering-attachment`
Il seguente esempio di codice mostra come utilizzare`create-transit-gateway-peering-attachment`.
**AWS CLI**
**Come creare un collegamento peering del gateway di transito**
L’esempio `create-transit-gateway-peering-attachment` seguente crea una richiesta di collegamento peering tra i due gateway di transito specificati.
```
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
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Accessori di peering del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-peering.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [CreateTransitGatewayPeeringAttachment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-peering-attachment.html)*Command Reference*.
### `create-transit-gateway-policy-table`
Il seguente esempio di codice mostra come utilizzare`create-transit-gateway-policy-table`.
**AWS CLI**
**Come creare una tabella di policy del gateway di transito**
L’esempio `create-transit-gateway-policy-table` seguente crea una tabella di policy del gateway di transito per il gateway di transito specificato.
```
aws ec2 create-transit-gateway-policy-table \
--transit-gateway-id tgw-067f8505c18f0bd6e
```
Output:
```
{
"TransitGatewayPolicyTable": {
"TransitGatewayPolicyTableId": "tgw-ptb-0a16f134b78668a81",
"TransitGatewayId": "tgw-067f8505c18f0bd6e",
"State": "pending",
"CreationTime": "2023-11-28T16:36:43+00:00"
}
}
```
Per ulteriori informazioni, consulta [Tabelle di policy del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-policy-tables.html) nella *Guida per l’utente di Transit Gateway*.
+ Per i dettagli sull'API, consulta [CreateTransitGatewayPolicyTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-policy-table.html)*Command Reference*.
### `create-transit-gateway-prefix-list-reference`
Il seguente esempio di codice mostra come utilizzare`create-transit-gateway-prefix-list-reference`.
**AWS CLI**
**Come creare un riferimento all’elenco di prefissi**
L’esempio `create-transit-gateway-prefix-list-reference` seguente crea un riferimento all’elenco di prefissi specificato nella tabella di routing del gateway di transito specificato.
```
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
```
Output:
```
{
"TransitGatewayPrefixListReference": {
"TransitGatewayRouteTableId": "tgw-rtb-0123456789abcd123",
"PrefixListId": "pl-11111122222222333",
"PrefixListOwnerId": "123456789012",
"State": "pending",
"Blackhole": false,
"TransitGatewayAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-aaaaaabbbbbb11111",
"ResourceType": "vpc",
"ResourceId": "vpc-112233445566aabbc"
}
}
}
```
Per ulteriori informazioni, consulta [Creare un riferimento all’elenco dei prefissi](https://docs.aws.amazon.com/vpc/latest/tgw/create-prefix-list-reference.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [CreateTransitGatewayPrefixListReference AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-prefix-list-reference.html)*Command Reference*.
### `create-transit-gateway-route-table`
Il seguente esempio di codice mostra come utilizzare`create-transit-gateway-route-table`.
**AWS CLI**
**Come creare una tabella di routing di un gateway di transito**
L’esempio `create-transit-gateway-route-table` seguente crea una tabella di routing per il gateway di transito specificato.
```
aws ec2 create-transit-gateway-route-table \
--transit-gateway-id tgw-0262a0e521EXAMPLE
```
Output:
```
{
"TransitGatewayRouteTable": {
"TransitGatewayRouteTableId": "tgw-rtb-0960981be7EXAMPLE",
"TransitGatewayId": "tgw-0262a0e521EXAMPLE",
"State": "pending",
"DefaultAssociationRouteTable": false,
"DefaultPropagationRouteTable": false,
"CreationTime": "2019-07-10T19:01:46.000Z"
}
}
```
Per ulteriori informazioni, consulta [Creare una tabella di routing del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html#create-tgw-route-table) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [CreateTransitGatewayRouteTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-route-table.html)*Command Reference*.
### `create-transit-gateway-route`
Il seguente esempio di codice mostra come utilizzare`create-transit-gateway-route`.
**AWS CLI**
**Come creare una route del gateway di transito**
L’esempio `create-transit-gateway-route` seguente crea una route, con la destinazione specificata, per la tabella di routing specificata.
```
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
```
Output:
```
{
"Route": {
"DestinationCidrBlock": "10.0.2.0/24",
"TransitGatewayAttachments": [
{
"ResourceId": "vpc-0065acced4EXAMPLE",
"TransitGatewayAttachmentId": "tgw-attach-0b5968d3b6EXAMPLE",
"ResourceType": "vpc"
}
],
"Type": "static",
"State": "active"
}
}
```
Per ulteriori informazioni, consulta [Tabelle di routing del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [CreateTransitGatewayRoute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-route.html)*Command Reference*.
### `create-transit-gateway-vpc-attachment`
Il seguente esempio di codice mostra come utilizzare`create-transit-gateway-vpc-attachment`.
**AWS CLI**
**Esempio 1: come associare un gateway di transito a un VPC**
L’esempio `create-transit-gateway-vpc-attachment` seguente crea un collegamento del gateway di transito alla VPN al VPC specificato.
```
aws ec2 create-transit-gateway-vpc-attachment \
--transit-gateway-id tgw-0262a0e521EXAMPLE \
--vpc-id vpc-07e8ffd50f49335df \
--subnet-id subnet-0752213d59EXAMPLE
```
Output:
```
{
"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"
}
}
}
```
Per ulteriori informazioni, consulta [Creare un collegamento del gateway di transito alla VPN a un VPC](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html#create-vpc-attachment) nella *Guida di Transit Gateway*.
**Esempio 2: come associare un gateway di transito a più sottoreti in un VPC**
L’esempio `create-transit-gateway-vpc-attachment` seguente crea un collegamento del gateway di transito alla VPN al VPC e alle sottoreti specificati.
```
aws ec2 create-transit-gateway-vpc-attachment \
--transit-gateway-id tgw-02f776b1a7EXAMPLE \
--vpc-id vpc-3EXAMPLE \
--subnet-ids "subnet-dEXAMPLE" "subnet-6EXAMPLE"
```
Output:
```
{
"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"
}
}
}
```
Per ulteriori informazioni, consulta [Creare un collegamento del gateway di transito alla VPN a un VPC](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html#create-vpc-attachment) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [CreateTransitGatewayVpcAttachment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway-vpc-attachment.html)*Command Reference*.
### `create-transit-gateway`
Il seguente esempio di codice mostra come utilizzare`create-transit-gateway`.
**AWS CLI**
**Come creare un gateway di transito**
L’esempio `create-transit-gateway` seguente crea un gateway di transito.
```
aws ec2 create-transit-gateway \
--description MyTGW \
--options AmazonSideAsn=64516,AutoAcceptSharedAttachments=enable,DefaultRouteTableAssociation=enable,DefaultRouteTablePropagation=enable,VpnEcmpSupport=enable,DnsSupport=enable
```
Output:
```
{
"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"
}
}
}
```
Per ulteriori informazioni, consulta [Creazione di un gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-transit-gateways.html#create-tgw) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [CreateTransitGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-transit-gateway.html)*Command Reference*.
### `create-verified-access-endpoint`
Il seguente esempio di codice mostra come utilizzare`create-verified-access-endpoint`.
**AWS CLI**
**Come creare un endpoint di accesso verificato**
L'`create-verified-access-endpoint`esempio seguente crea un endpoint Verified Access per il gruppo Verified Access specificato. L’interfaccia di rete e il gruppo di sicurezza specificati devono appartenere allo stesso 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}]
```
Output:
```
{
"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"
}
]
}
}
```
Per ulteriori informazioni, consulta [Endpoint di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-endpoints.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [CreateVerifiedAccessEndpoint AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-verified-access-endpoint.html)*Command Reference.*
### `create-verified-access-group`
Il seguente esempio di codice mostra come utilizzare`create-verified-access-group`.
**AWS CLI**
**Come creare un gruppo di accesso verificato**
L’esempio `create-verified-access-group` seguente crea un gruppo di accesso verificato per l’istanza di accesso verificato specificata.
```
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}]
```
Output:
```
{
"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"
}
]
}
}
```
Per ulteriori informazioni, consulta [Gruppi di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-groups.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [CreateVerifiedAccessGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-verified-access-group.html)*Command Reference*.
### `create-verified-access-instance`
Il seguente esempio di codice mostra come utilizzare`create-verified-access-instance`.
**AWS CLI**
**Come creare un’istanza di accesso verificato**
L’esempio `create-verified-access-instance` seguente crea un’istanza di accesso verificato con un tag del nome.
```
aws ec2 create-verified-access-instance \
--tag-specifications ResourceType=verified-access-instance,Tags=[{Key=Name,Value=my-va-instance}]
```
Output:
```
{
"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"
}
]
}
}
```
Per ulteriori informazioni, consulta [Istanze di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-instances.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [CreateVerifiedAccessInstance AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-verified-access-instance.html)*Command Reference*.
### `create-verified-access-trust-provider`
Il seguente esempio di codice mostra come utilizzare`create-verified-access-trust-provider`.
**AWS CLI**
**Come creare un provider di attendibilità di accesso verificato**
L'`create-verified-access-trust-provider`esempio seguente configura un provider fiduciario ad accesso verificato utilizzando 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}]
```
Output:
```
{
"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"
}
]
}
}
```
Per ulteriori informazioni, consulta [Provider di attendibilità per Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/trust-providers.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [CreateVerifiedAccessTrustProvider AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-verified-access-trust-provider.html)*Command Reference*.
### `create-volume`
Il seguente esempio di codice mostra come utilizzare`create-volume`.
**AWS CLI**
**Come creare un volume SSD per uso generico (gp2) vuoto**
L’esempio `create-volume` seguente crea un volume SSD (gp2) per scopi generici da 80 GiB nella zona di disponibilità specificata. Si noti che la Regione corrente deve essere `us-east-1`, oppure è possibile aggiungere il parametro `--region` per specificare la Regione per il comando.
```
aws ec2 create-volume \
--volume-type gp2 \
--size 80 \
--availability-zone us-east-1a
```
Output:
```
{
"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 non si specifica un tipo di volume, il tipo di volume predefinito è `gp2`.
```
aws ec2 create-volume \
--size 80 \
--availability-zone us-east-1a
```
**Esempio 2: come creare un volume SSD con IOPS con capacità di IOPS allocata (io1) da un’snapshot**
L’esempio `create-volume` seguente crea un volume SSD con capacità di IOPS allocata (io1) con 1000 IOPS assegnati nella zona di disponibilità specificata utilizzando lo snapshot specificato.
```
aws ec2 create-volume \
--volume-type io1 \
--iops 1000 \
--snapshot-id snap-066877671789bd71b \
--availability-zone us-east-1a
```
Output:
```
{
"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
}
```
**Esempio 3: come creare un volume crittografato**
L’esempio `create-volume` seguente crea un volume crittografato utilizzando la chiave gestita dal cliente (CMK) predefinita per la crittografia EBS. Se la crittografia è disabilitata per impostazione predefinita, è necessario specificare il parametro `--encrypted` come segue.
```
aws ec2 create-volume \
--size 80 \
--encrypted \
--availability-zone us-east-1a
```
Output:
```
{
"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 la crittografia è abilitata per impostazione predefinita, il seguente comando di esempio crea un volume crittografato anche senza il parametro `--encrypted`.
```
aws ec2 create-volume \
--size 80 \
--availability-zone us-east-1a
```
Se si utilizza il parametro `--kms-key-id` per specificare una chiave gestita dal cliente (CMK), è necessario specificare il parametro `--encrypted` anche se la crittografia predefinita è abilitata.
```
aws ec2 create-volume \
--volume-type gp2 \
--size 80 \
--encrypted \
--kms-key-id 0ea3fef3-80a7-4778-9d8c-1c0c6EXAMPLE \
--availability-zone us-east-1a
```
**Esempio 4: come creare un volume con tag**
L’esempio `create-volume` seguente crea un volume e aggiunge due tag.
```
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}]'
```
+ Per i dettagli sull'API, consulta [CreateVolume AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-volume.html)*Command Reference*.
### `create-vpc-endpoint-connection-notification`
Il seguente esempio di codice mostra come utilizzare`create-vpc-endpoint-connection-notification`.
**AWS CLI**
**Come creare una notifica di connessione endpoint**
Questo esempio crea una notifica per un servizio endpoint specifico che avvisa quando gli endpoint dell’interfaccia si sono connessi al servizio e quando gli endpoint sono stati accettati per il servizio.
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
```
Output:
```
{
"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"
}
}
```
+ Per i dettagli sull'API, consulta [CreateVpcEndpointConnectionNotification AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint-connection-notification.html)*Command Reference*.
### `create-vpc-endpoint-service-configuration`
Il seguente esempio di codice mostra come utilizzare`create-vpc-endpoint-service-configuration`.
**AWS CLI**
**Esempio 1: come creare una configurazione del servizio endpoint per un endpoint di interfaccia**
L’esempio `create-vpc-endpoint-service-configuration` seguente crea una configurazione del servizio endpoint VPC utilizzando Network Load Balancer `nlb-vpce`. Questo esempio specifica, inoltre, che le richieste di connessione al servizio tramite un endpoint di interfaccia devono essere accettate.
```
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
```
Output:
```
{
"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"
]
}
}
```
Per ulteriori informazioni, consulta [Creare un servizio endpoint](https://docs.aws.amazon.com/vpc/latest/privatelink/create-endpoint-service.html) nella *Guida per l'AWS PrivateLink utente*.
**Esempio 2: come creare una configurazione del servizio endpoint per gli endpoint Gateway Load Balancer**
L’esempio `create-vpc-endpoint-service-configuration` seguente crea una configurazione del servizio endpoint VPC utilizzando Gateway Load Balancer `GWLBService`. Le richieste di connessione al servizio tramite un endpoint Gateway Load Balancer vengono accettate 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
```
Output:
```
{
"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"
]
}
}
```
*Per ulteriori informazioni, consulta [Creare un servizio endpoint Gateway Load Balancer](https://docs.aws.amazon.com/vpc/latest/privatelink/create-gateway-load-balancer-endpoint-service.html) nella Guida per l'AWS PrivateLink utente.*
+ Per i dettagli sull'API, consulta *AWS CLI Command [CreateVpcEndpointServiceConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint-service-configuration.html)Reference*.
### `create-vpc-endpoint`
Il seguente esempio di codice mostra come utilizzare`create-vpc-endpoint`.
**AWS CLI**
**Esempio 1: come creare un endpoint del gateway**
L’esempio `create-vpc-endpoint` seguente crea un endpoint VPC del gateway tra il VPC `vpc-1a2b3c4d` e Amazon S3 nella Regione `us-east-1` e associa la tabella di routing `rtb-11aa22bb` all’endpoint.
```
aws ec2 create-vpc-endpoint \
--vpc-id vpc-1a2b3c4d \
--service-name com.amazonaws.us-east-1.s3 \
--route-table-ids rtb-11aa22bb
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Creare un endpoint gateway](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-s3.html#create-gateway-endpoint-s3) nella *Guida per l'AWS PrivateLink utente*.
**Esempio 2: come creare un endpoint dell’interfaccia**
L’esempio `create-vpc-endpoint` seguente crea un endpoint VPC dell’interfaccia tra il VPC `vpc-1a2b3c4d` e Amazon S3 nella Regione `us-east-1`. Il comando crea l’endpoint nella sottorete `subnet-1a2b3c4d`, lo associa al gruppo di sicurezza `sg-1a2b3c4d` e aggiunge un tag con la chiave “Service” e il valore di “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}]
```
Output:
```
{
"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"
}
}
```
*Per ulteriori informazioni, consulta [Creare un endpoint VPC di interfaccia](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html) nella Guida per l'AWS PrivateLink utente.*
**Esempio 3: come creare un endpoint Gateway Load Balancer**
L’esempio `create-vpc-endpoint` seguente crea un endpoint Gateway Load Balancer tra il VPC `vpc-111122223333aabbc` e un servizio configurato tramite un Gateway Load Balancer.
```
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
```
Output:
```
{
"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"
}
}
```
*Per ulteriori informazioni, consulta gli [endpoint Gateway Load Balancer](https://docs.aws.amazon.com/vpc/latest/privatelink/gateway-load-balancer-endpoints.html) nella Guida per l'AWS PrivateLink utente.*
**Esempio 4: come creare un endpoint della risorsa**
L’esempio `create-vpc-endpoint` seguente crea un endpoint delle risorse.
```
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
```
Output:
```
{
"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"
}
}
```
*Per ulteriori informazioni, consulta [Resource endpoints nella Guida](https://docs.aws.amazon.com/vpc/latest/privatelink/privatelink-access-resources.html) per l'AWS PrivateLink utente.*
**Esempio 5: come creare un endpoint della rete di servizi**
L’esempio `create-vpc-endpoint` seguente crea un endpoint della rete di servizi.
```
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
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Service Network Endpoints nella Guida](https://docs.aws.amazon.com/vpc/latest/privatelink/privatelink-access-service-networks.html) per l'*AWS PrivateLink utente*.
+ Per i dettagli sull'API, consulta [CreateVpcEndpoint AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html)*Command Reference.*
### `create-vpc-peering-connection`
Il seguente esempio di codice mostra come utilizzare`create-vpc-peering-connection`.
**AWS CLI**
**Per creare una connessione peering VPC tra i tuoi VPCs**
Questo esempio richiede una connessione peering tra vpc-1a2b3c4d e VPCs vpc-11122233.
Comando:
```
aws ec2 create-vpc-peering-connection --vpc-id vpc-1a2b3c4d --peer-vpc-id vpc-11122233
```
Output:
```
{
"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"
}
}
}
```
**Come creare una connessione peering VPC a un VPC in un altro account**
Questo esempio richiede una connessione peering tra il tuo VPC (vpc-1a2b3c4d) e un VPC (vpc-11122233) che appartiene all'account 123456789012. AWS
Comando:
```
aws ec2 create-vpc-peering-connection --vpc-id vpc-1a2b3c4d --peer-vpc-id vpc-11122233 --peer-owner-id 123456789012
```
**Come creare una connessione peering VPC a un VPC in un’altra Regione**
Questo esempio richiede una connessione peering tra il VPC nella Regione corrente (vpc-1a2b3c4d) e un VPC (vpc-11122233) nell’account nella Regione `us-west-2`.
Comando:
```
aws ec2 create-vpc-peering-connection --vpc-id vpc-1a2b3c4d --peer-vpc-id vpc-11122233 --peer-region us-west-2
```
Questo esempio richiede una connessione peering tra il tuo VPC nella regione corrente (vpc-1a2b3c4d) e un VPC (vpc-11122233) che appartiene all'account 123456789012 che si trova nella regione. 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
```
+ Per [CreateVpcPeeringConnection](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-peering-connection.html)*i AWS CLI dettagli* sull'API, consulta Command Reference.
### `create-vpc`
Il seguente esempio di codice mostra come utilizzare`create-vpc`.
**AWS CLI**
**Esempio 1: come creare un VPC**
L'`create-vpc`esempio seguente crea un VPC con il blocco IPv4 CIDR specificato e un tag Name.
```
aws ec2 create-vpc \
--cidr-block 10.0.0.0/16 \
--tag-specifications ResourceType=vpc,Tags=[{Key=Name,Value=MyVpc}]
```
Output:
```
{
"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"
}
]
}
}
```
**Esempio 2: come creare un VPC con tenancy dedicata**
L'`create-vpc`esempio seguente crea un VPC con il blocco IPv4 CIDR specificato e una tenancy dedicata.
```
aws ec2 create-vpc \
--cidr-block 10.0.0.0/16 \
--instance-tenancy dedicated
```
Output:
```
{
"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
}
}
```
**Esempio 3: creare un VPC con un IPv6 blocco CIDR**
L'`create-vpc`esempio seguente crea un VPC con un blocco CIDR fornito da Amazon IPv6 .
```
aws ec2 create-vpc \
--cidr-block 10.0.0.0/16 \
--amazon-provided-ipv6-cidr-block
```
Output:
```
{
"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
}
}
```
**Esempio 4: come creare un VPC con un CIDR di un pool IPAM**
Nell’esempio di `create-vpc` seguente viene creato un VPC con un CIDR di un pool di Gestione indirizzi IP (IPAM) di 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"}]
```
Output:
```
{
"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"
}
]
}
}
```
Per ulteriori informazioni, consulta [Creare un VPC che utilizza un CIDR del pool IPAM](https://docs.aws.amazon.com/vpc/latest/ipam/create-vpc-ipam.html) nella *Guida per l’utente di Amazon VPC IPAM*.
+ *Per i dettagli sull'API, consulta [CreateVpc](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc.html)Command Reference.AWS CLI *
### `create-vpn-connection-route`
Il seguente esempio di codice mostra come utilizzare`create-vpn-connection-route`.
**AWS CLI**
**Come creare una route statica per una connessione VPN**
Questo esempio crea una route statica per la connessione VPN specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 create-vpn-connection-route --vpn-connection-id vpn-40f41529 --destination-cidr-block 11.12.0.0/16
```
+ Per i dettagli sull'API, consulta [CreateVpnConnectionRoute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpn-connection-route.html)*Command Reference*.
### `create-vpn-connection`
Il seguente esempio di codice mostra come utilizzare`create-vpn-connection`.
**AWS CLI**
**Esempio 1: come creare una connessione VPN con routing dinamico**
L’esempio `create-vpn-connection` seguente crea una connessione VPN tra il gateway privato virtuale e il gateway del cliente specificati e applica i tag alla connessione VPN. L’output include le informazioni di configurazione per il dispositivo del gateway del cliente, in 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}]'
```
Output:
```
{
"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"
}
]
}
}
```
Per ulteriori informazioni, consulta [Come funziona la AWS Site-to-Site VPN](https://docs.aws.amazon.com/vpn/latest/s2svpn/how_it_works.html) nella *Guida per l'utente della AWS Site-to-Site VPN*.
**Esempio 2: come creare una connessione VPN con routing statico**
L’esempio `create-vpn-connection` seguente crea una connessione VPN tra il gateway privato virtuale e il gateway del cliente specificati. Le opzioni specificano il routing statico. L’output include le informazioni di configurazione per il dispositivo del gateway del cliente, in formato XML.
```
aws ec2 create-vpn-connection \
--type ipsec.1 \
--customer-gateway-id cgw-001122334455aabbc \
--vpn-gateway-id vgw-1a1a1a1a1a1a2b2b2 \
--options "{\"StaticRoutesOnly\":true}"
```
Output:
```
{
"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": []
}
}
```
Per ulteriori informazioni, consulta [Come funziona la AWS Site-to-Site VPN](https://docs.aws.amazon.com/vpn/latest/s2svpn/how_it_works.html) nella *Guida per l'utente della AWS Site-to-Site VPN*.
**Esempio 3: come creare una connessione VPN e specificare il CIDR interno e la chiave precondivisa**
L’esempio `create-vpn-connection` seguente crea una connessione VPN e specifica l’intervallo CIDR interno degli indirizzi IP e una chiave pre-condivisa personalizzata per ogni tunnel. I valori specificati vengono restituiti nelle informazioni `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}]'
```
Output:
```
{
"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": []
}
}
```
Per ulteriori informazioni, consulta [Come funziona la AWS Site-to-Site VPN](https://docs.aws.amazon.com/vpn/latest/s2svpn/how_it_works.html) nella *Guida per l'utente della AWS Site-to-Site VPN*.
**Esempio 4: creare una connessione VPN che supporti IPv6 il traffico**
L'`create-vpn-connection`esempio seguente crea una connessione VPN che supporta il IPv6 traffico tra il gateway di transito specificato e il gateway del cliente specificato. Le opzioni di tunnel per entrambi i tunnel specificano che AWS deve avviare la negoziazione 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}]
```
Output:
```
{
"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": []
}
}
```
*Per ulteriori informazioni, consulta [Come funziona la AWS Site-to-Site VPN](https://docs.aws.amazon.com/vpn/latest/s2svpn/how_it_works.html) nella Guida per l'utente della AWS Site-to-Site VPN.*
+ Per i dettagli sull'API, consulta [CreateVpnConnection AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpn-connection.html)*Command Reference*.
### `create-vpn-gateway`
Il seguente esempio di codice mostra come utilizzare`create-vpn-gateway`.
**AWS CLI**
**Come creare un gateway privato virtuale**
Questo esempio crea un gateway privato virtuale.
Comando:
```
aws ec2 create-vpn-gateway --type ipsec.1
```
Output:
```
{
"VpnGateway": {
"AmazonSideAsn": 64512,
"State": "available",
"Type": "ipsec.1",
"VpnGatewayId": "vgw-9a4cacf3",
"VpcAttachments": []
}
}
```
**Come creare un gateway privato virtuale con un ASN specifico per il lato Amazon**
Questo esempio crea un gateway privato virtuale e specifica l’Autonomous System Number (ASN) per il lato Amazon della sessione BGP.
Comando:
```
aws ec2 create-vpn-gateway --type ipsec.1 --amazon-side-asn 65001
```
Output:
```
{
"VpnGateway": {
"AmazonSideAsn": 65001,
"State": "available",
"Type": "ipsec.1",
"VpnGatewayId": "vgw-9a4cacf3",
"VpcAttachments": []
}
}
```
+ Per i dettagli sull'API, consulta [CreateVpnGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpn-gateway.html)*Command Reference*.
### `delete-carrier-gateway`
Il seguente esempio di codice mostra come utilizzare`delete-carrier-gateway`.
**AWS CLI**
**Come eliminare un gateway carrier**
L’esempio `delete-carrier-gateway` seguente elimina il gateway carrier specificato.
```
aws ec2 delete-carrier-gateway \
--carrier-gateway-id cagw-0465cdEXAMPLE1111
```
Output:
```
{
"CarrierGateway": {
"CarrierGatewayId": "cagw-0465cdEXAMPLE1111",
"VpcId": "vpc-0c529aEXAMPLE1111",
"State": "deleting",
"OwnerId": "123456789012"
}
}
```
Per ulteriori informazioni, consulta [Gateway carrier](https://docs.aws.amazon.com/vpc/latest/userguide/Carrier_Gateway.html) nella *Guida per l’utente di Amazon Virtual Private Cloud*.
+ Per i dettagli sull'API, consulta [DeleteCarrierGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-carrier-gateway.html)*Command Reference*.
### `delete-client-vpn-endpoint`
Il seguente esempio di codice mostra come utilizzare`delete-client-vpn-endpoint`.
**AWS CLI**
**Come eliminare un endpoint VPN Client**
L’esempio `delete-client-vpn-endpoint` seguente elimina l’endpoint VPN Client specificato.
```
aws ec2 delete-client-vpn-endpoint \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde
```
Output:
```
{
"Status": {
"Code": "deleting"
}
}
```
Per ulteriori informazioni, consulta [Endpoint Client VPN](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-endpoints.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [DeleteClientVpnEndpoint AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-client-vpn-endpoint.html)*Command Reference*.
### `delete-client-vpn-route`
Il seguente esempio di codice mostra come utilizzare`delete-client-vpn-route`.
**AWS CLI**
**Come eliminare una route di un endpoint VPN Client**
L’esempio `delete-client-vpn-route` seguente elimina la route `0.0.0.0/0` per la sottorete specificata di un endpoint VPN Client.
```
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
```
Output:
```
{
"Status": {
"Code": "deleting"
}
}
```
Per ulteriori informazioni, consulta [Route](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-routes.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [DeleteClientVpnRoute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-client-vpn-route.html)*Command Reference*.
### `delete-coip-cidr`
Il seguente esempio di codice mostra come utilizzare`delete-coip-cidr`.
**AWS CLI**
**Come eliminare un intervallo di indirizzi IP di proprietà del cliente (CoIP)**
L’esempio `delete-coip-cidr` seguente elimina l’intervallo specificato di indirizzi CoIP nel pool CoIP specificato.
```
aws ec2 delete-coip-cidr \
--cidr 14.0.0.0/24 \
--coip-pool-id ipv4pool-coip-1234567890abcdefg
```
Output:
```
{
"CoipCidr": {
"Cidr": "14.0.0.0/24",
"CoipPoolId": "ipv4pool-coip-1234567890abcdefg",
"LocalGatewayRouteTableId": "lgw-rtb-abcdefg1234567890"
}
}
```
Per ulteriori informazioni, consulta [Indirizzi IP di proprietà del cliente](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#ip-addressing) nella *Guida per l’utente di AWS Outposts*.
+ Per i dettagli sull'API, consulta [DeleteCoipCidr AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-coip-cidr.html)*Command Reference*.
### `delete-coip-pool`
Il seguente esempio di codice mostra come utilizzare`delete-coip-pool`.
**AWS CLI**
**Come eliminare un pool di indirizzi IP di proprietà del cliente (CoIP)**
L’esempio `delete-coip-pool` seguente elimina un pool CoIP di indirizzi CoIP.
```
aws ec2 delete-coip-pool \
--coip-pool-id ipv4pool-coip-1234567890abcdefg
```
Output:
```
{
"CoipPool": {
"PoolId": "ipv4pool-coip-1234567890abcdefg",
"LocalGatewayRouteTableId": "lgw-rtb-abcdefg1234567890",
"PoolArn": "arn:aws:ec2:us-west-2:123456789012:coip-pool/ipv4pool-coip-1234567890abcdefg"
}
}
```
Per ulteriori informazioni, consulta [Indirizzi IP di proprietà del cliente](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#ip-addressing) nella *Guida per l’utente di AWS Outposts*.
+ Per i dettagli sull'API, consulta [DeleteCoipPool AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-coip-pool.html)*Command Reference*.
### `delete-customer-gateway`
Il seguente esempio di codice mostra come utilizzare`delete-customer-gateway`.
**AWS CLI**
**Come eliminare un gateway del cliente**
Questo esempio elimina il gateway del cliente specificato. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-customer-gateway --customer-gateway-id cgw-0e11f167
```
+ Per i dettagli sull'API, consulta [DeleteCustomerGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-customer-gateway.html)*Command Reference*.
### `delete-dhcp-options`
Il seguente esempio di codice mostra come utilizzare`delete-dhcp-options`.
**AWS CLI**
**Come eliminare un set di opzioni DHCP**
Questo esempio elimina il set di opzioni DHCP specificato. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-dhcp-options --dhcp-options-id dopt-d9070ebb
```
+ Per i dettagli sull'API, consulta [DeleteDhcpOptions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-dhcp-options.html)*Command Reference*.
### `delete-egress-only-internet-gateway`
Il seguente esempio di codice mostra come utilizzare`delete-egress-only-internet-gateway`.
**AWS CLI**
**Come eliminare un gateway Internet di sola uscita**
Questo esempio elimina il gateway Internet di sola uscita specificato.
Comando:
```
aws ec2 delete-egress-only-internet-gateway --egress-only-internet-gateway-id eigw-01eadbd45ecd7943f
```
Output:
```
{
"ReturnCode": true
}
```
+ Per i dettagli sull'API, consulta [DeleteEgressOnlyInternetGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-egress-only-internet-gateway.html)*Command Reference*.
### `delete-fleets`
Il seguente esempio di codice mostra come utilizzare`delete-fleets`.
**AWS CLI**
**Esempio 1: come eliminare un parco EC2 e terminare le istanze associate**
L’esempio `delete-fleets` seguente elimina il parco EC2 specificato e termina le istanze on demand e le istanze spot associate.
```
aws ec2 delete-fleets \
--fleet-ids fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE \
--terminate-instances
```
Output:
```
{
"SuccessfulFleetDeletions": [
{
"CurrentFleetState": "deleted_terminating",
"PreviousFleetState": "active",
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE"
}
],
"UnsuccessfulFleetDeletions": []
}
```
Per ulteriori informazioni, consulta [Eliminazione di un parco EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html#delete-fleet) nella *Guida per l’utente di Amazon Elastic Compute Cloud per le istanze Linux*.
**Esempio 2: come eliminare un parco EC2 e terminare le istanze associate**
L’esempio `delete-fleets` seguente elimina il parco EC2 specificato senza terminare le istanze on demand e le istanze spot associate.
```
aws ec2 delete-fleets \
--fleet-ids fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE \
--no-terminate-instances
```
Output:
```
{
"SuccessfulFleetDeletions": [
{
"CurrentFleetState": "deleted_running",
"PreviousFleetState": "active",
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE"
}
],
"UnsuccessfulFleetDeletions": []
}
```
Per ulteriori informazioni, consulta [Eliminazione di un parco EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html#delete-fleet) nella *Guida per l’utente di Amazon Elastic Compute Cloud per le istanze Linux*.
+ Per i dettagli sull'API, consulta [DeleteFleets AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-fleets.html)*Command Reference*.
### `delete-flow-logs`
Il seguente esempio di codice mostra come utilizzare`delete-flow-logs`.
**AWS CLI**
**Come eliminare un log di flusso**
L’esempio `delete-flow-logs` seguente elimina il log di flusso specificato.
```
aws ec2 delete-flow-logs --flow-log-id fl-11223344556677889
```
Output:
```
{
"Unsuccessful": []
}
```
+ Per i dettagli sull'API, consulta [DeleteFlowLogs AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-flow-logs.html)*Command Reference*.
### `delete-fpga-image`
Il seguente esempio di codice mostra come utilizzare`delete-fpga-image`.
**AWS CLI**
**Come eliminare un’immagine FPGA di Amazon (AFI)**
Questo esempio elimina l’AFI specificata.
Comando:
```
aws ec2 delete-fpga-image --fpga-image-id afi-06b12350a123fbabc
```
Output:
```
{
"Return": true
}
```
+ Per i dettagli sull'API, consulta [DeleteFpgaImage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-fpga-image.html)*Command Reference*.
### `delete-instance-connect-endpoint`
Il seguente esempio di codice mostra come utilizzare`delete-instance-connect-endpoint`.
**AWS CLI**
**Come eliminare un endpoint EC2 Instance Connect**
L’esempio `delete-instance-connect-endpoint` seguente elimina l’endpoint EC2 Instance Connect specificato.
```
aws ec2 delete-instance-connect-endpoint \
--instance-connect-endpoint-id eice-03f5e49b83924bbc7
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Rimozione dell’endpoint EC2 Instance Connect](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/delete-ec2-instance-connect-endpoint.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DeleteInstanceConnectEndpoint AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-instance-connect-endpoint.html)*Command Reference*.
### `delete-instance-event-window`
Il seguente esempio di codice mostra come utilizzare`delete-instance-event-window`.
**AWS CLI**
**Esempio 1: come eliminare una finestra di eventi**
L’esempio `delete-instance-event-window` seguente elimina una finestra di eventi.
```
aws ec2 delete-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890
```
Output:
```
{
"InstanceEventWindowState": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"State": "deleting"
}
}
```
Per i vincoli relativi alla finestra di eventi, consulta [Considerazioni](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) nella sezione Eventi pianificati della *Guida per l’utente di Amazon EC2*.
**Esempio 2: come forzare l’eliminazione di una finestra di eventi**
L’esempio `delete-instance-event-window` seguente forza l’eliminazione di una finestra di eventi se la finestra di eventi è attualmente associata a destinazioni.
```
aws ec2 delete-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890 \
--force-delete
```
Output:
```
{
"InstanceEventWindowState": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"State": "deleting"
}
}
```
Per i vincoli relativi alla finestra di eventi, consulta [Considerazioni](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) nella sezione Eventi pianificati della *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DeleteInstanceEventWindow AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-instance-event-window.html)*Command Reference*.
### `delete-internet-gateway`
Il seguente esempio di codice mostra come utilizzare`delete-internet-gateway`.
**AWS CLI**
**Come eliminare un gateway Internet**
L’esempio `delete-internet-gateway` seguente elimina il gateway Internet specificato.
```
aws ec2 delete-internet-gateway \
--internet-gateway-id igw-0d0fb496b3EXAMPLE
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Gateway Internet](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [DeleteInternetGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-internet-gateway.html)*Command Reference*.
### `delete-ipam-pool`
Il seguente esempio di codice mostra come utilizzare`delete-ipam-pool`.
**AWS CLI**
**Come eliminare un pool IPAM**
In questo esempio, l’utente è un amministratore delegato IPAM che desidera eliminare un pool IPAM che non è più necessario, ma al pool è stato assegnato un CIDR. Non è possibile eliminare un pool se ne è stato CIDRs fornito il provisioning a meno che non si utilizzi l'`--cascade`opzione, quindi la `--cascade` userete.
Per completare questa richiesta:
Avrai bisogno dell'ID del pool IPAM con cui puoi ottenere [describe-ipam-pools](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-ipam-pools.html). `--region` Deve essere la regione di origine IPAM.
L'`delete-ipam-pool`esempio seguente elimina un pool IPAM nel tuo account. AWS
```
aws ec2 delete-ipam-pool \
--ipam-pool-id ipam-pool-050c886a3ca41cd5b \
--cascade \
--region us-east-1
```
Output:
```
{
"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
}
}
```
Per ulteriori informazioni, consulta [Eliminare un pool](https://docs.aws.amazon.com/vpc/latest/ipam/delete-pool-ipam.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [DeleteIpamPool](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-ipam-pool.html)Reference*.
### `delete-ipam-resource-discovery`
Il seguente esempio di codice mostra come utilizzare`delete-ipam-resource-discovery`.
**AWS CLI**
**Come eliminare un’individuazione delle risorse**
In questo esempio, un amministratore delegato IPAM desidera eliminare un rilevamento di risorse non predefinito creato per la condivisione con un altro amministratore IPAM durante il processo di integrazione IPAM con account esterni all’organizzazione.
Per completare questa richiesta:
`--region` deve essere la Regione in cui è stato creato il rilevamento di risorse. Non è possibile eliminare un rilevamento di risorse predefinito se `"IsDefault": true`. Un rilevamento di risorse predefinito viene creato automaticamente quando si crea un’IPAM. Per eliminare un rilevamento di risorse predefinito, è necessario eliminare l’IPAM.
L’esempio `delete-ipam-resource-discovery` seguente elimina un rilevamento di risorse.
```
aws ec2 delete-ipam-resource-discovery \
--ipam-resource-discovery-id ipam-res-disco-0e39761475298ee0f \
--region us-east-1
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni sui rilevamenti delle risorse, consulta [Lavorare con il rilevamento delle risorse](https://docs.aws.amazon.com/vpc/latest/ipam/res-disc-work-with.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta [DeleteIpamResourceDiscovery AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-ipam-resource-discovery.html)*Command Reference*.
### `delete-ipam-scope`
Il seguente esempio di codice mostra come utilizzare`delete-ipam-scope`.
**AWS CLI**
**Come eliminare un ambito IPAM**
L’esempio `delete-ipam-scope` seguente elimina un’IPAM.
```
aws ec2 delete-ipam-scope \
--ipam-scope-id ipam-scope-01c1ebab2b63bd7e4
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Eliminare un ambito](https://docs.aws.amazon.com/vpc/latest/ipam/delete-scope-ipam.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta [DeleteIpamScope AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-ipam-scope.html)*Command Reference*.
### `delete-ipam`
Il seguente esempio di codice mostra come utilizzare`delete-ipam`.
**AWS CLI**
**Come eliminare un IPAM**
L’esempio `delete-ipam` seguente elimina un’IPAM.
```
aws ec2 delete-ipam \
--ipam-id ipam-036486dfa6af58ee0
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Eliminare un IPAM](https://docs.aws.amazon.com/vpc/latest/ipam/delete-ipam.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta [DeleteIpam AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-ipam.html)*Command Reference*.
### `delete-key-pair`
Il seguente esempio di codice mostra come utilizzare`delete-key-pair`.
**AWS CLI**
**Come eliminare una coppia di chiavi**
L’esempio `delete-key-pair` seguente elimina la coppia di chiavi specificata.
```
aws ec2 delete-key-pair \
--key-name my-key-pair
```
Output:
```
{
"Return": true,
"KeyPairId": "key-03c8d3aceb53b507"
}
```
Per ulteriori informazioni, consulta [Create and delete key pairs](https://docs.aws.amazon.com/cli/latest/userguide/cli-ec2-keypairs.html) nella *Guida per l’utente dell’Interfaccia a riga di comando AWS *.
+ Per i dettagli sull'API, consulta [DeleteKeyPair AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-key-pair.html)*Command Reference*.
### `delete-launch-template-versions`
Il seguente esempio di codice mostra come utilizzare`delete-launch-template-versions`.
**AWS CLI**
**Come eliminare una versione del modello di avvio**
Questo esempio elimina la versione del modello di avvio specificato.
Comando:
```
aws ec2 delete-launch-template-versions --launch-template-id lt-0abcd290751193123 --versions 1
```
Output:
```
{
"UnsuccessfullyDeletedLaunchTemplateVersions": [],
"SuccessfullyDeletedLaunchTemplateVersions": [
{
"LaunchTemplateName": "TestVersion",
"VersionNumber": 1,
"LaunchTemplateId": "lt-0abcd290751193123"
}
]
}
```
+ Per i dettagli sull'API, consulta [DeleteLaunchTemplateVersions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-launch-template-versions.html)*Command Reference*.
### `delete-launch-template`
Il seguente esempio di codice mostra come utilizzare`delete-launch-template`.
**AWS CLI**
**Come eliminare un modello di avvio**
In questo esempio viene eliminato il modello di avvio specificato.
Comando:
```
aws ec2 delete-launch-template --launch-template-id lt-0abcd290751193123
```
Output:
```
{
"LaunchTemplate": {
"LatestVersionNumber": 2,
"LaunchTemplateId": "lt-0abcd290751193123",
"LaunchTemplateName": "TestTemplate",
"DefaultVersionNumber": 2,
"CreatedBy": "arn:aws:iam::123456789012:root",
"CreateTime": "2017-11-23T16:46:25.000Z"
}
}
```
+ Per i dettagli sull'API, consulta [DeleteLaunchTemplate AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-launch-template.html)*Command Reference*.
### `delete-local-gateway-route-table-virtual-interface-group-association`
Il seguente esempio di codice mostra come utilizzare`delete-local-gateway-route-table-virtual-interface-group-association`.
**AWS CLI**
**Per dissociare una tabella di routing del gateway locale da un gruppo di interfacce virtuali () VIFs**
L’esempio `delete-local-gateway-route-table-virtual-interface-group-association` seguente elimina l’associazione tra la tabella di routing del gateway locale specificata e il gruppo 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
```
Output:
```
{
"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": []
}
}
```
Per ulteriori informazioni, consulta [Associazioni di gruppi VIF](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#vif-group-associations) nella *Guida per l’utente di AWS Outposts*.
+ Per i dettagli sull'API, vedere [DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-local-gateway-route-table-virtual-interface-group-association.html)in *AWS CLI Command Reference*.
### `delete-local-gateway-route-table-vpc-association`
Il seguente esempio di codice mostra come utilizzare`delete-local-gateway-route-table-vpc-association`.
**AWS CLI**
**Come dissociare una tabella di routing del gateway locale da un VPC**
L’esempio `delete-local-gateway-route-table-vpc-association` seguente elimina l’associazione tra la tabella di routing del gateway locale e il VPC.
```
aws ec2 delete-local-gateway-route-table-vpc-association \
--local-gateway-route-table-vpc-association-id vpc-example0123456789
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Associazioni VPC](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#vpc-associations) nella *Guida per l’utente di AWS Outposts*.
+ Per i dettagli sull'API, consulta [DeleteLocalGatewayRouteTableVpcAssociation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-local-gateway-route-table-vpc-association.html)*Command Reference*.
### `delete-local-gateway-route-table`
Il seguente esempio di codice mostra come utilizzare`delete-local-gateway-route-table`.
**AWS CLI**
**Come eliminare una tabella di routing del gateway locale**
L’esempio `delete-local-gateway-route-table` seguente crea una tabella di routing del gateway locale con la modalità di routing VPC diretta.
```
aws ec2 delete-local-gateway-route-table \
--local-gateway-route-table-id lgw-rtb-abcdefg1234567890
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Tabelle di routing del gateway locale](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html) nella *Guida per l’utente di AWS Outposts*.
+ Per i dettagli sull'API, consulta [DeleteLocalGatewayRouteTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-local-gateway-route-table.html)*Command Reference*.
### `delete-local-gateway-route`
Il seguente esempio di codice mostra come utilizzare`delete-local-gateway-route`.
**AWS CLI**
**Come eliminare una route da una tabella di routing del gateway locale**
L’esempio `delete-local-gateway-route` seguente elimina la route specificata dalla tabella di routing del gateway locale specificata.
```
aws ec2 delete-local-gateway-route \
--destination-cidr-block 0.0.0.0/0 \
--local-gateway-route-table-id lgw-rtb-059615ef7dEXAMPLE
```
Output:
```
{
"Route": {
"DestinationCidrBlock": "0.0.0.0/0",
"LocalGatewayVirtualInterfaceGroupId": "lgw-vif-grp-07145b276bEXAMPLE",
"Type": "static",
"State": "deleted",
"LocalGatewayRouteTableId": "lgw-rtb-059615ef7EXAMPLE"
}
}
```
+ Per i dettagli sull'API, consulta [DeleteLocalGatewayRoute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-local-gateway-route.html)*Command Reference*.
### `delete-managed-prefix-list`
Il seguente esempio di codice mostra come utilizzare`delete-managed-prefix-list`.
**AWS CLI**
**Come eliminare un elenco di prefissi**
L’esempio `delete-managed-prefix-list` seguente elimina l’elenco di prefissi specificato.
```
aws ec2 delete-managed-prefix-list \
--prefix-list-id pl-0123456abcabcabc1
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Elenchi di prefissi gestiti](https://docs.aws.amazon.com/vpc/latest/userguide/managed-prefix-lists.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [DeleteManagedPrefixList AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-managed-prefix-list.html)*Command Reference*.
### `delete-nat-gateway`
Il seguente esempio di codice mostra come utilizzare`delete-nat-gateway`.
**AWS CLI**
**Come eliminare un gateway NAT**
Questo esempio elimina il gateway NAT `nat-04ae55e711cec5680`.
Comando:
```
aws ec2 delete-nat-gateway --nat-gateway-id nat-04ae55e711cec5680
```
Output:
```
{
"NatGatewayId": "nat-04ae55e711cec5680"
}
```
+ Per i dettagli sull'API, consulta [DeleteNatGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-nat-gateway.html)*Command Reference*.
### `delete-network-acl-entry`
Il seguente esempio di codice mostra come utilizzare`delete-network-acl-entry`.
**AWS CLI**
**Come eliminare una voce della lista di controllo degli accessi alla rete (ACL)**
Questo esempio elimina la regola di ingresso numero 100 dalla lista di controllo degli accessi alla rete (ACL) specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-network-acl-entry --network-acl-id acl-5fb85d36 --ingress --rule-number 100
```
+ Per i dettagli sull'API, consulta [DeleteNetworkAclEntry AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-network-acl-entry.html)*Command Reference*.
### `delete-network-acl`
Il seguente esempio di codice mostra come utilizzare`delete-network-acl`.
**AWS CLI**
**Come eliminare una lista di controllo degli accessi alla rete (ACL)**
Questo esempio elimina la lista di controllo degli accessi alla rete (ACL) specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-network-acl --network-acl-id acl-5fb85d36
```
+ Per i dettagli sull'API, consulta [DeleteNetworkAcl AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-network-acl.html)*Command Reference*.
### `delete-network-insights-access-scope-analysis`
Il seguente esempio di codice mostra come utilizzare`delete-network-insights-access-scope-analysis`.
**AWS CLI**
**Come eliminare un’analisi di ambito di accesso alla rete**
L’esempio `delete-network-insights-access-scope-analysis` seguente elimina l’analisi di ambito di accesso alla rete specificata.
```
aws ec2 delete-network-insights-access-scope-analysis \
--network-insights-access-scope-analysis-id nisa-01234567891abcdef
```
Output:
```
{
"NetworkInsightsAccessScopeAnalysisId": "nisa-01234567891abcdef
}
```
Per ulteriori informazioni, consulta [Guida introduttiva a Network Access Analyzer utilizzando la AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli.html) *nella Guida Network Access* Analyzer.
+ *Per i dettagli sull'API, consulta Command [DeleteNetworkInsightsAccessScopeAnalysis](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-network-insights-access-scope-analysis.html)Reference AWS CLI .*
### `delete-network-insights-access-scope`
Il seguente esempio di codice mostra come utilizzare`delete-network-insights-access-scope`.
**AWS CLI**
**Come eliminare un ambito di accesso alla rete**
L’esempio `delete-network-insights-access-scope` seguente elimina l’analisi di ambito di accesso alla rete specificata.
```
aws ec2 delete-network-insights-access-scope \
--network-insights-access-scope-id nis-123456789abc01234
```
Output:
```
{
"NetworkInsightsAccessScopeId": "nis-123456789abc01234"
}
```
Per ulteriori informazioni, consulta [Guida introduttiva a Network Access Analyzer utilizzando la AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli.html) *nella Guida Network Access* Analyzer.
+ *Per i dettagli sull'API, consulta Command [DeleteNetworkInsightsAccessScope](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-network-insights-access-scope.html)Reference AWS CLI .*
### `delete-network-insights-analysis`
Il seguente esempio di codice mostra come utilizzare`delete-network-insights-analysis`.
**AWS CLI**
**Come eliminare un’analisi del percorso**
L’esempio `delete-network-insights-analysis` seguente elimina l’analisi specificata.
```
aws ec2 delete-network-insights-analysis \
--network-insights-analysis-id nia-02207aa13eb480c7a
```
Output:
```
{
"NetworkInsightsAnalysisId": "nia-02207aa13eb480c7a"
}
```
Per ulteriori informazioni, consulta [Guida introduttiva all'uso della AWS CLI](https://docs.aws.amazon.com/vpc/latest/reachability/getting-started-cli.html) nella Reachability *Analyzer Guide*.
+ *Per i dettagli sull'API, consulta Command [DeleteNetworkInsightsAnalysis](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-network-insights-analysis.html)Reference AWS CLI .*
### `delete-network-insights-path`
Il seguente esempio di codice mostra come utilizzare`delete-network-insights-path`.
**AWS CLI**
**Come eliminare un percorso**
L’esempio `delete-network-insights-path` seguente elimina il percorso specificato. Prima di poter eliminare un percorso, è necessario eliminare tutte le relative analisi utilizzando il comando `delete-network-insights-analysis`.
```
aws ec2 delete-network-insights-path \
--network-insights-path-id nip-0b26f224f1d131fa8
```
Output:
```
{
"NetworkInsightsPathId": "nip-0b26f224f1d131fa8"
}
```
Per ulteriori informazioni, consulta [Guida introduttiva all'uso della AWS CLI](https://docs.aws.amazon.com/vpc/latest/reachability/getting-started-cli.html) nella Reachability *Analyzer Guide*.
+ *Per i dettagli sull'API, consulta Command [DeleteNetworkInsightsPath](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-network-insights-path.html)Reference AWS CLI .*
### `delete-network-interface-permission`
Il seguente esempio di codice mostra come utilizzare`delete-network-interface-permission`.
**AWS CLI**
**Come eliminare l’autorizzazione di un’interfaccia di rete**
Questo esempio elimina l’autorizzazione dell’interfaccia di rete specificata.
Comando:
```
aws ec2 delete-network-interface-permission --network-interface-permission-id eni-perm-06fd19020ede149ea
```
Output:
```
{
"Return": true
}
```
+ Per i dettagli sull'API, consulta [DeleteNetworkInterfacePermission AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-network-interface-permission.html)*Command Reference*.
### `delete-network-interface`
Il seguente esempio di codice mostra come utilizzare`delete-network-interface`.
**AWS CLI**
**Come eliminare un’interfaccia di rete**
Questo esempio elimina l’interfaccia di rete specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-network-interface --network-interface-id eni-e5aa89a3
```
+ Per i dettagli sull'API, consulta [DeleteNetworkInterface AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-network-interface.html)*Command Reference*.
### `delete-placement-group`
Il seguente esempio di codice mostra come utilizzare`delete-placement-group`.
**AWS CLI**
**Come eliminare un gruppo di posizionamento**
Questo comando di esempio elimina il gruppo di posizionamento specificato.
Comando:
```
aws ec2 delete-placement-group --group-name my-cluster
```
+ Per i dettagli sull'API, consulta [DeletePlacementGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-placement-group.html)*Command Reference*.
### `delete-queued-reserved-instances`
Il seguente esempio di codice mostra come utilizzare`delete-queued-reserved-instances`.
**AWS CLI**
**Come eliminare un acquisto in coda**
L’esempio `delete-queued-reserved-instances` seguente elimina l’istanza riservata specificata, che era in coda per l’acquisto.
```
aws ec2 delete-queued-reserved-instances \
--reserved-instances-ids af9f760e-6f91-4559-85f7-4980eexample
```
Output:
```
{
"SuccessfulQueuedPurchaseDeletions": [
{
"ReservedInstancesId": "af9f760e-6f91-4559-85f7-4980eexample"
}
],
"FailedQueuedPurchaseDeletions": []
}
```
+ Per i dettagli sull'API, consulta [DeleteQueuedReservedInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-queued-reserved-instances.html)*Command Reference*.
### `delete-route-table`
Il seguente esempio di codice mostra come utilizzare`delete-route-table`.
**AWS CLI**
**Come eliminare una tabella di routing**
Questo esempio elimina la tabella di routing specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-route-table --route-table-id rtb-22574640
```
+ Per i dettagli sull'API, consulta [DeleteRouteTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-route-table.html)*Command Reference*.
### `delete-route`
Il seguente esempio di codice mostra come utilizzare`delete-route`.
**AWS CLI**
**Come eliminare una route**
Questo esempio elimina la route specificata dalla tabella di routing specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-route --route-table-id rtb-22574640 --destination-cidr-block 0.0.0.0/0
```
+ Per i dettagli sull'API, consulta [DeleteRoute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-route.html)*Command Reference*.
### `delete-security-group`
Il seguente esempio di codice mostra come utilizzare`delete-security-group`.
**AWS CLI**
**[EC2-Classic] Come eliminare un gruppo di sicurezza**
In questo esempio viene eliminato il gruppo di sicurezza denominato `MySecurityGroup`. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-security-group --group-name MySecurityGroup
```
**[EC2-VPC] Come eliminare un gruppo di sicurezza**
In questo esempio viene eliminato il gruppo di sicurezza con ID `sg-903004f8`. Non è possibile fare riferimento a un gruppo di sicurezza per EC2-VPC utilizzando il nome. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-security-group --group-id sg-903004f8
```
Per ulteriori informazioni, consulta Utilizzo dei gruppi di sicurezza nella *Guida per l’utente dell’Interfaccia a riga di comando AWS *.
+ Per i dettagli sull'API, consulta [DeleteSecurityGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-security-group.html)*Command Reference*.
### `delete-snapshot`
Il seguente esempio di codice mostra come utilizzare`delete-snapshot`.
**AWS CLI**
**Come eliminare uno snapshot**
Questo comando di esempio elimina uno snapshot con ID `snap-1234567890abcdef0`. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-snapshot --snapshot-id snap-1234567890abcdef0
```
+ Per i dettagli sull'API, consulta [DeleteSnapshot AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-snapshot.html)*Command Reference*.
### `delete-spot-datafeed-subscription`
Il seguente esempio di codice mostra come utilizzare`delete-spot-datafeed-subscription`.
**AWS CLI**
**Come annullare una sottoscrizione al feed di dati di un’istanza spot**
Questo comando di esempio elimina una sottoscrizione al feed di dati spot per l’account. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-spot-datafeed-subscription
```
+ Per i dettagli sull'API, consulta [DeleteSpotDatafeedSubscription AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-spot-datafeed-subscription.html)*Command Reference*.
### `delete-subnet-cidr-reservation`
Il seguente esempio di codice mostra come utilizzare`delete-subnet-cidr-reservation`.
**AWS CLI**
**Come eliminare una prenotazione CIDR della sottorete**
L’esempio `delete-subnet-cidr-reservation` seguente elimina la prenotazione CIDR della sottorete specificata.
```
aws ec2 delete-subnet-cidr-reservation \
--subnet-cidr-reservation-id scr-044f977c4eEXAMPLE
```
Output:
```
{
"DeletedSubnetCidrReservation": {
"SubnetCidrReservationId": "scr-044f977c4eEXAMPLE",
"SubnetId": "subnet-03c51e2e6cEXAMPLE",
"Cidr": "10.1.0.16/28",
"ReservationType": "prefix",
"OwnerId": "123456789012"
}
}
```
Per ulteriori informazioni, consulta [Prenotazioni della CIDR per la sottorete](https://docs.aws.amazon.com/vpc/latest/userguide/subnet-cidr-reservation.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [DeleteSubnetCidrReservation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-subnet-cidr-reservation.html)*Command Reference*.
### `delete-subnet`
Il seguente esempio di codice mostra come utilizzare`delete-subnet`.
**AWS CLI**
**Come eliminare una sottorete**
Questo esempio elimina la sottorete specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-subnet --subnet-id subnet-9d4a7b6c
```
+ Per i dettagli sull'API, consulta [DeleteSubnet AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-subnet.html)*Command Reference*.
### `delete-tags`
Il seguente esempio di codice mostra come utilizzare`delete-tags`.
**AWS CLI**
**Esempio 1: come eliminare un tag da una risorsa**
L’esempio `delete-tags` seguente elimina il tag `Stack=Test` dall’immagine specificata. Quando vengono specificati sia un valore che un nome di chiave, il tag viene eliminato solo se il valore del tag corrisponde al valore specificato.
```
aws ec2 delete-tags \
--resources ami-1234567890abcdef0 \
--tags Key=Stack,Value=Test
```
È facoltativo specificare il valore per un tag. L’esempio `delete-tags` seguente elimina il tag con il nome della chiave `purpose` dall’istanza specificata, indipendentemente dal valore del tag.
```
aws ec2 delete-tags \
--resources i-1234567890abcdef0 \
--tags Key=purpose
```
Se come valore del tag viene specificata una stringa vuota, il tag viene eliminato solo se il relativo valore corrisponde alla stringa vuota. L’esempio `delete-tags` seguente specifica la stringa vuota come valore del tag da eliminare.
```
aws ec2 delete-tags \
--resources i-1234567890abcdef0 \
--tags Key=Name,Value=
```
**Esempio 2: come eliminare un tag da più risorse**
L’esempio `delete-tags` seguente elimina il tag ``Purpose=test`` sia da un’istanza che da un’AMI. Come mostrato nell’esempio precedente, è possibile omettere il valore del tag dal comando.
```
aws ec2 delete-tags \
--resources i-1234567890abcdef0 ami-1234567890abcdef0 \
--tags Key=Purpose
```
+ Per i dettagli sull'API, consulta [DeleteTags AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-tags.html)*Command Reference*.
### `delete-traffic-mirror-filter-rule`
Il seguente esempio di codice mostra come utilizzare`delete-traffic-mirror-filter-rule`.
**AWS CLI**
**Come eliminare una regola di filtro di mirroring del traffico**
L’esempio `delete-traffic-mirror-filter-rule` seguente elimina la regola di filtro di mirroring del traffico specificata.
```
aws ec2 delete-traffic-mirror-filter-rule \
--traffic-mirror-filter-rule-id tmfr-081f71283bEXAMPLE
```
Output:
```
{
"TrafficMirrorFilterRuleId": "tmfr-081f71283bEXAMPLE"
}
```
Per ulteriori informazioni, consulta [Modificare le regole di filtro del mirroring del traffico](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-filter.html#modify-traffic-mirroring-filter-rules) nella *Guida di Mirroring del traffico AWS *.
+ Per i dettagli sull'API, consulta [DeleteTrafficMirrorFilterRule AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-traffic-mirror-filter-rule.html)*Command Reference*.
### `delete-traffic-mirror-filter`
Il seguente esempio di codice mostra come utilizzare`delete-traffic-mirror-filter`.
**AWS CLI**
**Come eliminare un filtro del mirroring del traffico**
L’esempio `delete-traffic-mirror-filter` seguente elimina il filtro di mirroring del traffico specificato.
```
aws ec2 delete-traffic-mirror-filter \
--traffic-mirror-filter-id tmf-0be0b25fcdEXAMPLE
```
Output:
```
{
"TrafficMirrorFilterId": "tmf-0be0b25fcdEXAMPLE"
}
```
Per ulteriori informazioni, consulta [Eliminare un filtro del mirroring del traffico](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-filter.html#delete-traffic-mirroring-filter) nella *Guida di Mirroring del traffico AWS *.
+ Per i dettagli sull'API, consulta [DeleteTrafficMirrorFilter AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-traffic-mirror-filter.html)*Command Reference*.
### `delete-traffic-mirror-session`
Il seguente esempio di codice mostra come utilizzare`delete-traffic-mirror-session`.
**AWS CLI**
**Come eliminare una sessione di mirroring del traffico**
L’esempio `delete-traffic-mirror-session` seguente elimina la sessione di mirroring del traffico specificata.
```
aws ec2 delete-traffic-mirror-session \
--traffic-mirror-session-id tms-0af3141ce5EXAMPLE
```
Output:
```
{
"TrafficMirrorSessionId": "tms-0af3141ce5EXAMPLE"
}
```
Per ulteriori informazioni, consulta [Eliminare una sessione di mirroring del traffico](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-session.html#delete-traffic-mirroring-session) nella *Guida di Mirroring del traffico AWS *.
+ Per i dettagli sull'API, consulta [DeleteTrafficMirrorSession AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-traffic-mirror-session.html)*Command Reference*.
### `delete-traffic-mirror-target`
Il seguente esempio di codice mostra come utilizzare`delete-traffic-mirror-target`.
**AWS CLI**
**Come eliminare una destinazione di mirroring del traffico**
L’esempio `delete-traffic-mirror-target` seguente elimina la destinazione di mirroring del traffico specificata.
```
aws ec2 delete-traffic-mirror-target \
--traffic-mirror-target-id tmt-060f48ce9EXAMPLE
```
Output:
```
{
"TrafficMirrorTargetId": "tmt-060f48ce9EXAMPLE"
}
```
Per ulteriori informazioni, consulta [Eliminare una destinazione del mirroring del traffico](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-target.html#delete-traffic-mirroring-target) nella *Guida di Mirroring del traffico AWS *.
+ Per i dettagli sull'API, consulta [DeleteTrafficMirrorTarget AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-traffic-mirror-target.html)*Command Reference*.
### `delete-transit-gateway-connect-peer`
Il seguente esempio di codice mostra come utilizzare`delete-transit-gateway-connect-peer`.
**AWS CLI**
**Come eliminare un peer di Transit Gateway Connect**
L’esempio `delete-transit-gateway-connect-peer` seguente elimina il peer Connect specificato.
```
aws ec2 delete-transit-gateway-connect-peer \
--transit-gateway-connect-peer-id tgw-connect-peer-0666adbac4EXAMPLE
```
Output:
```
{
"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"
}
]
}
}
}
```
Per ulteriori informazioni, consulta [Collegamenti Transit gateway Connect e peer Connect](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DeleteTransitGatewayConnectPeer AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-connect-peer.html)*Command Reference*.
### `delete-transit-gateway-connect`
Il seguente esempio di codice mostra come utilizzare`delete-transit-gateway-connect`.
**AWS CLI**
**Come eliminare un collegamento per il Transit Gateway Connect**
L’esempio `delete-transit-gateway-connect` seguente elimina il collegamento Connect specificato.
```
aws ec2 delete-transit-gateway-connect \
--transit-gateway-attachment-id tgw-attach-037012e5dcEXAMPLE
```
Output:
```
{
"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"
}
}
}
```
Per ulteriori informazioni, consulta [Collegamenti Transit gateway Connect e peer Connect](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DeleteTransitGatewayConnect AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-connect.html)*Command Reference*.
### `delete-transit-gateway-multicast-domain`
Il seguente esempio di codice mostra come utilizzare`delete-transit-gateway-multicast-domain`.
**AWS CLI**
**Come eliminare un dominio multicast (trasmissione uno a molti) del gateway di transito**
L’esempio `delete-transit-gateway-multicast-domain` seguente elimina il dominio multicast (trasmissione uno a molti) specificato.
```
aws ec2 delete-transit-gateway-multicast-domain \
--transit-gateway-multicast-domain-id tgw-mcast-domain-0c4905cef7EXAMPLE
```
Output:
```
{
"TransitGatewayMulticastDomain": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-02bb79002bEXAMPLE",
"TransitGatewayId": "tgw-0d88d2d0d5EXAMPLE",
"State": "deleting",
"CreationTime": "2019-11-20T22:02:03.000Z"
}
}
```
Per ulteriori informazioni, consulta [Gestione dei domini multicast (trasmissione uno a molti)](https://docs.aws.amazon.com/vpc/latest/tgw/manage-domain.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DeleteTransitGatewayMulticastDomain AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-multicast-domain.html)*Command Reference*.
### `delete-transit-gateway-peering-attachment`
Il seguente esempio di codice mostra come utilizzare`delete-transit-gateway-peering-attachment`.
**AWS CLI**
**Come eliminare un collegamento peering del gateway di transito**
L’esempio `delete-transit-gateway-peering-attachment` seguente elimina il collegamento peering del gateway di transito specificato.
```
aws ec2 delete-transit-gateway-peering-attachment \
--transit-gateway-attachment-id tgw-attach-4455667788aabbccd
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Accessori di peering del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-peering.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DeleteTransitGatewayPeeringAttachment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-peering-attachment.html)*Command Reference*.
### `delete-transit-gateway-policy-table`
Il seguente esempio di codice mostra come utilizzare`delete-transit-gateway-policy-table`.
**AWS CLI**
**Come eliminare una tabella di policy del gateway di transito**
L’esempio `delete-transit-gateway-policy-table` seguente elimina la tabella di policy del gateway di transito specificata.
```
aws ec2 delete-transit-gateway-policy-table \
--transit-gateway-policy-table-id tgw-ptb-0a16f134b78668a81
```
Output:
```
{
"TransitGatewayPolicyTables": [
{
"TransitGatewayPolicyTableId": "tgw-ptb-0a16f134b78668a81",
"TransitGatewayId": "tgw-067f8505c18f0bd6e",
"State": "deleting",
"CreationTime": "2023-11-28T16:36:43+00:00",
"Tags": []
}
]
}
```
Per ulteriori informazioni, consulta [Tabelle di policy del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-policy-tables.html) nella *Guida per l’utente di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DeleteTransitGatewayPolicyTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-policy-table.html)*Command Reference*.
### `delete-transit-gateway-prefix-list-reference`
Il seguente esempio di codice mostra come utilizzare`delete-transit-gateway-prefix-list-reference`.
**AWS CLI**
**Come eliminare un riferimento all’elenco di prefissi**
L’esempio `delete-transit-gateway-prefix-list-reference` seguente elimina il riferimento all’elenco di prefissi specificato.
```
aws ec2 delete-transit-gateway-prefix-list-reference \
--transit-gateway-route-table-id tgw-rtb-0123456789abcd123 \
--prefix-list-id pl-11111122222222333
```
Output:
```
{
"TransitGatewayPrefixListReference": {
"TransitGatewayRouteTableId": "tgw-rtb-0123456789abcd123",
"PrefixListId": "pl-11111122222222333",
"PrefixListOwnerId": "123456789012",
"State": "deleting",
"Blackhole": false,
"TransitGatewayAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-aabbccddaabbccaab",
"ResourceType": "vpc",
"ResourceId": "vpc-112233445566aabbc"
}
}
}
```
Per ulteriori informazioni, consulta [Riferimenti elenco dei prefissi](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-prefix-lists.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DeleteTransitGatewayPrefixListReference AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-prefix-list-reference.html)*Command Reference*.
### `delete-transit-gateway-route-table`
Il seguente esempio di codice mostra come utilizzare`delete-transit-gateway-route-table`.
**AWS CLI**
**Come eliminare la tabella di routing di un gateway di transito**
L’esempio `delete-transit-gateway-route-table` seguente elimina la tabella di routing del gateway di transito specificata.
```
aws ec2 delete-transit-gateway-route-table \
--transit-gateway-route-table-id tgw-rtb-0b6f6aaa01EXAMPLE
```
Output:
```
{
"TransitGatewayRouteTable": {
"TransitGatewayRouteTableId": "tgw-rtb-0b6f6aaa01EXAMPLE",
"TransitGatewayId": "tgw-02f776b1a7EXAMPLE",
"State": "deleting",
"DefaultAssociationRouteTable": false,
"DefaultPropagationRouteTable": false,
"CreationTime": "2019-07-17T20:27:26.000Z"
}
}
```
Per ulteriori informazioni, consulta [Eliminare la tabella di routing di un gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html#delete-tgw-route-table) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DeleteTransitGatewayRouteTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-route-table.html)*Command Reference*.
### `delete-transit-gateway-route`
Il seguente esempio di codice mostra come utilizzare`delete-transit-gateway-route`.
**AWS CLI**
**Come eliminare un intervallo CIDR da una tabella di routing**
L’esempio `delete-transit-gateway-route` seguente elimina l’intervallo CIDR dalla tabella di routing del gateway di transito specificata.
```
aws ec2 delete-transit-gateway-route \
--transit-gateway-route-table-id tgw-rtb-0b6f6aaa01EXAMPLE \
--destination-cidr-block 10.0.2.0/24
```
Output:
```
{
"Route": {
"DestinationCidrBlock": "10.0.2.0/24",
"TransitGatewayAttachments": [
{
"ResourceId": "vpc-0065acced4EXAMPLE",
"TransitGatewayAttachmentId": "tgw-attach-0b5968d3b6EXAMPLE",
"ResourceType": "vpc"
}
],
"Type": "static",
"State": "deleted"
}
}
```
Per ulteriori informazioni, consulta [Eliminare una route statica](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html#tgw-delete-static-route) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DeleteTransitGatewayRoute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-route.html)*Command Reference*.
### `delete-transit-gateway-vpc-attachment`
Il seguente esempio di codice mostra come utilizzare`delete-transit-gateway-vpc-attachment`.
**AWS CLI**
**Come eliminare un collegamento VPC del gateway di transito**
L’esempio `delete-transit-gateway-vpc-attachment` seguente elimina il collegamento VPC specificato.
```
aws ec2 delete-transit-gateway-vpc-attachment \
--transit-gateway-attachment-id tgw-attach-0d2c54bdbEXAMPLE
```
Output:
```
{
"TransitGatewayVpcAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-0d2c54bdb3EXAMPLE",
"TransitGatewayId": "tgw-02f776b1a7EXAMPLE",
"VpcId": "vpc-0065acced4f61c651",
"VpcOwnerId": "111122223333",
"State": "deleting",
"CreationTime": "2019-07-17T16:04:27.000Z"
}
}
```
Per ulteriori informazioni, consulta [Eliminare un collegamento a un VPC](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html#delete-vpc-attachment) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DeleteTransitGatewayVpcAttachment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway-vpc-attachment.html)*Command Reference*.
### `delete-transit-gateway`
Il seguente esempio di codice mostra come utilizzare`delete-transit-gateway`.
**AWS CLI**
**Come eliminare un gateway di transito**
L’esempio `delete-transit-gateway` seguente elimina il gateway di transito specificato.
```
aws ec2 delete-transit-gateway \
--transit-gateway-id tgw-01f04542b2EXAMPLE
```
Output:
```
{
"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"
}
}
}
```
Per ulteriori informazioni, consulta [Eliminare un gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-transit-gateways.html#delete-tgw) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DeleteTransitGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-transit-gateway.html)*Command Reference*.
### `delete-verified-access-endpoint`
Il seguente esempio di codice mostra come utilizzare`delete-verified-access-endpoint`.
**AWS CLI**
**Come eliminare un endpoint di accesso verificato**
L’esempio `delete-verified-access-endpoint` seguente elimina l’endpoint di accesso verificato specificato.
```
aws ec2 delete-verified-access-endpoint \
--verified-access-endpoint-id vae-066fac616d4d546f2
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Endpoint di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-endpoints.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [DeleteVerifiedAccessEndpoint AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-verified-access-endpoint.html)*Command Reference*.
### `delete-verified-access-group`
Il seguente esempio di codice mostra come utilizzare`delete-verified-access-group`.
**AWS CLI**
**Come eliminare un gruppo di accesso verificato**
L’esempio `delete-verified-access-group` seguente elimina il gruppo di accesso verificato specificato.
```
aws ec2 delete-verified-access-group \
--verified-access-group-id vagr-0dbe967baf14b7235
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Gruppi di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-groups.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [DeleteVerifiedAccessGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-verified-access-group.html)*Command Reference*.
### `delete-verified-access-instance`
Il seguente esempio di codice mostra come utilizzare`delete-verified-access-instance`.
**AWS CLI**
**Come eliminare un’istanza di accesso verificato**
L’esempio `delete-verified-access-instance` seguente elimina l’istanza di accesso verificato specificata.
```
aws ec2 delete-verified-access-instance \
--verified-access-instance-id vai-0ce000c0b7643abea
```
Output:
```
{
"VerifiedAccessInstance": {
"VerifiedAccessInstanceId": "vai-0ce000c0b7643abea",
"Description": "Testing Verified Access",
"VerifiedAccessTrustProviders": [],
"CreationTime": "2023-08-25T18:27:56",
"LastUpdatedTime": "2023-08-26T01:00:18"
}
}
```
Per ulteriori informazioni, consulta [Istanze di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-instances.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [DeleteVerifiedAccessInstance AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-verified-access-instance.html)*Command Reference*.
### `delete-verified-access-trust-provider`
Il seguente esempio di codice mostra come utilizzare`delete-verified-access-trust-provider`.
**AWS CLI**
**Come eliminare un provider di attendibilità di accesso verificato**
L’esempio `delete-verified-access-trust-provider` seguente elimina il provider di attendibilità di accesso verificato specificato.
```
aws ec2 delete-verified-access-trust-provider \
--verified-access-trust-provider-id vatp-0bb32de759a3e19e7
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Provider di attendibilità per Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/trust-providers.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [DeleteVerifiedAccessTrustProvider AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-verified-access-trust-provider.html)*Command Reference*.
### `delete-volume`
Il seguente esempio di codice mostra come utilizzare`delete-volume`.
**AWS CLI**
**Come eliminare un volume**
Questo comando di esempio elimina un volume disponibile con l’ID volume di `vol-049df61146c4d7901`. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-volume --volume-id vol-049df61146c4d7901
```
+ Per i dettagli sull'API, consulta [DeleteVolume AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-volume.html)*Command Reference*.
### `delete-vpc-endpoint-connection-notifications`
Il seguente esempio di codice mostra come utilizzare`delete-vpc-endpoint-connection-notifications`.
**AWS CLI**
**Come eliminare una notifica della connessione endpoint**
Questo esempio elimina la notifica della connessione endpoint specificata.
Comando:
```
aws ec2 delete-vpc-endpoint-connection-notifications --connection-notification-ids vpce-nfn-008776de7e03f5abc
```
Output:
```
{
"Unsuccessful": []
}
```
+ Per i dettagli sull'API, consulta [DeleteVpcEndpointConnectionNotifications AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-vpc-endpoint-connection-notifications.html)*Command Reference*.
### `delete-vpc-endpoint-service-configurations`
Il seguente esempio di codice mostra come utilizzare`delete-vpc-endpoint-service-configurations`.
**AWS CLI**
**Come eliminare una configurazione di servizio endpoint**
Questo esempio elimina la configurazione di servizio endpoint specificata.
Comando:
```
aws ec2 delete-vpc-endpoint-service-configurations --service-ids vpce-svc-03d5ebb7d9579a2b3
```
Output:
```
{
"Unsuccessful": []
}
```
+ Per i dettagli sull'API, consulta [DeleteVpcEndpointServiceConfigurations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-vpc-endpoint-service-configurations.html)*Command Reference*.
### `delete-vpc-endpoints`
Il seguente esempio di codice mostra come utilizzare`delete-vpc-endpoints`.
**AWS CLI**
**Come eliminare un endpoint**
Questo esempio elimina gli endpoint vpce-aa22bb33 e vpce-1a2b3c4d. Se il comando ha esito parzialmente positivo o negativo, viene restituito un elenco di elementi non riusciti. Se il comando ha esito positivo, l’elenco restituito è vuoto.
Comando:
```
aws ec2 delete-vpc-endpoints --vpc-endpoint-ids vpce-aa22bb33 vpce-1a2b3c4d
```
Output:
```
{
"Unsuccessful": []
}
```
+ Per i dettagli sull'API, consulta [DeleteVpcEndpoints AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-vpc-endpoints.html)*Command Reference*.
### `delete-vpc-peering-connection`
Il seguente esempio di codice mostra come utilizzare`delete-vpc-peering-connection`.
**AWS CLI**
**Come eliminare una connessione peering VPC**
Questo esempio elimina la connessione peering VPC specificata.
Comando:
```
aws ec2 delete-vpc-peering-connection --vpc-peering-connection-id pcx-1a2b3c4d
```
Output:
```
{
"Return": true
}
```
+ Per i dettagli sull'API, consulta [DeleteVpcPeeringConnection AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-vpc-peering-connection.html)*Command Reference*.
### `delete-vpc`
Il seguente esempio di codice mostra come utilizzare`delete-vpc`.
**AWS CLI**
**Come eliminare un VPC**
Questo esempio elimina il VPC specificato. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-vpc --vpc-id vpc-a01106c2
```
+ Per i dettagli sull'API, consulta [DeleteVpc AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-vpc.html)*Command Reference*.
### `delete-vpn-connection-route`
Il seguente esempio di codice mostra come utilizzare`delete-vpn-connection-route`.
**AWS CLI**
**Come eliminare un routing statico da una connessione VPN**
Questo esempio elimina la route statica specificata dalla connessione VPN specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-vpn-connection-route --vpn-connection-id vpn-40f41529 --destination-cidr-block 11.12.0.0/16
```
+ Per i dettagli sull'API, consulta [DeleteVpnConnectionRoute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-vpn-connection-route.html)*Command Reference*.
### `delete-vpn-connection`
Il seguente esempio di codice mostra come utilizzare`delete-vpn-connection`.
**AWS CLI**
**Come eliminare una connessione VPN**
Questo esempio elimina la connessione VPN specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-vpn-connection --vpn-connection-id vpn-40f41529
```
+ Per i dettagli sull'API, consulta [DeleteVpnConnection AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-vpn-connection.html)*Command Reference*.
### `delete-vpn-gateway`
Il seguente esempio di codice mostra come utilizzare`delete-vpn-gateway`.
**AWS CLI**
**Come eliminare un gateway privato virtuale**
Questo esempio elimina il gateway privato virtuale specificato. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 delete-vpn-gateway --vpn-gateway-id vgw-9a4cacf3
```
+ Per i dettagli sull'API, consulta [DeleteVpnGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/delete-vpn-gateway.html)*Command Reference*.
### `deprovision-byoip-cidr`
Il seguente esempio di codice mostra come utilizzare`deprovision-byoip-cidr`.
**AWS CLI**
**Come rimuovere un intervallo di indirizzi IP dall’uso**
L'esempio seguente rimuove l'intervallo di indirizzi specificato dall'uso con AWS.
```
aws ec2 deprovision-byoip-cidr \
--cidr 203.0.113.25/24
```
Output:
```
{
"ByoipCidr": {
"Cidr": "203.0.113.25/24",
"State": "pending-deprovision"
}
}
```
+ Per i dettagli sull'API, vedere [DeprovisionByoipCidr](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/deprovision-byoip-cidr.html)in *AWS CLI Command Reference*.
### `deprovision-ipam-pool-cidr`
Il seguente esempio di codice mostra come utilizzare`deprovision-ipam-pool-cidr`.
**AWS CLI**
**Come revocare il provisioning di un CIDR del pool IPAM**
L’esempio `deprovision-ipam-pool-cidr` seguente revoca il provisioning di un CIDR assegnato a un pool 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
```
Output:
```
{
"IpamPoolCidr": {
"Cidr": "11.0.0.0/16",
"State": "pending-deprovision"
}
}
```
Per ulteriori informazioni, consulta [Deprovisioning pool CIDRs](https://docs.aws.amazon.com/vpc/latest/ipam/depro-pool-cidr-ipam.html) nella *Amazon VPC IPAM* User Guide.
+ *Per i dettagli sull'API, consulta Command [DeprovisionIpamPoolCidr](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/deprovision-ipam-pool-cidr.html)Reference AWS CLI .*
### `deregister-image`
Il seguente esempio di codice mostra come utilizzare`deregister-image`.
**AWS CLI**
**Come annullare la registrazione di un’AMI**
Questo esempio annulla la registrazione dell’AMI specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 deregister-image --image-id ami-4fa54026
```
+ Per i dettagli sull'API, consulta [DeregisterImage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/deregister-image.html)*Command Reference*.
### `deregister-instance-event-notification-attributes`
Il seguente esempio di codice mostra come utilizzare`deregister-instance-event-notification-attributes`.
**AWS CLI**
**Esempio 1: come rimuovere tutti i tag dalle notifiche eventi**
L’esempio `deregister-instance-event-notification-attributes` seguente rimuove `IncludeAllTagsOfInstance=true`, che ha l’effetto di impostare `IncludeAllTagsOfInstance` su `false`.
```
aws ec2 deregister-instance-event-notification-attributes \
--instance-tag-attribute IncludeAllTagsOfInstance=true
```
Output:
```
{
"InstanceTagAttribute": {
"InstanceTagKeys": [],
"IncludeAllTagsOfInstance": true
}
}
```
Per ulteriori informazioni, consulta [Eventi pianificati per le istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html) nella *Guida per l’utente di Amazon Elastic Compute Cloud per le istanze Linux*.
**Esempio 2: come rimuovere tag specifici dalle notifiche eventi**
L’esempio `deregister-instance-event-notification-attributes` seguente rimuove il tag specificato dai tag inclusi nelle notifiche eventi. Per descrivere i tag rimanenti inclusi nelle notifiche eventi, utilizza `describe-instance-event-notification-attributes`.
```
aws ec2 deregister-instance-event-notification-attributes \
--instance-tag-attribute InstanceTagKeys="tag-key2"
```
Output:
```
{
"InstanceTagAttribute": {
"InstanceTagKeys": [
"tag-key2"
],
"IncludeAllTagsOfInstance": false
}
}
```
Per ulteriori informazioni, consulta [Eventi pianificati per le istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html) nella *Guida per l’utente di Amazon Elastic Compute Cloud per le istanze Linux*.
+ Per i dettagli sull'API, consulta [DeregisterInstanceEventNotificationAttributes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/deregister-instance-event-notification-attributes.html)*Command Reference*.
### `deregister-transit-gateway-multicast-group-members`
Il seguente esempio di codice mostra come utilizzare`deregister-transit-gateway-multicast-group-members`.
**AWS CLI**
**Come annullare la registrazione di membri da un gruppo multicast (trasmissione uno a molti)**
Questo esempio annulla la registrazione del membro del gruppo di interfaccia di rete specificato per il gruppo multicast (trasmissione uno a molti) del gateway di transito.
```
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
```
Output:
```
{
"DeregisteredMulticastGroupMembers": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-0c4905cef7EXAMPLE",
"RegisteredNetworkInterfaceIds": [
"eni-0e246d3269EXAMPLE"
],
"GroupIpAddress": "224.0.1.0"
}
}
```
Per ulteriori informazioni, consulta [Annullare la registrazione di membri da un gruppo multicast (trasmissione uno a molti)](https://docs.aws.amazon.com/vpc/latest/tgw/working-with-multicast.html#remove-members-multicast-group) nella *Guida per l’utente di AWS Transit Gateway*.
+ Per i dettagli sull'API, consulta [DeregisterTransitGatewayMulticastGroupMembers AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/deregister-transit-gateway-multicast-group-members.html)*Command Reference*.
### `deregister-transit-gateway-multicast-group-source`
Il seguente esempio di codice mostra come utilizzare`deregister-transit-gateway-multicast-group-source`.
**AWS CLI**
**Come annullare la registrazione di un’origine dal gruppo multicast (trasmissione uno a molti) del gateway di transito**
Questo esempio annulla la registrazione dell’origine del gruppo di interfacce di rete specificato dal gruppo multicast (trasmissione uno a molti).
```
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
```
Output:
```
{
"DeregisteredMulticastGroupSources": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-0c4905cef79d6e597",
"DeregisteredNetworkInterfaceIds": [
"eni-07f290fc3c090cbae"
],
"GroupIpAddress": "224.0.1.0"
}
}
```
Per ulteriori informazioni, consulta [Annullamento della registrazione delle origini da un gruppo multicast (trasmissione uno a molti)](https://docs.aws.amazon.com/vpc/latest/tgw/working-with-multicast.html#remove-source-multicast-group) nella *Guida per l’utente di AWS Transit Gateway*.
+ Per i dettagli sull'API, consulta [DeregisterTransitGatewayMulticastGroupSource AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/deregister-transit-gateway-multicast-group-source.html)*Command Reference*.
### `describe-account-attributes`
Il seguente esempio di codice mostra come utilizzare`describe-account-attributes`.
**AWS CLI**
**Per descrivere tutti gli attributi del tuo AWS account**
Questo esempio descrive gli attributi del tuo AWS account.
Comando:
```
aws ec2 describe-account-attributes
```
Output:
```
{
"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"
}
]
}
]
}
```
**Per descrivere un singolo attributo del tuo AWS account**
Questo esempio descrive l'`supported-platforms`attributo del tuo AWS account.
Comando:
```
aws ec2 describe-account-attributes --attribute-names supported-platforms
```
Output:
```
{
"AccountAttributes": [
{
"AttributeName": "supported-platforms",
"AttributeValues": [
{
"AttributeValue": "EC2"
},
{
"AttributeValue": "VPC"
}
]
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeAccountAttributes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-account-attributes.html)*Command Reference*.
### `describe-address-transfers`
Il seguente esempio di codice mostra come utilizzare`describe-address-transfers`.
**AWS CLI**
**Come descrivere il trasferimento di un indirizzo IP elastico**
L’esempio `describe-address-transfers` seguente descrive il trasferimento dell’indirizzo IP elastico per l’indirizzo IP elastico specificato.
```
aws ec2 describe-address-transfers \
--allocation-ids eipalloc-09ad461b0d03f6aaf
```
Output:
```
{
"AddressTransfers": [
{
"PublicIp": "100.21.184.216",
"AllocationId": "eipalloc-09ad461b0d03f6aaf",
"TransferAccountId": "123456789012",
"TransferOfferExpirationTimestamp": "2023-02-22T22:51:01.000Z",
"AddressTransferStatus": "pending"
}
]
}
```
Per ulteriori informazioni, consulta [Trasferimento degli indirizzi IP elastici](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-eips.html#transfer-EIPs-intro) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [DescribeAddressTransfers AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-address-transfers.html)*Command Reference*.
### `describe-addresses-attribute`
Il seguente esempio di codice mostra come utilizzare`describe-addresses-attribute`.
**AWS CLI**
**Come visualizzare gli attributi del nome di dominio associato a un indirizzo IP elastico**
Gli esempi `describe-addresses-attribute` seguenti restituiscono gli attributi del nome di dominio associato all’indirizzo IP elastico.
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
```
Output:
```
{
"Addresses": [
{
"PublicIp": "192.0.2.0",
"AllocationId": "eipalloc-abcdef01234567890",
"PtrRecord": "example.com."
}
]
}
```
Per visualizzare gli attributi di un indirizzo IP elastico, è necessario aver prima associato un nome di dominio all’indirizzo IP elastico. Per ulteriori informazioni, consulta [Use reverse DNS per le applicazioni di posta elettronica](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html#Using_Elastic_Addressing_Reverse_DNS) nella *Amazon EC2 User* Guide [modify-address-attribute](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-address-attribute.html)o nel *AWS CLI* Command Reference.
+ *Per i dettagli sull'API, consulta Command [DescribeAddressesAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-addresses-attribute.html)Reference AWS CLI .*
### `describe-addresses`
Il seguente esempio di codice mostra come utilizzare`describe-addresses`.
**AWS CLI**
**Esempio 1: come recuperare i dettagli di tutti gli indirizzi IP elastici**
Nell’esempio di `describe addresses` seguente vengono visualizzati tutti i dettagli relativi agli indirizzi IP elastici.
```
aws ec2 describe-addresses
```
Output:
```
{
"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"
}
]
}
```
**Esempio 2: come recuperare i dettagli degli indirizzi IP elastici per EC2-VPC**
Nell’esempio di `describe-addresses` seguente vengono visualizzati i dettagli relativi agli indirizzi IP elastici utilizzati per le istanze in un VPC.
```
aws ec2 describe-addresses \
--filters "Name=domain,Values=vpc"
```
Output:
```
{
"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"
}
]
}
```
**Esempio 3: come recuperare i dettagli di un indirizzo IP elastico specificato dall’ID di allocazione**
Nell’esempio di `describe-addresses` seguente vengono visualizzati i dettagli relativi all’indirizzo IP elastico con l’ID di allocazione specificato, associato a un’istanza in EC2-VPC.
```
aws ec2 describe-addresses \
--allocation-ids eipalloc-282d9641
```
Output:
```
{
"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"
}
]
}
```
**Esempio 4: come recuperare i dettagli di un indirizzo IP elastico specificato dall’indirizzo IP privato del VPC**
Nell’esempio di `describe-addresses` seguente vengono visualizzati i dettagli relativi all’indirizzo IP elastico associato a un indirizzo IP privato specifico in EC2-VPC.
```
aws ec2 describe-addresses \
--filters "Name=private-ip-address,Values=10.251.50.12"
```
**Esempio 5: come recuperare i dettagli degli indirizzi IP elastici in EC2-Classic**
L'`describe-addresses`esempio seguente mostra i dettagli sugli indirizzi IP elastici da utilizzare in EC2-Classic.
```
aws ec2 describe-addresses \
--filters "Name=domain,Values=standard"
```
Output:
```
{
"Addresses": [
{
"InstanceId": "i-1234567890abcdef0",
"PublicIp": "203.0.110.25",
"PublicIpv4Pool": "amazon",
"Domain": "standard"
}
]
}
```
**Esempio 6: come recuperare i dettagli di un indirizzo IP elastico specificato dall’indirizzo IP pubblico**
Nell’esempio di `describe-addresses` seguente vengono visualizzati i dettagli relativi all’indirizzo IP elastico con valore `203.0.110.25`, associato a un’istanza in EC2-Classic.
```
aws ec2 describe-addresses \
--public-ips 203.0.110.25
```
Output:
```
{
"Addresses": [
{
"InstanceId": "i-1234567890abcdef0",
"PublicIp": "203.0.110.25",
"PublicIpv4Pool": "amazon",
"Domain": "standard"
}
]
}
```
+ Per i dettagli sull'API, consulta *AWS CLI Command [DescribeAddresses](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-addresses.html)Reference*.
### `describe-aggregate-id-format`
Il seguente esempio di codice mostra come utilizzare`describe-aggregate-id-format`.
**AWS CLI**
**Come descrivere le impostazioni del formato ID più lungo per tutti i tipi di risorse in una Regione**
L’esempio `describe-aggregate-id-format` seguente descrive lo stato complessivo del formato ID lungo per la Regione corrente. Il valore `Deadline` indica che le scadenze per il passaggio permanente di queste risorse dal formato ID breve al formato ID lungo sono scadute. Il valore `UseLongIdsAggregated` indica che tutti gli utenti e i ruoli IAM sono configurati per utilizzare il formato ID lungo per tutti i tipi di risorse.
```
aws ec2 describe-aggregate-id-format
```
Output:
```
{
"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
},
...
]
}
```
+ Per i dettagli sull'API, consulta [DescribeAggregateIdFormat AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-aggregate-id-format.html)*Command Reference*.
### `describe-availability-zones`
Il seguente esempio di codice mostra come utilizzare`describe-availability-zones`.
**AWS CLI**
**Come descrivere le zone di disponibilità**
In questo esempio di `describe-availability-zones` vengono mostrati i dettagli della zona di disponibilità disponibili a te. La risposta include le zone di disponibilità solo per la regione attuale. In questo esempio si utilizza la regione predefinita del profilo `us-west-2` (Oregon).
```
aws ec2 describe-availability-zones
```
Output:
```
{
"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"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeAvailabilityZones AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-availability-zones.html)*Command Reference*.
### `describe-aws-network-performance-metric-subscription`
Il seguente esempio di codice mostra come utilizzare`describe-aws-network-performance-metric-subscription`.
**AWS CLI**
**Come descrivere le sottoscrizioni di parametri di prestazioni**
L’esempio `describe-aws-network-performance-metric-subscriptions` seguente descrive le sottoscrizioni di parametri di prestazioni.
```
aws ec2 describe-aws-network-performance-metric-subscriptions
```
Output:
```
{
"Subscriptions": [
{
"Source": "us-east-1",
"Destination": "eu-west-1",
"Metric": "aggregate-latency",
"Statistic": "p50",
"Period": "five-minutes"
}
]
}
```
Per ulteriori informazioni, consulta [Gestione delle sottoscrizioni](https://docs.aws.amazon.com/network-manager/latest/infrastructure-performance/nmip-subscriptions-cw.html) nella *Guida per l’utente di Infrastructure Performance*.
+ Per i dettagli sull'API, consulta [DescribeAwsNetworkPerformanceMetricSubscription AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-aws-network-performance-metric-subscription.html)*Command Reference*.
### `describe-aws-network-performance-metric-subscriptions`
Il seguente esempio di codice mostra come utilizzare`describe-aws-network-performance-metric-subscriptions`.
**AWS CLI**
**Come descrivere le sottoscrizioni di parametri di prestazioni**
L’esempio `describe-aws-network-performance-metric-subscriptions` seguente descrive le sottoscrizioni di parametri di prestazioni.
```
aws ec2 describe-aws-network-performance-metric-subscriptions
```
Output:
```
{
"Subscriptions": [
{
"Source": "us-east-1",
"Destination": "eu-west-1",
"Metric": "aggregate-latency",
"Statistic": "p50",
"Period": "five-minutes"
}
]
}
```
Per ulteriori informazioni, consulta [Gestione delle sottoscrizioni](https://docs.aws.amazon.com/network-manager/latest/infrastructure-performance/nmip-subscriptions-cw.html) nella *Guida per l’utente di Infrastructure Performance*.
+ Per i dettagli sull'API, consulta [DescribeAwsNetworkPerformanceMetricSubscriptions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-aws-network-performance-metric-subscriptions.html)*Command Reference*.
### `describe-bundle-tasks`
Il seguente esempio di codice mostra come utilizzare`describe-bundle-tasks`.
**AWS CLI**
**Come descrivere le attività del bundle**
Questo esempio descrive tutte le attività del bundle.
Comando:
```
aws ec2 describe-bundle-tasks
```
Output:
```
{
"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"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeBundleTasks AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-bundle-tasks.html)*Command Reference*.
### `describe-byoip-cidrs`
Il seguente esempio di codice mostra come utilizzare`describe-byoip-cidrs`.
**AWS CLI**
**Come descrivere gli intervalli di indirizzi allocati**
L'`describe-byoip-cidrs`esempio seguente visualizza i dettagli sugli intervalli di IPv4 indirizzi pubblici da AWS cui è stato assegnato il provisioning.
```
aws ec2 describe-byoip-cidrs
```
Output:
```
{
"ByoipCidrs": [
{
"Cidr": "203.0.113.25/24",
"StatusMessage": "ipv4pool-ec2-1234567890abcdef0",
"State": "provisioned"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeByoipCidrs AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-byoip-cidrs.html)*Command Reference.*
### `describe-capacity-reservation-fleets`
Il seguente esempio di codice mostra come utilizzare`describe-capacity-reservation-fleets`.
**AWS CLI**
**Come visualizzare un parco di prenotazione della capacità**
L’esempio `describe-capacity-reservation-fleets` seguente elenca le informazioni di configurazione e le capacità per il parco di prenotazione della capacità specificato. Elenca inoltre i dettagli relativi alle singole prenotazioni della capacità presenti nel parco.
```
aws ec2 describe-capacity-reservation-fleets \
--capacity-reservation-fleet-ids crf-abcdef01234567890
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni sui parchi di prenotazione della capacità, consulta [Parchi prenotazione della capacità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cr-fleets.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DescribeCapacityReservationFleets AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-capacity-reservation-fleets.html)*Command Reference*.
### `describe-capacity-reservations`
Il seguente esempio di codice mostra come utilizzare`describe-capacity-reservations`.
**AWS CLI**
**Esempio 1: come descrivere una o più prenotazioni della capacità**
L'`describe-capacity-reservations`esempio seguente mostra i dettagli su tutte le prenotazioni di capacità nella AWS regione corrente.
```
aws ec2 describe-capacity-reservations
```
Output:
```
{
"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": []
}
]
}
```
**Esempio 2: come descrivere una o più prenotazioni della capacità**
L’esempio `describe-capacity-reservations` seguente visualizza i dettagli sulla prenotazione della capacità specificata.
```
aws ec2 describe-capacity-reservations \
--capacity-reservation-ids cr-1234abcd56EXAMPLE
```
Output:
```
{
"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": []
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzazione di una prenotazione della capacità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservations-using.html#capacity-reservations-view) nella *Guida per l’utente di Amazon Elastic Compute Cloud per le istanze Linux*.
+ Per i dettagli sull'API, consulta [DescribeCapacityReservations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-capacity-reservations.html)*Command Reference*.
### `describe-carrier-gateways`
Il seguente esempio di codice mostra come utilizzare`describe-carrier-gateways`.
**AWS CLI**
**Come descrivere tutti i gateway carrier**
L’esempio `describe-carrier-gateways` seguente elenca tutti i gateway carrier in uso.
```
aws ec2 describe-carrier-gateways
```
Output:
```
{
"CarrierGateways": [
{
"CarrierGatewayId": "cagw-0465cdEXAMPLE1111",
"VpcId": "vpc-0c529aEXAMPLE",
"State": "available",
"OwnerId": "123456789012",
"Tags": [
{
"Key": "example",
"Value": "tag"
}
]
}
]
}
```
*Per ulteriori informazioni, consulta Carrier gateways< https://docs.aws.amazon.com/vpc/ latest/userguide/Carrier \$1gateway.html> nella Amazon Virtual Private Cloud User Guide.*
+ *Per i dettagli sull'API, consulta Command Reference. [DescribeCarrierGateways](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-carrier-gateways.html)AWS CLI *
### `describe-classic-link-instances`
Il seguente esempio di codice mostra come utilizzare`describe-classic-link-instances`.
**AWS CLI**
**Come descrivere le istanze EC2-Classic collegate**
Questo esempio elenca tutte le istanze EC2-Classic collegate.
Comando:
```
aws ec2 describe-classic-link-instances
```
Output:
```
{
"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"
}
]
}
]
}
```
Questo esempio elenca tutte le istanze EC2-Classic collegate e filtra la risposta per includere solo le istanze collegate al VPC vpc-88888888.
Comando:
```
aws ec2 describe-classic-link-instances --filter "Name=vpc-id,Values=vpc-88888888"
```
Output:
```
{
"Instances": [
{
"InstanceId": "i-1234567890abcdef0",
"VpcId": "vpc-88888888",
"Groups": [
{
"GroupId": "sg-11122233"
}
],
"Tags": [
{
"Value": "ClassicInstance",
"Key": "Name"
}
]
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeClassicLinkInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-classic-link-instances.html)*Command Reference*.
### `describe-client-vpn-authorization-rules`
Il seguente esempio di codice mostra come utilizzare`describe-client-vpn-authorization-rules`.
**AWS CLI**
**Come descrivere le regole di autorizzazione per un endpoint VPN Client**
L’esempio `describe-client-vpn-authorization-rules` seguente visualizza i dettagli relativi alle regole di autorizzazione per l’endpoint VPN Client specificato.
```
aws ec2 describe-client-vpn-authorization-rules \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde
```
Output:
```
{
"AuthorizationRules": [
{
"ClientVpnEndpointId": "cvpn-endpoint-123456789123abcde",
"GroupId": "",
"AccessAll": true,
"DestinationCidr": "0.0.0.0/0",
"Status": {
"Code": "active"
}
}
]
}
```
Per ulteriori informazioni, consulta [Regole di autorizzazione](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-rules.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [DescribeClientVpnAuthorizationRules AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-client-vpn-authorization-rules.html)*Command Reference*.
### `describe-client-vpn-connections`
Il seguente esempio di codice mostra come utilizzare`describe-client-vpn-connections`.
**AWS CLI**
**Come descrivere le connessioni a un endpoint VPN Client**
L’esempio `describe-client-vpn-connections` seguente visualizza i dettagli relativi alle connessioni client all’endpoint VPN Client specificato.
```
aws ec2 describe-client-vpn-connections \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde
```
Output:
```
{
"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": "-"
}
]
}
```
Per ulteriori informazioni, consulta [Connessioni client](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-connections.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [DescribeClientVpnConnections AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-client-vpn-connections.html)*Command Reference*.
### `describe-client-vpn-endpoints`
Il seguente esempio di codice mostra come utilizzare`describe-client-vpn-endpoints`.
**AWS CLI**
**Come descrivere gli endpoint VPN Client**
L’esempio `describe-client-vpn-endpoints` seguente mostra i dettagli di tutti gli endpoint VPN Client.
```
aws ec2 describe-client-vpn-endpoints
```
Output:
```
{
"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
}
}
]
}
```
Per ulteriori informazioni, consulta [Endpoint Client VPN](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-endpoints.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [DescribeClientVpnEndpoints AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-client-vpn-endpoints.html)*Command Reference*.
### `describe-client-vpn-routes`
Il seguente esempio di codice mostra come utilizzare`describe-client-vpn-routes`.
**AWS CLI**
**Come descrivere le route per un endpoint VPN Client**
L’esempio `describe-client-vpn-routes` seguente visualizza i dettagli delle route per l’endpoint VPN Client specificato.
```
aws ec2 describe-client-vpn-routes \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde
```
Output:
```
{
"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"
}
}
]
}
```
Per ulteriori informazioni, consulta [Route](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-routes.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [DescribeClientVpnRoutes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-client-vpn-routes.html)*Command Reference*.
### `describe-client-vpn-target-networks`
Il seguente esempio di codice mostra come utilizzare`describe-client-vpn-target-networks`.
**AWS CLI**
**Come descrivere le reti di destinazione per un endpoint VPN Client**
L’esempio `describe-client-vpn-target-networks` seguente mostra i dettagli relativi alle reti di destinazione per l’endpoint VPN Client specificato.
```
aws ec2 describe-client-vpn-target-networks \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde
```
Output:
```
{
"ClientVpnTargetNetworks": [
{
"AssociationId": "cvpn-assoc-012e837060753dc3d",
"VpcId": "vpc-11111222222333333",
"TargetNetworkId": "subnet-0123456789abcabca",
"ClientVpnEndpointId": "cvpn-endpoint-123456789123abcde",
"Status": {
"Code": "associating"
},
"SecurityGroups": [
"sg-012345678910abcab"
]
}
]
}
```
Per ulteriori informazioni, consulta [Reti target](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-target.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [DescribeClientVpnTargetNetworks AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-client-vpn-target-networks.html)*Command Reference*.
### `describe-coip-pools`
Il seguente esempio di codice mostra come utilizzare`describe-coip-pools`.
**AWS CLI**
**Come descrivere i pool di indirizzi IP di proprietà del cliente**
L'`describe-coip-pools`esempio seguente descrive i pool di indirizzi IP di proprietà del cliente presenti nell'account AWS .
```
aws ec2 describe-coip-pools
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Indirizzi IP di proprietà del cliente](https://docs.aws.amazon.com/outposts/latest/userguide/outposts-networking-components.html#ip-addressing) nella *Guida per l’utente di AWS Outposts*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [DescribeCoipPools](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-coip-pools.html)Reference*.
### `describe-conversion-tasks`
Il seguente esempio di codice mostra come utilizzare`describe-conversion-tasks`.
**AWS CLI**
**Come visualizzare lo stato di un’attività di conversione**
Questo esempio restituisce lo stato di un'attività di conversione con l'ID import-i-ffvko 9js.
Comando:
```
aws ec2 describe-conversion-tasks --conversion-task-ids import-i-ffvko9js
```
Output:
```
{
"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"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeConversionTasks AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-conversion-tasks.html)*Command Reference.*
### `describe-customer-gateways`
Il seguente esempio di codice mostra come utilizzare`describe-customer-gateways`.
**AWS CLI**
**Come descrivere i gateway del cliente**
Questo esempio descrive i gateway del cliente.
Comando:
```
aws ec2 describe-customer-gateways
```
Output:
```
{
"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"
}
]
}
```
**Come descrivere un gateway del cliente specifico**
Questo esempio descrive il gateway del cliente specificato.
Comando:
```
aws ec2 describe-customer-gateways --customer-gateway-ids cgw-0e11f167
```
Output:
```
{
"CustomerGateways": [
{
"CustomerGatewayId": "cgw-0e11f167",
"IpAddress": "12.1.2.3",
"State": "available",
"Type": "ipsec.1",
"BgpAsn": "65534"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeCustomerGateways AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-customer-gateways.html)*Command Reference*.
### `describe-dhcp-options`
Il seguente esempio di codice mostra come utilizzare`describe-dhcp-options`.
**AWS CLI**
**Esempio 1: come descrivere le opzioni DHCP**
L’esempio `describe-dhcp-options` seguente recupera i dettagli delle opzioni DHCP in uso.
```
aws ec2 describe-dhcp-options
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Utilizzo dei set di opzioni DHCP](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html#DHCPOptionSet) nella *Guida per l’utente di AWS VPC*.
**Esempio 2: come descrivere le opzioni DHCP e filtrare l’output**
L’esempio `describe-dhcp-options` seguente descrive le opzioni DHCP e utilizza un filtro per restituire solo le opzioni DHCP che hanno `example.com` come server dei nomi di dominio. L’esempio utilizza il parametro `--query` per visualizzare solo le informazioni di configurazione e l’ID nell’output.
```
aws ec2 describe-dhcp-options \
--filters Name=key,Values=domain-name-servers Name=value,Values=example.com \
--query "DhcpOptions[*].[DhcpConfigurations,DhcpOptionsId]"
```
Output:
```
[
[
[
{
"Key": "domain-name",
"Values": [
{
"Value": "example.com"
}
]
},
{
"Key": "domain-name-servers",
"Values": [
{
"Value": "172.16.16.16"
}
]
}
],
"dopt-001122334455667ab"
]
]
```
Per ulteriori informazioni, consulta [Utilizzo dei set di opzioni DHCP](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html#DHCPOptionSet) nella *Guida per l’utente di AWS VPC*.
+ Per i dettagli sull'API, consulta [DescribeDhcpOptions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-dhcp-options.html)*Command Reference*.
### `describe-egress-only-internet-gateways`
Il seguente esempio di codice mostra come utilizzare`describe-egress-only-internet-gateways`.
**AWS CLI**
**Come descrivere gateway Internet di sola uscita**
Questo esempio descrive i gateway Internet di sola uscita.
Comando:
```
aws ec2 describe-egress-only-internet-gateways
```
Output:
```
{
"EgressOnlyInternetGateways": [
{
"EgressOnlyInternetGatewayId": "eigw-015e0e244e24dfe8a",
"Attachments": [
{
"State": "attached",
"VpcId": "vpc-0c62a468"
}
]
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeEgressOnlyInternetGateways AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-egress-only-internet-gateways.html)*Command Reference*.
### `describe-elastic-gpus`
Il seguente esempio di codice mostra come utilizzare`describe-elastic-gpus`.
**AWS CLI**
**Come descrivere una GPU elastica**
Comando:
```
aws ec2 describe-elastic-gpus --elastic-gpu-ids egpu-12345678901234567890abcdefghijkl
```
+ Per i dettagli sull'API, consulta [DescribeElasticGpus AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-elastic-gpus.html)*Command Reference*.
### `describe-export-image-tasks`
Il seguente esempio di codice mostra come utilizzare`describe-export-image-tasks`.
**AWS CLI**
**Come monitorare un’attività di esportazione di immagini**
L’esempio `describe-export-image-tasks` seguente controlla lo stato dell’attività di esportazione di immagini specificata. Il file di immagine risultante in Amazon S3 è `my-export-bucket/exports/export-ami-1234567890abcdef0.vmdk`.
```
aws ec2 describe-export-image-tasks \
--export-image-task-ids export-ami-1234567890abcdef0
```
Output di un’attività di esportazione di immagini in corso.
```
{
"ExportImageTasks": [
{
"ExportImageTaskId": "export-ami-1234567890abcdef0"
"Progress": "21",
"S3ExportLocation": {
"S3Bucket": "my-export-bucket",
"S3Prefix": "exports/"
},
"Status": "active",
"StatusMessage": "updating"
}
]
}
```
Output di un’attività di esportazione di immagini completata.
```
{
"ExportImageTasks": [
{
"ExportImageTaskId": "export-ami-1234567890abcdef0"
"S3ExportLocation": {
"S3Bucket": "my-export-bucket",
"S3Prefix": "exports/"
},
"Status": "completed"
}
]
}
```
Per ulteriori informazioni, [consulta Esportazione di una macchina virtuale da un'AMI nella Guida](https://docs.aws.amazon.com/vm-import/latest/userguide/vmexport_image.html) per l'* Import/Export utente della macchina virtuale*.
+ Per i dettagli sull'API, vedere [DescribeExportImageTasks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-export-image-tasks.html)in *AWS CLI Command Reference*.
### `describe-export-tasks`
Il seguente esempio di codice mostra come utilizzare`describe-export-tasks`.
**AWS CLI**
**Come elencare i dettagli di un’attività di esportazione di istanze**
Questo esempio descrive l'attività di esportazione con ID export-i-fh 8sjjsq.
Comando:
```
aws ec2 describe-export-tasks --export-task-ids export-i-fh8sjjsq
```
Output:
```
{
"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"
}
]
}
```
+ *Per i dettagli sull'API, consulta [DescribeExportTasks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-export-tasks.html)Command Reference.AWS CLI *
### `describe-fast-launch-images`
Il seguente esempio di codice mostra come utilizzare`describe-fast-launch-images`.
**AWS CLI**
**Per descrivere i dettagli relativi a Windows AMIs configurati per un avvio più rapido**
L'`describe-fast-launch-images`esempio seguente descrive i dettagli di ciascuno degli elementi dell' AMIs account configurati per un avvio più rapido, tra cui il tipo di risorsa, la configurazione dell'istantanea, i dettagli del modello di avvio, il numero massimo di avvii paralleli, l'ID proprietario dell'AMI, lo stato della configurazione di avvio rapido, il motivo per cui lo stato è stato modificato e l'ora in cui è avvenuta la modifica dello stato.
```
aws ec2 describe-fast-launch-images
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni sulla configurazione di un’AMI Windows per un avvio più rapido, consulta [Configurare l’AMI per un avvio più rapido](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/windows-ami-version-history.html#win-ami-config-fast-launch) nella *Guida per l’utente di Amazon EC2*.
+ *Per i dettagli sull'API, consulta Command [DescribeFastLaunchImages](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-fast-launch-images.html)Reference AWS CLI .*
### `describe-fast-snapshot-restores`
Il seguente esempio di codice mostra come utilizzare`describe-fast-snapshot-restores`.
**AWS CLI**
**Come descrivere i ripristini rapidi degli snapshot**
L’esempio `describe-fast-snapshot-restores` seguente visualizza i dettagli di tutti i ripristini rapidi degli snapshot con uno stato di `disabled`.
```
aws ec2 describe-fast-snapshot-restores \
--filters Name=state,Values=disabled
```
Output:
```
{
"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"
}
]
}
```
L’esempio `describe-fast-snapshot-restores` seguente descrive tutti i ripristini rapidi degli snapshot.
```
aws ec2 describe-fast-snapshot-restores
```
+ Per i dettagli sull'API, consulta [DescribeFastSnapshotRestores AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-fast-snapshot-restores.html)*Command Reference*.
### `describe-fleet-history`
Il seguente esempio di codice mostra come utilizzare`describe-fleet-history`.
**AWS CLI**
**Come descrivere la cronologia del parco EC2**
L’esempio `describe-fleet-history` seguente restituisce la cronologia del parco EC2 specificato a partire dall’ora specificata. L’output è per un parco EC2 con due istanze in esecuzione.
```
aws ec2 describe-fleet-history \
--fleet-id fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE \
--start-time 2020-09-01T00:00:00Z
```
Output:
```
{
"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"
}
```
Per ulteriori informazioni, consulta [Gestione di un parco EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html) nella *Guida per l’utente di Amazon Elastic Compute Cloud per le istanze Linux*.
+ Per i dettagli sull'API, consulta [DescribeFleetHistory AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-fleet-history.html)*Command Reference*.
### `describe-fleet-instances`
Il seguente esempio di codice mostra come utilizzare`describe-fleet-instances`.
**AWS CLI**
**Come descrivere le istanze in esecuzione per un parco EC2**
L’esempio `describe-fleet-instances` seguente descrive le istanze in esecuzione per il parco EC2 specificato.
```
aws ec2 describe-fleet-instances \
--fleet-id 12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE
```
Output:
```
{
"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"
}
```
Per ulteriori informazioni, consulta [Gestione di un parco EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html) nella *Guida per l’utente di Amazon Elastic Compute Cloud per le istanze Linux*.
+ Per i dettagli sull'API, consulta [DescribeFleetInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-fleet-instances.html)*Command Reference*.
### `describe-fleets`
Il seguente esempio di codice mostra come utilizzare`describe-fleets`.
**AWS CLI**
**Come descrivere un parco EC2**
L’esempio `describe-fleets` seguente descrive il parco EC2 specificato.
```
aws ec2 describe-fleets \
--fleet-ids fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE
```
Output:
```
{
"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"
}
}
]
}
```
Per ulteriori informazioni, consulta [Gestione di un parco EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html) nella *Guida per l’utente di Amazon Elastic Compute Cloud per le istanze Linux*.
+ Per i dettagli sull'API, consulta [DescribeFleets AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-fleets.html)*Command Reference*.
### `describe-flow-logs`
Il seguente esempio di codice mostra come utilizzare`describe-flow-logs`.
**AWS CLI**
**Esempio 1: come descrivere tutti i log di flusso**
L’esempio `describe-flow-logs` seguente visualizza i dettagli di tutti i log di flusso.
```
aws ec2 describe-flow-logs
```
Output:
```
{
"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}"
}
]
}
```
**Esempio 2: come descrivere un subset di log di flusso**
L'`describe-flow-logs`esempio seguente utilizza un filtro per visualizzare i dettagli solo per i log di flusso che si trovano nel gruppo di log specificato in Amazon CloudWatch Logs.
```
aws ec2 describe-flow-logs \
--filter "Name=log-group-name,Values=MyFlowLogs"
```
+ Per i dettagli sull'API, consulta *AWS CLI Command [DescribeFlowLogs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-flow-logs.html)Reference*.
### `describe-fpga-image-attribute`
Il seguente esempio di codice mostra come utilizzare`describe-fpga-image-attribute`.
**AWS CLI**
**Come descrivere gli attributi di un’immagine FPGA di Amazon (AFI)**
Questo esempio descrive le autorizzazioni di caricamento per l’AFI specificato.
Comando:
```
aws ec2 describe-fpga-image-attribute --fpga-image-id afi-0d123e123bfc85abc --attribute loadPermission
```
Output:
```
{
"FpgaImageAttribute": {
"FpgaImageId": "afi-0d123e123bfc85abc",
"LoadPermissions": [
{
"UserId": "123456789012"
}
]
}
}
```
+ Per i dettagli sull'API, consulta [DescribeFpgaImageAttribute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-fpga-image-attribute.html)*Command Reference*.
### `describe-fpga-images`
Il seguente esempio di codice mostra come utilizzare`describe-fpga-images`.
**AWS CLI**
**Come descrivere le immagini FPGA di Amazon (AFI)**
Questo esempio descrive AFIs che sono di proprietà dell'account`123456789012`.
Comando:
```
aws ec2 describe-fpga-images --filters Name=owner-id,Values=123456789012
```
Output:
```
{
"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"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeFpgaImages AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-fpga-images.html)*Command Reference*.
### `describe-host-reservation-offerings`
Il seguente esempio di codice mostra come utilizzare`describe-host-reservation-offerings`.
**AWS CLI**
**Come descrivere le offerte per le prenotazioni degli host dedicati**
Questo esempio descrive le prenotazioni di host dedicati per la famiglia di istanze M4 disponibili per l’acquisto.
Comando:
```
aws ec2 describe-host-reservation-offerings --filter Name=instance-family,Values=m4
```
Output:
```
{
"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
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeHostReservationOfferings AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-host-reservation-offerings.html)*Command Reference*.
### `describe-host-reservations`
Il seguente esempio di codice mostra come utilizzare`describe-host-reservations`.
**AWS CLI**
**Come descrivere le prenotazioni di host dedicati nell’account in uso**
Questo esempio descrive le prenotazioni di host dedicati nell’account in uso.
Comando:
```
aws ec2 describe-host-reservations
```
Output:
```
{
"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
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeHostReservations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-host-reservations.html)*Command Reference*.
### `describe-hosts`
Il seguente esempio di codice mostra come utilizzare`describe-hosts`.
**AWS CLI**
**Come visualizzare i dettagli degli host dedicati**
L'`describe-hosts`esempio seguente mostra i dettagli degli host `available` dedicati del tuo AWS account.
```
aws ec2 describe-hosts --filter "Name=state,Values=available"
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzazione di host dedicati](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/how-dedicated-hosts-work.html#dedicated-hosts-managing) nella *Guida per l’utente di Amazon Elastic Compute Cloud per le istanze Linux*.
+ Per i dettagli sull'API, consulta [DescribeHosts AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-hosts.html)*Command Reference*.
### `describe-iam-instance-profile-associations`
Il seguente esempio di codice mostra come utilizzare`describe-iam-instance-profile-associations`.
**AWS CLI**
**Come descrivere le associazioni del profilo dell’istanza IAM**
In questo esempio vengono descritte tutte le associazioni del profilo dell’istanza IAM.
Comando:
```
aws ec2 describe-iam-instance-profile-associations
```
Output:
```
{
"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"
}
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeIamInstanceProfileAssociations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-iam-instance-profile-associations.html)*Command Reference*.
### `describe-id-format`
Il seguente esempio di codice mostra come utilizzare`describe-id-format`.
**AWS CLI**
**Esempio 1: come descrivere il formato di ID di una risorsa**
L’esempio `describe-id-format` seguente descrive il formato ID del gruppo di sicurezza.
```
aws ec2 describe-id-format \
--resource security-group
```
Nell’output di esempio seguente, il valore `Deadline` indica che per questo tipo di risorsa il tempo massimo per il passaggio definitivo dal formato ID breve al formato ID lungo è scaduto alle 00:00 UTC del 15 agosto 2018.
```
{
"Statuses": [
{
"Deadline": "2018-08-15T00:00:00.000Z",
"Resource": "security-group",
"UseLongIds": true
}
]
}
```
**Esempio 2: come descrivere il formato di ID di tutte le risorse**
L’esempio `describe-id-format` seguente descrive il formato ID di tutti i tipi di risorse. Tutti i tipi di risorse che supportavano il formato ID breve sono stati convertiti al formato ID lungo.
```
aws ec2 describe-id-format
```
+ Per i dettagli sull'API, consulta [DescribeIdFormat AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-id-format.html)*Command Reference*.
### `describe-identity-id-format`
Il seguente esempio di codice mostra come utilizzare`describe-identity-id-format`.
**AWS CLI**
**Come descrivere il formato di ID per un ruolo IAM**
L'`describe-identity-id-format`esempio seguente descrive il formato ID ricevuto dalle istanze create dal ruolo IAM `EC2Role` nel tuo AWS account.
```
aws ec2 describe-identity-id-format \
--principal-arn arn:aws:iam::123456789012:role/my-iam-role \
--resource instance
```
L'output seguente indica che le istanze create da questo ruolo ricevono IDs in formato ID lungo.
```
{
"Statuses": [
{
"Deadline": "2016-12-15T00:00:00Z",
"Resource": "instance",
"UseLongIds": true
}
]
}
```
**Come descrivere il formato di ID per un utente IAM**
L'`describe-identity-id-format`esempio seguente descrive il formato ID ricevuto dagli snapshot creati dall'utente IAM `AdminUser` nel tuo AWS account.
```
aws ec2 describe-identity-id-format \
--principal-arn arn:aws:iam::123456789012:user/AdminUser \
--resource snapshot
```
L'output indica che le istantanee create da questo utente vengono ricevute IDs in formato ID lungo.
```
{
"Statuses": [
{
"Deadline": "2016-12-15T00:00:00Z",
"Resource": "snapshot",
"UseLongIds": true
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeIdentityIdFormat AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-identity-id-format.html)*Command Reference.*
### `describe-image-attribute`
Il seguente esempio di codice mostra come utilizzare`describe-image-attribute`.
**AWS CLI**
**Come descrivere le autorizzazioni di avvio di un’AMI**
Questo esempio descrive le autorizzazioni di avvio per l’AMI specificata.
Comando:
```
aws ec2 describe-image-attribute --image-id ami-5731123e --attribute launchPermission
```
Output:
```
{
"LaunchPermissions": [
{
"UserId": "123456789012"
}
],
"ImageId": "ami-5731123e",
}
```
**Come descrivere i codici prodotto di un’AMI**
Questo esempio descrive i codici prodotto per l’AMI specificata. Nota che questa AMI non dispone di codici prodotto.
Comando:
```
aws ec2 describe-image-attribute --image-id ami-5731123e --attribute productCodes
```
Output:
```
{
"ProductCodes": [],
"ImageId": "ami-5731123e",
}
```
+ Per i dettagli sull'API, consulta [DescribeImageAttribute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-image-attribute.html)*Command Reference*.
### `describe-images`
Il seguente esempio di codice mostra come utilizzare`describe-images`.
**AWS CLI**
**Esempio 1: come descrivere un’AMI**
Nell’esempio di `describe-images` seguente viene descritta l’AMI specificata nella regione specificata.
```
aws ec2 describe-images \
--region us-east-1 \
--image-ids ami-1234567890EXAMPLE
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Amazon Machine Image (AMI)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: Descrivere AMIs in base ai filtri**
L'`describe-images`esempio seguente descrive Windows AMIs fornito da Amazon e supportato da Amazon EBS.
```
aws ec2 describe-images \
--owners amazon \
--filters "Name=platform,Values=windows" "Name=root-device-type,Values=ebs"
```
Per un esempio dell’output di `describe-images`, consulta l’Esempio 1.
Per ulteriori esempi di utilizzo dei filtri, consulta [Elencare e filtrare le risorse](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Filtering.html#Filtering_Resources_CLI) nella *Guida per l’utente di Amazon EC2*.
**Esempio 3: descrivere in AMIs base ai tag**
L'`describe-images`esempio seguente descrive tutto ciò AMIs che ha il tag`Type=Custom`. L'esempio utilizza il `--query` parametro per visualizzare solo l'AMI IDs.
```
aws ec2 describe-images \
--filters "Name=tag:Type,Values=Custom" \
--query 'Images[*].[ImageId]' \
--output text
```
Output:
```
ami-1234567890EXAMPLE
ami-0abcdef1234567890
```
Per ulteriori esempi di utilizzo dei filtri di tag, consulta [Utilizzo dei tag](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_CLI) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, vedere [DescribeImages](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-images.html)in *AWS CLI Command Reference*.
### `describe-import-image-tasks`
Il seguente esempio di codice mostra come utilizzare`describe-import-image-tasks`.
**AWS CLI**
**Come monitorare un’attività di importazione di immagini**
L’esempio `describe-import-image-tasks` seguente controlla lo stato dell’attività di importazione di immagini specificata.
```
aws ec2 describe-import-image-tasks \
--import-task-ids import-ami-1234567890abcdef0
```
Output di un’attività di importazione di immagini in corso.
```
{
"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"
}
]
}
```
Output di un’attività di importazione di immagini completata. L’ID dell’AMI risultante è fornito da `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"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeImportImageTasks AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-import-image-tasks.html)*Command Reference*.
### `describe-import-snapshot-tasks`
Il seguente esempio di codice mostra come utilizzare`describe-import-snapshot-tasks`.
**AWS CLI**
**Come monitorare un’attività di importazione di snapshot**
L’esempio `describe-import-snapshot-tasks` seguente controlla lo stato dell’attività di importazione di snapshot specificata.
```
aws ec2 describe-import-snapshot-tasks \
--import-task-ids import-snap-1234567890abcdef0
```
Output di un’attività di importazione di snapshot in corso:
```
{
"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"
}
}
}
]
}
```
Output di un’attività di importazione di snapshot completata. L’ID dello snapshot risultante è fornito da `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"
}
}
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeImportSnapshotTasks AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-import-snapshot-tasks.html)*Command Reference*.
### `describe-instance-attribute`
Il seguente esempio di codice mostra come utilizzare`describe-instance-attribute`.
**AWS CLI**
**Come descrivere il tipo di istanza**
Questo esempio descrive il tipo di istanza dell’istanza specificata.
Comando:
```
aws ec2 describe-instance-attribute --instance-id i-1234567890abcdef0 --attribute instanceType
```
Output:
```
{
"InstanceId": "i-1234567890abcdef0"
"InstanceType": {
"Value": "t1.micro"
}
}
```
**Per descrivere l' disableApiTermination attributo**
Questo esempio descrive l’attributo `disableApiTermination` dell’istanza specificata.
Comando:
```
aws ec2 describe-instance-attribute --instance-id i-1234567890abcdef0 --attribute disableApiTermination
```
Output:
```
{
"InstanceId": "i-1234567890abcdef0"
"DisableApiTermination": {
"Value": "false"
}
}
```
**Come descrivere la mappatura dei dispositivi a blocchi per un’istanza**
Questo esempio descrive l’attributo `blockDeviceMapping` dell’istanza specificata.
Comando:
```
aws ec2 describe-instance-attribute --instance-id i-1234567890abcdef0 --attribute blockDeviceMapping
```
Output:
```
{
"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"
}
}
],
}
```
+ Per i dettagli sull'API, consulta [DescribeInstanceAttribute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-attribute.html)*Command Reference*.
### `describe-instance-connect-endpoints`
Il seguente esempio di codice mostra come utilizzare`describe-instance-connect-endpoints`.
**AWS CLI**
**Come descrivere un endpoint EC2 Instance Connect**
L’esempio `describe-instance-connect-endpoints` seguente descrive un endpoint EC2 Instance Connect specificato.
```
aws ec2 describe-instance-connect-endpoints \
--region us-east-1 \
--instance-connect-endpoint-ids eice-0123456789example
```
Output:
```
{
"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": []
}
]
}
```
Per ulteriori informazioni, consulta [Creazione di un endpoint EC2 Instance Connect](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-ec2-instance-connect-endpoints.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DescribeInstanceConnectEndpoints AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-connect-endpoints.html)*Command Reference*.
### `describe-instance-credit-specifications`
Il seguente esempio di codice mostra come utilizzare`describe-instance-credit-specifications`.
**AWS CLI**
**Come descrivere l’opzione di credito per l’utilizzo della CPU di una o più istanze**
L’esempio `describe-instance-credit-specifications` seguente descrive l’opzione di credito CPU per l’istanza specificata.
```
aws ec2 describe-instance-credit-specifications \
--instance-ids i-1234567890abcdef0
```
Output:
```
{
"InstanceCreditSpecifications": [
{
"InstanceId": "i-1234567890abcdef0",
"CpuCredits": "unlimited"
}
]
}
```
Per ulteriori informazioni, consulta [Utilizzo di istanze a prestazioni espandibili](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-how-to.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DescribeInstanceCreditSpecifications AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-credit-specifications.html)*Command Reference*.
### `describe-instance-event-notification-attributes`
Il seguente esempio di codice mostra come utilizzare`describe-instance-event-notification-attributes`.
**AWS CLI**
**Come descrivere i tag per le notifiche di eventi pianificati**
L’esempio `describe-instance-event-notification-attributes` seguente descrive i tag da visualizzare nelle notifiche di eventi pianificati.
```
aws ec2 describe-instance-event-notification-attributes
```
Output:
```
{
"InstanceTagAttribute": {
"InstanceTagKeys": [],
"IncludeAllTagsOfInstance": true
}
}
```
Per ulteriori informazioni, consulta [Eventi pianificati per le istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html) nella *Guida per l’utente di Amazon Elastic Compute Cloud per le istanze Linux*.
+ Per i dettagli sull'API, consulta [DescribeInstanceEventNotificationAttributes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-event-notification-attributes.html)*Command Reference*.
### `describe-instance-event-windows`
Il seguente esempio di codice mostra come utilizzare`describe-instance-event-windows`.
**AWS CLI**
**Esempio 1: come descrivere tutte le finestre di eventi**
L’esempio `describe-instance-event-windows` seguente descrive tutte le finestre di eventi nella Regione specificata.
```
aws ec2 describe-instance-event-windows \
--region us-east-1
```
Output:
```
{
"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"
}
```
**Esempio 2: come descrivere una finestra di eventi specifica**
L’esempio `describe-instance-event-windows` seguente descrive un evento specifico utilizzando il parametro `instance-event-window` per descrivere una finestra di eventi specifica.
```
aws ec2 describe-instance-event-windows \
--region us-east-1 \
--instance-event-window-ids iew-0abcdef1234567890
```
Output:
```
{
"InstanceEventWindows": [
{
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"AssociationTarget": {
"InstanceIds": [
"i-1234567890abcdef0",
"i-0598c7d356eba48d7"
],
"Tags": [],
"DedicatedHostIds": []
},
"State": "active",
"Tags": []
}
}
```
**Esempio 3: come descrivere le finestre di eventi che corrispondono a uno o più filtri**
L’esempio `describe-instance-event-windows` seguente descrive le finestre di eventi che corrispondono a uno o più filtri tramite il parametro `filter`. Il filtro `instance-id` viene utilizzato per descrivere tutte le finestre di eventi associate all’istanza specificata. Quando viene utilizzato un filtro, si stabilisce una corrispondenza diretta. Tuttavia, il filtro `instance-id` è diverso. Se non esiste una corrispondenza diretta con l’ID istanza, viene restituito alle associazioni indirette con la finestra di eventi, ad esempio i tag dell’istanza o l’ID host dedicato (se l’istanza si trova su un host dedicato).
```
aws ec2 describe-instance-event-windows \
--region us-east-1 \
--filters Name=instance-id,Values=i-1234567890abcdef0 \
--max-results 100 \
--next-token
```
Output:
```
{
"InstanceEventWindows": [
{
"InstanceEventWindowId": "iew-0dbc0adb66f235982",
"TimeRanges": [
{
"StartWeekDay": "sunday",
"StartHour": 2,
"EndWeekDay": "sunday",
"EndHour": 8
}
],
"Name": "myEventWindowName",
"AssociationTarget": {
"InstanceIds": [],
"Tags": [],
"DedicatedHostIds": [
"h-0140d9a7ecbd102dd"
]
},
"State": "active",
"Tags": []
}
]
}
```
Nell’output di esempio, l’istanza si trova su un host dedicato, associato alla finestra di eventi.
Per i vincoli relativi alla finestra di eventi, consulta [Considerazioni](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DescribeInstanceEventWindows AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-event-windows.html)*Command Reference*.
### `describe-instance-image-metadata`
Il seguente esempio di codice mostra come utilizzare`describe-instance-image-metadata`.
**AWS CLI**
**Esempio 1: come descrivere i metadati AMI per tutte le istanze**
L'`describe-instance-image-metadata`esempio seguente descrive i metadati AMI di tutte le istanze del tuo AWS account nella regione specificata.
```
aws ec2 describe-instance-image-metadata \
--region us-east-1
```
Output:
```
{
"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..."
}
```
Per ulteriori informazioni, consulta [Amazon Machine Image in Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come descrivere i metadati AMI per le istanze specificate**
L’esempio `describe-instance-image-metadata` seguente descrive i metadati AMI per le istanze specificate.
```
aws ec2 describe-instance-image-metadata \
--region us-east-1 \
--instance-ids i-1234567890EXAMPLE i-0987654321EXAMPLE
```
Output:
```
{
"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
}
}
]
}
```
Per ulteriori informazioni, consulta [Amazon Machine Image in Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 3: come descrivere i metadati AMI per le istanze basate sui filtri**
L’esempio `describe-instance-image-metadata` seguente descrive i metadati AMI per le istanze `t2.nano` e `t2.micro` nella zona di disponibilità `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
```
Output:
```
{
"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..."
}
```
Per ulteriori informazioni, consulta [Amazon Machine Image in Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [DescribeInstanceImageMetadata](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-image-metadata.html)Reference*.
### `describe-instance-status`
Il seguente esempio di codice mostra come utilizzare`describe-instance-status`.
**AWS CLI**
**Come descrivere lo stato delle istanze**
Nell’esempio di `describe-instance-status` seguente viene descritto lo stato attuale dell’istanza specificata.
```
aws ec2 describe-instance-status \
--instance-ids i-1234567890abcdef0
```
Output:
```
{
"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"
}
]
}
}
]
}
```
Per ulteriori informazioni, consulta [Monitoraggio dello stato delle istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DescribeInstanceStatus AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-status.html)*Command Reference*.
### `describe-instance-topology`
Il seguente esempio di codice mostra come utilizzare`describe-instance-topology`.
**AWS CLI**
**Come descrivere la topologia dell’istanza di tutte le istanze**
L’esempio `describe-instance-topology` seguente descrive la topologia di tutte le istanze che corrispondono ai tipi di istanze supportati per questo comando.
```
aws ec2 describe-instance-topology \
--region us-west-2
```
Output:
```
{
"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"
}
```
Per ulteriori informazioni, inclusi altri esempi, consulta la [Topologia dell’istanza Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-topology.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DescribeInstanceTopology AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-topology.html)*Command Reference*.
### `describe-instance-type-offerings`
Il seguente esempio di codice mostra come utilizzare`describe-instance-type-offerings`.
**AWS CLI**
**Esempio 1: come elencare i tipi di istanze offerti in una Regione**
L'`describe-instance-type-offerings`esempio seguente elenca i tipi di istanza offerti nella regione configurata come regione predefinita per la AWS CLI.
```
aws ec2 describe-instance-type-offerings
```
Per elencare i tipi di istanza offerti in una Regione differente, specifica la Regione utilizzando il parametro `--region`.
```
aws ec2 describe-instance-type-offerings \
--region us-east-2
```
Output:
```
{
"InstanceTypeOfferings": [
{
"InstanceType": "m5.2xlarge",
"LocationType": "region",
"Location": "us-east-2"
},
{
"InstanceType": "t3.micro",
"LocationType": "region",
"Location": "us-east-2"
},
...
]
}
```
**Esempio 2: come elencare i tipi di istanza offerti in una zona di disponibilità**
L’esempio `describe-instance-type-offerings` seguente visualizza i tipi di istanza offerti nella zona di disponibilità specificata. La zona di disponibilità deve trovarsi nella Regione specificata.
```
aws ec2 describe-instance-type-offerings \
--location-type availability-zone \
--filters Name=location,Values=us-east-2a \
--region us-east-2
```
**Esempio 3: come verificare se un tipo di istanza è supportato**
Il comando `describe-instance-type-offerings` seguente indica se il tipo di istanza `c5.xlarge` è supportato nella Regione specificata.
```
aws ec2 describe-instance-type-offerings \
--filters Name=instance-type,Values=c5.xlarge \
--region us-east-2
```
L’esempio `describe-instance-type-offerings` seguente elenca tutti i tipi di istanza C5 supportati nella Regione specificata.
```
aws ec2 describe-instance-type-offerings \
--filters Name=instance-type,Values=c5* \
--query "InstanceTypeOfferings[].InstanceType" \
--region us-east-2
```
Output:
```
[
"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"
]
```
+ Per i dettagli sull'API, consulta [DescribeInstanceTypeOfferings AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-type-offerings.html)*Command Reference.*
### `describe-instance-types`
Il seguente esempio di codice mostra come utilizzare`describe-instance-types`.
**AWS CLI**
**Esempio 1: come descrivere un tipo di istanza**
Nell’esempio di `describe-instance-types` seguente vengono visualizzati i dettagli del tipo di istanza specificato.
```
aws ec2 describe-instance-types \
--instance-types t2.micro
```
Output:
```
{
"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
}
]
}
```
Per ulteriori informazioni, consulta [Tipi di istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) nella *Guida per l’utente di Amazon Elastic Compute Cloud per le istanze Linux*.
**Esempio 2: come filtrare i tipi di istanza disponibili**
È possibile specificare un filtro per rifinire i risultati in base ai tipi di istanza che hanno una caratteristica specifica. Nell’esempio di `describe-instance-types` seguente vengono elencati i tipi di istanza che supportano l’ibernazione.
```
aws ec2 describe-instance-types \
--filters Name=hibernation-supported,Values=true --query 'InstanceTypes[*].InstanceType'
```
Output:
```
[
"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"
]
```
Per ulteriori informazioni, consulta [Tipi di istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) nella *Guida per l’utente di Amazon Elastic Compute Cloud per le istanze Linux*.
+ Per i dettagli sull'API, consulta [DescribeInstanceTypes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instance-types.html)*Command Reference*.
### `describe-instances`
Il seguente esempio di codice mostra come utilizzare`describe-instances`.
**AWS CLI**
**Esempio 1: come descrivere un’istanza**
Nell’esempio di `describe-instances` seguente viene descritta l’istanza specificata.
```
aws ec2 describe-instances \
--instance-ids i-1234567890abcdef0
```
Output:
```
{
"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"
}
]
}
```
**Esempio 2: come filtrare per istanze secondo il tipo specificato**
Nell’esempio di `describe-instances` seguente vengono utilizzati filtri per rifinire i risultati in base alle istanze del tipo specificato.
```
aws ec2 describe-instances \
--filters Name=instance-type,Values=m5.large
```
Per un output di esempio, consulta l’Esempio 1.
Per ulteriori informazioni, consulta [Elencare e filtrare tramite la CLI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Filtering.html#Filtering_Resources_CLI) nella *Guida per l’utente di Amazon EC2*.
**Esempio 3: come filtrare per istanze secondo il tipo e la zona di disponibilità specificati**
Nell’esempio di `describe-instances` seguente vengono utilizzati più filtri per rifinire i risultati in base alle istanze del tipo specificato che si trovano anche nella zona di disponibilità specificata.
```
aws ec2 describe-instances \
--filters Name=instance-type,Values=t2.micro,t3.micro Name=availability-zone,Values=us-east-2c
```
Per un output di esempio, vedi l’Esempio 1.
**Esempio 4: come filtrare per istanze secondo il tipo e la zona di disponibilità specificati utilizzando un file JSON**
Nell’esempio di `describe-instances` seguente viene utilizzato un file di input JSON per eseguire gli stessi filtri definiti nell’esempio precedente. Quando i filtri diventano più complicati, può essere più facile specificarli in un file JSON.
```
aws ec2 describe-instances \
--filters file://filters.json
```
Contenuto di `filters.json`:
```
[
{
"Name": "instance-type",
"Values": ["t2.micro", "t3.micro"]
},
{
"Name": "availability-zone",
"Values": ["us-east-2c"]
}
]
```
Per un output di esempio, vedi l’Esempio 1.
**Esempio 5: come filtrare per istanze secondo il tag Proprietario specificato**
Nell’esempio di `describe-instances` seguente vengono utilizzati filtri tag per rifinire i risultati in base alle istanze che hanno un tag con la chiave tag specificata (Proprietario), a prescindere dal valore del tag.
```
aws ec2 describe-instances \
--filters "Name=tag-key,Values=Owner"
```
Per un output di esempio, vedi l’Esempio 1.
**Esempio 6: come filtrare per istanze secondo il valore tag my-team specificato**
Nell’esempio di `describe-instances` seguente vengono utilizzati filtri tag per rifinire i risultati in base alle istanze che hanno un tag con il valore tag specificato (my-team), a prescindere dalla chiave del tag.
```
aws ec2 describe-instances \
--filters "Name=tag-value,Values=my-team"
```
Per un output di esempio, vedi l’Esempio 1.
**Esempio 7: come filtrare le istanze secondo i valori tag Proprietario e my-team specificati**
Nell’esempio di `describe-instances` seguente vengono utilizzati filtri tag per rifinire i risultati in base alle istanze che hanno il tag specificato (Proprietario=my-team).
```
aws ec2 describe-instances \
--filters "Name=tag:Owner,Values=my-team"
```
Per un output di esempio, vedi l’Esempio 1.
**Esempio 8: Per visualizzare solo l'istanza e la sottorete IDs per tutte le istanze**
`describe-instances`Gli esempi seguenti utilizzano il `--query` parametro per visualizzare solo l'istanza e la sottorete IDs per tutte le istanze, in 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
```
Output:
```
[
{
"Instance": "i-057750d42936e468a",
"Subnet": "subnet-069beee9b12030077"
},
{
"Instance": "i-001efd250faaa6ffa",
"Subnet": "subnet-0b715c6b7db68927a"
},
{
"Instance": "i-027552a73f021f3bd",
"Subnet": "subnet-0250c25a1f4e15235"
}
...
]
```
**Esempio 9: per filtrare le istanze del tipo specificato e visualizzare solo le relative istanze IDs**
L'`describe-instances`esempio seguente utilizza i filtri per limitare i risultati alle istanze del tipo specificato e il `--query` parametro per visualizzare solo l'istanza. IDs
```
aws ec2 describe-instances \
--filters "Name=instance-type,Values=t2.micro" \
--query "Reservations[*].Instances[*].[InstanceId]" \
--output text
```
Output:
```
i-031c0dc19de2fb70c
i-00d8bff789a736b75
i-0b715c6b7db68927a
i-0626d4edd54f1286d
i-00b8ae04f9f99908e
i-0fc71c25d2374130c
```
**Esempio 10: per filtrare le istanze del tipo specificato e visualizzare solo la relativa istanza IDs, la zona di disponibilità e il valore del tag specificato**
Negli esempi di `describe-instances` seguenti vengono visualizzati l’ID dell’istanza, la zona di disponibilità e il valore del tag `Name` per le istanze che hanno un tag con il nome `tag-key`, in formato tabella.
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
```
Output:
```
-------------------------------------------------------------
| 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 |
+--------------+-----------------------+--------------------+
```
**Esempio 11: come descrivere le istanze in un gruppo di posizionamento delle partizioni**
L’esempio `describe-instances` seguente descrive l’istanza specificata. L’output include le informazioni di collocamento dell’istanza, che a loro volta comprendono il nome del gruppo di collocamento e il numero di partizioni per l’istanza.
```
aws ec2 describe-instances \
--instance-ids i-0123a456700123456 \
--query "Reservations[*].Instances[*].Placement"
```
Output:
```
[
[
{
"AvailabilityZone": "us-east-1c",
"GroupName": "HDFS-Group-A",
"PartitionNumber": 3,
"Tenancy": "default"
}
]
]
```
Per ulteriori informazioni, consulta [Descrizione di istanze in un gruppo di collocamento](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html#describe-instance-placement) nella *Guida per l’utente di Amazon EC2*.
**Esempio 12: come filtrare le istanze secondo il gruppo di collocamento e il numero di partizioni specificati**
Nell’esempio di `describe-instances` seguente i risultati vengono filtrati solamente in base alle istanze con il gruppo di collocamento e il numero di partizioni specificati.
```
aws ec2 describe-instances \
--filters "Name=placement-group-name,Values=HDFS-Group-A" "Name=placement-partition-number,Values=7"
```
Di seguito vengono mostrate solo le informazioni rilevanti contenute nell’output.
```
"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"
}
],
```
Per ulteriori informazioni, consulta [Descrizione di istanze in un gruppo di collocamento](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html#describe-instance-placement) nella *Guida per l’utente di Amazon EC2*.
**Esempio 13: come filtrare le istanze configurate per consentire l’accesso ai tag dai metadati dell’istanza**
Nell’esempio di `describe-instances` seguente i risultati vengono filtrati solamente in base alle istanze configurate per consentire l’accesso ai tag dell’istanza dai metadati dell’istanza stessa.
```
aws ec2 describe-instances \
--filters "Name=metadata-options.instance-metadata-tags,Values=enabled" \
--query "Reservations[*].Instances[*].InstanceId" \
--output text
```
Di seguito è riportato l’output previsto.
```
i-1234567890abcdefg
i-abcdefg1234567890
i-11111111aaaaaaaaa
i-aaaaaaaa111111111
```
Per ulteriori informazioni, consulta [Utilizzo dei tag dell’istanza nei metadati dell’istanza](https://docs.aws.amazon.com/en_us/AWSEC2/latest/UserGuide/Using_Tags.html#view-access-to-tags-in-IMDS) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DescribeInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instances.html)*Command Reference.*
### `describe-internet-gateways`
Il seguente esempio di codice mostra come utilizzare`describe-internet-gateways`.
**AWS CLI**
**Come descrivere un gateway Internet**
L’esempio `describe-internet-gateways` seguente descrive il gateway Internet specificato.
```
aws ec2 describe-internet-gateways \
--internet-gateway-ids igw-0d0fb496b3EXAMPLE
```
Output:
```
{
"InternetGateways": [
{
"Attachments": [
{
"State": "available",
"VpcId": "vpc-0a60eb65b4EXAMPLE"
}
],
"InternetGatewayId": "igw-0d0fb496b3EXAMPLE",
"OwnerId": "123456789012",
"Tags": [
{
"Key": "Name",
"Value": "my-igw"
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Gateway Internet](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [DescribeInternetGateways AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-internet-gateways.html)*Command Reference*.
### `describe-ipam-pools`
Il seguente esempio di codice mostra come utilizzare`describe-ipam-pools`.
**AWS CLI**
**Come visualizzare i dettagli di un pool IPAM**
L’esempio `describe-ipam-pools` seguente mostra i dettagli per i pool.
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
```
Output:
```
{
"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"
}
]
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeIpamPools AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-ipam-pools.html)*Command Reference*.
### `describe-ipam-resource-discoveries`
Il seguente esempio di codice mostra come utilizzare`describe-ipam-resource-discoveries`.
**AWS CLI**
**Esempio 1: come visualizzare i dettagli completi delle Individuazioni di risorse**
In questo esempio, sei un amministratore IPAM delegato che desidera creare e condividere un rilevamento delle risorse con l'amministratore IPAM di un'altra AWS organizzazione in modo che l'amministratore possa gestire e monitorare gli indirizzi IP delle risorse dell'organizzazione.
Questo esempio può essere utile se:
Si è cercato di creare un rilevamento di risorse, ma è stato visualizzato un errore che indica che è stato raggiunto il limite di 1. Ci si rende conto di aver già creato un rilevamento di risorse e si desidera visualizzarlo nell’account in uso. Si dispone di risorse in una Regione che non vengono rilevate dall’IPAM. Si desidera visualizzare le `--operating-regions` definite per la risorsa e assicurarti di aver aggiunto la Regione corretta come Regione operativa, in modo che le risorse presenti possano essere rilevate.
L'`describe-ipam-resource-discoveries`esempio seguente elenca i dettagli della scoperta delle risorse nel tuo account. AWS È possibile effettuare una sola ricerca di risorse per AWS regione.
```
aws ec2 describe-ipam-resource-discoveries \
--region us-east-1
```
Output:
```
{
"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": []
}
]
}
```
Per ulteriori informazioni, consulta [Come integrare IPAM con account esterni alla tua organizzazione](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam-outside-org.html) nella *Guida per l’utente IPAM di Amazon VPC*.
**Esempio 2: Visualizza solo l'individuazione delle risorse IDs**
L'`describe-ipam-resource-discoveries`esempio seguente elenca l'ID della scoperta delle risorse nel tuo AWS account. È possibile effettuare una sola ricerca di risorse per AWS regione.
```
aws ec2 describe-ipam-resource-discoveries \
--query "IpamResourceDiscoveries[*].IpamResourceDiscoveryId" \
--output text
```
Output:
```
ipam-res-disco-0481e39b242860333
```
Per ulteriori informazioni, consulta [Come integrare IPAM con account esterni alla tua organizzazione](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam-outside-org.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta [DescribeIpamResourceDiscoveries AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-ipam-resource-discoveries.html)*Command Reference*.
### `describe-ipam-resource-discovery-associations`
Il seguente esempio di codice mostra come utilizzare`describe-ipam-resource-discovery-associations`.
**AWS CLI**
**Come visualizzare tutte le associazioni di rilevamento delle risorse con l’IPAM in uso**
In questo esempio, un amministratore delegato IPAM dispone di rilevamenti di risorse associati all’IPAM in uso per integrare altri account con l’IPAM in uso. IPAM non rileva le risorse nelle Regioni operative del rilevamento di risorse come previsto. Si vuole controllare lo stato e la situazione del rilevamento di risorse per assicurarsi che l’account utilizzato per crearla sia ancora attivo e che il rilevamento di risorse sia ancora condiviso.
`--region` deve essere la Regione di origine dell’IPAM.
L'`describe-ipam-resource-discovery-associations`esempio seguente elenca le associazioni di ricerca delle risorse nel tuo AWS account.
```
aws ec2 describe-ipam-resource-discovery-associations \
--region us-east-1
```
Output:
```
{
"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": []
}
]
}
```
In questo esempio, dopo aver eseguito questo comando, si nota che è disponibile un rilevamento di risorse non predefinito (`"IsDefault": false ``) that is ``"ResourceDiscoveryStatus": "not-found"` e `"State": "create-complete"`. L’account del proprietario del rilevamento di risorse è stato chiuso. Se, in un altro caso, si nota che è `"ResourceDiscoveryStatus": "not-found"` e `"State": "associate-complete"`, ciò indica che si è verificata una delle seguenti situazioni:
Il rilevamento delle risorse è stato eliminato dal proprietario del rilevamento. Il proprietario del rilevamento delle risorse ha annullato la condivisione del rilevamento delle risorse.
Per ulteriori informazioni, consulta [Come integrare IPAM con account esterni alla tua organizzazione](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam-outside-org.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta [DescribeIpamResourceDiscoveryAssociations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-ipam-resource-discovery-associations.html)*Command Reference*.
### `describe-ipam-scopes`
Il seguente esempio di codice mostra come utilizzare`describe-ipam-scopes`.
**AWS CLI**
**Come visualizzare i dettagli di un ambito IPAM**
L’esempio `describe-ipam-scopes` seguente mostra i dettagli per gli ambiti.
```
aws ec2 describe-ipam-scopes \
--filters Name=owner-id,Values=123456789012 Name=ipam-id,Values=ipam-08440e7a3acde3908
```
Output:
```
{
"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"
}
]
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeIpamScopes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-ipam-scopes.html)*Command Reference*.
### `describe-ipams`
Il seguente esempio di codice mostra come utilizzare`describe-ipams`.
**AWS CLI**
**Come visualizzare i dettagli IPAM**
L’esempio `describe-ipams` seguente mostra i dettagli di un’IPAM.
```
aws ec2 describe-ipams \
--filters Name=owner-id,Values=123456789012
```
Output:
```
{
"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"
}
]
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeIpams AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-ipams.html)*Command Reference*.
### `describe-ipv6-pools`
Il seguente esempio di codice mostra come utilizzare`describe-ipv6-pools`.
**AWS CLI**
**Per descrivere i tuoi pool di IPv6 indirizzi**
L'`describe-ipv6-pools`esempio seguente mostra i dettagli di tutti i tuoi pool di IPv6 indirizzi.
```
aws ec2 describe-ipv6-pools
```
Output:
```
{
"Ipv6Pools": [
{
"PoolId": "ipv6pool-ec2-012345abc12345abc",
"PoolCidrBlocks": [
{
"Cidr": "2001:db8:123::/48"
}
],
"Tags": [
{
"Key": "pool-1",
"Value": "public"
}
]
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeIpv6Pools](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-ipv6-pools.html) in *AWS CLI Command Reference.*
### `describe-key-pairs`
Il seguente esempio di codice mostra come utilizzare`describe-key-pairs`.
**AWS CLI**
**Come visualizzare una coppia di chiavi**
Nell’esempio di `describe-key-pairs` seguente vengono visualizzate informazioni sulla coppia di chiavi specificata.
```
aws ec2 describe-key-pairs \
--key-names my-key-pair
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Descrizione delle chiavi pubbliche](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/describe-keys.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DescribeKeyPairs AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-key-pairs.html)*Command Reference*.
### `describe-launch-template-versions`
Il seguente esempio di codice mostra come utilizzare`describe-launch-template-versions`.
**AWS CLI**
**Come descrivere le versioni del modello di avvio**
Questo esempio descrive le versioni del modello di avvio specificato.
Comando:
```
aws ec2 describe-launch-template-versions --launch-template-id lt-068f72b72934aff71
```
Output:
```
{
"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"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeLaunchTemplateVersions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-launch-template-versions.html)*Command Reference*.
### `describe-launch-templates`
Il seguente esempio di codice mostra come utilizzare`describe-launch-templates`.
**AWS CLI**
**Come descrivere i modelli di avvio**
Questo esempio descrive i modelli di avvio in uso.
Comando:
```
aws ec2 describe-launch-templates
```
Output:
```
{
"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"
},
]
}
```
+ Per i dettagli sull'API, consulta [DescribeLaunchTemplates AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-launch-templates.html)*Command Reference*.
### `describe-local-gateway-route-table-virtual-interface-group-associations`
Il seguente esempio di codice mostra come utilizzare`describe-local-gateway-route-table-virtual-interface-group-associations`.
**AWS CLI**
**Come descrivere le associazioni tra gruppi di interfacce virtuali e tabelle di routing del gateway locale**
L'`describe-local-gateway-route-table-virtual-interface-group-associations`esempio seguente descrive le associazioni tra i gruppi di interfacce virtuali e le tabelle di routing del gateway locale presenti nell' AWS account.
```
aws ec2 describe-local-gateway-route-table-virtual-interface-group-associations
```
Output:
```
{
"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": []
}
]
}
```
Per ulteriori informazioni, consulta [Utilizzo di gateway locali](https://docs.aws.amazon.com/outposts/latest/userguide/outposts-local-gateways.html) nella *Guida per l’utente di AWS Outposts*.
+ Per i dettagli sull'API, consulta [DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-local-gateway-route-table-virtual-interface-group-associations.html)*Command Reference*.
### `describe-local-gateway-route-table-vpc-associations`
Il seguente esempio di codice mostra come utilizzare`describe-local-gateway-route-table-vpc-associations`.
**AWS CLI**
**Per descrivere le associazioni tra le tabelle di routing del gateway locale VPCs e le tabelle di routing**
L'`describe-local-gateway-route-table-vpc-associations`esempio seguente visualizza informazioni sull'associazione specificata tra le tabelle di routing del gateway locale VPCs e quelle relative all'associazione specificata.
```
aws ec2 describe-local-gateway-route-table-vpc-associations \
--local-gateway-route-table-vpc-association-ids lgw-vpc-assoc-0e0f27af15EXAMPLE
```
Output:
```
{
"LocalGatewayRouteTableVpcAssociation": {
"LocalGatewayRouteTableVpcAssociationId": "lgw-vpc-assoc-0e0f27af1EXAMPLE",
"LocalGatewayRouteTableId": "lgw-rtb-059615ef7dEXAMPLE",
"LocalGatewayId": "lgw-09b493aa7cEXAMPLE",
"VpcId": "vpc-0efe9bde08EXAMPLE",
"State": "associated"
}
}
```
Per ulteriori informazioni, consulta [Tabelle di routing del gateway locale](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html) nella *Guida per l’utente di Outposts*.
+ Per i dettagli sull'API, vedere [DescribeLocalGatewayRouteTableVpcAssociations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-local-gateway-route-table-vpc-associations.html)in *AWS CLI Command Reference*.
### `describe-local-gateway-route-tables`
Il seguente esempio di codice mostra come utilizzare`describe-local-gateway-route-tables`.
**AWS CLI**
**Come descrivere le tabelle di routing del gateway locale**
L’esempio `describe-local-gateway-route-tables` seguente visualizza i dettagli relativi alle tabelle di routing del gateway locale.
```
aws ec2 describe-local-gateway-route-tables
```
Output:
```
{
"LocalGatewayRouteTables": [
{
"LocalGatewayRouteTableId": "lgw-rtb-059615ef7deEXAMPLE",
"LocalGatewayId": "lgw-09b493aa7cEXAMPLE",
"OutpostArn": "arn:aws:outposts:us-west-2:111122223333:outpost/op-0dc11b66edEXAMPLE",
"State": "available"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeLocalGatewayRouteTables AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-local-gateway-route-tables.html)*Command Reference*.
### `describe-local-gateway-virtual-interface-groups`
Il seguente esempio di codice mostra come utilizzare`describe-local-gateway-virtual-interface-groups`.
**AWS CLI**
**Come descrivere i gruppi di interfacce virtuali del gateway locale**
L'`describe-local-gateway-virtual-interface-groups`esempio seguente descrive i gruppi di interfaccia virtuale del gateway locale presenti nell' AWS account.
```
aws ec2 describe-local-gateway-virtual-interface-groups
```
Output:
```
{
"LocalGatewayVirtualInterfaceGroups": [
{
"LocalGatewayVirtualInterfaceGroupId": "lgw-vif-grp-07145b276bEXAMPLE",
"LocalGatewayVirtualInterfaceIds": [
"lgw-vif-01a23bc4d5EXAMPLE",
"lgw-vif-543ab21012EXAMPLE"
],
"LocalGatewayId": "lgw-0ab1c23d4eEXAMPLE",
"OwnerId": "123456789012",
"Tags": []
}
]
}
```
Per ulteriori informazioni, consulta [Utilizzo di gateway locali](https://docs.aws.amazon.com/outposts/latest/userguide/outposts-local-gateways.html) nella *Guida per l’utente di AWS Outposts*.
+ Per i dettagli sull'API, consulta [DescribeLocalGatewayVirtualInterfaceGroups AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-local-gateway-virtual-interface-groups.html)*Command Reference*.
### `describe-local-gateway-virtual-interfaces`
Il seguente esempio di codice mostra come utilizzare`describe-local-gateway-virtual-interfaces`.
**AWS CLI**
**Come descrivere le interfacce virtuali del gateway locale**
L'`describe-local-gateway-virtual-interfaces`esempio seguente descrive le interfacce virtuali del gateway locale del tuo AWS account.
```
aws ec2 describe-local-gateway-virtual-interfaces
```
Output:
```
{
"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": []
}
]
}
```
Per ulteriori informazioni, consulta [Utilizzo di gateway locali](https://docs.aws.amazon.com/outposts/latest/userguide/outposts-local-gateways.html) nella *Guida per l’utente di AWS Outposts*.
+ Per i dettagli sull'API, consulta [DescribeLocalGatewayVirtualInterfaces AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-local-gateway-virtual-interfaces.html)*Command Reference.*
### `describe-local-gateways`
Il seguente esempio di codice mostra come utilizzare`describe-local-gateways`.
**AWS CLI**
**Come descrivere i gateway locali**
L’esempio `describe-local-gateways` seguente visualizza i dettagli dei gateway locali disponibili per l’utente.
```
aws ec2 describe-local-gateways
```
Output:
```
{
"LocalGateways": [
{
"LocalGatewayId": "lgw-09b493aa7cEXAMPLE",
"OutpostArn": "arn:aws:outposts:us-west-2:123456789012:outpost/op-0dc11b66ed59f995a",
"OwnerId": "123456789012",
"State": "available"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeLocalGateways AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-local-gateways.html)*Command Reference*.
### `describe-locked-snapshots`
Il seguente esempio di codice mostra come utilizzare`describe-locked-snapshots`.
**AWS CLI**
**Come descrivere lo stato di blocco di uno snapshot**
L’esempio `describe-locked-snapshots` seguente descrive lo stato di blocco dello snapshot specificato.
```
aws ec2 describe-locked-snapshots \
--snapshot-ids snap-0b5e733b4a8df6e0d
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Snapshot Lock](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-snapshot-lock.html) nella *Guida per l’utente di Amazon EBS*.
+ Per i dettagli sull'API, consulta [DescribeLockedSnapshots AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-locked-snapshots.html)*Command Reference*.
### `describe-managed-prefix-lists`
Il seguente esempio di codice mostra come utilizzare`describe-managed-prefix-lists`.
**AWS CLI**
**Come descrivere gli elenchi di prefissi gestiti**
L'`describe-managed-prefix-lists`esempio seguente descrive gli elenchi di prefissi di proprietà di un AWS account`123456789012`.
```
aws ec2 describe-managed-prefix-lists \
--filters Name=owner-id,Values=123456789012
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Elenchi di prefissi gestiti](https://docs.aws.amazon.com/vpc/latest/userguide/managed-prefix-lists.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, vedere [DescribeManagedPrefixLists](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-managed-prefix-lists.html)in *AWS CLI Command Reference.*
### `describe-moving-addresses`
Il seguente esempio di codice mostra come utilizzare`describe-moving-addresses`.
**AWS CLI**
**Come descrivere gli indirizzi di spostamento in uso**
Questo esempio descrive tutti gli indirizzi IP elastici di spostamento.
Comando:
```
aws ec2 describe-moving-addresses
```
Output:
```
{
"MovingAddressStatuses": [
{
"PublicIp": "198.51.100.0",
"MoveStatus": "MovingToVpc"
}
]
}
```
Questo esempio descrive tutti gli indirizzi che vengono spostati nella piattaforma EC2-VPC.
Comando:
```
aws ec2 describe-moving-addresses --filters Name=moving-status,Values=MovingToVpc
```
+ Per i dettagli sull'API, consulta [DescribeMovingAddresses AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-moving-addresses.html)*Command Reference*.
### `describe-nat-gateways`
Il seguente esempio di codice mostra come utilizzare`describe-nat-gateways`.
**AWS CLI**
**Esempio 1: come descrivere un gateway NAT pubblico**
L’esempio `describe-nat-gateways` seguente descrive il gateway NAT pubblico specificato.
```
aws ec2 describe-nat-gateways \
--nat-gateway-id nat-01234567890abcdef
```
Output:
```
{
"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"
}
]
}
```
**Esempio 2: come descrivere un gateway NAT privato**
L’esempio `describe-nat-gateways` seguente descrive il gateway NAT privato specificato.
```
aws ec2 describe-nat-gateways \
--nat-gateway-id nat-1234567890abcdef0
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [DescribeNatGateways AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-nat-gateways.html)*Command Reference*.
### `describe-network-acls`
Il seguente esempio di codice mostra come utilizzare`describe-network-acls`.
**AWS CLI**
**Per descrivere la rete ACLs**
L'`describe-network-acls`esempio seguente recupera i dettagli sulla rete ACLs.
```
aws ec2 describe-network-acls
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Network ACLs](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html) in the *AWS VPC User* Guide.
+ Per i dettagli sull'API, consulta [DescribeNetworkAcls AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-network-acls.html)*Command Reference.*
### `describe-network-insights-access-scope-analyses`
Il seguente esempio di codice mostra come utilizzare`describe-network-insights-access-scope-analyses`.
**AWS CLI**
**Come descrivere le analisi dell’ambito di accesso alle informazioni di rete**
L'`describe-network-insights-access-scope-analyses`esempio seguente descrive l'analisi dell'ambito di accesso nel tuo AWS account.
```
aws ec2 describe-network-insights-access-scope-analyses \
--region us-east-1
```
Output:
```
{
"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": []
}
]
}
```
Per ulteriori informazioni, consulta [Guida introduttiva a Network Access Analyzer utilizzando la AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli-naa.html) *nella Guida Network Access* Analyzer.
+ *Per i dettagli sull'API, consulta Command [DescribeNetworkInsightsAccessScopeAnalyses](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-network-insights-access-scope-analyses.html)Reference AWS CLI .*
### `describe-network-insights-access-scopes`
Il seguente esempio di codice mostra come utilizzare`describe-network-insights-access-scopes`.
**AWS CLI**
**Come descrivere gli ambiti di accesso alle informazioni di rete**
L'`describe-network-insights-access-scopes`esempio seguente descrive le analisi dell'ambito di accesso nel tuo account. AWS
```
aws ec2 describe-network-insights-access-scopes \
--region us-east-1
```
Output:
```
{
"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": []
}
]
}
```
Per ulteriori informazioni, consulta [Guida introduttiva a Network Access Analyzer utilizzando la AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli-naa.html) *nella Guida Network Access* Analyzer.
+ *Per i dettagli sull'API, consulta Command [DescribeNetworkInsightsAccessScopes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-network-insights-access-scopes.html)Reference AWS CLI .*
### `describe-network-insights-analyses`
Il seguente esempio di codice mostra come utilizzare`describe-network-insights-analyses`.
**AWS CLI**
**Come visualizzare i risultati di un’analisi del percorso**
L’esempio `describe-network-insights-analyses` seguente descrive l’analisi specificata. In questo esempio, l’origine è un gateway Internet, la destinazione è un’istanza EC2 e il protocollo è TCP. L’analisi è riuscita (`Status` è `succeeded`) e il percorso non è raggiungibile (`NetworkPathFound` è `false`). Il codice di spiegazione `ENI_SG_RULES_MISMATCH` indica che il gruppo di sicurezza per l’istanza non contiene una regola che consente il traffico sulla porta di destinazione.
```
aws ec2 describe-network-insights-analyses \
--network-insights-analysis-ids nia-02207aa13eb480c7a
```
Output:
```
{
"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": []
}
]
}
```
Per ulteriori informazioni, consulta [Guida introduttiva all'uso della AWS CLI](https://docs.aws.amazon.com/vpc/latest/reachability/getting-started-cli.html) nella Reachability *Analyzer Guide*.
+ *Per i dettagli sull'API, consulta Command [DescribeNetworkInsightsAnalyses](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-network-insights-analyses.html)Reference AWS CLI .*
### `describe-network-insights-paths`
Il seguente esempio di codice mostra come utilizzare`describe-network-insights-paths`.
**AWS CLI**
**Come descrivere un percorso**
L’esempio `describe-network-insights-paths` seguente descrive il percorso specificato.
```
aws ec2 describe-network-insights-paths \
--network-insights-path-ids nip-0b26f224f1d131fa8
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Guida introduttiva all'uso della AWS CLI](https://docs.aws.amazon.com/vpc/latest/reachability/getting-started-cli.html) nella Reachability *Analyzer Guide*.
+ *Per i dettagli sull'API, consulta Command [DescribeNetworkInsightsPaths](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-network-insights-paths.html)Reference AWS CLI .*
### `describe-network-interface-attribute`
Il seguente esempio di codice mostra come utilizzare`describe-network-interface-attribute`.
**AWS CLI**
**Come descrivere l’attributo attachment di un’interfaccia di rete**
Questo comando di esempio descrive l’attributo `attachment` dell’interfaccia di rete specificata.
Comando:
```
aws ec2 describe-network-interface-attribute --network-interface-id eni-686ea200 --attribute attachment
```
Output:
```
{
"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"
}
}
```
**Come descrivere l’attributo description di un’interfaccia di rete**
Questo comando di esempio descrive l’attributo `description` dell’interfaccia di rete specificata.
Comando:
```
aws ec2 describe-network-interface-attribute --network-interface-id eni-686ea200 --attribute description
```
Output:
```
{
"NetworkInterfaceId": "eni-686ea200",
"Description": {
"Value": "My description"
}
}
```
**Come descrivere l’attributo groupSet di un’interfaccia di rete**
Questo comando di esempio descrive l’attributo `groupSet` dell’interfaccia di rete specificata.
Comando:
```
aws ec2 describe-network-interface-attribute --network-interface-id eni-686ea200 --attribute groupSet
```
Output:
```
{
"NetworkInterfaceId": "eni-686ea200",
"Groups": [
{
"GroupName": "my-security-group",
"GroupId": "sg-903004f8"
}
]
}
```
**Per descrivere l' sourceDestCheck attributo di un'interfaccia di rete**
Questo comando di esempio descrive l’attributo `sourceDestCheck` dell’interfaccia di rete specificata.
Comando:
```
aws ec2 describe-network-interface-attribute --network-interface-id eni-686ea200 --attribute sourceDestCheck
```
Output:
```
{
"NetworkInterfaceId": "eni-686ea200",
"SourceDestCheck": {
"Value": true
}
}
```
+ Per i dettagli sull'API, consulta [DescribeNetworkInterfaceAttribute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-network-interface-attribute.html)*Command Reference*.
### `describe-network-interface-permissions`
Il seguente esempio di codice mostra come utilizzare`describe-network-interface-permissions`.
**AWS CLI**
**Come descrivere le autorizzazioni dell’interfaccia di rete**
Questo esempio descrive tutte le autorizzazione dell’interfaccia di rete.
Comando:
```
aws ec2 describe-network-interface-permissions
```
Output:
```
{
"NetworkInterfacePermissions": [
{
"PermissionState": {
"State": "GRANTED"
},
"NetworkInterfacePermissionId": "eni-perm-06fd19020ede149ea",
"NetworkInterfaceId": "eni-b909511a",
"Permission": "INSTANCE-ATTACH",
"AwsAccountId": "123456789012"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeNetworkInterfacePermissions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-network-interface-permissions.html)*Command Reference*.
### `describe-network-interfaces`
Il seguente esempio di codice mostra come utilizzare`describe-network-interfaces`.
**AWS CLI**
**Come descrivere le interfacce di rete**
Questo esempio descrive tutte le interfacce di rete.
Comando:
```
aws ec2 describe-network-interfaces
```
Output:
```
{
"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"
}
]
}
```
Questo esempio descrive le interfacce di rete che hanno un tag con la chiave `Purpose` e il valore `Prod`.
Comando:
```
aws ec2 describe-network-interfaces --filters Name=tag:Purpose,Values=Prod
```
Output:
```
{
"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"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeNetworkInterfaces AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-network-interfaces.html)*Command Reference*.
### `describe-placement-groups`
Il seguente esempio di codice mostra come utilizzare`describe-placement-groups`.
**AWS CLI**
**Come descrivere i gruppi di posizionamento**
Questo comando di esempio descrive tutti i gruppi di posizionamento.
Comando:
```
aws ec2 describe-placement-groups
```
Output:
```
{
"PlacementGroups": [
{
"GroupName": "my-cluster",
"State": "available",
"Strategy": "cluster"
},
...
]
}
```
+ Per i dettagli sull'API, consulta [DescribePlacementGroups AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-placement-groups.html)*Command Reference*.
### `describe-prefix-lists`
Il seguente esempio di codice mostra come utilizzare`describe-prefix-lists`.
**AWS CLI**
**Come descrivere gli elenchi di prefissi**
Questo esempio elenca tutti gli elenchi di prefissi disponibili per la Regione.
Comando:
```
aws ec2 describe-prefix-lists
```
Output:
```
{
"PrefixLists": [
{
"PrefixListName": "com.amazonaws.us-east-1.s3",
"Cidrs": [
"54.231.0.0/17"
],
"PrefixListId": "pl-63a5400a"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribePrefixLists AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-prefix-lists.html)*Command Reference*.
### `describe-principal-id-format`
Il seguente esempio di codice mostra come utilizzare`describe-principal-id-format`.
**AWS CLI**
**Come descrivere il formato ID per gli utenti e i ruoli IAM con il formato ID lungo abilitato**
L’esempio `describe-principal-id-format` seguente descrive il formato ID per l’utente root, tutti i ruoli IAM e tutti gli utenti IAM con il formato ID lungo abilitato.
```
aws ec2 describe-principal-id-format \
--resource instance
```
Output:
```
{
"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
},
]
},
...
]
}
```
+ Per i dettagli sull'API, consulta [DescribePrincipalIdFormat AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-principal-id-format.html)*Command Reference*.
### `describe-public-ipv4-pools`
Il seguente esempio di codice mostra come utilizzare`describe-public-ipv4-pools`.
**AWS CLI**
**Per descrivere i pool di IPv4 indirizzi pubblici**
L'`describe-public-ipv4-pools`esempio seguente mostra i dettagli sui pool di indirizzi che sono stati creati quando è stato eseguito il provisioning di intervalli di IPv4 indirizzi pubblici utilizzando Bring Your Own IP Addresses (BYOIP).
```
aws ec2 describe-public-ipv4-pools
```
Output:
```
{
"PublicIpv4Pools": [
{
"PoolId": "ipv4pool-ec2-1234567890abcdef0",
"PoolAddressRanges": [
{
"FirstAddress": "203.0.113.0",
"LastAddress": "203.0.113.255",
"AddressCount": 256,
"AvailableAddressCount": 256
}
],
"TotalAddressCount": 256,
"TotalAvailableAddressCount": 256
}
]
}
```
+ *Per i dettagli sull'API, consulta [DescribePublicIpv4Pools](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-public-ipv4-pools.html) in Command Reference.AWS CLI *
### `describe-regions`
Il seguente esempio di codice mostra come utilizzare`describe-regions`.
**AWS CLI**
**Esempio 1: come descrivere tutte le Regioni abilitate**
Nell’esempio di `describe-regions` seguente vengono descritte tutte le regioni abilitate per l’account.
```
aws ec2 describe-regions
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Regioni e zone di disponibilità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come descrivere le Regioni abilitate all’interno di un endpoint il cui nome contiene una stringa specifica**
Nell’esempio di `describe-regions` seguente vengono descritte tutte le regioni abilitate che contengono la stringa "us" nell’endpoint.
```
aws ec2 describe-regions \
--filters "Name=endpoint,Values=*us*"
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Regioni e zone di disponibilità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 3: come descrivere tutte le Regioni**
Nell’esempio di `describe-regions` seguente vengono descritte tutte le regioni disponibili, comprese le regioni disabilitate.
```
aws ec2 describe-regions \
--all-regions
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Regioni e zone di disponibilità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 4: come elencare solo i nomi delle Regioni**
Nell’esempio di `describe-regions` seguente viene utilizzato il parametro `--query` per filtrare l’output e restituire solo i nomi delle regioni come testo.
```
aws ec2 describe-regions \
--all-regions \
--query "Regions[].{Name:RegionName}" \
--output text
```
Output:
```
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
```
Per ulteriori informazioni, consulta [Regioni e zone di disponibilità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DescribeRegions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-regions.html)*Command Reference*.
### `describe-replace-root-volume-tasks`
Il seguente esempio di codice mostra come utilizzare`describe-replace-root-volume-tasks`.
**AWS CLI**
**Esempio 1: come visualizzare informazioni su una specifica attività di sostituzione del volume root**
L’esempio `describe-replace-root-volume-tasks` seguente descrive l’attività di sostituzione del volume root replacevol-0111122223333abcd.
```
aws ec2 describe-replace-root-volume-tasks \
--replace-root-volume-task-ids replacevol-0111122223333abcd
```
Output:
```
{
"ReplaceRootVolumeTasks": [
{
"ReplaceRootVolumeTaskId": "replacevol-0111122223333abcd",
"Tags": [],
"InstanceId": "i-0123456789abcdefa",
"TaskState": "succeeded",
"StartTime": "2022-03-14T15:16:28Z",
"CompleteTime": "2022-03-14T15:16:52Z"
}
]
}
```
Per ulteriori informazioni, consulta [Sostituzione di un volume root](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-restoring-volume.html#replace-root) nella *Guida per l’utente di Amazon Elastic Compute Cloud*.
**Esempio 2: come visualizzare informazioni su tutte le attività di sostituzione del volume root per un’istanza specifica**
L’esempio `describe-replace-root-volume-tasks` seguente descrive tutte le attività di sostituzione del volume root, ad esempio i-0123456789abcdefa.
```
aws ec2 describe-replace-root-volume-tasks \
--filters Name=instance-id,Values=i-0123456789abcdefa
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Sostituzione di un volume root](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-restoring-volume.html#replace-root) nella *Guida per l’utente di Amazon Elastic Compute Cloud*.
+ Per i dettagli sull'API, consulta [DescribeReplaceRootVolumeTasks AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-replace-root-volume-tasks.html)*Command Reference*.
### `describe-reserved-instances-listings`
Il seguente esempio di codice mostra come utilizzare`describe-reserved-instances-listings`.
**AWS CLI**
**Come descrivere un elenco di istanze riservate**
L’esempio `describe-reserved-instances-listings` seguente recupera le informazioni sull’elenco di istanze riservate.
```
aws ec2 describe-reserved-instances-listings \
--reserved-instances-listing-id 5ec28771-05ff-4b9b-aa31-9e57dexample
```
Questo comando non produce alcun output.
+ Per i dettagli sull'API, consulta [DescribeReservedInstancesListings AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-reserved-instances-listings.html)*Command Reference*.
### `describe-reserved-instances-modifications`
Il seguente esempio di codice mostra come utilizzare`describe-reserved-instances-modifications`.
**AWS CLI**
**Come descrivere le modifiche delle istanze riservate**
Questo comando di esempio descrive tutte le richieste di modifica delle istanze riservate che sono state inviate per l’account in uso.
Comando:
```
aws ec2 describe-reserved-instances-modifications
```
Output:
```
{
"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"
}
]
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeReservedInstancesModifications AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-reserved-instances-modifications.html)*Command Reference*.
### `describe-reserved-instances-offerings`
Il seguente esempio di codice mostra come utilizzare`describe-reserved-instances-offerings`.
**AWS CLI**
**Come descrivere le offerte di istanze riservate**
Questo comando di esempio descrive tutte le istanze riservate disponibili per l’acquisto nella Regione.
Comando:
```
aws ec2 describe-reserved-instances-offerings
```
Output:
```
{
"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"
},
...
}
```
**Come descrivere le offerte di istanze riservate utilizzando le opzioni**
Questo esempio elenca le istanze riservate offerte da AWS con le seguenti specifiche: tipi di istanze t1.micro, prodotto Windows (Amazon VPC) e offerte Heavy Utilization.
Comando:
```
aws ec2 describe-reserved-instances-offerings --no-include-marketplace --instance-type "t1.micro" --product-description "Windows (Amazon VPC)" --offering-type "no upfront"
```
Output:
```
{
"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"
}
]
}
```
+ *Per i dettagli sull'API, consulta Command Reference. [DescribeReservedInstancesOfferings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-reserved-instances-offerings.html)AWS CLI *
### `describe-reserved-instances`
Il seguente esempio di codice mostra come utilizzare`describe-reserved-instances`.
**AWS CLI**
**Come descrivere le istanze riservate in uso**
Questo comando di esempio descrive le istanze riservate di proprietà dell’utente.
Comando:
```
aws ec2 describe-reserved-instances
```
Output:
```
{
"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
},
...
]
}
```
**Come descrivere le istanze riservate utilizzando i filtri**
Questo esempio filtra la risposta per includere solo le istanze Linux/UNIX riservate t2.micro di tre anni in 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
```
Output:
```
{
"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
}
]
}
```
Per ulteriori informazioni, consulta Utilizzo delle istanze Amazon EC2 nella *Guida per l’utente dell’Interfaccia a riga di comando AWS *.
+ *Per i dettagli sull'API, consulta Command Reference. [DescribeReservedInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-reserved-instances.html)AWS CLI *
### `describe-route-tables`
Il seguente esempio di codice mostra come utilizzare`describe-route-tables`.
**AWS CLI**
**Come descrivere le tabelle di routing**
L’esempio `describe-route-tables` seguente recupera i dettagli di tutte le tabelle di routing.
```
aws ec2 describe-route-tables
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Utilizzo delle tabelle di routing](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html#WorkWithRouteTables) nella *Guida per l’utente di AWS VPC*.
+ Per i dettagli sull'API, consulta [DescribeRouteTables AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-route-tables.html)*Command Reference*.
### `describe-scheduled-instance-availability`
Il seguente esempio di codice mostra come utilizzare`describe-scheduled-instance-availability`.
**AWS CLI**
**Come descrivere una pianificazione disponibile**
Questo esempio descrive una pianificazione che si verifica ogni settimana di domenica, a partire dalla data specificata.
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
```
Output:
```
{
"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"
},
...
]
}
```
Per limitare i risultati, è possibile aggiungere filtri che specificano il sistema operativo, la rete e il tipo di istanza.
Comando:
--filters Name=platform,Values=Linux/UNIX Name=network-platform,Values=EC2-VPC Name=instance-type,Values=c4.large
+ Per i dettagli sull'API, consulta [DescribeScheduledInstanceAvailability AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-scheduled-instance-availability.html)*Command Reference*.
### `describe-scheduled-instances`
Il seguente esempio di codice mostra come utilizzare`describe-scheduled-instances`.
**AWS CLI**
**Come descrivere le istanze pianificate**
Questo esempio descrive l’istanza pianificata specificata.
Comando:
```
aws ec2 describe-scheduled-instances --scheduled-instance-ids sci-1234-1234-1234-1234-123456789012
```
Output:
```
{
"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"
}
]
}
```
Questo esempio descrive tutte le istanze pianificate.
Comando:
```
aws ec2 describe-scheduled-instances
```
+ Per i dettagli sull'API, consulta [DescribeScheduledInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-scheduled-instances.html)*Command Reference*.
### `describe-security-group-references`
Il seguente esempio di codice mostra come utilizzare`describe-security-group-references`.
**AWS CLI**
**Come descrivere i riferimenti dei gruppi di sicurezza**
Questo esempio descrive i riferimenti dei gruppi di sicurezza per`sg-bbbb2222`. La risposta indica che un gruppo di sicurezza `sg-bbbb2222` fa riferimento a un gruppo di sicurezza nel VPC `vpc-aaaaaaaa`:
Comando:
```
aws ec2 describe-security-group-references --group-id sg-bbbbb22222
```
Output:
```
{
"SecurityGroupsReferenceSet": [
{
"ReferencingVpcId": "vpc-aaaaaaaa ",
"GroupId": "sg-bbbbb22222",
"VpcPeeringConnectionId": "pcx-b04deed9"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeSecurityGroupReferences AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-security-group-references.html)*Command Reference*.
### `describe-security-group-rules`
Il seguente esempio di codice mostra come utilizzare`describe-security-group-rules`.
**AWS CLI**
**Esempio 1: come descrivere le regole del gruppo di sicurezza per un gruppo di sicurezza**
L’esempio `describe-security-group-rules` seguente descrive le regole del gruppo di sicurezza di un gruppo di sicurezza specificato. Utilizza l’opzione `filters` per limitare i risultati a un gruppo di sicurezza specifico.
```
aws ec2 describe-security-group-rules \
--filters Name="group-id",Values="sg-1234567890abcdef0"
```
Output:
```
{
"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": []
}
]
}
```
**Esempio 2: come descrivere una regola del gruppo di sicurezza**
L’esempio `describe-security-group-rules` seguente descrive la regola del gruppo di sicurezza specificata.
```
aws ec2 describe-security-group-rules \
--security-group-rule-ids sgr-cdef01234567890ab
```
Output:
```
{
"SecurityGroupRules": [
{
"SecurityGroupRuleId": "sgr-cdef01234567890ab",
"GroupId": "sg-1234567890abcdef0",
"GroupOwnerId": "111122223333",
"IsEgress": true,
"IpProtocol": "-1",
"FromPort": -1,
"ToPort": -1,
"CidrIpv4": "0.0.0.0/0",
"Tags": []
}
]
}
```
Per ulteriori informazioni, consulta [Regole del gruppo di sicurezza](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [DescribeSecurityGroupRules AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-security-group-rules.html)*Command Reference*.
### `describe-security-group-vpc-associations`
Il seguente esempio di codice mostra come utilizzare`describe-security-group-vpc-associations`.
**AWS CLI**
**Come descrivere le associazioni VPC**
L’esempio `describe-security-group-vpc-associations` seguente descrive le associazioni VPC per il gruppo di sicurezza specificato.
```
aws ec2 describe-security-group-vpc-associations \
--filters Name=group-id,Values=sg-04dbb43907d3f8a78
```
Output:
```
{
"SecurityGroupVpcAssociations": [
{
"GroupId": "sg-04dbb43907d3f8a78",
"VpcId": "vpc-0bf4c2739bc05a694",
"VpcOwnerId": "123456789012",
"State": "associated"
}
]
}
```
Per ulteriori informazioni, consulta [Associare gruppi di sicurezza a più](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-assoc.html) gruppi VPCs nella *Amazon VPC User Guide*.
+ Per i dettagli sull'API, consulta [DescribeSecurityGroupVpcAssociations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-security-group-vpc-associations.html)*Command Reference.*
### `describe-security-groups`
Il seguente esempio di codice mostra come utilizzare`describe-security-groups`.
**AWS CLI**
**Esempio 1: come descrivere un gruppo di sicurezza**
Nell’esempio di `describe-security-groups` seguente viene descritto il gruppo di sicurezza specificato.
```
aws ec2 describe-security-groups \
--group-ids sg-903004f8
```
Output:
```
{
"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",
}
]
}
```
**Esempio 2: come descrivere gruppi di sicurezza con regole specifiche**
L’esempio `describe-security-groups` seguente utilizza filtri per definire l’ambito dei risultati in base ai gruppi di sicurezza che includono una regola che consente il traffico SSH (porta 22) e una regola che consente il traffico da tutti gli indirizzi (`0.0.0.0/0`). Nell’esempio viene utilizzato il parametro `--query` per visualizzare solamente i nomi dei gruppi di sicurezza. I gruppi di sicurezza devono corrispondere a tutti i filtri per essere restituiti nei risultati; tuttavia, una singola regola non deve corrispondere a tutti i filtri. Per esempio, l’output restituisce un gruppo di sicurezza con una regola che consente il traffico SSH da un indirizzo IP specifico e un’altra regola che consente il traffico HTTP da tutti gli indirizzi.
```
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
```
Output:
```
default
my-security-group
web-servers
launch-wizard-1
```
**Esempio 3: come descrivere gruppi di sicurezza in base ai tag**
Nell’esempio di `describe-security-groups` seguente vengono utilizzati filtri per rifinire i risultati in base ai gruppi di sicurezza che includono `test` nel nome del gruppo di sicurezza e che hanno il tag `Test=To-delete`. L'esempio utilizza il `--query` parametro per visualizzare solo i nomi e i gruppi IDs di sicurezza.
```
aws ec2 describe-security-groups \
--filters Name=group-name,Values=*test* Name=tag:Test,Values=To-delete \
--query "SecurityGroups[*].{Name:GroupName,ID:GroupId}"
```
Output:
```
[
{
"Name": "testfornewinstance",
"ID": "sg-33bb22aa"
},
{
"Name": "newgrouptest",
"ID": "sg-1a2b3c4d"
}
]
```
Per ulteriori esempi di utilizzo dei filtri di tag, consulta [Utilizzo dei tag](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_CLI) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, vedere [DescribeSecurityGroups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-security-groups.html)in *AWS CLI Command Reference*.
### `describe-snapshot-attribute`
Il seguente esempio di codice mostra come utilizzare`describe-snapshot-attribute`.
**AWS CLI**
**Come descrivere gli attributi di uno snapshot**
L’esempio `describe-snapshot-attribute` seguente elenca gli account con cui è condiviso uno snapshot.
```
aws ec2 describe-snapshot-attribute \
--snapshot-id snap-01234567890abcedf \
--attribute createVolumePermission
```
Output:
```
{
"SnapshotId": "snap-01234567890abcedf",
"CreateVolumePermissions": [
{
"UserId": "123456789012"
}
]
}
```
Per ulteriori informazioni, consulta [Condivisione di uno snapshot Amazon EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-modifying-snapshot-permissions.html#share-unencrypted-snapshot) nella *Guida per l’utente di Amazon Elastic Compute Cloud*.
+ Per i dettagli sull'API, consulta [DescribeSnapshotAttribute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-snapshot-attribute.html)*Command Reference*.
### `describe-snapshot-tier-status`
Il seguente esempio di codice mostra come utilizzare`describe-snapshot-tier-status`.
**AWS CLI**
**Come visualizzare le informazioni di archiviazione su uno snapshot archiviato**
L’esempio `describe-snapshot-tier-status` seguente fornisce informazioni di archiviazione su uno snapshot archiviato.
```
aws ec2 describe-snapshot-tier-status \
--filters "Name=snapshot-id, Values=snap-01234567890abcedf"
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzazione degli snapshot archiviati](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-snapshot-archiving.html#view-archived-snapshot) nella *Guida per l’utente di Amazon Elastic Compute Cloud*.
+ Per i dettagli sull'API, consulta [DescribeSnapshotTierStatus AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-snapshot-tier-status.html)*Command Reference*.
### `describe-snapshots`
Il seguente esempio di codice mostra come utilizzare`describe-snapshots`.
**AWS CLI**
**Esempio 1: come descrivere uno snapshot**
Nell’esempio di `describe-snapshots` seguente viene descritto lo snapshot specificato.
```
aws ec2 describe-snapshots \
--snapshot-ids snap-1234567890abcdef0
```
Output:
```
{
"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"
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Snapshot Amazon EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSSnapshots.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come descrivere snapshot in base ai filtri**
L'`describe-snapshots`esempio seguente utilizza i filtri per limitare i risultati alle istantanee di proprietà AWS dell'account che si trovano nello `pending` stato. L'esempio utilizza il `--query` parametro per visualizzare solo l'istantanea IDs e l'ora di avvio dell'istantanea.
```
aws ec2 describe-snapshots \
--owner-ids self \
--filters Name=status,Values=pending \
--query "Snapshots[*].{ID:SnapshotId,Time:StartTime}"
```
Output:
```
[
{
"ID": "snap-1234567890abcdef0",
"Time": "2019-08-04T12:48:18.000Z"
},
{
"ID": "snap-066877671789bd71b",
"Time": "2019-08-04T02:45:16.000Z
},
...
]
```
Nell’esempio di `describe-snapshots` seguente vengono utilizzati filtri per rifinire i risultati in base agli snapshot creati dal volume specificato. L'esempio utilizza il `--query` parametro per visualizzare solo l'istantanea. IDs
```
aws ec2 describe-snapshots \
--filters Name=volume-id,Values=049df61146c4d7901 \
--query "Snapshots[*].[SnapshotId]" \
--output text
```
Output:
```
snap-1234567890abcdef0
snap-08637175a712c3fb9
...
```
Per ulteriori esempi di utilizzo dei filtri, consulta [Elencare e filtrare le risorse](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Filtering.html#Filtering_Resources_CLI) nella *Guida per l’utente di Amazon EC2*.
**Esempio 3: come descrivere snapshot in base ai tag**
Nell’esempio di `describe-snapshots` seguente vengono utilizzati filtri per rifinire i risultati in base agli snapshot che hanno il tag `Stack=Prod`.
```
aws ec2 describe-snapshots \
--filters Name=tag:Stack,Values=prod
```
Per un esempio dell’output di `describe-snapshots`, vedi l’Esempio 1.
Per ulteriori esempi di utilizzo dei filtri di tag, consulta [Utilizzo dei tag](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_CLI) nella *Guida per l’utente di Amazon EC2*.
**Esempio 4: come descrivere snapshot in base all’età**
L'`describe-snapshots`esempio seguente utilizza JMESPath espressioni per descrivere tutte le istantanee create dall' AWS account prima della data specificata. Visualizza solo l'istantanea IDs.
```
aws ec2 describe-snapshots \
--owner-ids 012345678910 \
--query "Snapshots[?(StartTime<='2020-03-31')].[SnapshotId]"
```
Per ulteriori esempi di utilizzo dei filtri, consulta [Elencare e filtrare le risorse](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Filtering.html#Filtering_Resources_CLI) nella *Guida per l’utente di Amazon EC2*.
**Esempio 5: come visualizzare solo gli snapshot archiviati**
Nell’esempio di `describe-snapshots` seguente vengono elencati solo gli snapshot memorizzati nel livello archivio.
```
aws ec2 describe-snapshots \
--filters "Name=storage-tier,Values=archive"
```
Output:
```
{
"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": []
},
]
}
```
Per ulteriori informazioni, consulta [Visualizzazione degli snapshot archiviati](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-snapshot-archiving.html#view-archived-snapshot) nella *Guida per l’utente di Amazon Elastic Compute Cloud*.
+ Per i dettagli sull'API, consulta [DescribeSnapshots AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-snapshots.html)*Command Reference.*
### `describe-spot-datafeed-subscription`
Il seguente esempio di codice mostra come utilizzare`describe-spot-datafeed-subscription`.
**AWS CLI**
**Come descrivere la sottoscrizione ai feed di dati dell’istanza spot per un account**
Questo comando di esempio descrive il feed di dati per l’account.
Comando:
```
aws ec2 describe-spot-datafeed-subscription
```
Output:
```
{
"SpotDatafeedSubscription": {
"OwnerId": "123456789012",
"Prefix": "spotdata",
"Bucket": "amzn-s3-demo-bucket",
"State": "Active"
}
}
```
+ Per i dettagli sull'API, consulta [DescribeSpotDatafeedSubscription AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-spot-datafeed-subscription.html)*Command Reference*.
### `describe-spot-fleet-instances`
Il seguente esempio di codice mostra come utilizzare`describe-spot-fleet-instances`.
**AWS CLI**
**Come descrivere le istanze spot associate a un parco istanze spot**
Questo comando di esempio elenca le istanze spot associate al parco istanze spot specificato.
Comando:
```
aws ec2 describe-spot-fleet-instances --spot-fleet-request-id sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE
```
Output:
```
{
"ActiveInstances": [
{
"InstanceId": "i-1234567890abcdef0",
"InstanceType": "m3.medium",
"SpotInstanceRequestId": "sir-08b93456"
},
...
],
"SpotFleetRequestId": "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE"
}
```
+ Per i dettagli sull'API, consulta [DescribeSpotFleetInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-spot-fleet-instances.html)*Command Reference*.
### `describe-spot-fleet-request-history`
Il seguente esempio di codice mostra come utilizzare`describe-spot-fleet-request-history`.
**AWS CLI**
**Come descrivere la cronologia del parco istanze spot**
Questo comando di esempio restituisce la cronologia del parco istanze spot specificato a partire dall’ora specificata.
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
```
L’output di esempio seguente mostra gli avvii riusciti di due istanze spot del parco istanze spot.
Output:
```
{
"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"
}
```
+ Per i dettagli sull'API, consulta [DescribeSpotFleetRequestHistory AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-spot-fleet-request-history.html)*Command Reference*.
### `describe-spot-fleet-requests`
Il seguente esempio di codice mostra come utilizzare`describe-spot-fleet-requests`.
**AWS CLI**
**Come descrivere le richieste del parco istanze spot**
Questo esempio descrive tutte le richieste del parco istanze spot.
Comando:
```
aws ec2 describe-spot-fleet-requests
```
Output:
```
{
"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"
}
]
}
```
**Come descrivere la richiesta del parco istanze spot**
Questo esempio descrive la richiesta del parco istanze spot specificata.
Comando:
```
aws ec2 describe-spot-fleet-requests --spot-fleet-request-ids sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE
```
Output:
```
{
"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"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeSpotFleetRequests AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-spot-fleet-requests.html)*Command Reference*.
### `describe-spot-instance-requests`
Il seguente esempio di codice mostra come utilizzare`describe-spot-instance-requests`.
**AWS CLI**
**Esempio 1: come descrivere una richiesta di istanze spot**
L’esempio `describe-spot-instance-requests` seguente descrive la richiesta di istanza spot specificata.
```
aws ec2 describe-spot-instance-requests \
--spot-instance-request-ids sir-08b93456
```
Output:
```
{
"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"
}
]
}
```
**Esempio 2: come descrivere le richieste di istanze spot in base ai filtri**
L’esempio `describe-spot-instance-requests` seguente utilizza i filtri per definire l’ambito dei risultati in base alle richieste di istanze spot con il tipo di istanza specificato nella zona di disponibilità specificata. L'esempio utilizza il `--query` parametro per visualizzare solo l'istanza 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
```
Output:
```
i-057750d42936e468a
i-001efd250faaa6ffa
i-027552a73f021f3bd
...
```
Per ulteriori esempi di utilizzo dei filtri, consulta [Elenco e filtraggio delle risorse](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Filtering.html#Filtering_Resources_CLI) nella *Guida per l’utente di Amazon Elastic Compute Cloud*.
**Esempio 3: come descrivere le richieste di istanze spot in base ai tag**
L’esempio `describe-spot-instance-requests` seguente utilizza i filtri di tag per definire l’ambito dei risultati in base alle richieste di istanze spot associate al tag `cost-center=cc123`.
```
aws ec2 describe-spot-instance-requests \
--filters Name=tag:cost-center,Values=cc123
```
Per un esempio dell’output di `describe-spot-instance-requests`, vedi l’Esempio 1.
Per ulteriori esempi di utilizzo dei filtri di tag, consulta [Utilizzo dei tag](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_CLI) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DescribeSpotInstanceRequests AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-spot-instance-requests.html)*Command Reference*.
### `describe-spot-price-history`
Il seguente esempio di codice mostra come utilizzare`describe-spot-price-history`.
**AWS CLI**
**Come descrivere la cronologia dei prezzi spot**
Questo comando di esempio restituisce la cronologia dei prezzi spot per le istanze m1.xlarge per un giorno di gennaio specifico.
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
```
Output:
```
{
"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"
},
...
}
```
**Per descrivere la cronologia dei prezzi Spot per Linux/UNIX Amazon VPC**
Questo comando di esempio restituisce lo storico dei prezzi Spot per m1.xlarge, istanze Amazon Linux/UNIX VPC per un determinato giorno di gennaio.
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
```
Output:
```
{
"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"
}
]
}
```
+ *Per i dettagli sull'API, consulta Command Reference. [DescribeSpotPriceHistory](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-spot-price-history.html)AWS CLI *
### `describe-stale-security-groups`
Il seguente esempio di codice mostra come utilizzare`describe-stale-security-groups`.
**AWS CLI**
**Come descrivere i gruppi di sicurezza obsoleti**
Questo esempio descrive le regole del gruppo di sicurezza obsoleto per `vpc-11223344`. La risposta mostra che sg-5fa68d3a nell’account in uso ha una regola SSH di ingresso obsoleta che fa riferimento a `sg-279ab042` nel VPC peer e che `sg-fe6fba9a` nell’account in uso ha una regola SSH in uscita non aggiornata che fa riferimento a `sg-ef6fba8b` nel VPC peer.
Comando:
```
aws ec2 describe-stale-security-groups --vpc-id vpc-11223344
```
Output:
```
{
"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"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeStaleSecurityGroups AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-stale-security-groups.html)*Command Reference*.
### `describe-store-image-tasks`
Il seguente esempio di codice mostra come utilizzare`describe-store-image-tasks`.
**AWS CLI**
**Come descrivere lo stato di avanzamento di un’attività di archiviazione AMI**
L’esempio `describe-store-image-tasks` seguente descrive lo stato di avanzamento di un’attività di archiviazione AMI.
```
aws ec2 describe-store-image-tasks
```
Output:
```
{
"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"
}
]
}
```
*Per ulteriori informazioni sull'archiviazione e il ripristino di un'AMI utilizzando S3, consulta Archiviazione e ripristino di un'AMI utilizzando S3 nella Amazon EC2 User Guide.*
+ *Per i [DescribeStoreImageTasks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-store-image-tasks.html)dettagli sull'API, consulta Command Reference.AWS CLI *
### `describe-subnets`
Il seguente esempio di codice mostra come utilizzare`describe-subnets`.
**AWS CLI**
**Esempio 1: come descrivere tutte le sottoreti**
Nell’esempio di `describe-subnets` seguente vengono visualizzati i dettagli delle sottoreti.
```
aws ec2 describe-subnets
```
Output:
```
{
"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
}
}
]
}
```
Per ulteriori informazioni, consulta [Working with VPCs and Subnet](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html) nella *AWS VPC* User Guide.
**Esempio 2: come descrivere le sottoreti di un VPC specifico**
Nell’esempio `describe-subnets` seguente viene utilizzato un filtro per recuperare i dettagli per le sottoreti del VPC specificato.
```
aws ec2 describe-subnets \
--filters "Name=vpc-id,Values=vpc-3EXAMPLE"
```
Output:
```
{
"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
}
}
]
}
```
Per ulteriori informazioni, consulta [Working with VPCs and Subnet](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html) nella *AWS VPC* User Guide.
**Esempio 3: come descrivere le sottoreti con un tag specifico**
L'`describe-subnets`esempio seguente utilizza un filtro per recuperare i dettagli di quelle sottoreti con il tag `CostCenter=123` e il `--query` parametro per visualizzare la sottorete delle IDs sottoreti con questo tag.
```
aws ec2 describe-subnets \
--filters "Name=tag:CostCenter,Values=123" \
--query "Subnets[*].SubnetId" \
--output text
```
Output:
```
subnet-0987a87c8b37348ef
subnet-02a95061c45f372ee
subnet-03f720e7de2788d73
```
Per ulteriori informazioni, consulta [Working with VPCs and Subnet](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html) nella Amazon *VPC* User Guide.
+ *Per i dettagli sull'API, consulta Command [DescribeSubnets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-subnets.html)Reference AWS CLI .*
### `describe-tags`
Il seguente esempio di codice mostra come utilizzare`describe-tags`.
**AWS CLI**
**Esempio 1: come descrivere tutti i tag di un’unica risorsa**
L’esempio `describe-tags` seguente descrive i tag per l’istanza specificata.
```
aws ec2 describe-tags \
--filters "Name=resource-id,Values=i-1234567890abcdef8"
```
Output:
```
{
"Tags": [
{
"ResourceType": "instance",
"ResourceId": "i-1234567890abcdef8",
"Value": "Test",
"Key": "Stack"
},
{
"ResourceType": "instance",
"ResourceId": "i-1234567890abcdef8",
"Value": "Beta Server",
"Key": "Name"
}
]
}
```
**Esempio 2: come descrivere tutti i tag di un tipo di risorsa**
L’esempio `describe-tags` seguente descrive i tag per i volumi in uso.
```
aws ec2 describe-tags \
--filters "Name=resource-type,Values=volume"
```
Output:
```
{
"Tags": [
{
"ResourceType": "volume",
"ResourceId": "vol-1234567890abcdef0",
"Value": "Project1",
"Key": "Purpose"
},
{
"ResourceType": "volume",
"ResourceId": "vol-049df61146c4d7901",
"Value": "Logs",
"Key": "Purpose"
}
]
}
```
**Esempio 3: come descrivere tutti tag**
L’esempio `describe-tags` seguente descrive i tag per tutte le risorse.
```
aws ec2 describe-tags
```
**Esempio 4: come descrivere i tag delle risorse in base a una chiave di tag**
L’esempio `describe-tags` seguente descrive i tag per le risorse che hanno un tag con la chiave `Stack`.
```
aws ec2 describe-tags \
--filters Name=key,Values=Stack
```
Output:
```
{
"Tags": [
{
"ResourceType": "volume",
"ResourceId": "vol-027552a73f021f3b",
"Value": "Production",
"Key": "Stack"
},
{
"ResourceType": "instance",
"ResourceId": "i-1234567890abcdef8",
"Value": "Test",
"Key": "Stack"
}
]
}
```
**Esempio 5: come descrivere i tag delle risorse in base a una chiave di tag e a un valore di tag**
L’esempio `describe-tags` seguente descrive i tag per le risorse che hanno il tag `Stack=Test`.
```
aws ec2 describe-tags \
--filters Name=key,Values=Stack Name=value,Values=Test
```
Output:
```
{
"Tags": [
{
"ResourceType": "image",
"ResourceId": "ami-3ac336533f021f3bd",
"Value": "Test",
"Key": "Stack"
},
{
"ResourceType": "instance",
"ResourceId": "i-1234567890abcdef8",
"Value": "Test",
"Key": "Stack"
}
]
}
```
L’esempio `describe-tags` seguente utilizza una sintassi alternativa per descrivere le risorse con il tag `Stack=Test`.
```
aws ec2 describe-tags \
--filters "Name=tag:Stack,Values=Test"
```
L’esempio `describe-tags` seguente descrive i tag per tutte le istanze che hanno un tag con la chiave `Purpose` e nessun valore.
```
aws ec2 describe-tags \
--filters "Name=resource-type,Values=instance" "Name=key,Values=Purpose" "Name=value,Values="
```
Output:
```
{
"Tags": [
{
"ResourceType": "instance",
"ResourceId": "i-1234567890abcdef5",
"Value": null,
"Key": "Purpose"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeTags AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-tags.html)*Command Reference*.
### `describe-traffic-mirror-filters`
Il seguente esempio di codice mostra come utilizzare`describe-traffic-mirror-filters`.
**AWS CLI**
**Come visualizzare i filtri di mirroring del traffico**
L’esempio `describe-traffic-mirror-filters` seguente mostra i dettagli di tutti i filtri di mirroring del traffico.
```
aws ec2 describe-traffic-mirror-filters
```
Output:
```
{
"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": []
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzare i filtri del mirroring del traffico](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-filter.html#view-traffic-mirroring-filter) nella *Guida di Mirroring del traffico*.
+ Per i dettagli sull'API, consulta [DescribeTrafficMirrorFilters AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-traffic-mirror-filters.html)*Command Reference*.
### `describe-traffic-mirror-sessions`
Il seguente esempio di codice mostra come utilizzare`describe-traffic-mirror-sessions`.
**AWS CLI**
**Come descrivere una sessione di mirroring del traffico**
L’esempio `describe-traffic-mirror-sessions` seguente visualizza i dettagli delle sessioni di mirroring del traffico.
```
aws ec2 describe-traffic-mirror-sessions
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzare i dettagli della sessione di mirroring del traffico](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-session.html#view-traffic-mirroring-session) nella *Guida di Mirroring del traffico AWS *.
+ Per i dettagli sull'API, consulta [DescribeTrafficMirrorSessions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-traffic-mirror-sessions.html)*Command Reference*.
### `describe-traffic-mirror-targets`
Il seguente esempio di codice mostra come utilizzare`describe-traffic-mirror-targets`.
**AWS CLI**
**Come descrivere una destinazione di mirroring del traffico**
L’esempio `describe-traffic-mirror-targets` seguente visualizza le informazioni sulla destinazione di mirroring del traffico specificata.
```
aws ec2 describe-traffic-mirror-targets \
--traffic-mirror-target-ids tmt-0dabe9b0a6EXAMPLE
```
Output:
```
{
"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": []
}
]
}
```
Per ulteriori informazioni, consulta [Destinazioni del mirroring del traffico](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-target.html) nella *Guida di Mirroring del traffico Amazon VPC*.
+ Per i dettagli sull'API, consulta [DescribeTrafficMirrorTargets AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-traffic-mirror-targets.html)*Command Reference*.
### `describe-transit-gateway-attachments`
Il seguente esempio di codice mostra come utilizzare`describe-transit-gateway-attachments`.
**AWS CLI**
**Come visualizzare i collegamenti del gateway di transito alla VPN**
L’esempio `describe-transit-gateway-attachments` seguente visualizza i dettagli per i collegamenti del gateway di transito alla VPN.
```
aws ec2 describe-transit-gateway-attachments
```
Output:
```
{
"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": []
}
]
}
```
Per ulteriori informazioni, consulta [Utilizzo dei gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/working-with-transit-gateways.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DescribeTransitGatewayAttachments AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateway-attachments.html)*Command Reference*.
### `describe-transit-gateway-connect-peers`
Il seguente esempio di codice mostra come utilizzare`describe-transit-gateway-connect-peers`.
**AWS CLI**
**Come descrivere un peer di Transit Gateway Connect**
L’esempio `describe-transit-gateway-connect-peers` seguente descrive il peer Connect specificato.
```
aws ec2 describe-transit-gateway-connect-peers \
--transit-gateway-connect-peer-ids tgw-connect-peer-0666adbac4EXAMPLE
```
Output:
```
{
"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": []
}
]
}
```
Per ulteriori informazioni, consulta [Collegamenti Transit gateway Connect e peer Connect](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DescribeTransitGatewayConnectPeers AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateway-connect-peers.html)*Command Reference*.
### `describe-transit-gateway-connects`
Il seguente esempio di codice mostra come utilizzare`describe-transit-gateway-connects`.
**AWS CLI**
**Come descrivere un collegamento Connect del gateway di transito**
L’esempio `describe-transit-gateway-connects` seguente descrive il collegamento Connect specificato.
```
aws ec2 describe-transit-gateway-connects \
--transit-gateway-attachment-ids tgw-attach-037012e5dcEXAMPLE
```
Output:
```
{
"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": []
}
]
}
```
Per ulteriori informazioni, consulta [Collegamenti Transit gateway Connect e peer Connect](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DescribeTransitGatewayConnects AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateway-connects.html)*Command Reference*.
### `describe-transit-gateway-multicast-domains`
Il seguente esempio di codice mostra come utilizzare`describe-transit-gateway-multicast-domains`.
**AWS CLI**
**Come descrivere i domini multicast (trasmissione uno a molti) del gateway di transito**
L’esempio `describe-transit-gateway-multicast-domains` seguente visualizza i dettagli per tutti i domini multicast (trasmissione uno a molti) del gateway di transito.
```
aws ec2 describe-transit-gateway-multicast-domains
```
Output:
```
{
"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"
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Gestione dei domini multicast (trasmissione uno a molti)](https://docs.aws.amazon.com/vpc/latest/tgw/manage-domain.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DescribeTransitGatewayMulticastDomains AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateway-multicast-domains.html)*Command Reference*.
### `describe-transit-gateway-peering-attachments`
Il seguente esempio di codice mostra come utilizzare`describe-transit-gateway-peering-attachments`.
**AWS CLI**
**Come descrivere i collegamenti peering del gateway di transito**
L’esempio `describe-transit-gateway-peering-attachments` seguente visualizza i dettagli di tutti i collegamenti peering del gateway di transito.
```
aws ec2 describe-transit-gateway-peering-attachments
```
Output:
```
{
"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": []
}
]
}
```
Per ulteriori informazioni, consulta [Accessori di peering del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-peering.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DescribeTransitGatewayPeeringAttachments AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateway-peering-attachments.html)*Command Reference*.
### `describe-transit-gateway-policy-tables`
Il seguente esempio di codice mostra come utilizzare`describe-transit-gateway-policy-tables`.
**AWS CLI**
**Come descrivere una tabella di policy del gateway di transito**
L’esempio `describe-transit-gateway-policy-tables` seguente descrive la tabella di policy del gateway di transito specificato.
```
aws ec2 describe-transit-gateway-policy-tables \
--transit-gateway-policy-table-ids tgw-ptb-0a16f134b78668a81
```
Output:
```
{
"TransitGatewayPolicyTables": [
{
"TransitGatewayPolicyTableId": "tgw-ptb-0a16f134b78668a81",
"TransitGatewayId": "tgw-067f8505c18f0bd6e",
"State": "available",
"CreationTime": "2023-11-28T16:36:43+00:00",
"Tags": []
}
]
}
```
Per ulteriori informazioni, consulta [Tabelle di policy del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-policy-tables.html) nella *Guida per l’utente di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DescribeTransitGatewayPolicyTables AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateway-policy-tables.html)*Command Reference*.
### `describe-transit-gateway-route-tables`
Il seguente esempio di codice mostra come utilizzare`describe-transit-gateway-route-tables`.
**AWS CLI**
**Come descrivere le tabelle di routing del gateway di transito**
L’esempio `describe-transit-gateway-route-tables` seguente visualizza i dettagli per le tabella di routing del gateway di transito.
```
aws ec2 describe-transit-gateway-route-tables
```
Output:
```
{
"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": []
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzare le tabelle di routing del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html#view-tgw-route-tables) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DescribeTransitGatewayRouteTables AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateway-route-tables.html)*Command Reference*.
### `describe-transit-gateway-vpc-attachments`
Il seguente esempio di codice mostra come utilizzare`describe-transit-gateway-vpc-attachments`.
**AWS CLI**
**Come descrivere gli allegati VPC del gateway di transito**
L’esempio `describe-transit-gateway-vpc-attachments` seguente visualizza i dettagli per gli allegati VPC del gateway di transito.
```
aws ec2 describe-transit-gateway-vpc-attachments
```
Output:
```
{
"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"
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzare i collegamenti al VPC](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html#view-vpc-attachment) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DescribeTransitGatewayVpcAttachments AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateway-vpc-attachments.html)*Command Reference*.
### `describe-transit-gateways`
Il seguente esempio di codice mostra come utilizzare`describe-transit-gateways`.
**AWS CLI**
**Come descrivere i gateway di transito**
L’esempio `describe-transit-gateways` seguente recupera i dettagli di tutti i gateway di transito.
```
aws ec2 describe-transit-gateways
```
Output:
```
{
"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"
}
]
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeTransitGateways AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-transit-gateways.html)*Command Reference*.
### `describe-verified-access-endpoints`
Il seguente esempio di codice mostra come utilizzare`describe-verified-access-endpoints`.
**AWS CLI**
**Come descrivere un endpoint di accesso verificato**
L’esempio `describe-verified-access-endpoints` seguente descrive l’endpoint di accesso verificato specificato.
```
aws ec2 describe-verified-access-endpoints \
--verified-access-endpoint-ids vae-066fac616d4d546f2
```
Output:
```
{
"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"
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Endpoint di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-endpoints.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [DescribeVerifiedAccessEndpoints AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-verified-access-endpoints.html)*Command Reference*.
### `describe-verified-access-groups`
Il seguente esempio di codice mostra come utilizzare`describe-verified-access-groups`.
**AWS CLI**
**Come descrivere un gruppo di accesso verificato**
L’esempio `describe-verified-access-groups` seguente descrive il gruppo di accesso verificato specificato.
```
aws ec2 describe-verified-access-groups \
--verified-access-group-ids vagr-0dbe967baf14b7235
```
Output:
```
{
"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"
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Gruppi di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-groups.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [DescribeVerifiedAccessGroups AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-verified-access-groups.html)*Command Reference*.
### `describe-verified-access-instance-logging-configurations`
Il seguente esempio di codice mostra come utilizzare`describe-verified-access-instance-logging-configurations`.
**AWS CLI**
**Come descrivere la configurazione di registrazione per un’istanza di accesso verificato**
L’esempio `describe-verified-access-instance-logging-configurations` seguente descrive la configurazione di registrazione dell’istanza di accesso verificato specificata.
```
aws ec2 describe-verified-access-instance-logging-configurations \
--verified-access-instance-ids vai-0ce000c0b7643abea
```
Output:
```
{
"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
}
}
]
}
```
Per ulteriori informazioni, consulta [Log di accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/access-logs.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [DescribeVerifiedAccessInstanceLoggingConfigurations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-verified-access-instance-logging-configurations.html)*Command Reference*.
### `describe-verified-access-instances`
Il seguente esempio di codice mostra come utilizzare`describe-verified-access-instances`.
**AWS CLI**
**Come descrivere un’istanza di accesso verificato**
L’esempio `describe-verified-access-instances` seguente descrive l’istanza di accesso verificato specificata.
```
aws ec2 describe-verified-access-instances \
--verified-access-instance-ids vai-0ce000c0b7643abea
```
Output:
```
{
"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"
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Istanze di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-instances.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [DescribeVerifiedAccessInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-verified-access-instances.html)*Command Reference*.
### `describe-verified-access-trust-providers`
Il seguente esempio di codice mostra come utilizzare`describe-verified-access-trust-providers`.
**AWS CLI**
**Come descrivere un provider di attendibilità di accesso verificato**
L’esempio `describe-verified-access-trust-providers` seguente descrive il provider di attendibilità di accesso verificato specificato.
```
aws ec2 describe-verified-access-trust-providers \
--verified-access-trust-provider-ids vatp-0bb32de759a3e19e7
```
Output:
```
{
"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"
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Provider di attendibilità per Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/trust-providers.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [DescribeVerifiedAccessTrustProviders AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-verified-access-trust-providers.html)*Command Reference*.
### `describe-volume-attribute`
Il seguente esempio di codice mostra come utilizzare`describe-volume-attribute`.
**AWS CLI**
**Come descrivere un attributo del volume**
Questo esempio imposta l’attributo `autoEnableIo` del volume con l’ID `vol-049df61146c4d7901`.
Comando:
```
aws ec2 describe-volume-attribute --volume-id vol-049df61146c4d7901 --attribute autoEnableIO
```
Output:
```
{
"AutoEnableIO": {
"Value": false
},
"VolumeId": "vol-049df61146c4d7901"
}
```
+ Per i dettagli sull'API, consulta [DescribeVolumeAttribute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-volume-attribute.html)*Command Reference*.
### `describe-volume-status`
Il seguente esempio di codice mostra come utilizzare`describe-volume-status`.
**AWS CLI**
**Come descrivere lo stato di un volume**
Questo comando di esempio descrive lo stato del volume `vol-1234567890abcdef0`.
Comando:
```
aws ec2 describe-volume-status --volume-ids vol-1234567890abcdef0
```
Output:
```
{
"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": []
}
]
}
```
**Come descrivere lo stato dei volumi danneggiati**
Questo comando di esempio descrive lo stato di tutti i volumi danneggiati. In questo output di esempio non sono presenti volumi danneggiati.
Comando:
```
aws ec2 describe-volume-status --filters Name=volume-status.status,Values=impaired
```
Output:
```
{
"VolumeStatuses": []
}
```
Se si dispone di un volume con un controllo di stato non riuscito (lo stato è danneggiato), consulta Utilizzo di un volume danneggiato nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DescribeVolumeStatus AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-volume-status.html)*Command Reference*.
### `describe-volumes-modifications`
Il seguente esempio di codice mostra come utilizzare`describe-volumes-modifications`.
**AWS CLI**
**Come descrivere lo stato di modifica di un volume**
L’esempio `describe-volumes-modifications` seguente descrive lo stato di modifica del volume specificato.
```
aws ec2 describe-volumes-modifications \
--volume-ids vol-1234567890abcdef0
```
Output:
```
{
"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
}
}
```
+ Per i dettagli sull'API, consulta [DescribeVolumesModifications AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-volumes-modifications.html)*Command Reference*.
### `describe-volumes`
Il seguente esempio di codice mostra come utilizzare`describe-volumes`.
**AWS CLI**
**Esempio 1: come descrivere un volume**
L’esempio `describe-volumes` seguente descrive i volumi specificati nella Regione corrente.
```
aws ec2 describe-volumes \
--volume-ids vol-049df61146c4d7901 vol-1234567890abcdef0
```
Output:
```
{
"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
}
]
}
```
**Esempio 2: come descrivere i volumi collegati a un’istanza specifica**
L’esempio `describe-volumes` seguente descrive tutti i volumi collegati all’istanza specificata e impostati per essere eliminati alla terminazione dell’istanza.
```
aws ec2 describe-volumes \
--region us-east-1 \
--filters Name=attachment.instance-id,Values=i-1234567890abcdef0 Name=attachment.delete-on-termination,Values=true
```
Per un esempio dell’output di `describe-volumes`, consulta l’Esempio 1.
**Esempio 3: come descrivere i volumi disponibili in una zona di disponibilità specifica**
L’esempio `describe-volumes` seguente descrive tutti i volumi con stato `available` e che si trovano nella zona di disponibilità specificata.
```
aws ec2 describe-volumes \
--filters Name=status,Values=available Name=availability-zone,Values=us-east-1a
```
Per un esempio dell’output di `describe-volumes`, vedi l’Esempio 1.
**Esempio 4: come descrivere i volumi in base ai tag**
L’esempio `describe-volumes` seguente descrive tutti i volumi con la chiave di tag `Name` e un valore che inizia con `Test`. L'output viene quindi filtrato con una query che visualizza solo i tag e IDs i volumi.
```
aws ec2 describe-volumes \
--filters Name=tag:Name,Values=Test* \
--query "Volumes[*].{ID:VolumeId,Tag:Tags}"
```
Output:
```
[
{
"Tag": [
{
"Value": "Test2",
"Key": "Name"
}
],
"ID": "vol-1234567890abcdef0"
},
{
"Tag": [
{
"Value": "Test1",
"Key": "Name"
}
],
"ID": "vol-049df61146c4d7901"
}
]
```
Per ulteriori esempi di utilizzo dei filtri di tag, consulta [Utilizzo dei tag](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_CLI) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DescribeVolumes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-volumes.html)*Command Reference.*
### `describe-vpc-attribute`
Il seguente esempio di codice mostra come utilizzare`describe-vpc-attribute`.
**AWS CLI**
**Per descrivere l' enableDnsSupport attributo**
Questo esempio descrive l’attributo `enableDnsSupport`. Questo attributo indica se la risoluzione DNS è abilitata per il VPC. Se questo attributo è `true`, il server Amazon DNS risolve i nomi host DNS per le istanze negli indirizzi IP corrispondenti, ma solo in quel caso.
Comando:
```
aws ec2 describe-vpc-attribute --vpc-id vpc-a01106c2 --attribute enableDnsSupport
```
Output:
```
{
"VpcId": "vpc-a01106c2",
"EnableDnsSupport": {
"Value": true
}
}
```
**Per descrivere l' enableDnsHostnames attributo**
Questo esempio descrive l’attributo `enableDnsHostnames`. Questo attributo indica se le istanze avviate nel VPC ricevono nomi di host DNS. Se questo attributo è `true`, le istanze nel VPC ottengono nomi host DNS, altrimenti no.
Comando:
```
aws ec2 describe-vpc-attribute --vpc-id vpc-a01106c2 --attribute enableDnsHostnames
```
Output:
```
{
"VpcId": "vpc-a01106c2",
"EnableDnsHostnames": {
"Value": true
}
}
```
+ Per i dettagli sull'API, consulta [DescribeVpcAttribute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-attribute.html)*Command Reference*.
### `describe-vpc-classic-link-dns-support`
Il seguente esempio di codice mostra come utilizzare`describe-vpc-classic-link-dns-support`.
**AWS CLI**
**Per descrivere il supporto ClassicLink DNS per VPCs**
Questo esempio descrive lo stato del supporto ClassicLink DNS di tutti i tuoi. VPCs
Comando:
```
aws ec2 describe-vpc-classic-link-dns-support
```
Output:
```
{
"Vpcs": [
{
"VpcId": "vpc-88888888",
"ClassicLinkDnsSupported": true
},
{
"VpcId": "vpc-1a2b3c4d",
"ClassicLinkDnsSupported": false
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeVpcClassicLinkDnsSupport AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-classic-link-dns-support.html)*Command Reference.*
### `describe-vpc-classic-link`
Il seguente esempio di codice mostra come utilizzare`describe-vpc-classic-link`.
**AWS CLI**
**Per descrivere lo ClassicLink stato del tuo VPCs**
Questo esempio elenca lo ClassicLink stato di vpc-88888888.
Comando:
```
aws ec2 describe-vpc-classic-link --vpc-id vpc-88888888
```
Output:
```
{
"Vpcs": [
{
"ClassicLinkEnabled": true,
"VpcId": "vpc-88888888",
"Tags": [
{
"Value": "classiclinkvpc",
"Key": "Name"
}
]
}
]
}
```
Questo esempio elenca solo VPCs quelli abilitati per Classiclink (il valore del `is-classic-link-enabled` filtro è impostato su). `true`
Comando:
```
aws ec2 describe-vpc-classic-link --filter "Name=is-classic-link-enabled,Values=true"
```
+ Per i dettagli sull'API, consulta *AWS CLI Command [DescribeVpcClassicLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-classic-link.html)Reference*.
### `describe-vpc-endpoint-associations`
Il seguente esempio di codice mostra come utilizzare`describe-vpc-endpoint-associations`.
**AWS CLI**
**Come descrivere le associazioni di endpoint VPC**
L’esempio `describe-vpc-endpoint-associations` seguente descrive le associazioni di endpoint VPC.
```
aws ec2 describe-vpc-endpoint-associations
```
Output:
```
{
"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"
}
]
}
```
*Per ulteriori informazioni, consulta [Gestire le associazioni degli endpoint VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/resource-configuration-associations.html#resource-config-manage-ep-association) nella Guida per l'AWS PrivateLink utente.*
+ Per i dettagli sulle API, consulta *AWS CLI Command [DescribeVpcEndpointAssociations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-endpoint-associations.html)Reference*.
### `describe-vpc-endpoint-connection-notifications`
Il seguente esempio di codice mostra come utilizzare`describe-vpc-endpoint-connection-notifications`.
**AWS CLI**
**Come descrivere le notifica della connessione endpoint**
L’esempio `describe-vpc-endpoint-connection-notifications` seguente descrive tutte le notifiche della connessione endpoint.
```
aws ec2 describe-vpc-endpoint-connection-notifications
```
Output:
```
{
"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"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeVpcEndpointConnectionNotifications AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-endpoint-connection-notifications.html)*Command Reference*.
### `describe-vpc-endpoint-connections`
Il seguente esempio di codice mostra come utilizzare`describe-vpc-endpoint-connections`.
**AWS CLI**
**Come descrivere le connessioni endpoint VPC**
Questo esempio descrive le connessioni endpoint dell’interfaccia al servizio endpoint e filtra i risultati per visualizzare gli endpoint che sono nello stato `PendingAcceptance`.
Comando:
```
aws ec2 describe-vpc-endpoint-connections --filters Name=vpc-endpoint-state,Values=pendingAcceptance
```
Output:
```
{
"VpcEndpointConnections": [
{
"VpcEndpointId": "vpce-0abed31004e618123",
"ServiceId": "vpce-svc-0abced088d20def56",
"CreationTimestamp": "2017-11-30T10:00:24.350Z",
"VpcEndpointState": "pendingAcceptance",
"VpcEndpointOwner": "123456789012"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeVpcEndpointConnections AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-endpoint-connections.html)*Command Reference*.
### `describe-vpc-endpoint-service-configurations`
Il seguente esempio di codice mostra come utilizzare`describe-vpc-endpoint-service-configurations`.
**AWS CLI**
**Come descrivere le configurazioni del servizio endpoint**
L’esempio `describe-vpc-endpoint-service-configurations` seguente descrive le configurazioni del servizio endpoint.
```
aws ec2 describe-vpc-endpoint-service-configurations
```
Output:
```
{
"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": []
}
]
}
```
Per ulteriori informazioni, vedere [Concepts](https://docs.aws.amazon.com/vpc/latest/privatelink/concepts.html) nella *Guida AWS PrivateLink per l'utente*.
+ Per i dettagli sull'API, consulta [DescribeVpcEndpointServiceConfigurations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-endpoint-service-configurations.html)*Command Reference*.
### `describe-vpc-endpoint-service-permissions`
Il seguente esempio di codice mostra come utilizzare`describe-vpc-endpoint-service-permissions`.
**AWS CLI**
**Come descrivere le autorizzazioni del servizio endpoint**
Questo esempio descrive le autorizzazioni per il servizio endpoint specificato.
Comando:
```
aws ec2 describe-vpc-endpoint-service-permissions --service-id vpce-svc-03d5ebb7d9579a2b3
```
Output:
```
{
"AllowedPrincipals": [
{
"PrincipalType": "Account",
"Principal": "arn:aws:iam::123456789012:root"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeVpcEndpointServicePermissions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-endpoint-service-permissions.html)*Command Reference*.
### `describe-vpc-endpoint-services`
Il seguente esempio di codice mostra come utilizzare`describe-vpc-endpoint-services`.
**AWS CLI**
**Esempio 1: come descrivere tutti i servizi endpoint VPC**
L'`describe-vpc-endpoint-services`esempio seguente elenca tutti i servizi endpoint VPC per una regione. AWS
```
aws ec2 describe-vpc-endpoint-services
```
Output:
```
{
"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"
]
}
```
**Esempio 2: come descrivere i dettagli di un servizio endpoint**
L’esempio `describe-vpc-endpoint-services` seguente elenca i dettagli del servizio endpoint dell’interfaccia Amazon S3.
```
aws ec2 describe-vpc-endpoint-services \
--filter 'Name=service-type,Values=Interface' Name=service-name,Values=com.amazonaws.us-east-1.s3
```
Output:
```
{
"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"
]
}
```
Per ulteriori informazioni, consulta [Visualizza i nomi dei AWS servizi disponibili nella Guida](https://docs.aws.amazon.com/vpc/latest/privatelink/aws-services-privatelink-support.html#vpce-view-available-services) per l'*AWS PrivateLink utente*.
+ Per i dettagli sull'API, consulta [DescribeVpcEndpointServices AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-endpoint-services.html)*Command Reference*.
### `describe-vpc-endpoints`
Il seguente esempio di codice mostra come utilizzare`describe-vpc-endpoints`.
**AWS CLI**
**Come descrivere gli endpoint VPC**
L’esempio `describe-vpc-endpoints` seguente visualizza i dettagli di tutti gli endpoint VPC.
```
aws ec2 describe-vpc-endpoints
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, vedere [Concepts](https://docs.aws.amazon.com/vpc/latest/privatelink/concepts.html) nella *Guida AWS PrivateLink per l'utente*.
+ Per i dettagli sull'API, consulta [DescribeVpcEndpoints AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-endpoints.html)*Command Reference*.
### `describe-vpc-peering-connections`
Il seguente esempio di codice mostra come utilizzare`describe-vpc-peering-connections`.
**AWS CLI**
**Come descrivere le connessioni peering VPC**
Questo esempio descrive tutte le connessioni peering VPC.
Comando:
```
aws ec2 describe-vpc-peering-connections
```
Output:
```
{
"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"
}
}
]
}
```
**Come descrivere connessioni peering VPC specifiche**
Questo esempio descrive tutte le connessioni peering VPC che si trovano nello stato di accettazione in sospeso.
Comando:
```
aws ec2 describe-vpc-peering-connections --filters Name=status-code,Values=pending-acceptance
```
Questo esempio descrive tutte le connessioni peering VPC con il tag Owner=Finance.
Comando:
```
aws ec2 describe-vpc-peering-connections --filters Name=tag:Owner,Values=Finance
```
Questo esempio descrive tutte le connessioni peering VPC richieste per il VPC specificato, vpc-1a2b3c4d.
Comando:
```
aws ec2 describe-vpc-peering-connections --filters Name=requester-vpc-info.vpc-id,Values=vpc-1a2b3c4d
```
+ Per i dettagli sull'API, consulta [DescribeVpcPeeringConnections AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpc-peering-connections.html)*Command Reference*.
### `describe-vpcs`
Il seguente esempio di codice mostra come utilizzare`describe-vpcs`.
**AWS CLI**
**Esempio 1: Per descrivere tutti i tuoi VPCs**
L'`describe-vpcs`esempio seguente recupera i dettagli sul tuo VPCs.
```
aws ec2 describe-vpcs
```
Output:
```
{
"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"
}
]
}
]
}
```
**Esempio 2: come descrivere un VPC specificato**
Nell’esempio `describe-vpcs` seguente vengono recuperati i dettagli per il VPC specificato.
```
aws ec2 describe-vpcs \
--vpc-ids vpc-06e4ab6c6cEXAMPLE
```
Output:
```
{
"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"
}
]
}
]
}
```
+ Per i dettagli sull'API, vedere [DescribeVpcs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpcs.html)in *AWS CLI Command Reference.*
### `describe-vpn-connections`
Il seguente esempio di codice mostra come utilizzare`describe-vpn-connections`.
**AWS CLI**
**Esempio 1: come descrivere le connessioni VPN**
L'`describe-vpn-connections`esempio seguente descrive tutte le connessioni Site-to-Site VPN.
```
aws ec2 describe-vpn-connections
```
Output:
```
{
"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": ""
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Come funziona la AWS Site-to-Site VPN](https://docs.aws.amazon.com/vpn/latest/s2svpn/how_it_works.html) nella *Guida per l'utente della AWS Site-to-Site VPN*.
**Esempio 2: come descrivere le connessioni VPN disponibili**
L'`describe-vpn-connections`esempio seguente descrive le tue connessioni Site-to-Site VPN con uno stato di`available`.
```
aws ec2 describe-vpn-connections \
--filters "Name=state,Values=available"
```
Per ulteriori informazioni, consulta [Come funziona la AWS Site-to-Site VPN](https://docs.aws.amazon.com/vpn/latest/s2svpn/how_it_works.html) nella *Guida per l'utente della AWS Site-to-Site VPN*.
+ Per i dettagli sull'API, consulta [DescribeVpnConnections AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpn-connections.html)*Command Reference*.
### `describe-vpn-gateways`
Il seguente esempio di codice mostra come utilizzare`describe-vpn-gateways`.
**AWS CLI**
**Come descrivere i gateway privati virtuali**
Questo esempio descrive i gateway privati virtuali.
Comando:
```
aws ec2 describe-vpn-gateways
```
Output:
```
{
"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"
}
]
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeVpnGateways AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-vpn-gateways.html)*Command Reference*.
### `detach-classic-link-vpc`
Il seguente esempio di codice mostra come utilizzare`detach-classic-link-vpc`.
**AWS CLI**
**Come scollegare (distaccare) un’istanza EC2-Classic da un VPC**
Questo esempio scollega l’istanza i-0598c7d356eba48d7 dal VPC vpc-88888888.
Comando:
```
aws ec2 detach-classic-link-vpc --instance-id i-0598c7d356eba48d7 --vpc-id vpc-88888888
```
Output:
```
{
"Return": true
}
```
+ Per i dettagli sull'API, consulta [DetachClassicLinkVpc AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/detach-classic-link-vpc.html)*Command Reference*.
### `detach-internet-gateway`
Il seguente esempio di codice mostra come utilizzare`detach-internet-gateway`.
**AWS CLI**
**Come scollegare un gateway Internet dal VPC**
L’esempio `detach-internet-gateway` seguente scollega il gateway Internet specificato dal VPC specifico.
```
aws ec2 detach-internet-gateway \
--internet-gateway-id igw-0d0fb496b3EXAMPLE \
--vpc-id vpc-0a60eb65b4EXAMPLE
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Gateway Internet](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [DetachInternetGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/detach-internet-gateway.html)*Command Reference*.
### `detach-network-interface`
Il seguente esempio di codice mostra come utilizzare`detach-network-interface`.
**AWS CLI**
**Come scollegare un’interfaccia di rete da un’istanza**
Questo esempio scollega l’interfaccia di rete specificata dall’istanza specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 detach-network-interface --attachment-id eni-attach-66c4350a
```
+ Per i dettagli sull'API, consulta [DetachNetworkInterface AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/detach-network-interface.html)*Command Reference*.
### `detach-verified-access-trust-provider`
Il seguente esempio di codice mostra come utilizzare`detach-verified-access-trust-provider`.
**AWS CLI**
**Come scollegare un provider di attendibilità da un’istanza**
L’esempio `detach-verified-access-trust-provider` seguente scollega il provider di attendibilità di accesso verificato specificato dall’istanza di accesso verificato specificata.
```
aws ec2 detach-verified-access-trust-provider \
--verified-access-instance-id vai-0ce000c0b7643abea \
--verified-access-trust-provider-id vatp-0bb32de759a3e19e7
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Istanze di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-instances.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [DetachVerifiedAccessTrustProvider AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/detach-verified-access-trust-provider.html)*Command Reference*.
### `detach-volume`
Il seguente esempio di codice mostra come utilizzare`detach-volume`.
**AWS CLI**
**Come scollegare un volume da un’istanza**
Questo comando di esempio scollega il volume (`vol-049df61146c4d7901`) dall’istanza a cui è collegato.
Comando:
```
aws ec2 detach-volume --volume-id vol-1234567890abcdef0
```
Output:
```
{
"AttachTime": "2014-02-27T19:23:06.000Z",
"InstanceId": "i-1234567890abcdef0",
"VolumeId": "vol-049df61146c4d7901",
"State": "detaching",
"Device": "/dev/sdb"
}
```
+ Per i dettagli sull'API, consulta [DetachVolume AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/detach-volume.html)*Command Reference*.
### `detach-vpn-gateway`
Il seguente esempio di codice mostra come utilizzare`detach-vpn-gateway`.
**AWS CLI**
**Come scollegare un gateway privato virtuale da un VPC**
Questo esempio scollega il gateway privato virtuale specificato dal VPC specificato. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 detach-vpn-gateway --vpn-gateway-id vgw-9a4cacf3 --vpc-id vpc-a01106c2
```
+ Per i dettagli sull'API, consulta [DetachVpnGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/detach-vpn-gateway.html)*Command Reference*.
### `disable-address-transfer`
Il seguente esempio di codice mostra come utilizzare`disable-address-transfer`.
**AWS CLI**
**Come disabilitare il trasferimento degli indirizzi IP elastici**
L’esempio `disable-address-transfer` seguente disabilita il trasferimento degli indirizzi IP elastici per l’indirizzo IP elastico specificato.
```
aws ec2 disable-address-transfer \
--allocation-id eipalloc-09ad461b0d03f6aaf
```
Output:
```
{
"AddressTransfer": {
"PublicIp": "100.21.184.216",
"AllocationId": "eipalloc-09ad461b0d03f6aaf",
"AddressTransferStatus": "disabled"
}
}
```
Per ulteriori informazioni, consulta [Trasferimento degli indirizzi IP elastici](https://docs.aws.amazon.com/vpc/latest/userguide/WorkWithEIPs.html#transfer-EIPs-intro) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [DisableAddressTransfer AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-address-transfer.html)*Command Reference*.
### `disable-aws-network-performance-metric-subscription`
Il seguente esempio di codice mostra come utilizzare`disable-aws-network-performance-metric-subscription`.
**AWS CLI**
**Come disabilitare una sottoscrizioni di parametri di prestazioni**
L’esempio `disable-aws-network-performance-metric-subscription` seguente disabilita il monitoraggio della latenza di rete aggregata tra le Regioni di origine e di destinazione specificate.
```
aws ec2 disable-aws-network-performance-metric-subscription \
--source us-east-1 \
--destination eu-west-1 \
--metric aggregate-latency \
--statistic p50
```
Output:
```
{
"Output": true
}
```
Per ulteriori informazioni, consulta [Gestire CloudWatch gli abbonamenti utilizzando la CLI](https://docs.aws.amazon.com/network-manager/latest/infrastructure-performance/getting-started-nmip-cli.html) nella *Infrastructure Performance User* Guide.
+ Per i dettagli sull'API, consulta *AWS CLI Command [DisableAwsNetworkPerformanceMetricSubscription](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-aws-network-performance-metric-subscription.html)Reference*.
### `disable-ebs-encryption-by-default`
Il seguente esempio di codice mostra come utilizzare`disable-ebs-encryption-by-default`.
**AWS CLI**
**Come disabilitare la crittografia EBS per impostazione predefinita**
L'`disable-ebs-encryption-by-default`esempio seguente disabilita la crittografia EBS per impostazione predefinita per il tuo AWS account nella regione corrente.
```
aws ec2 disable-ebs-encryption-by-default
```
Output:
```
{
"EbsEncryptionByDefault": false
}
```
+ Per i dettagli sull'API, consulta *AWS CLI Command [DisableEbsEncryptionByDefault](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-ebs-encryption-by-default.html)Reference*.
### `disable-fast-launch`
Il seguente esempio di codice mostra come utilizzare`disable-fast-launch`.
**AWS CLI**
**Come interrompere l’avvio rapido di un’immagine**
L’esempio `disable-fast-launch` seguente interrompe l’avvio rapido per l’AMI specificata e rimuove gli snapshot con pre-provisioning esistenti.
```
aws ec2 disable-fast-launch \
--image-id ami-01234567890abcedf
```
Output:
```
{
"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"
}
```
Per ulteriori informazioni, consulta [Configurare le impostazioni di avvio rapido di EC2 per l’AMI di Windows](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/win-fast-launch-configure.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DisableFastLaunch AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-fast-launch.html)*Command Reference*.
### `disable-fast-snapshot-restores`
Il seguente esempio di codice mostra come utilizzare`disable-fast-snapshot-restores`.
**AWS CLI**
**Come disabilitare il ripristino rapido degli snapshot**
L’esempio `disable-fast-snapshot-restores` seguente disabilita il ripristino rapido degli snapshot per gli snapshot specificati nella zona di disponibilità specificata.
```
aws ec2 disable-fast-snapshot-restores \
--availability-zones us-east-2a \
--source-snapshot-ids snap-1234567890abcdef0
```
Output:
```
{
"Successful": [
{
"SnapshotId": "snap-1234567890abcdef0"
"AvailabilityZone": "us-east-2a",
"State": "disabling",
"StateTransitionReason": "Client.UserInitiated",
"OwnerId": "123456789012",
"EnablingTime": "2020-01-25T23:57:49.602Z"
}
],
"Unsuccessful": []
}
```
+ Per i dettagli sull'API, consulta [DisableFastSnapshotRestores AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-fast-snapshot-restores.html)*Command Reference*.
### `disable-image-block-public-access`
Il seguente esempio di codice mostra come utilizzare`disable-image-block-public-access`.
**AWS CLI**
**Per disabilitare l'accesso pubblico a blocchi AMIs nella regione specificata**
L'`disable-image-block-public-access`esempio seguente disabilita l'accesso pubblico a blocchi AMIs a livello di account nella regione specificata.
```
aws ec2 disable-image-block-public-access \
--region us-east-1
```
Output:
```
{
"ImageBlockPublicAccessState": "unblocked"
}
```
Per ulteriori informazioni, consulta [Bloccare l'accesso pubblico al tuo AMIs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-public-access-to-amis.html) nella Guida per l'*utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DisableImageBlockPublicAccess AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-image-block-public-access.html)*Command Reference.*
### `disable-image-deprecation`
Il seguente esempio di codice mostra come utilizzare`disable-image-deprecation`.
**AWS CLI**
**Come annullare la deprecazione di un’AMI**
L’esempio `disable-image-deprecation` seguente annulla l’obsolescenza di un’AMI, che rimuove il campo `DeprecationTime` dall’output `describe-images`. Per eseguire questa procedura, è necessario essere il proprietario dell’AMI.
```
aws ec2 disable-image-deprecation \
--image-id ami-1234567890abcdef0
```
Output:
```
{
"RequestID": "11aabb229-4eac-35bd-99ed-be587EXAMPLE",
"Return": "true"
}
```
Per ulteriori informazioni, consulta [Dichiarazione di un’AMI come obsoleta](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deprecate.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DisableImageDeprecation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-image-deprecation.html)*Command Reference*.
### `disable-image-deregistration-protection`
Il seguente esempio di codice mostra come utilizzare`disable-image-deregistration-protection`.
**AWS CLI**
**Come disabilitare la protezione da annullamento della registrazione**
L’esempio `disable-image-deregistration-protection` seguente disabilita la protezione da annullamento della registrazione per l’immagine specificata.
```
aws ec2 disable-image-deregistration-protection \
--image-id ami-0b1a928a144a74ec9
```
Output:
```
{
"Return": "disabled"
}
```
Per ulteriori informazioni, consulta [Proteggere un’AMI dall’annullamento della registrazione](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deregistration-protection.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DisableImageDeregistrationProtection AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-image-deregistration-protection.html)*Command Reference*.
### `disable-image`
Il seguente esempio di codice mostra come utilizzare`disable-image`.
**AWS CLI**
**Come disabilitare un’AMI**
L’esempio `disable-image` seguente disabilita l’AMI specificata.
```
aws ec2 disable-image \
--image-id ami-1234567890abcdef0
```
Output:
```
{
"Return": "true"
}
```
Per ulteriori informazioni, consulta [Disabilitazione di un’AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/disable-an-ami.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DisableImage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-image.html)*Command Reference*.
### `disable-ipam-organization-admin-account`
Il seguente esempio di codice mostra come utilizzare`disable-ipam-organization-admin-account`.
**AWS CLI**
**Come disabilitare l’amministratore IPAM delegato**
In alcuni scenari, integrerai IPAM con AWS Organizations. Quando si esegue questa operazione, l'account di gestione AWS Organizations delega un account membro di AWS Organizations come amministratore IPAM.
In questo esempio, sei l'account di gestione AWS Organizations che ha delegato l'account amministratore IPAM e desideri disabilitare tale account dall'essere amministratore IPAM.
È possibile utilizzare qualsiasi AWS regione per effettuare questa `--region` richiesta. Non è necessario utilizzare la Regione in cui è stato originariamente delegato l’amministratore, dove è stato creato l’IPAM o una Regione operativa dell’IPAM. Se si disattiva l’account amministratore delegato, è possibile riattivarlo in qualsiasi momento o delegare un nuovo account come amministratore IPAM.
L'`disable-ipam-organization-admin-account`esempio seguente disabilita l'amministratore IPAM delegato nel tuo account. AWS
```
aws ec2 disable-ipam-organization-admin-account \
--delegated-admin-account-id 320805250157 \
--region ap-south-1
```
Output:
```
{
"Success": true
}
```
Per ulteriori informazioni, consulta [Integrare IPAM con gli account di un' AWS organizzazione nella Guida](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam.html) per l'utente *IPAM di Amazon VPC*.
+ *Per i dettagli sull'API, consulta Command [DisableIpamOrganizationAdminAccount](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-ipam-organization-admin-account.html)Reference AWS CLI .*
### `disable-serial-console-access`
Il seguente esempio di codice mostra come utilizzare`disable-serial-console-access`.
**AWS CLI**
**Come disabilitare l’accesso alla console seriale EC2 per l’account in uso**
L’esempio `disable-serial-console-access` seguente disabilita l’accesso account alla console seriale.
```
aws ec2 disable-serial-console-access
```
Output:
```
{
"SerialConsoleAccessEnabled": false
}
```
Per ulteriori informazioni, consulta [Console seriale EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-serial-console.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DisableSerialConsoleAccess AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-serial-console-access.html)*Command Reference*.
### `disable-snapshot-block-public-access`
Il seguente esempio di codice mostra come utilizzare`disable-snapshot-block-public-access`.
**AWS CLI**
**Come disabilitare il blocco dell’accesso pubblico per gli snapshot**
L’esempio `disable-snapshot-block-public-access` seguente disabilita il blocco dell’accesso pubblico per gli snapshot per consentire la condivisione pubblica degli snapshot.
```
aws ec2 disable-snapshot-block-public-access
```
Output:
```
{
"State": "unblocked"
}
```
Per ulteriori informazioni, consulta [Blocco dell’accesso pubblico per gli snapshot](https://docs.aws.amazon.com/ebs/latest/userguide/block-public-access-snapshots.html) nella *Guida per l’utente di Amazon EBS*.
+ Per i dettagli sull'API, consulta [DisableSnapshotBlockPublicAccess AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-snapshot-block-public-access.html)*Command Reference*.
### `disable-transit-gateway-route-table-propagation`
Il seguente esempio di codice mostra come utilizzare`disable-transit-gateway-route-table-propagation`.
**AWS CLI**
**Come disabilitare un collegamento del gateway di transito alla VPN per propagare le route alla tabella di routing di propagazione specificata**
L’esempio `disable-transit-gateway-route-table-propagation` seguente disabilita l’allegato specificato per propagare le route alla tabella di routing di propagazione specificata.
```
aws ec2 disable-transit-gateway-route-table-propagation \
--transit-gateway-route-table-id tgw-rtb-0a823edbdeEXAMPLE \
--transit-gateway-attachment-id tgw-attach-09b52ccdb5EXAMPLE
```
Output:
```
{
"Propagation": {
"TransitGatewayAttachmentId": "tgw-attach-09b52ccdb5EXAMPLE",
"ResourceId": "vpc-4d7de228",
"ResourceType": "vpc",
"TransitGatewayRouteTableId": "tgw-rtb-0a823edbdeEXAMPLE",
"State": "disabled"
}
}
```
Per ulteriori informazioni, consulta [Tabelle di routing del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DisableTransitGatewayRouteTablePropagation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-transit-gateway-route-table-propagation.html)*Command Reference*.
### `disable-vgw-route-propagation`
Il seguente esempio di codice mostra come utilizzare`disable-vgw-route-propagation`.
**AWS CLI**
**Come disabilitare la propagazione di route**
Questo esempio disabilita il gateway privato virtuale specificato per propagare route statiche alla tabella di routing specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 disable-vgw-route-propagation --route-table-id rtb-22574640 --gateway-id vgw-9a4cacf3
```
+ Per i dettagli sull'API, consulta [DisableVgwRoutePropagation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-vgw-route-propagation.html)*Command Reference*.
### `disable-vpc-classic-link-dns-support`
Il seguente esempio di codice mostra come utilizzare`disable-vpc-classic-link-dns-support`.
**AWS CLI**
**Per disabilitare il supporto ClassicLink DNS per un VPC**
Questo esempio disabilita il supporto ClassicLink DNS per. `vpc-88888888`
Comando:
```
aws ec2 disable-vpc-classic-link-dns-support --vpc-id vpc-88888888
```
Output:
```
{
"Return": true
}
```
+ Per i dettagli sull'API, vedere [DisableVpcClassicLinkDnsSupport](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-vpc-classic-link-dns-support.html)in *AWS CLI Command Reference*.
### `disable-vpc-classic-link`
Il seguente esempio di codice mostra come utilizzare`disable-vpc-classic-link`.
**AWS CLI**
**Da disattivare ClassicLink per un VPC**
Questo esempio disabilita ClassicLink vpc-8888888.
Comando:
```
aws ec2 disable-vpc-classic-link --vpc-id vpc-88888888
```
Output:
```
{
"Return": true
}
```
+ *Per i dettagli sull'API, consulta [DisableVpcClassicLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disable-vpc-classic-link.html)Command Reference.AWS CLI *
### `disassociate-address`
Il seguente esempio di codice mostra come utilizzare`disassociate-address`.
**AWS CLI**
**Come annullare l’associazione di indirizzi IP elastici a EC2-Classic**
Nell’esempio seguente viene rimossa l’associazione di un indirizzo IP elastico a un’istanza in EC2-Classic. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 disassociate-address --public-ip 198.51.100.0
```
**Come annullare l’associazione di un indirizzo IP elastico in EC2-VPC**
Nell’esempio seguente viene rimossa l’associazione di un indirizzo IP elastico a un’istanza in un VPC. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 disassociate-address --association-id eipassoc-2bebb745
```
+ Per i dettagli sull'API, consulta [DisassociateAddress AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-address.html)*Command Reference*.
### `disassociate-client-vpn-target-network`
Il seguente esempio di codice mostra come utilizzare`disassociate-client-vpn-target-network`.
**AWS CLI**
**Come annullare l’associazione di una rete da un endpoint VPN Client**
L’esempio `disassociate-client-vpn-target-network` seguente annulla l’associazione della rete di destinazione associata all’ID associazione `cvpn-assoc-12312312312312312` per l’endpoint VPN Client specificato.
```
aws ec2 disassociate-client-vpn-target-network \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde \
--association-id cvpn-assoc-12312312312312312
```
Output:
```
{
"AssociationId": "cvpn-assoc-12312312312312312",
"Status": {
"Code": "disassociating"
}
}
```
Per ulteriori informazioni, consulta [Reti target](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-target.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [DisassociateClientVpnTargetNetwork AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-client-vpn-target-network.html)*Command Reference*.
### `disassociate-iam-instance-profile`
Il seguente esempio di codice mostra come utilizzare`disassociate-iam-instance-profile`.
**AWS CLI**
**Come annullare l’associazione di un profilo dell’istanza IAM**
Questo esempio annulla l’associazione di un profilo dell’istanza IAM dall’ID associazione `iip-assoc-05020b59952902f5f`.
Comando:
```
aws ec2 disassociate-iam-instance-profile --association-id iip-assoc-05020b59952902f5f
```
Output:
```
{
"IamInstanceProfileAssociation": {
"InstanceId": "i-123456789abcde123",
"State": "disassociating",
"AssociationId": "iip-assoc-05020b59952902f5f",
"IamInstanceProfile": {
"Id": "AIPAI5IVIHMFFYY2DKV5Y",
"Arn": "arn:aws:iam::123456789012:instance-profile/admin-role"
}
}
}
```
+ Per i dettagli sull'API, consulta [DisassociateIamInstanceProfile AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-iam-instance-profile.html)*Command Reference*.
### `disassociate-instance-event-window`
Il seguente esempio di codice mostra come utilizzare`disassociate-instance-event-window`.
**AWS CLI**
**Esempio 1: come dissociare una o più istanze da una finestra di eventi**
L’esempio `disassociate-instance-event-window` seguente annulla l’associazione di una o più istanze da una finestra di eventi. Imposta il parametro `instance-event-window-id` per specificare la finestra di eventi. Per dissociare le istanze, specificate il `association-target` parametro e, per i valori dei parametri, specificate una o più istanze. IDs
```
aws ec2 disassociate-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890 \
--association-target "InstanceIds=i-1234567890abcdef0,i-0598c7d356eba48d7"
```
Output:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"AssociationTarget": {
"InstanceIds": [],
"Tags": [],
"DedicatedHostIds": []
},
"State": "creating"
}
}
```
Per i vincoli relativi alla finestra di eventi, consulta [Considerazioni](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) nella sezione Eventi pianificati della *Guida per l’utente di Amazon EC2*.
**Esempio 2: come dissociare i tag di istanza da una finestra di eventi**
L’esempio `disassociate-instance-event-window` seguente annulla l’associazione dei tag di istanza da una finestra di eventi. Imposta il parametro `instance-event-window-id` per specificare la finestra di eventi. Per dissociare i tag di istanza, specifica il parametro `association-target` e per i valori dei parametri specifica uno o più tag.
```
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}]"
```
Output:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"AssociationTarget": {
"InstanceIds": [],
"Tags": [],
"DedicatedHostIds": []
},
"State": "creating"
}
}
```
Per i vincoli relativi alla finestra di eventi, consulta [Considerazioni](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) nella sezione Eventi pianificati della *Guida per l’utente di Amazon EC2*.
**Esempio 3: come dissociare un host dedicato da una finestra di eventi**
L’esempio `disassociate-instance-event-window` seguente dissocia un host dedicato da una finestra di eventi. Imposta il parametro `instance-event-window-id` per specificare la finestra di eventi. Per dissociare un host dedicato, specificate il `association-target` parametro e, per i valori dei parametri, specificate uno o più host dedicati. IDs
```
aws ec2 disassociate-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890 \
--association-target DedicatedHostIds=h-029fa35a02b99801d
```
Output:
```
{
"InstanceEventWindow": {
"InstanceEventWindowId": "iew-0abcdef1234567890",
"Name": "myEventWindowName",
"CronExpression": "* 21-23 * * 2,3",
"AssociationTarget": {
"InstanceIds": [],
"Tags": [],
"DedicatedHostIds": []
},
"State": "creating"
}
}
```
Per i vincoli relativi alla finestra di eventi, consulta [Considerazioni](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) nella sezione Eventi pianificati della *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [DisassociateInstanceEventWindow AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-instance-event-window.html)*Command Reference.*
### `disassociate-ipam-resource-discovery`
Il seguente esempio di codice mostra come utilizzare`disassociate-ipam-resource-discovery`.
**AWS CLI**
**Come annullare l’associazione di un rilevamento delle risorse da un’IPAM**
In questo esempio, l’utente è un account amministratore delegato IPAM e desidera dissociare un rilevamento di risorse IPAM dall’IPAM in uso. L’utente ha eseguito il comando describe e ha notato che `"ResourceDiscoveryStatus": "not-found"` e desidera dissociarlo dall’IPAM per fare spazio ad altre associazioni.
L'`disassociate-ipam-resource-discovery`esempio seguente dissocia l'individuazione di una risorsa IPAM nell'account. AWS
```
aws ec2 disassociate-ipam-resource-discovery \
--ipam-resource-discovery-association-id ipam-res-disco-assoc-04382a6346357cf82 \
--region us-east-1
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Come integrare IPAM con account esterni alla tua organizzazione](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam-outside-org.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ *Per i dettagli sull'API, consulta Command [DisassociateIpamResourceDiscovery](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-ipam-resource-discovery.html)Reference AWS CLI .*
### `disassociate-nat-gateway-address`
Il seguente esempio di codice mostra come utilizzare`disassociate-nat-gateway-address`.
**AWS CLI**
**Come dissociare un indirizzo IP elastico da un gateway NAT pubblico**
L’esempio `disassociate-nat-gateway-address` seguente dissocia l’indirizzo IP elastico specificato dal gateway NAT pubblico specificato.
```
aws ec2 disassociate-nat-gateway-address \
--nat-gateway-id nat-1234567890abcdef0 \
--association-ids eipassoc-0f96bdca17EXAMPLE
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [DisassociateNatGatewayAddress AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-nat-gateway-address.html)*Command Reference*.
### `disassociate-route-table`
Il seguente esempio di codice mostra come utilizzare`disassociate-route-table`.
**AWS CLI**
**Come dissociare una tabella di routing**
Questo esempio dissocia la tabella di routing specificata dalla sottorete specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 disassociate-route-table --association-id rtbassoc-781d0d1a
```
+ Per i dettagli sull'API, consulta [DisassociateRouteTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-route-table.html)*Command Reference*.
### `disassociate-security-group-vpc`
Il seguente esempio di codice mostra come utilizzare`disassociate-security-group-vpc`.
**AWS CLI**
**Come dissociare un gruppo di sicurezza da un VPC**
L’esempio `disassociate-security-group-vpc` seguente dissocia il gruppo di sicurezza specificato dal VPC specificato.
```
aws ec2 disassociate-security-group-vpc \
--group-id sg-04dbb43907d3f8a78 \
--vpc-id vpc-0bf4c2739bc05a694
```
Output:
```
{
"State": "disassociating"
}
```
Per ulteriori informazioni, consulta [Associare gruppi di sicurezza a più](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-assoc.html) gruppi VPCs nella *Amazon VPC User Guide*.
+ Per i dettagli sull'API, consulta [DisassociateSecurityGroupVpc AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-security-group-vpc.html)*Command Reference.*
### `disassociate-subnet-cidr-block`
Il seguente esempio di codice mostra come utilizzare`disassociate-subnet-cidr-block`.
**AWS CLI**
**Per dissociare un blocco IPv6 CIDR da una sottorete**
Questo esempio dissocia un blocco IPv6 CIDR da una sottorete utilizzando l'ID di associazione per il blocco CIDR.
Comando:
```
aws ec2 disassociate-subnet-cidr-block --association-id subnet-cidr-assoc-3aa54053
```
Output:
```
{
"SubnetId": "subnet-5f46ec3b",
"Ipv6CidrBlockAssociation": {
"Ipv6CidrBlock": "2001:db8:1234:1a00::/64",
"AssociationId": "subnet-cidr-assoc-3aa54053",
"Ipv6CidrBlockState": {
"State": "disassociating"
}
}
}
```
+ *Per i dettagli sull'API, consulta Command Reference. [DisassociateSubnetCidrBlock](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-subnet-cidr-block.html)AWS CLI *
### `disassociate-transit-gateway-multicast-domain`
Il seguente esempio di codice mostra come utilizzare`disassociate-transit-gateway-multicast-domain`.
**AWS CLI**
**Come dissociare sottoreti da un dominio multicast (trasmissione uno a molti)**
L’esempio `disassociate-transit-gateway-multicast-domain` seguente dissocia una sottorete dal dominio multicast (trasmissione uno a molti) specificato.
```
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
```
Output:
```
{
"Associations": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-0c4905cef7EXAMPLE",
"TransitGatewayAttachmentId": "tgw-attach-070e571cd1EXAMPLE",
"ResourceId": "vpc-7EXAMPLE",
"ResourceType": "vpc",
"Subnets": [
{
"SubnetId": "subnet-000de86e3bEXAMPLE",
"State": "disassociating"
}
]
}
}
```
Per ulteriori informazioni, consulta [Domini multicast (trasmissione uno a molti)](https://docs.aws.amazon.com/vpc/latest/tgw/multicast-domains-about.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DisassociateTransitGatewayMulticastDomain AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-transit-gateway-multicast-domain.html)*Command Reference*.
### `disassociate-transit-gateway-route-table`
Il seguente esempio di codice mostra come utilizzare`disassociate-transit-gateway-route-table`.
**AWS CLI**
**Come dissociare una tabella di routing del gateway di transito da un allegato delle risorse**
L’esempio `disassociate-transit-gateway-route-table` seguente dissocia l’allegato specificato dalla tabella di routing del gateway di transito.
```
aws ec2 disassociate-transit-gateway-route-table \
--transit-gateway-route-table-id tgw-rtb-002573ed1eEXAMPLE \
--transit-gateway-attachment-id tgw-attach-08e0bc912cEXAMPLE
```
Output:
```
{
"Association": {
"TransitGatewayRouteTableId": "tgw-rtb-002573ed1eEXAMPLE",
"TransitGatewayAttachmentId": "tgw-attach-08e0bc912cEXAMPLE",
"ResourceId": "11460968-4ac1-4fd3-bdb2-00599EXAMPLE",
"ResourceType": "direct-connect-gateway",
"State": "disassociating"
}
}
```
Per ulteriori informazioni, consulta [Tabelle di routing del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [DisassociateTransitGatewayRouteTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-transit-gateway-route-table.html)*Command Reference*.
### `disassociate-vpc-cidr-block`
Il seguente esempio di codice mostra come utilizzare`disassociate-vpc-cidr-block`.
**AWS CLI**
**Per dissociare un blocco IPv6 CIDR da un VPC**
Questo esempio dissocia un blocco IPv6 CIDR da un VPC utilizzando l'ID di associazione per il blocco CIDR.
Comando:
```
aws ec2 disassociate-vpc-cidr-block --association-id vpc-cidr-assoc-eca54085
```
Output:
```
{
"Ipv6CidrBlockAssociation": {
"Ipv6CidrBlock": "2001:db8:1234:1a00::/56",
"AssociationId": "vpc-cidr-assoc-eca54085",
"Ipv6CidrBlockState": {
"State": "disassociating"
}
},
"VpcId": "vpc-a034d6c4"
}
```
**Per dissociare un blocco IPv4 CIDR da un VPC**
Questo esempio dissocia un blocco IPv4 CIDR da un VPC.
Comando:
```
aws ec2 disassociate-vpc-cidr-block --association-id vpc-cidr-assoc-0287ac6b
```
Output:
```
{
"CidrBlockAssociation": {
"AssociationId": "vpc-cidr-assoc-0287ac6b",
"CidrBlock": "172.18.0.0/16",
"CidrBlockState": {
"State": "disassociating"
}
},
"VpcId": "vpc-27621243"
}
```
+ *Per i dettagli sull'API, consulta [DisassociateVpcCidrBlock](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/disassociate-vpc-cidr-block.html)Command Reference.AWS CLI *
### `enable-address-transfer`
Il seguente esempio di codice mostra come utilizzare`enable-address-transfer`.
**AWS CLI**
**Come abilitare il trasferimento degli indirizzi IP elastici**
L’esempio `enable-address-transfer` seguente abilita il trasferimento degli indirizzi IP elastici per l’indirizzo IP elastico specificato nell’account specificato.
```
aws ec2 enable-address-transfer \
--allocation-id eipalloc-09ad461b0d03f6aaf \
--transfer-account-id 123456789012
```
Output:
```
{
"AddressTransfer": {
"PublicIp": "100.21.184.216",
"AllocationId": "eipalloc-09ad461b0d03f6aaf",
"TransferAccountId": "123456789012",
"TransferOfferExpirationTimestamp": "2023-02-22T20:51:01.000Z",
"AddressTransferStatus": "pending"
}
}
```
Per ulteriori informazioni, consulta [Trasferimento degli indirizzi IP elastici](https://docs.aws.amazon.com/vpc/latest/userguide/WorkWithEIPs.html#transfer-EIPs-intro) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [EnableAddressTransfer AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-address-transfer.html)*Command Reference*.
### `enable-aws-network-performance-metric-subscription`
Il seguente esempio di codice mostra come utilizzare`enable-aws-network-performance-metric-subscription`.
**AWS CLI**
**Come abilitare una sottoscrizioni di parametri di prestazioni**
L’esempio `enable-aws-network-performance-metric-subscription` seguente abilita il monitoraggio della latenza di rete aggregata tra le Regioni di origine e di destinazione specificate.
```
aws ec2 enable-aws-network-performance-metric-subscription \
--source us-east-1 \
--destination eu-west-1 \
--metric aggregate-latency \
--statistic p50
```
Output:
```
{
"Output": true
}
```
Per ulteriori informazioni, consulta [Gestione delle sottoscrizioni](https://docs.aws.amazon.com/network-manager/latest/infrastructure-performance/nmip-subscriptions-cw.html) nella *Guida per l’utente di Infrastructure Performance*.
+ Per i dettagli sull'API, consulta [EnableAwsNetworkPerformanceMetricSubscription AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-aws-network-performance-metric-subscription.html)*Command Reference*.
### `enable-ebs-encryption-by-default`
Il seguente esempio di codice mostra come utilizzare`enable-ebs-encryption-by-default`.
**AWS CLI**
**Come abilitare la crittografia EBS per impostazione predefinita**
L'`enable-ebs-encryption-by-default`esempio seguente abilita la crittografia EBS per impostazione predefinita per il tuo AWS account nella regione corrente.
```
aws ec2 enable-ebs-encryption-by-default
```
Output:
```
{
"EbsEncryptionByDefault": true
}
```
+ Per i dettagli sull'API, consulta [EnableEbsEncryptionByDefault AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-ebs-encryption-by-default.html)*Command Reference.*
### `enable-fast-launch`
Il seguente esempio di codice mostra come utilizzare`enable-fast-launch`.
**AWS CLI**
**Come attivare l’avvio rapido di un’immagine**
L’esempio `enable-fast-launch` seguente configura l’AMI specificata per l’avvio rapido e imposta il numero massimo di istanze parallele da avviare su 6. Il tipo di risorsa da utilizzare per il pre-provisioning dell’AMI è impostato su `snapshot`, che è anche il valore predefinito.
```
aws ec2 enable-fast-launch \
--image-id ami-01234567890abcedf \
--max-parallel-launches 6 \
--resource-type snapshot
```
Output:
```
{
"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"
}
```
Per ulteriori informazioni, consulta [Configurare le impostazioni di avvio rapido di EC2 per l’AMI di Windows](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/win-fast-launch-configure.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [EnableFastLaunch AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-fast-launch.html)*Command Reference*.
### `enable-fast-snapshot-restores`
Il seguente esempio di codice mostra come utilizzare`enable-fast-snapshot-restores`.
**AWS CLI**
**Come abilitare il ripristino rapido degli snapshot**
L’esempio `enable-fast-snapshot-restores` seguente abilita il ripristino rapido degli snapshot per gli snapshot specificati nelle zone di disponibilità specificate.
```
aws ec2 enable-fast-snapshot-restores \
--availability-zones us-east-2a us-east-2b \
--source-snapshot-ids snap-1234567890abcdef0
```
Output:
```
{
"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": []
}
```
+ Per i dettagli sull'API, consulta [EnableFastSnapshotRestores AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-fast-snapshot-restores.html)*Command Reference*.
### `enable-image-block-public-access`
Il seguente esempio di codice mostra come utilizzare`enable-image-block-public-access`.
**AWS CLI**
**Per abilitare il blocco dell'accesso pubblico AMIs nella regione specificata**
L'`enable-image-block-public-access`esempio seguente abilita il blocco dell'accesso pubblico AMIs a livello di account nella regione specificata.
```
aws ec2 enable-image-block-public-access \
--region us-east-1 \
--image-block-public-access-state block-new-sharing
```
Output:
```
{
"ImageBlockPublicAccessState": "block-new-sharing"
}
```
Per ulteriori informazioni, consulta [Bloccare l'accesso pubblico al tuo AMIs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sharingamis-intro.html#block-public-access-to-amis) nella Guida per l'*utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [EnableImageBlockPublicAccess AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-image-block-public-access.html)*Command Reference.*
### `enable-image-deprecation`
Il seguente esempio di codice mostra come utilizzare`enable-image-deprecation`.
**AWS CLI**
**Come dichiarare un’AMI come obsoleta**
L’esempio `enable-image-deprecation` seguente dichiara un’AMI come obsoleta in una data e un’ora specifiche. Se si specifica un valore in secondi, Amazon EC2 arrotonda i secondi al minuto più vicino. Per eseguire questa procedura, è necessario essere il proprietario dell’AMI.
```
aws ec2 enable-image-deprecation \
--image-id ami-1234567890abcdef0 \
--deprecate-at '2022-10-15T13:17:12.000Z'
```
Output:
```
{
"RequestID": "59dbff89-35bd-4eac-99ed-be587EXAMPLE",
"Return": "true"
}
```
Per ulteriori informazioni, consulta [Dichiarazione di un’AMI come obsoleta](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deprecate.html#deprecate-ami) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [EnableImageDeprecation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-image-deprecation.html)*Command Reference*.
### `enable-image-deregistration-protection`
Il seguente esempio di codice mostra come utilizzare`enable-image-deregistration-protection`.
**AWS CLI**
**Come abilitare la protezione da annullamento della registrazione**
L’esempio `enable-image-deregistration-protection` seguente abilita la protezione da annullamento della registrazione per l’immagine specificata.
```
aws ec2 enable-image-deregistration-protection \
--image-id ami-0b1a928a144a74ec9
```
Output:
```
{
"Return": "enabled-without-cooldown"
}
```
Per ulteriori informazioni, consulta [Proteggere un’AMI EC2 dall’annullamento della registrazione](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deregistration-protection.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [EnableImageDeregistrationProtection AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-image-deregistration-protection.html)*Command Reference*.
### `enable-image`
Il seguente esempio di codice mostra come utilizzare`enable-image`.
**AWS CLI**
**Come abilitare un’AMI**
L’esempio `enable-image` seguente abilita l’AMI specificata.
```
aws ec2 enable-image \
--image-id ami-1234567890abcdef0
```
Output:
```
{
"Return": "true"
}
```
Per ulteriori informazioni, consulta [Disabilitazione di un’AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/disable-an-ami.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [EnableImage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-image.html)*Command Reference*.
### `enable-ipam-organization-admin-account`
Il seguente esempio di codice mostra come utilizzare`enable-ipam-organization-admin-account`.
**AWS CLI**
**Integrarsi con AWS Organizations e delegare un account membro come account IPAM**
L'`enable-ipam-organization-admin-account`esempio seguente integra IPAM con AWS Organizations e delega un account membro come account IPAM.
```
aws ec2 enable-ipam-organization-admin-account \
--delegated-admin-account-id 320805250157
```
Output:
```
{
"Success": true
}
```
Per ulteriori informazioni, consulta [Integrate IPAM with AWS Organizations](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam.html) nella *Amazon VPC IPAM* User Guide.
+ *Per i dettagli sull'API, consulta Command [EnableIpamOrganizationAdminAccount](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-ipam-organization-admin-account.html)Reference AWS CLI .*
### `enable-reachability-analyzer-organization-sharing`
Il seguente esempio di codice mostra come utilizzare`enable-reachability-analyzer-organization-sharing`.
**AWS CLI**
**Come abilitare l’accesso attendibile per Sistema di analisi della reperibilità**
L’esempio `enable-reachability-analyzer-organization-sharing` seguente abilita l’accesso attendibile per Sistema di analisi della reperibilità.
```
aws ec2 enable-reachability-analyzer-organization-sharing
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Analisi tra account](https://docs.aws.amazon.com/vpc/latest/reachability/multi-account.html) nella *Guida per l’utente di Sistema di analisi della reperibilità*.
+ Per i dettagli sull'API, consulta [EnableReachabilityAnalyzerOrganizationSharing AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-reachability-analyzer-organization-sharing.html)*Command Reference*.
### `enable-serial-console-access`
Il seguente esempio di codice mostra come utilizzare`enable-serial-console-access`.
**AWS CLI**
**Come abilitare l’accesso alla console seriale per l’account in uso**
L’esempio `enable-serial-console-access` seguente abilita l’accesso account alla console seriale.
```
aws ec2 enable-serial-console-access
```
Output:
```
{
"SerialConsoleAccessEnabled": true
}
```
Per ulteriori informazioni, consulta [Console seriale EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-serial-console.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [EnableSerialConsoleAccess AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-serial-console-access.html)*Command Reference*.
### `enable-snapshot-block-public-access`
Il seguente esempio di codice mostra come utilizzare`enable-snapshot-block-public-access`.
**AWS CLI**
**Come abilitare il blocco dell’accesso pubblico per gli snapshot**
L’esempio `enable-snapshot-block-public-access` seguente blocca tutte le condivisioni pubbliche degli snapshot.
```
aws ec2 enable-snapshot-block-public-access \
--state block-all-sharing
```
Output:
```
{
"State": "block-all-sharing"
}
```
Per ulteriori informazioni, consulta [Blocco dell’accesso pubblico per gli snapshot](https://docs.aws.amazon.com/ebs/latest/userguide/block-public-access-snapshots.html) nella *Guida per l’utente di Amazon EBS*.
+ Per i dettagli sull'API, consulta [EnableSnapshotBlockPublicAccess AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-snapshot-block-public-access.html)*Command Reference*.
### `enable-transit-gateway-route-table-propagation`
Il seguente esempio di codice mostra come utilizzare`enable-transit-gateway-route-table-propagation`.
**AWS CLI**
**Come abilitare un collegamento del gateway di transito alla VPN per propagare le route alla tabella di routing di propagazione specificata**
L’esempio `enable-transit-gateway-route-table-propagation` seguente abilita l’allegato specificato per propagare le route alla tabella di routing di propagazione specificata.
```
aws ec2 enable-transit-gateway-route-table-propagation \
--transit-gateway-route-table-id tgw-rtb-0a823edbdeEXAMPLE \
--transit-gateway-attachment-id tgw-attach-09b52ccdb5EXAMPLE
```
Output:
```
{
"Propagation": {
"TransitGatewayAttachmentId": "tgw-attach-09b52ccdb5EXAMPLE",
"ResourceId": "vpc-4d7de228",
"ResourceType": "vpc",
"TransitGatewayRouteTableId": "tgw-rtb-0a823edbdeEXAMPLE",
"State": "disabled"
}
}
```
Per ulteriori informazioni, consulta [Tabelle di routing del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [EnableTransitGatewayRouteTablePropagation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-transit-gateway-route-table-propagation.html)*Command Reference*.
### `enable-vgw-route-propagation`
Il seguente esempio di codice mostra come utilizzare`enable-vgw-route-propagation`.
**AWS CLI**
**Come abilitare la propagazione di route**
Questo esempio abilita il gateway privato virtuale specificato per propagare route statiche alla tabella di routing specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 enable-vgw-route-propagation --route-table-id rtb-22574640 --gateway-id vgw-9a4cacf3
```
+ Per i dettagli sull'API, consulta [EnableVgwRoutePropagation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-vgw-route-propagation.html)*Command Reference*.
### `enable-volume-io`
Il seguente esempio di codice mostra come utilizzare`enable-volume-io`.
**AWS CLI**
** I/O Per abilitare un volume**
Questo esempio abilita I/O on volume`vol-1234567890abcdef0`.
Comando:
```
aws ec2 enable-volume-io --volume-id vol-1234567890abcdef0
```
Output:
```
{
"Return": true
}
```
+ Per i dettagli sull'API, consulta [EnableVolumeIo AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-volume-io.html)*Command Reference*.
### `enable-vpc-classic-link-dns-support`
Il seguente esempio di codice mostra come utilizzare`enable-vpc-classic-link-dns-support`.
**AWS CLI**
**Per abilitare il supporto ClassicLink DNS per un VPC**
Questo esempio abilita il supporto ClassicLink DNS per. `vpc-88888888`
Comando:
```
aws ec2 enable-vpc-classic-link-dns-support --vpc-id vpc-88888888
```
Output:
```
{
"Return": true
}
```
+ Per i dettagli sull'API, consulta [EnableVpcClassicLinkDnsSupport AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-vpc-classic-link-dns-support.html)*Command Reference.*
### `enable-vpc-classic-link`
Il seguente esempio di codice mostra come utilizzare`enable-vpc-classic-link`.
**AWS CLI**
**Per abilitare un VPC per ClassicLink**
Questo esempio abilita vpc-8888888 per. ClassicLink
Comando:
```
aws ec2 enable-vpc-classic-link --vpc-id vpc-88888888
```
Output:
```
{
"Return": true
}
```
+ *Per i dettagli sull'API, consulta Command [EnableVpcClassicLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/enable-vpc-classic-link.html)Reference AWS CLI .*
### `export-client-vpn-client-certificate-revocation-list`
Il seguente esempio di codice mostra come utilizzare`export-client-vpn-client-certificate-revocation-list`.
**AWS CLI**
**Come esportare un elenco di revoche di certificati client**
L’esempio `export-client-vpn-client-certificate-revocation-list` seguente esporta l’elenco di revoche di certificati client per l’endpoint VPN Client specificato. In questo esempio, l’output viene restituito in formato di testo per semplificarne la lettura.
```
aws ec2 export-client-vpn-client-certificate-revocation-list \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde \
--output text
```
Output:
```
-----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
```
Per ulteriori informazioni, consulta [Elenchi di revoche di certificati client](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-certificates.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [ExportClientVpnClientCertificateRevocationList AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/export-client-vpn-client-certificate-revocation-list.html)*Command Reference*.
### `export-client-vpn-client-configuration`
Il seguente esempio di codice mostra come utilizzare`export-client-vpn-client-configuration`.
**AWS CLI**
**Come esportare la configurazione del client**
L’esempio `export-client-vpn-client-configuration` seguente esporta la configurazione del client per l’endpoint VPN Client specificato. In questo esempio, l’output viene restituito in formato di testo per semplificarne la lettura.
```
aws ec2 export-client-vpn-client-configuration \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde \
--output text
```
Output:
```
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
```
Per ulteriori informazioni, consulta [Esportazione del file di configurazione dell’endpoint VPN client](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-endpoint-export.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [ExportClientVpnClientConfiguration AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/export-client-vpn-client-configuration.html)*Command Reference*.
### `export-image`
Il seguente esempio di codice mostra come utilizzare`export-image`.
**AWS CLI**
**Come esportare una VM da un’AMI**
L’esempio `export-image` seguente esporta l’AMI specificata nel bucket specificato nel formato specificato.
```
aws ec2 export-image \
--image-id ami-1234567890abcdef0 \
--disk-image-format VMDK \
--s3-export-location S3Bucket=my-export-bucket,S3Prefix=exports/
```
Output:
```
{
"DiskImageFormat": "vmdk",
"ExportImageTaskId": "export-ami-1234567890abcdef0"
"ImageId": "ami-1234567890abcdef0",
"RoleName": "vmimport",
"Progress": "0",
"S3ExportLocation": {
"S3Bucket": "my-export-bucket",
"S3Prefix": "exports/"
},
"Status": "active",
"StatusMessage": "validating"
}
```
+ Per i dettagli sull'API, consulta [ExportImage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/export-image.html)*Command Reference*.
### `get-associated-ipv6-pool-cidrs`
Il seguente esempio di codice mostra come utilizzare`get-associated-ipv6-pool-cidrs`.
**AWS CLI**
**Per ottenere le associazioni per un pool di IPv6 indirizzi**
L'`get-associated-ipv6-pool-cidrs`esempio seguente ottiene le associazioni per il pool di IPv6 indirizzi specificato.
```
aws ec2 get-associated-ipv6-pool-cidrs \
--pool-id ipv6pool-ec2-012345abc12345abc
```
Output:
```
{
"Ipv6CidrAssociations": [
{
"Ipv6Cidr": "2001:db8:1234:1a00::/56",
"AssociatedResource": "vpc-111111222222333ab"
}
]
}
```
+ Per i dettagli sull'API, vedere [GetAssociatedIpv6 PoolCidrs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-associated-ipv6-pool-cidrs.html) in *AWS CLI Command Reference*.
### `get-aws-network-performance-data`
Il seguente esempio di codice mostra come utilizzare`get-aws-network-performance-data`.
**AWS CLI**
**Come ottenere dati sulle prestazioni di rete**
L’esempio `get-aws-network-performance-data` seguente recupera i dati sulle prestazioni di rete tra le Regioni specificate nel periodo di tempo specificato.
```
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
```
Output:
```
{
"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"
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Monitoraggio delle prestazioni di rete](https://docs.aws.amazon.com/network-manager/latest/infrastructure-performance/nmip-performance-cli.html) nella *Guida per l’utente di Infrastructure Performance*.
+ Per i dettagli sull'API, consulta [GetAwsNetworkPerformanceData AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-aws-network-performance-data.html)*Command Reference*.
### `get-capacity-reservation-usage`
Il seguente esempio di codice mostra come utilizzare`get-capacity-reservation-usage`.
**AWS CLI**
**Per visualizzare l'utilizzo della prenotazione della capacità tra AWS gli account**
L’esempio `get-capacity-reservation-usage` seguente visualizza le informazioni di utilizzo per la prenotazione della capacità specificata.
```
aws ec2 get-capacity-reservation-usage \
--capacity-reservation-id cr-1234abcd56EXAMPLE
```
Output:
```
{
"CapacityReservationId": "cr-1234abcd56EXAMPLE ",
"InstanceUsages": [
{
"UsedInstanceCount": 1,
"AccountId": "123456789012"
}
],
"AvailableInstanceCount": 4,
"TotalInstanceCount": 5,
"State": "active",
"InstanceType": "t2.medium"
}
```
Per ulteriori informazioni, consulta [Prenotazioni della capacità condivise](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservation-sharing.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [GetCapacityReservationUsage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-capacity-reservation-usage.html)*Command Reference*.
### `get-coip-pool-usage`
Il seguente esempio di codice mostra come utilizzare`get-coip-pool-usage`.
**AWS CLI**
**Come ottenere l’utilizzo del pool di indirizzi IP di proprietà del cliente**
L’esempio `get-coip-pool-usage` seguente recupera i dettagli di utilizzo del pool di indirizzi IP specificato di proprietà del cliente.
```
aws ec2 get-coip-pool-usage \
--pool-id ipv4pool-coip-123a45678bEXAMPLE
```
Output:
```
{
"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"
}
```
Per ulteriori informazioni, consulta [Indirizzi IP di proprietà del cliente](https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#ip-addressing) nella *Guida per l’utente di AWS Outposts per i rack Outposts*.
+ Per i dettagli sull'API, consulta [GetCoipPoolUsage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-coip-pool-usage.html)*Command Reference*.
### `get-console-output`
Il seguente esempio di codice mostra come utilizzare`get-console-output`.
**AWS CLI**
**Esempio 1: come ottenere l’output della console**
L’esempio `get-console-output` seguente ottiene l’output della console per l’istanza Linux specificata.
```
aws ec2 get-console-output \
--instance-id i-1234567890abcdef0
```
Output:
```
{
"InstanceId": "i-1234567890abcdef0",
"Timestamp": "2013-07-25T21:23:53.000Z",
"Output": "..."
}
```
Per ulteriori informazioni, consulta [Output della console delle istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-console.html#instance-console-console-output) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come ottenere l’output più recente della console**
L’esempio `get-console-output` seguente ottiene l’output più recente della console per l’istanza Linux specificata.
```
aws ec2 get-console-output \
--instance-id i-1234567890abcdef0 \
--latest \
--output text
```
Output:
```
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
```
Per ulteriori informazioni, consulta [Output della console delle istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-console.html#instance-console-console-output) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [GetConsoleOutput AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-console-output.html)*Command Reference*.
### `get-console-screenshot`
Il seguente esempio di codice mostra come utilizzare`get-console-screenshot`.
**AWS CLI**
**Come recuperare uno screenshot di un’istanza in esecuzione**
L’esempio `get-console-screenshot` seguente recupera uno screenshot dell’istanza specificata in formato .jpg. Lo screenshot viene restituito come stringa codificata Base64.
```
aws ec2 get-console-screenshot \
--instance-id i-1234567890abcdef0
```
Output:
```
{
"ImageData": "997987/8kgj49ikjhewkwwe0008084EXAMPLE",
"InstanceId": "i-1234567890abcdef0"
}
```
+ Per i dettagli sull'API, consulta [GetConsoleScreenshot AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-console-screenshot.html)*Command Reference*.
### `get-default-credit-specification`
Il seguente esempio di codice mostra come utilizzare`get-default-credit-specification`.
**AWS CLI**
**Come descrivere l’opzione di credito predefinita**
L’esempio `get-default-credit-specification` seguente descrive l’opzione di credito predefinita per le istanze T2.
```
aws ec2 get-default-credit-specification \
--instance-family t2
```
Output:
```
{
"InstanceFamilyCreditSpecification": {
"InstanceFamily": "t2",
"CpuCredits": "standard"
}
}
```
+ Per i dettagli sull'API, consulta [GetDefaultCreditSpecification AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-default-credit-specification.html)*Command Reference*.
### `get-ebs-default-kms-key-id`
Il seguente esempio di codice mostra come utilizzare`get-ebs-default-kms-key-id`.
**AWS CLI**
**Come descrivere la chiave gestita dal cliente (CMK) predefinita per la crittografia EBS**
L'`get-ebs-default-kms-key-id`esempio seguente descrive la crittografia CMK for EBS predefinita per il tuo AWS account.
```
aws ec2 get-ebs-default-kms-key-id
```
L'output mostra la CMK predefinita per la crittografia EBS, che è una CMK AWS gestita con l'alias. `alias/aws/ebs`
```
{
"KmsKeyId": "alias/aws/ebs"
}
```
L’output seguente mostra una chiave gestita dal cliente (CMK) personalizzata per la crittografia EBS.
```
{
"KmsKeyId": "arn:aws:kms:us-west-2:123456789012:key/0ea3fef3-80a7-4778-9d8c-1c0c6EXAMPLE"
}
```
+ *Per i dettagli sull'API, consulta [GetEbsDefaultKmsKeyId](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ebs-default-kms-key-id.html)Command Reference.AWS CLI *
### `get-ebs-encryption-by-default`
Il seguente esempio di codice mostra come utilizzare`get-ebs-encryption-by-default`.
**AWS CLI**
**Come descrivere se la crittografia EBS è abilitata per impostazione predefinita**
L'`get-ebs-encryption-by-default`esempio seguente indica se la crittografia EBS per impostazione predefinita è abilitata per l' AWS account nell'area corrente.
```
aws ec2 get-ebs-encryption-by-default
```
L’output seguente indica che la crittografia EBS è disabilitata per impostazione predefinita.
```
{
"EbsEncryptionByDefault": false
}
```
L’output seguente indica che la crittografia EBS è abilitata per impostazione predefinita.
```
{
"EbsEncryptionByDefault": true
}
```
+ Per i dettagli sull'API, consulta [GetEbsEncryptionByDefault AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ebs-encryption-by-default.html)*Command Reference.*
### `get-flow-logs-integration-template`
Il seguente esempio di codice mostra come utilizzare`get-flow-logs-integration-template`.
**AWS CLI**
**Per creare un CloudFormation modello per automatizzare l'integrazione dei log di flusso VPC con Amazon Athena**
`get-flow-logs-integration-template`Gli esempi seguenti creano un CloudFormation modello per automatizzare l'integrazione dei log di flusso VPC con 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}]
```
Output:
```
{
"Result": "https://amzn-s3-demo-bucket.s3.us-east-2.amazonaws.com/VPCFlowLogsIntegrationTemplate_fl-1234567890abcdef0_Wed%20Jul%2021%2000%3A57%3A56%20UTC%202021.yml"
}
```
*Per informazioni sull'uso dei CloudFormation modelli, consulta [Lavorare con i AWS CloudFormation modelli](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html) nella Guida per l'utente.AWS CloudFormation *
Per informazioni sull’utilizzo di Amazon Athena e dei log di flusso, consulta [Eseguire una query dei flussi di log tramite Amazon Athena](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-athena.html) nella *Guida per l’utente di Amazon Virtual Private Cloud*.
+ Per i dettagli sull'API, consulta [GetFlowLogsIntegrationTemplate AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-flow-logs-integration-template.html)*Command Reference*.
### `get-groups-for-capacity-reservation`
Il seguente esempio di codice mostra come utilizzare`get-groups-for-capacity-reservation`.
**AWS CLI**
**Come elencare i gruppi di risorse con una prenotazione della capacità**
L’esempio `get-groups-for-capacity-reservation` seguente elenca i gruppi di risorse a cui è stata aggiunta la prenotazione della capacità specificata.
```
aws ec2 get-groups-for-capacity-reservation \
--capacity-reservation-id cr-1234abcd56EXAMPLE
```
Output:
```
{
"CapacityReservationsGroup": [
{
"GroupArn": "arn:aws:resource-groups:us-west-2:123456789012:group/my-resource-group",
"OwnerId": "123456789012"
}
]
}
```
Per ulteriori informazioni, consulta [Gruppi Prenotazione della capacità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-cr-group.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [GetGroupsForCapacityReservation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-groups-for-capacity-reservation.html)*Command Reference*.
### `get-host-reservation-purchase-preview`
Il seguente esempio di codice mostra come utilizzare`get-host-reservation-purchase-preview`.
**AWS CLI**
**Come visualizzare un’anteprima di acquisto per una prenotazione dell’host dedicato**
Questo esempio fornisce un’anteprima dei costi di una specifica prenotazione dell’host dedicato specificato nell’account in uso.
Comando:
```
aws ec2 get-host-reservation-purchase-preview --offering-id hro-03f707bf363b6b324 --host-id-set h-013abcd2a00cbd123
```
Output:
```
{
"TotalHourlyPrice": "1.499",
"Purchase": [
{
"HourlyPrice": "1.499",
"InstanceFamily": "m4",
"PaymentOption": "NoUpfront",
"HostIdSet": [
"h-013abcd2a00cbd123"
],
"UpfrontPrice": "0.000",
"Duration": 31536000
}
],
"TotalUpfrontPrice": "0.000"
}
```
+ Per i dettagli sull'API, consulta [GetHostReservationPurchasePreview AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-host-reservation-purchase-preview.html)*Command Reference*.
### `get-image-block-public-access-state`
Il seguente esempio di codice mostra come utilizzare`get-image-block-public-access-state`.
**AWS CLI**
**Per ottenere lo stato di blocco dell'accesso pubblico AMIs nella regione specificata**
L'`get-image-block-public-access-state`esempio seguente ottiene lo stato di blocco dell'accesso pubblico AMIs a livello di account nella regione specificata.
```
aws ec2 get-image-block-public-access-state \
--region us-east-1
```
Output:
```
{
"ImageBlockPublicAccessState": "block-new-sharing"
}
```
Per ulteriori informazioni, consulta [Bloccare l'accesso pubblico al tuo AMIs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sharingamis-intro.html#block-public-access-to-amis) nella Guida per l'*utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [GetImageBlockPublicAccessState AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-image-block-public-access-state.html)*Command Reference.*
### `get-instance-types-from-instance-requirements`
Il seguente esempio di codice mostra come utilizzare`get-instance-types-from-instance-requirements`.
**AWS CLI**
**Come visualizzare in anteprima i tipi di istanza che corrispondono agli attributi specificati**
L’esempio `get-instance-types-from-instance-requirements` seguente genera innanzitutto un elenco di tutti i possibili attributi che possono essere specificati utilizzando il parametro `--generate-cli-skeleton` e salva l’elenco in un file JSON. Quindi, il file JSON viene utilizzato per personalizzare gli attributi per i quali visualizzare in anteprima i tipi di istanza corrispondenti.
Per generare tutti gli attributi possibili e salvare l’output direttamente in un file JSON, utilizza il seguente comando.
```
aws ec2 get-instance-types-from-instance-requirements \
--region us-east-1 \
--generate-cli-skeleton input > attributes.json
```
Output:
```
{
"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": ""
}
```
Configurare il file JSON. È necessario fornire valori per `ArchitectureTypes`, `VirtualizationTypes`, `VCpuCount` e `MemoryMiB`. È possibile omettere gli altri attributi. Se omessi, vengono utilizzati i valori predefiniti. Per una descrizione di ogni attributo e dei relativi valori predefiniti, vedere get-instance-types-from -instance-requirements < - -requirements.html>. https://docs.aws.amazon.com/cli/ latest/reference/ec2/get instance-types-from-instance
Visualizza l’anteprima dei tipi di istanza che hanno gli attributi specificati in `attributes.json`. Specifica il nome e il percorso del file JSON utilizzando il parametro `--cli-input-json`. Nella seguente richiesta, l’output viene formattato come una tabella.
```
aws ec2 get-instance-types-from-instance-requirements \
--cli-input-json file://attributes.json \
--output table
```
Contenuto del file `attributes.json`:
```
{
"ArchitectureTypes": [
"x86_64"
],
"VirtualizationTypes": [
"hvm"
],
"InstanceRequirements": {
"VCpuCount": {
"Min": 4,
"Max": 6
},
"MemoryMiB": {
"Min": 2048
},
"InstanceGenerations": [
"current"
]
}
}
```
Output:
```
------------------------------------------
|GetInstanceTypesFromInstanceRequirements|
+----------------------------------------+
|| InstanceTypes ||
|+--------------------------------------+|
|| InstanceType ||
|+--------------------------------------+|
|| c4.xlarge ||
|| c5.xlarge ||
|| c5a.xlarge ||
|| c5ad.xlarge ||
|| c5d.xlarge ||
|| c5n.xlarge ||
|| d2.xlarge ||
...
```
Per ulteriori informazioni sulla selezione del tipo di istanza basata sugli attributi, consulta [Come funziona la selezione del tipo di istanza basata su attributi](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-attribute-based-instance-type-selection.html#ec2fleet-abs-how-it-works) nella *Guida per l’utente di Amazon EC2*.
+ Per *AWS CLI i [GetInstanceTypesFromInstanceRequirements](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-instance-types-from-instance-requirements.html)*dettagli sull'API, consulta Command Reference.
### `get-instance-uefi-data`
Il seguente esempio di codice mostra come utilizzare`get-instance-uefi-data`.
**AWS CLI**
**Come recuperare i dati UEFI da un’istanza**
L’esempio `get-instance-uefi-data` seguente recupera i dati UEFI da un’istanza. Se l’output è vuoto, l’istanza non contiene dati UEFI.
```
aws ec2 get-instance-uefi-data \
--instance-id i-0123456789example
```
Output:
```
{
"InstanceId": "i-0123456789example",
"UefiData": "QU1aTlVFRkkf+uLXAAAAAHj5a7fZ9+3dBzxXb/.
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4L/J/AODshho="
}
```
Per ulteriori informazioni, consulta [UEFI Secure Boot](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/uefi-secure-boot.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [GetInstanceUefiData AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-instance-uefi-data.html)*Command Reference*.
### `get-ipam-address-history`
Il seguente esempio di codice mostra come utilizzare`get-ipam-address-history`.
**AWS CLI**
**Come ottenere la cronologia di un CIDR**
L’esempio `get-ipam-address-history` seguente recupera la cronologia di un 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
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzare la cronologia degli indirizzi IP](https://docs.aws.amazon.com/vpc/latest/ipam/view-history-cidr-ipam.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta [GetIpamAddressHistory AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ipam-address-history.html)*Command Reference*.
### `get-ipam-discovered-accounts`
Il seguente esempio di codice mostra come utilizzare`get-ipam-discovered-accounts`.
**AWS CLI**
**Come visualizzare gli account rilevati da un’IPAM**
In questo scenario, sei un amministratore delegato IPAM che desidera visualizzare gli AWS account proprietari delle risorse che l'IPAM sta scoprendo.
`--discovery-region` è la Regione operativa IPAM in cui visualizzare gli stati degli account monitorati. Ad esempio, se si dispone di tre Regioni operative IPAM, potrebbe essere necessario effettuare questa richiesta tre volte per visualizzare i timestamp specifici da individuare in ciascuna di tali particolari Regioni.
L'`get-ipam-discovered-accounts`esempio seguente elenca gli AWS account che possiedono le risorse rilevate dall'IPAM.
```
aws ec2 get-ipam-discovered-accounts \
--ipam-resource-discovery-id ipam-res-disco-0365d2977fc1672fe \
--discovery-region us-east-1
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Come integrare IPAM con account esterni alla tua organizzazione](https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam-outside-org.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, vedere [GetIpamDiscoveredAccounts](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ipam-discovered-accounts.html)in *AWS CLI Command Reference.*
### `get-ipam-discovered-public-addresses`
Il seguente esempio di codice mostra come utilizzare`get-ipam-discovered-public-addresses`.
**AWS CLI**
**Come visualizzare gli indirizzi IP pubblici rilevati**
In questo esempio, l’utente è un amministratore delegato IPAM che desidera visualizzare gli indirizzi IP delle risorse individuate dall’IPAM. È possibile ottenere l'ID di scoperta della risorsa con [describe-ipam-resource-discoveries](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-ipam-resource-discoveries.html).
L’esempio `get-ipam-discovered-public-addresses` seguente mostra gli indirizzi IP pubblici rilevati per un’operazione di rilevamento delle risorse.
```
aws ec2 get-ipam-discovered-public-addresses \
--ipam-resource-discovery-id ipam-res-disco-0f4ef577a9f37a162 \
--address-region us-east-1 \
--region us-east-1
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Visualizzazione di informazioni sugli IP pubblici](https://docs.aws.amazon.com/vpc/latest/ipam/view-public-ip-insights.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta [GetIpamDiscoveredPublicAddresses AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ipam-discovered-public-addresses.html)*Command Reference*.
### `get-ipam-discovered-resource-cidrs`
Il seguente esempio di codice mostra come utilizzare`get-ipam-discovered-resource-cidrs`.
**AWS CLI**
**Per visualizzare l'indirizzo IP CIDRs scoperto da un IPAM**
In questo esempio, sei un amministratore delegato IPAM che desidera visualizzare i dettagli relativi all'indirizzo CIDRs IP delle risorse che l'IPAM sta scoprendo.
Per completare questa richiesta:
L'individuazione delle risorse scelta deve essere associata all'IPAM. Questa è la regione in cui `--resource-region` è stata creata la risorsa. AWS
L’esempio `get-ipam-discovered-resource-cidrs` seguente elenca gli indirizzi IP delle risorse rilevate dall’IPAM.
```
aws ec2 get-ipam-discovered-resource-cidrs \
--ipam-resource-discovery-id ipam-res-disco-0365d2977fc1672fe \
--resource-region us-east-1
```
Output:
```
{
{
"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"
}
}
}
```
Per ulteriori informazioni, consulta [Monitoraggio dell’utilizzo del CIDR per risorsa](https://docs.aws.amazon.com/vpc/latest/ipam/monitor-cidr-compliance-ipam.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ *Per i dettagli sull'API, consulta Command [GetIpamDiscoveredResourceCidrs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ipam-discovered-resource-cidrs.html)Reference AWS CLI .*
### `get-ipam-pool-allocations`
Il seguente esempio di codice mostra come utilizzare`get-ipam-pool-allocations`.
**AWS CLI**
**Per ottenere l' CIDRs allocazione da un pool IPAM**
L'`get-ipam-pool-allocations`esempio seguente ottiene l' CIDRs allocazione da un 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
```
Output:
```
{
"IpamPoolAllocations": [
{
"Cidr": "10.0.0.0/16",
"IpamPoolAllocationId": "ipam-pool-alloc-0e6186d73999e47389266a5d6991e6220",
"ResourceType": "custom",
"ResourceOwner": "123456789012"
}
]
}
```
+ Per i dettagli sull'API, vedere [GetIpamPoolAllocations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ipam-pool-allocations.html)in *AWS CLI Command Reference*.
### `get-ipam-pool-cidrs`
Il seguente esempio di codice mostra come utilizzare`get-ipam-pool-cidrs`.
**AWS CLI**
**Per far sì che il CIDRs provisioning venga inserito in un pool IPAM**
L'`get-ipam-pool-cidrs`esempio seguente ottiene il CIDRs provisioning in un 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.*
```
Output:
```
{
"IpamPoolCidr": {
"Cidr": "10.0.0.0/24",
"State": "provisioned"
}
}
```
+ Per i dettagli sull'API, vedere [GetIpamPoolCidrs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ipam-pool-cidrs.html)in *AWS CLI Command Reference*.
### `get-ipam-resource-cidrs`
Il seguente esempio di codice mostra come utilizzare`get-ipam-resource-cidrs`.
**AWS CLI**
**Per ottenere l' CIDRs allocazione a una risorsa**
L'`get-ipam-resource-cidrs`esempio seguente ottiene l' CIDRs allocazione a una risorsa.
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
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Monitoraggio dell’utilizzo del CIDR per risorsa](https://docs.aws.amazon.com/vpc/latest/ipam/monitor-cidr-compliance-ipam.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, vedere [GetIpamResourceCidrs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-ipam-resource-cidrs.html)in *AWS CLI Command Reference.*
### `get-launch-template-data`
Il seguente esempio di codice mostra come utilizzare`get-launch-template-data`.
**AWS CLI**
**Come ottenere i dati dell’istanza per un modello di avvio**
Questo esempio ottiene i dati sull’istanza specificata e utilizza l’opzione `--query` per restituire il contenuto in `LaunchTemplateData`. È possibile utilizzare l’output come base per creare un nuovo modello di avvio o una nuova versione del modello di avvio.
Comando:
```
aws ec2 get-launch-template-data --instance-id i-0123d646e8048babc --query 'LaunchTemplateData'
```
Output:
```
{
"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"
}
]
}
```
+ Per i dettagli sull'API, consulta [GetLaunchTemplateData AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-launch-template-data.html)*Command Reference*.
### `get-managed-prefix-list-associations`
Il seguente esempio di codice mostra come utilizzare`get-managed-prefix-list-associations`.
**AWS CLI**
**Come ottenere le associazioni dell’elenco di prefissi**
L’esempio `get-managed-prefix-list-associations` seguente recupera le risorse associate all’elenco di prefissi specificato.
```
aws ec2 get-managed-prefix-list-associations \
--prefix-list-id pl-0123456abcabcabc1
```
Output:
```
{
"PrefixListAssociations": [
{
"ResourceId": "sg-0abc123456abc12345",
"ResourceOwner": "123456789012"
}
]
}
```
Per ulteriori informazioni, consulta [Elenchi di prefissi gestiti](https://docs.aws.amazon.com/vpc/latest/userguide/managed-prefix-lists.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [GetManagedPrefixListAssociations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-managed-prefix-list-associations.html)*Command Reference*.
### `get-managed-prefix-list-entries`
Il seguente esempio di codice mostra come utilizzare`get-managed-prefix-list-entries`.
**AWS CLI**
**Come ottenere le voci per un elenco di prefissi**
Il comando `get-managed-prefix-list-entries` seguente recupera le voci per l’elenco di prefissi specificato.
```
aws ec2 get-managed-prefix-list-entries \
--prefix-list-id pl-0123456abcabcabc1
```
Output:
```
{
"Entries": [
{
"Cidr": "10.0.0.0/16",
"Description": "vpc-a"
},
{
"Cidr": "10.2.0.0/16",
"Description": "vpc-b"
}
]
}
```
Per ulteriori informazioni, consulta [Elenchi di prefissi gestiti](https://docs.aws.amazon.com/vpc/latest/userguide/managed-prefix-lists.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [GetManagedPrefixListEntries AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-managed-prefix-list-entries.html)*Command Reference*.
### `get-network-insights-access-scope-analysis-findings`
Il seguente esempio di codice mostra come utilizzare`get-network-insights-access-scope-analysis-findings`.
**AWS CLI**
**Come ottenere gli esiti dell’analisi dell’ambito di accesso alle informazioni di rete**
L'`get-network-insights-access-scope-analysis-findings`esempio seguente ottiene i risultati dell'analisi dell'ambito selezionato nel tuo AWS account.
```
aws ec2 get-network-insights-access-scope-analysis-findings \
--region us-east-1 \
--network-insights-access-scope-analysis-id nis \
--nis-123456789111
```
Output:
```
{
"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]
]
}
}
]
}
```
Per ulteriori informazioni, consulta [Guida introduttiva a Network Access Analyzer utilizzando la AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli.html) *nella Guida Network Access* Analyzer.
+ *Per i dettagli sull'API, consulta Command [GetNetworkInsightsAccessScopeAnalysisFindings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-network-insights-access-scope-analysis-findings.html)Reference AWS CLI .*
### `get-network-insights-access-scope-content`
Il seguente esempio di codice mostra come utilizzare`get-network-insights-access-scope-content`.
**AWS CLI**
**Come ottenere il contenuto dell’ambito di accesso alle informazioni di rete**
L'`get-network-insights-access-scope-content`esempio seguente ottiene il contenuto dell'ID di analisi dell'ambito selezionato nel tuo AWS account.
```
aws ec2 get-network-insights-access-scope-content \
--region us-east-1 \
--network-insights-access-scope-id nis-123456789222
```
Output:
```
{
"NetworkInsightsAccessScopeContent": {
"NetworkInsightsAccessScopeId": "nis-123456789222",
"MatchPaths": [
{
"Source": {
"ResourceStatement": {
"ResourceTypes": [
"AWS::EC2::NetworkInterface"
]
}
},
"Destination": {
"ResourceStatement": {
"ResourceTypes": [
"AWS::EC2::InternetGateway"
]
}
}
}
]
}
}
```
Per ulteriori informazioni, consulta [Guida introduttiva a Network Access Analyzer utilizzando la AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli.html) *nella Guida Network Access* Analyzer.
+ *Per i dettagli sull'API, consulta Command [GetNetworkInsightsAccessScopeContent](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-network-insights-access-scope-content.html)Reference AWS CLI .*
### `get-password-data`
Il seguente esempio di codice mostra come utilizzare`get-password-data`.
**AWS CLI**
**Come ottenere la password crittografata**
Questo esempio recupera la password crittografata.
Comando:
```
aws ec2 get-password-data --instance-id i-1234567890abcdef0
```
Output:
```
{
"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=="
}
```
**Come ottenere la password decrittografata**
Questo esempio recupera la password decrittografata.
Comando:
```
aws ec2 get-password-data --instance-id i-1234567890abcdef0 --priv-launch-key C:\Keys\MyKeyPair.pem
```
Output:
```
{
"InstanceId": "i-1234567890abcdef0",
"Timestamp": "2013-08-30T23:18:05.000Z",
"PasswordData": "&ViJ652e*u"
}
```
+ Per i dettagli sull'API, consulta [GetPasswordData AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-password-data.html)*Command Reference*.
### `get-reserved-instances-exchange-quote`
Il seguente esempio di codice mostra come utilizzare`get-reserved-instances-exchange-quote`.
**AWS CLI**
**Come ottenere un preventivo per lo scambio di un’istanza riservata modificabile**
Questo esempio ottiene le informazioni di scambio per le istanze riservate modificabili specificate.
Comando:
```
aws ec2 get-reserved-instances-exchange-quote --reserved-instance-ids 7b8750c3-397e-4da4-bbcb-a45ebexample --target-configurations OfferingId=6fea5434-b379-434c-b07b-a7abexample
```
Output:
```
{
"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"
}
}
```
+ Per i dettagli sull'API, consulta [GetReservedInstancesExchangeQuote AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-reserved-instances-exchange-quote.html)*Command Reference*.
### `get-security-groups-for-vpc`
Il seguente esempio di codice mostra come utilizzare`get-security-groups-for-vpc`.
**AWS CLI**
**Come visualizzare i gruppi di sicurezza che possono essere associati alle interfacce di rete in un VPC specificato.**
L’esempio `get-security-groups-for-vpc` seguente mostra i gruppi di sicurezza che possono essere associati alle interfacce di rete nel VPC.
```
aws ec2 get-security-groups-for-vpc \
--vpc-id vpc-6c31a611 \
--region us-east-1
```
Output:
```
{
"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"
}
}
```
+ Per i dettagli sull'API, consulta [GetSecurityGroupsForVpc AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-security-groups-for-vpc.html)*Command Reference*.
### `get-serial-console-access-status`
Il seguente esempio di codice mostra come utilizzare`get-serial-console-access-status`.
**AWS CLI**
**Come visualizzare l’accesso account alla console seriale**
L’esempio `get-serial-console-access-status` seguente determina se l’accesso alla console seriale è abilitato per l’account in uso.
```
aws ec2 get-serial-console-access-status
```
Output:
```
{
"SerialConsoleAccessEnabled": true
}
```
Per ulteriori informazioni, consulta [Console seriale EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-serial-console.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [GetSerialConsoleAccessStatus AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-serial-console-access-status.html)*Command Reference*.
### `get-snapshot-block-public-access-state`
Il seguente esempio di codice mostra come utilizzare`get-snapshot-block-public-access-state`.
**AWS CLI**
**Come ottenere lo stato corrente del blocco dell’accesso pubblico per gli snapshot**
L’esempio `get-snapshot-block-public-access-state` seguente ottiene lo stato corrente del blocco dell’accesso pubblico per gli snapshot.
```
aws ec2 get-snapshot-block-public-access-state
```
Output:
```
{
"State": "block-all-sharing"
}
```
Per ulteriori informazioni, consulta [Blocco dell’accesso pubblico per gli snapshot](https://docs.aws.amazon.com/ebs/latest/userguide/block-public-access-snapshots.html) nella *Guida per l’utente di Amazon EBS*.
+ Per i dettagli sull'API, consulta [GetSnapshotBlockPublicAccessState AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-snapshot-block-public-access-state.html)*Command Reference*.
### `get-spot-placement-scores`
Il seguente esempio di codice mostra come utilizzare`get-spot-placement-scores`.
**AWS CLI**
**Come calcolare il punteggio di posizionamento spot per i requisiti specificati**
L’esempio `get-spot-placement-scores` seguente genera innanzitutto un elenco di tutti i parametri possibili che possono essere specificati per la configurazione del punteggio di posizionamento spot utilizzando il parametro `--generate-cli-skeleton` e salva l’elenco in un file JSON. Quindi, il file JSON viene utilizzato per configurare i requisiti da utilizzare per calcolare il punteggio di posizionamento spot.
Come generare tutti i possibili parametri che possono essere specificati per la configurazione del punteggio di posizionamento spot e salvare l’output direttamente in un file JSON.
```
aws ec2 get-spot-placement-scores \
--region us-east-1 \
--generate-cli-skeleton input > attributes.json
```
Output:
```
{
"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": ""
}
```
Configurare il file JSON. È necessario fornire un valore per `TargetCapacity`: Per una descrizione di ogni parametro e dei relativi valori predefiniti, consulta Calculate the Spot placement score (AWS CLI) . calculate-sps-cli
Calcola il punteggio di posizionamento spot per i requisiti specificati in `attributes.json`. Specifica il nome e il percorso del file JSON utilizzando il parametro `--cli-input-json`.
```
aws ec2 get-spot-placement-scores \
--region us-east-1 \
--cli-input-json file://attributes.json
```
Viene restituito un output se `SingleAvailabilityZone` è impostato su `false` o omesso (se omesso, il valore predefinito è `false`). Viene restituito un elenco con punteggio di Regioni.
```
"Recommendation": [
{
"Region": "us-east-1",
"Score": 7
},
{
"Region": "us-west-1",
"Score": 5
},
...
```
Viene restituito un output se `SingleAvailabilityZone` è impostato su `true`. Viene restituito un elenco di zone con punteggio. SingleAvailability
```
"Recommendation": [
{
"Region": "us-east-1",
"AvailabilityZoneId": "use1-az1"
"Score": 8
},
{
"Region": "us-east-1",
"AvailabilityZoneId": "usw2-az3"
"Score": 6
},
...
```
Per ulteriori informazioni sul calcolo di un punteggio di posizionamento spot e, ad esempio, sulle configurazioni, consulta [Calcolo di un punteggio di posizionamento spot](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-placement-score.html#work-with-spot-placement-score) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [GetSpotPlacementScores AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-spot-placement-scores.html)*Command Reference*.
### `get-subnet-cidr-reservations`
Il seguente esempio di codice mostra come utilizzare`get-subnet-cidr-reservations`.
**AWS CLI**
**Come ottenere informazioni su una prenotazione CIDR della sottorete**
L’esempio `get-subnet-cidr-reservations` seguente visualizza informazioni sulla prenotazione CIDR della sottorete specificata.
```
aws ec2 get-subnet-cidr-reservations \
--subnet-id subnet-03c51e2e6cEXAMPLE
```
Output:
```
{
"SubnetIpv4CidrReservations": [
{
"SubnetCidrReservationId": "scr-044f977c4eEXAMPLE",
"SubnetId": "subnet-03c51e2e6cEXAMPLE",
"Cidr": "10.1.0.16/28",
"ReservationType": "prefix",
"OwnerId": "123456789012"
}
],
"SubnetIpv6CidrReservations": []
}
```
Per ulteriori informazioni, consulta [Prenotazioni della CIDR per la sottorete](https://docs.aws.amazon.com/vpc/latest/userguide/subnet-cidr-reservation.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [GetSubnetCidrReservations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-subnet-cidr-reservations.html)*Command Reference*.
### `get-transit-gateway-attachment-propagations`
Il seguente esempio di codice mostra come utilizzare`get-transit-gateway-attachment-propagations`.
**AWS CLI**
**Come elencare le tabelle di routing in cui l’allegato della risorsa specificata propaga le route**
L’esempio `get-transit-gateway-attachment-propagations` seguente elenca le tabelle di routing in cui l’allegato della risorsa specificata propaga le route.
```
aws ec2 get-transit-gateway-attachment-propagations \
--transit-gateway-attachment-id tgw-attach-09fbd47ddfEXAMPLE
```
Output:
```
{
"TransitGatewayAttachmentPropagations": [
{
"TransitGatewayRouteTableId": "tgw-rtb-0882c61b97EXAMPLE",
"State": "enabled"
}
]
}
```
Per ulteriori informazioni, consulta [Tabelle di routing del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [GetTransitGatewayAttachmentPropagations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-transit-gateway-attachment-propagations.html)*Command Reference*.
### `get-transit-gateway-multicast-domain-associations`
Il seguente esempio di codice mostra come utilizzare`get-transit-gateway-multicast-domain-associations`.
**AWS CLI**
**Come visualizzare le informazioni sulle associazioni per un dominio multicast (trasmissione uno a molti) del gateway di transito**
L’esempio `get-transit-gateway-multicast-domain-associations` seguente restituisce le associazioni per il dominio multicast (trasmissione uno a molti) specificato.
```
aws ec2 get-transit-gateway-multicast-domain-associations \
--transit-gateway-multicast-domain-id tgw-mcast-domain-0c4905cef7EXAMPLE
```
Output:
```
{
"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"
}
}
]
}
```
Per ulteriori informazioni, consulta [Domini multicast (trasmissione uno a molti)](https://docs.aws.amazon.com/vpc/latest/tgw/multicast-domains-about.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [GetTransitGatewayMulticastDomainAssociations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-transit-gateway-multicast-domain-associations.html)*Command Reference*.
### `get-transit-gateway-prefix-list-references`
Il seguente esempio di codice mostra come utilizzare`get-transit-gateway-prefix-list-references`.
**AWS CLI**
**Come ottenere i riferimenti all’elenco di prefissi nella tabella di routing del gateway di transito**
L’esempio `get-transit-gateway-prefix-list-references` seguente ottiene i riferimenti all’elenco di prefissi per la tabella di routing del gateway di transito specificata e filtra in base all’ID di un elenco di prefissi specifico.
```
aws ec2 get-transit-gateway-prefix-list-references \
--transit-gateway-route-table-id tgw-rtb-0123456789abcd123 \
--filters Name=prefix-list-id,Values=pl-11111122222222333
```
Output:
```
{
"TransitGatewayPrefixListReferences": [
{
"TransitGatewayRouteTableId": "tgw-rtb-0123456789abcd123",
"PrefixListId": "pl-11111122222222333",
"PrefixListOwnerId": "123456789012",
"State": "available",
"Blackhole": false,
"TransitGatewayAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-aabbccddaabbccaab",
"ResourceType": "vpc",
"ResourceId": "vpc-112233445566aabbc"
}
}
]
}
```
Per ulteriori informazioni, consulta [Riferimenti elenco dei prefissi](https://docs.aws.amazon.com/vpc/latest/tgw/create-prefix-list-reference.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [GetTransitGatewayPrefixListReferences AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-transit-gateway-prefix-list-references.html)*Command Reference*.
### `get-transit-gateway-route-table-associations`
Il seguente esempio di codice mostra come utilizzare`get-transit-gateway-route-table-associations`.
**AWS CLI**
**Come ottenere informazioni sulle associazioni per la tabella di routing del gateway di transito specificata**
L’esempio `get-transit-gateway-route-table-associations` seguente visualizza informazioni sulle associazioni per la tabella di routing del gateway di transito specificata.
```
aws ec2 get-transit-gateway-route-table-associations \
--transit-gateway-route-table-id tgw-rtb-0a823edbdeEXAMPLE
```
Output:
```
{
"Associations": [
{
"TransitGatewayAttachmentId": "tgw-attach-09b52ccdb5EXAMPLE",
"ResourceId": "vpc-4d7de228",
"ResourceType": "vpc",
"State": "associating"
}
]
}
```
Per ulteriori informazioni, consulta [Tabelle di routing del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html#associate-tgw-route-table) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [GetTransitGatewayRouteTableAssociations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-transit-gateway-route-table-associations.html)*Command Reference*.
### `get-transit-gateway-route-table-propagations`
Il seguente esempio di codice mostra come utilizzare`get-transit-gateway-route-table-propagations`.
**AWS CLI**
**Come visualizzare informazioni sulle propagazioni delle tabelle di routing per la tabella di routing del gateway di transito specificato**
L’esempio `get-transit-gateway-route-table-propagations` seguente restituisce le propagazioni della tabella di routing per la tabella di routing specificata.
```
aws ec2 get-transit-gateway-route-table-propagations \
--transit-gateway-route-table-id tgw-rtb-002573ed1eEXAMPLE
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Tabelle di routing del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [GetTransitGatewayRouteTablePropagations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-transit-gateway-route-table-propagations.html)*Command Reference*.
### `get-verified-access-endpoint-policy`
Il seguente esempio di codice mostra come utilizzare`get-verified-access-endpoint-policy`.
**AWS CLI**
**Come ottenere la policy di accesso verificato di un endpoint**
L’esempio `get-verified-access-endpoint-policy` seguente ottiene la policy di accesso verificato dell’endpoint specificato.
```
aws ec2 get-verified-access-endpoint-policy \
--verified-access-endpoint-id vae-066fac616d4d546f2
```
Output:
```
{
"PolicyEnabled": true,
"PolicyDocument": "permit(principal,action,resource)\nwhen {\n context.identity.groups.contains(\"finance\") &&\n context.identity.email_verified == true\n};"
}
```
Per ulteriori informazioni, consulta [Policy di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/auth-policies.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [GetVerifiedAccessEndpointPolicy AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-verified-access-endpoint-policy.html)*Command Reference*.
### `get-verified-access-group-policy`
Il seguente esempio di codice mostra come utilizzare`get-verified-access-group-policy`.
**AWS CLI**
**Come ottenere la policy di accesso verificato di un gruppo**
L’esempio `get-verified-access-group-policy` seguente recupera la policy di accesso verificato del gruppo specificato.
```
aws ec2 get-verified-access-group-policy \
--verified-access-group-id vagr-0dbe967baf14b7235
```
Output:
```
{
"PolicyEnabled": true,
"PolicyDocument": "permit(principal,action,resource)\nwhen {\n context.identity.groups.contains(\"finance\") &&\n context.identity.email_verified == true\n};"
}
```
Per ulteriori informazioni, consulta [Gruppi di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-groups.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [GetVerifiedAccessGroupPolicy AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-verified-access-group-policy.html)*Command Reference*.
### `get-vpn-connection-device-sample-configuration`
Il seguente esempio di codice mostra come utilizzare`get-vpn-connection-device-sample-configuration`.
**AWS CLI**
**Come scaricare un file di configurazione di esempio**
L’esempio `get-vpn-connection-device-sample-configuration` seguente scarica il file di configurazione di esempio specificato. Per elencare i dispositivi gateway con un file di configurazione di esempio, chiama il 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
```
Output:
```
{
"VpnConnectionDeviceSampleConfiguration": "contents-of-the-sample-configuration-file"
}
```
Per ulteriori informazioni, consulta [Scaricare il file di configurazione](https://docs.aws.amazon.com/vpn/latest/s2svpn/SetUpVPNConnections.html#vpn-download-config) nella *Guida per l'utente della AWS Site-to-Site VPN*.
+ Per i dettagli sull'API, consulta [GetVpnConnectionDeviceSampleConfiguration AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-vpn-connection-device-sample-configuration.html)*Command Reference*.
### `get-vpn-connection-device-types`
Il seguente esempio di codice mostra come utilizzare`get-vpn-connection-device-types`.
**AWS CLI**
**Come elencare i dispositivi gateway con un file di configurazione di esempio**
L’esempio `get-vpn-connection-device-types` seguente elenca i dispositivi gateway di Palo Alto Networks che dispongono di file di configurazione di esempio.
```
aws ec2 get-vpn-connection-device-types \
--query "VpnConnectionDeviceTypes[?Vendor==`Palo Alto Networks`]"
```
Output:
```
[
{
"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+"
}
]
```
Per ulteriori informazioni, consulta [Scaricare il file di configurazione](https://docs.aws.amazon.com/vpn/latest/s2svpn/SetUpVPNConnections.html#vpn-download-config) nella *Guida per l'utente della AWS Site-to-Site VPN*.
+ Per i dettagli sull'API, consulta [GetVpnConnectionDeviceTypes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/get-vpn-connection-device-types.html)*Command Reference*.
### `import-client-vpn-client-certificate-revocation-list`
Il seguente esempio di codice mostra come utilizzare`import-client-vpn-client-certificate-revocation-list`.
**AWS CLI**
**Come importare un elenco di revoche di certificati client**
L’esempio `import-client-vpn-client-certificate-revocation-list` seguente importa un elenco di revoche di certificati client nell’endpoint VPN Client specificando la posizione del file sul computer locale.
```
aws ec2 import-client-vpn-client-certificate-revocation-list \
--certificate-revocation-list file:///path/to/crl.pem \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni, consulta [Elenchi di revoche di certificati client](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-certificates.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [ImportClientVpnClientCertificateRevocationList AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/import-client-vpn-client-certificate-revocation-list.html)*Command Reference*.
### `import-image`
Il seguente esempio di codice mostra come utilizzare`import-image`.
**AWS CLI**
**Come importare un file di immagine della VM come AMI**
L’esempio `import-image` seguente importa l’OVA specificato.
```
aws ec2 import-image \
--disk-containers Format=ova,UserBucket="{S3Bucket=my-import-bucket,S3Key=vms/my-server-vm.ova}"
```
Output:
```
{
"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"
}
```
+ Per i dettagli sull'API, consulta [ImportImage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/import-image.html)*Command Reference*.
### `import-key-pair`
Il seguente esempio di codice mostra come utilizzare`import-key-pair`.
**AWS CLI**
**Come importare una chiave pubblica**
Innanzitutto, genera una coppia di chiavi con lo strumento desiderato. Ad esempio, utilizza il comando ssh-keygen:
Comando:
```
ssh-keygen -t rsa -C "my-key" -f ~/.ssh/my-key
```
Output:
```
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.
...
```
Questo comando di esempio importa la chiave pubblica specificata.
Comando:
```
aws ec2 import-key-pair --key-name "my-key" --public-key-material fileb://~/.ssh/my-key.pub
```
Output:
```
{
"KeyName": "my-key",
"KeyFingerprint": "1f:51:ae:28:bf:89:e9:d8:1f:25:5d:37:2d:7d:b8:ca"
}
```
+ Per i dettagli sull'API, consulta [ImportKeyPair AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/import-key-pair.html)*Command Reference*.
### `import-snapshot`
Il seguente esempio di codice mostra come utilizzare`import-snapshot`.
**AWS CLI**
**Come importare uno snapshot**
L’esempio `import-snapshot` seguente importa il disco specificato come snapshot.
```
aws ec2 import-snapshot \
--description "My server VMDK" \
--disk-container Format=VMDK,UserBucket={'S3Bucket=my-import-bucket,S3Key=vms/my-server-vm.vmdk'}
```
Output:
```
{
"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"
}
}
}
```
+ Per i dettagli sull'API, consulta [ImportSnapshot AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/import-snapshot.html)*Command Reference*.
### `list-images-in-recycle-bin`
Il seguente esempio di codice mostra come utilizzare`list-images-in-recycle-bin`.
**AWS CLI**
**Come elencare le immagini nel Cestino**
L’esempio `list-images-in-recycle-bin` seguente elenca tutte le immagini attualmente mantenute nel Cestino.
```
aws ec2 list-images-in-recycle-bin
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Recover deleted AMIs from the Recycle Bin](https://docs.aws.amazon.com/ebs/latest/userguide/recycle-bin-working-with-amis.html) nella *Amazon EBS User* Guide.
+ Per i dettagli sull'API, consulta *AWS CLI Command [ListImagesInRecycleBin](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/list-images-in-recycle-bin.html)Reference*.
### `list-snapshots-in-recycle-bin`
Il seguente esempio di codice mostra come utilizzare`list-snapshots-in-recycle-bin`.
**AWS CLI**
**Come visualizzare gli snapshot nel Cestino**
L’esempio `list-snapshots-in-recycle-bin` seguente elenca le informazioni sugli snapshot nel Cestino, tra cui l’ID snapshot, una descrizione dello snapshot, l’ID del volume da cui è stato creato lo snapshot, la data e l’ora in cui lo snapshot è stato eliminato ed è entrato nel Cestino e la data e l’ora in cui scade il periodo di conservazione.
```
aws ec2 list-snapshots-in-recycle-bin \
--snapshot-id snap-01234567890abcdef
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni sul Cestino, consulta [Ripristino degli snapshot dal Cestino](https://docs.aws.amazon.com/ebs/latest/userguide/recycle-bin-working-with-snaps.html) nella *Guida per l’utente di Amazon EBS*.
+ Per i dettagli sull'API, consulta [ListSnapshotsInRecycleBin AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/list-snapshots-in-recycle-bin.html)*Command Reference*.
### `lock-snapshot`
Il seguente esempio di codice mostra come utilizzare`lock-snapshot`.
**AWS CLI**
**Esempio 1: come bloccare uno snapshot in modalità di governance**
L’esempio `lock-snapshot` seguente blocca lo snapshot specificato in modalità di governance.
```
aws ec2 lock-snapshot \
--snapshot-id snap-0b5e733b4a8df6e0d \
--lock-mode governance \
--lock-duration 365
```
Output:
```
{
"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"
}
```
Per ulteriori informazioni, consulta [Snapshot Lock](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-snapshot-lock.html) nella *Guida per l’utente di Amazon EBS*.
**Esempio 2: come bloccare uno snapshot in modalità di conformità**
L’esempio `lock-snapshot` seguente blocca lo snapshot specificato in modalità di conformità.
```
aws ec2 lock-snapshot \
--snapshot-id snap-0163a8524c5b9901f \
--lock-mode compliance \
--cool-off-period 24 \
--lock-duration 365
```
Output:
```
{
"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"
}
```
Per ulteriori informazioni, consulta [Snapshot Lock](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-snapshot-lock.html) nella *Guida per l’utente di Amazon EBS*.
+ Per i dettagli sull'API, consulta [LockSnapshot AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/lock-snapshot.html)*Command Reference*.
### `modify-address-attribute`
Il seguente esempio di codice mostra come utilizzare`modify-address-attribute`.
**AWS CLI**
**Come modificare l’attributo del nome di dominio associato a un indirizzo IP elastico**
Gli esempi `modify-address-attribute` seguenti modificano l’attributo del nome di dominio di un indirizzo IP elastico.
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
```
Output:
```
{
"Addresses": [
{
"PublicIp": "192.0.2.0",
"AllocationId": "eipalloc-abcdef01234567890",
"PtrRecord": "example.net."
"PtrRecordUpdate": {
"Value": "example.com.",
"Status": "PENDING"
}
]
}
```
Per monitorare la modifica in sospeso e per visualizzare gli attributi modificati di un indirizzo IP elastico, consulta la *AWS CLI [describe-addresses-attribute](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-addresses-attribute.html)*Command Reference.
+ Per i dettagli sull'API, consulta *AWS CLI Command [ModifyAddressAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-address-attribute.html)Reference*.
### `modify-availability-zone-group`
Il seguente esempio di codice mostra come utilizzare`modify-availability-zone-group`.
**AWS CLI**
**Come abilitare un gruppo di zone**
L’esempio `modify-availability-zone-group` seguente abilita il gruppo di zone specificato.
```
aws ec2 modify-availability-zone-group \
--group-name us-west-2-lax-1 \
--opt-in-status opted-in
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni, consulta [Regioni e zone di disponibilità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [ModifyAvailabilityZoneGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-availability-zone-group.html)*Command Reference*.
### `modify-capacity-reservation-fleet`
Il seguente esempio di codice mostra come utilizzare`modify-capacity-reservation-fleet`.
**AWS CLI**
**Esempio 1: come modificare la capacità di destinazione totale e la data di un parco di prenotazione della capacità**
L’esempio `modify-capacity-reservation-fleet` seguente modifica la capacità target totale del parco di prenotazione della capacità specificato. Quando modifichi la capacità target totale di un parco istanze di prenotazione della capacità, questo crea automaticamente nuove prenotazioni di capacità o modifica o annulla le prenotazioni di capacità esistenti nel parco istanze per soddisfare la nuova capacità target totale. Non è possibile tentare ulteriori modifiche a un parco istanze mentre si trova nello stato `modifying`.
```
aws ec2 modify-capacity-reservation-fleet \
--capacity-reservation-fleet-id crf-01234567890abcedf \
--total-target-capacity 160
```
Output:
```
{
"Return": true
}
```
**Esempio 2: come modificare la data di fine di un parco di prenotazione della capacità**
L’esempio `modify-capacity-reservation-fleet` seguente modifica la data di fine del parco di prenotazione della capacità specificato. Quando modifichi la data di fine del parco istanze, le date di fine per tutte le singole prenotazioni di capacità vengono aggiornate di conseguenza. Non è possibile tentare ulteriori modifiche a un parco istanze mentre si trova nello stato `modifying`.
```
aws ec2 modify-capacity-reservation-fleet \
--capacity-reservation-fleet-id crf-01234567890abcedf \
--end-date 2022-07-04T23:59:59.000Z
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni sui parchi di prenotazione della capacità, consulta [Parchi prenotazione della capacità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cr-fleets.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [ModifyCapacityReservationFleet AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-capacity-reservation-fleet.html)*Command Reference*.
### `modify-capacity-reservation`
Il seguente esempio di codice mostra come utilizzare`modify-capacity-reservation`.
**AWS CLI**
**Esempio 1: come modificare il numero di istanze riservate da una prenotazione della capacità esistente**
L’esempio `modify-capacity-reservation` seguente modifica il numero di istanze per cui la prenotazione della capacità riserva la capacità.
```
aws ec2 modify-capacity-reservation \
--capacity-reservation-id cr-1234abcd56EXAMPLE \
--instance-count 5
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni, consulta [Modifica di una prenotazione della capacità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservations-modify.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come modificare la data e l’ora di fine di una prenotazione della capacità esistente**
L’esempio `modify-capacity-reservation` seguente modifica una prenotazione della capacità esistente in modo che termini alla data e all’ora specificate.
```
aws ec2 modify-capacity-reservation \
--capacity-reservation-id cr-1234abcd56EXAMPLE \
--end-date-type limited \
--end-date 2019-08-31T23:59:59Z
```
Per ulteriori informazioni, consulta [Modifica di una prenotazione della capacità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservations-modify.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [ModifyCapacityReservation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-capacity-reservation.html)*Command Reference*.
### `modify-client-vpn-endpoint`
Il seguente esempio di codice mostra come utilizzare`modify-client-vpn-endpoint`.
**AWS CLI**
**Come modificare un endpoint VPN Client**
L’esempio `modify-client-vpn-endpoint` seguente abilita la registrazione della connessione client per l’endpoint VPN Client specificato.
```
aws ec2 modify-client-vpn-endpoint \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde \
--connection-log-options Enabled=true,CloudwatchLogGroup=ClientVPNLogs
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni, consulta [Endpoint Client VPN](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-endpoints.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [ModifyClientVpnEndpoint AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-client-vpn-endpoint.html)*Command Reference*.
### `modify-default-credit-specification`
Il seguente esempio di codice mostra come utilizzare`modify-default-credit-specification`.
**AWS CLI**
**Come modificare l’opzione di credito predefinita**
L’esempio `modify-default-credit-specification` seguente modifica l’opzione di credito predefinita per le istanze T2.
```
aws ec2 modify-default-credit-specification \
--instance-family t2 \
--cpu-credits unlimited
```
Output:
```
{
"InstanceFamilyCreditSpecification": {
"InstanceFamily": "t2",
"CpuCredits": "unlimited"
}
}
```
+ Per i dettagli sull'API, consulta [ModifyDefaultCreditSpecification AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-default-credit-specification.html)*Command Reference*.
### `modify-ebs-default-kms-key-id`
Il seguente esempio di codice mostra come utilizzare`modify-ebs-default-kms-key-id`.
**AWS CLI**
**Come impostare la chiave gestita dal cliente (CMK) predefinita per la crittografia EBS**
L'`modify-ebs-default-kms-key-id`esempio seguente imposta la CMK specificata come CMK predefinita per la crittografia EBS per l' AWS account nella regione corrente.
```
aws ec2 modify-ebs-default-kms-key-id \
--kms-key-id alias/my-cmk
```
Output:
```
{
"KmsKeyId": "arn:aws:kms:us-west-2:123456789012:key/0ea3fef3-80a7-4778-9d8c-1c0c6EXAMPLE"
}
```
+ *Per i dettagli sull'API, consulta Command [ModifyEbsDefaultKmsKeyId](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-ebs-default-kms-key-id.html)Reference AWS CLI .*
### `modify-fleet`
Il seguente esempio di codice mostra come utilizzare`modify-fleet`.
**AWS CLI**
**Come scalare un parco EC2**
L’esempio `modify-fleet` seguente modifica la capacità di destinazione del parco EC2 specificato. Se il valore specificato è superiore alla capacità attuale, il parco EC2 avvia ulteriori istanze. Se il valore specificato è inferiore alla capacità corrente, il parco EC2 annulla tutte le richieste aperte e, se la policy di terminazione è `terminate`, il parco EC2 termina tutte le istanze che superano la nuova capacità di destinazione.
```
aws ec2 modify-fleet \
--fleet-ids fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE \
--target-capacity-specification TotalTargetCapacity=5
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni, consulta [Gestire un parco EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [ModifyFleet AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-fleet.html)*Command Reference*.
### `modify-fpga-image-attribute`
Il seguente esempio di codice mostra come utilizzare`modify-fpga-image-attribute`.
**AWS CLI**
**Come modificare gli attributi di un’immagine FPGA di Amazon (AFI)**
Questo esempio aggiunge le autorizzazioni di caricamento per l’ID account `123456789012` per l’AFI specificata.
Comando:
```
aws ec2 modify-fpga-image-attribute --attribute loadPermission --fpga-image-id afi-0d123e123bfc85abc --load-permission Add=[{UserId=123456789012}]
```
Output:
```
{
"FpgaImageAttribute": {
"FpgaImageId": "afi-0d123e123bfc85abc",
"LoadPermissions": [
{
"UserId": "123456789012"
}
]
}
}
```
+ Per i dettagli sull'API, consulta [ModifyFpgaImageAttribute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-fpga-image-attribute.html)*Command Reference*.
### `modify-hosts`
Il seguente esempio di codice mostra come utilizzare`modify-hosts`.
**AWS CLI**
**Esempio 1: come abilitare il posizionamento automatico per un host dedicato**
L’esempio `modify-hosts` seguente abilita il posizionamento automatico per un host dedicato in modo che accetti qualsiasi tipo di avvio di istanze non mirate corrispondenti alla relativa configurazione del tipo di istanza.
```
aws ec2 modify-hosts \
--host-id h-06c2f189b4EXAMPLE \
--auto-placement on
```
Output:
```
{
"Successful": [
"h-06c2f189b4EXAMPLE"
],
"Unsuccessful": []
}
```
Per ulteriori informazioni, consulta [Modificare l’impostazione del posizionamento automatico per un host dedicato](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/modify-host-auto-placement.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come abilitare il ripristino dell’host per un host dedicato**
L’esempio `modify-hosts` seguente abilita il ripristino host per l’host dedicato specificato.
```
aws ec2 modify-hosts \
--host-id h-06c2f189b4EXAMPLE \
--host-recovery on
```
Output:
```
{
"Successful": [
"h-06c2f189b4EXAMPLE"
],
"Unsuccessful": []
}
```
Per ulteriori informazioni, consulta [Modificare l’impostazione del posizionamento automatico per un host dedicato](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/modify-host-auto-placement.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [ModifyHosts AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-hosts.html)*Command Reference*.
### `modify-id-format`
Il seguente esempio di codice mostra come utilizzare`modify-id-format`.
**AWS CLI**
**Come abilitare il formato di ID più lungo per una risorsa**
L’esempio `modify-id-format` seguente abilita il formato ID più lungo per il tipo di risorsa `instance`.
```
aws ec2 modify-id-format \
--resource instance \
--use-long-ids
```
**Come disabilitare il formato di ID più lungo per una risorsa**
L’esempio `modify-id-format` seguente disabilita il formato ID più lungo per il tipo di risorsa `instance`.
```
aws ec2 modify-id-format \
--resource instance \
--no-use-long-ids
```
L’esempio `modify-id-format` seguente abilita il formato ID più lungo per tutti i tipi di risorsa supportati che rientrano nel rispettivo periodo di adesione.
```
aws ec2 modify-id-format \
--resource all-current \
--use-long-ids
```
+ Per i dettagli sull'API, consulta [ModifyIdFormat AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-id-format.html)*Command Reference*.
### `modify-identity-id-format`
Il seguente esempio di codice mostra come utilizzare`modify-identity-id-format`.
**AWS CLI**
**Per consentire a un ruolo IAM di utilizzare più a IDs lungo una risorsa**
L'`modify-identity-id-format`esempio seguente consente al ruolo IAM `EC2Role` nel tuo AWS account di utilizzare il formato ID lungo per il tipo di `instance` risorsa.
```
aws ec2 modify-identity-id-format \
--principal-arn arn:aws:iam::123456789012:role/EC2Role \
--resource instance \
--use-long-ids
```
**Per consentire a un utente IAM di utilizzare più a IDs lungo una risorsa**
L'`modify-identity-id-format`esempio seguente consente all'utente `AdminUser` IAM del tuo AWS account di utilizzare il formato ID più lungo per il tipo di `volume` risorsa.
```
aws ec2 modify-identity-id-format \
--principal-arn arn:aws:iam::123456789012:user/AdminUser \
--resource volume \
--use-long-ids
```
L'`modify-identity-id-format`esempio seguente consente all'utente `AdminUser` IAM del tuo AWS account di utilizzare il formato ID più lungo per tutti i tipi di risorse supportati che rientrano nel periodo di attivazione.
```
aws ec2 modify-identity-id-format \
--principal-arn arn:aws:iam::123456789012:user/AdminUser \
--resource all-current \
--use-long-ids
```
+ Per i dettagli sull'API, consulta [ModifyIdentityIdFormat AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-identity-id-format.html)*Command Reference.*
### `modify-image-attribute`
Il seguente esempio di codice mostra come utilizzare`modify-image-attribute`.
**AWS CLI**
**Esempio 1: come rendere pubblica un’AMI**
L’esempio `modify-instance-attribute` seguente rende pubblica l’AMI specificata.
```
aws ec2 modify-image-attribute \
--image-id ami-5731123e \
--launch-permission "Add=[{Group=all}]"
```
Questo comando non produce alcun output.
**Esempio 2: come rendere privata un’AMI**
L’esempio `modify-instance-attribute` seguente rende privata l’AMI specificata.
```
aws ec2 modify-image-attribute \
--image-id ami-5731123e \
--launch-permission "Remove=[{Group=all}]"
```
Questo comando non produce alcun output.
**Esempio 3: concedere l'autorizzazione di avvio a un AWS account**
L'`modify-instance-attribute`esempio seguente concede le autorizzazioni di avvio all'account specificato AWS .
```
aws ec2 modify-image-attribute \
--image-id ami-5731123e \
--launch-permission "Add=[{UserId=123456789012}]"
```
Questo comando non produce alcun output.
**Esempio 4: Per rimuovere l'autorizzazione di avvio da un account AWS **
L'`modify-instance-attribute`esempio seguente rimuove le autorizzazioni di avvio dall' AWS account specificato.
```
aws ec2 modify-image-attribute \
--image-id ami-5731123e \
--launch-permission "Remove=[{UserId=123456789012}]"
```
+ Per i dettagli sull'API, vedere [ModifyImageAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-image-attribute.html)in *AWS CLI Command Reference.*
### `modify-instance-attribute`
Il seguente esempio di codice mostra come utilizzare`modify-instance-attribute`.
**AWS CLI**
**Esempio 1: come modificare il tipo di istanza**
L’esempio `modify-instance-attribute` seguente modifica il tipo di istanza dell’istanza specificata. L’istanza deve essere nello stato `stopped`.
```
aws ec2 modify-instance-attribute \
--instance-id i-1234567890abcdef0 \
--instance-type "{\"Value\": \"m1.small\"}"
```
Questo comando non produce alcun output.
**Esempio 2: come abilitare le reti avanzate per un’istanza**
L’esempio `modify-instance-attribute` seguente abilita le reti avanzate per l’istanza specificata. L’istanza deve essere nello stato `stopped`.
```
aws ec2 modify-instance-attribute \
--instance-id i-1234567890abcdef0 \
--sriov-net-support simple
```
Questo comando non produce alcun output.
**Esempio 3: Per modificare l' sourceDestCheck attributo**
L’esempio `modify-instance-attribute` seguente imposta l’attributo `sourceDestCheck` dell’istanza specificata su `true`. L’istanza deve trovarsi in un VPC.
```
aws ec2 modify-instance-attribute --instance-id i-1234567890abcdef0 --source-dest-check "{\"Value\": true}"
```
Questo comando non produce alcun output.
**Esempio 4: modificare l' deleteOnTermination attributo del volume principale**
L’esempio `modify-instance-attribute` seguente imposta l’attributo `deleteOnTermination` per il volume root dell’istanza supportata da Amazon EBS specificata su `false`. Per impostazione predefinita, questo attributo è `true` per il volume root.
Comando:
```
aws ec2 modify-instance-attribute \
--instance-id i-1234567890abcdef0 \
--block-device-mappings "[{\"DeviceName\": \"/dev/sda1\",\"Ebs\":{\"DeleteOnTermination\":false}}]"
```
Questo comando non produce alcun output.
**Esempio 5: come modificare i dati utente associati a un’istanza**
L'`modify-instance-attribute`esempio seguente aggiunge il contenuto del file `UserData.txt` come UserData per l'istanza specificata.
Contenuto del file `UserData.txt` originale:
```
#!/bin/bash
yum update -y
service httpd start
chkconfig httpd on
```
I contenuti del file devono essere codificati in formato Base64. Il primo comando converte il file di testo in formato Base64 e lo salva come un nuovo file.
Versione Linux/macOS del comando:
```
base64 UserData.txt > UserData.base64.txt
```
Questo comando non produce alcun output.
Versione Windows del comando:
```
certutil -encode UserData.txt tmp.b64 && findstr /v /c:- tmp.b64 > UserData.base64.txt
```
Output:
```
Input Length = 67
Output Length = 152
CertUtil: -encode command completed successfully.
```
A questo punto è possibile fare riferimento al file nel comando della CLI che segue:
```
aws ec2 modify-instance-attribute \
--instance-id=i-09b5a14dbca622e76 \
--attribute userData --value file://UserData.base64.txt
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [User Data and the AWS CLI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html#user-data-api-cli) nella Guida per l'utente di *EC2*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [ModifyInstanceAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-instance-attribute.html)Reference*.
### `modify-instance-capacity-reservation-attributes`
Il seguente esempio di codice mostra come utilizzare`modify-instance-capacity-reservation-attributes`.
**AWS CLI**
**Esempio 1: come modificare le impostazioni di targeting per la prenotazione della capacità di un’istanza**
L’esempio `modify-instance-capacity-reservation-attributes` seguente modifica un’istanza per fare riferimento a una prenotazione della capacità specifica.
```
aws ec2 modify-instance-capacity-reservation-attributes \
--instance-id i-EXAMPLE8765abcd4e \
--capacity-reservation-specification 'CapacityReservationTarget={CapacityReservationId= cr-1234abcd56EXAMPLE }'
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni, consulta [Modifica delle impostazioni di prenotazione della capacità dell’istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservations-modify-instance.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come modificare le impostazioni di targeting per la prenotazione della capacità di un’istanza**
L’esempio `modify-instance-capacity-reservation-attributes` seguente modifica un’istanza interrotta che ha come obiettivo la prenotazione della capacità specificata per l’avvio in qualsiasi prenotazione della capacità che abbia attributi corrispondenti (tipo di istanza, piattaforma, zona di disponibilità) e che abbia criteri di corrispondenza dell’istanza aperti.
```
aws ec2 modify-instance-capacity-reservation-attributes \
--instance-id i-EXAMPLE8765abcd4e \
--capacity-reservation-specification 'CapacityReservationPreference=open'
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni, consulta [Modifica delle impostazioni di prenotazione della capacità dell’istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservations-modify-instance.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [ModifyInstanceCapacityReservationAttributes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-instance-capacity-reservation-attributes.html)*Command Reference*.
### `modify-instance-credit-specification`
Il seguente esempio di codice mostra come utilizzare`modify-instance-credit-specification`.
**AWS CLI**
**Come modificare l’opzione di credito per l’utilizzo della CPU di un’istanza**
Questo esempio modifica l’opzione di credito per l’utilizzo della CPU dell’istanza specificata nella Regione specificata impostandola su “unlimited” (Illimitato). Le opzioni di credito valide sono “standard” e “unlimited”.
Comando:
```
aws ec2 modify-instance-credit-specification --instance-credit-specification "InstanceId=i-1234567890abcdef0,CpuCredits=unlimited"
```
Output:
```
{
"SuccessfulInstanceCreditSpecifications": [
{
"InstanceId": "i-1234567890abcdef0"
}
],
"UnsuccessfulInstanceCreditSpecifications": []
}
```
+ Per i dettagli sull'API, consulta [ModifyInstanceCreditSpecification AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-instance-credit-specification.html)*Command Reference*.
### `modify-instance-event-start-time`
Il seguente esempio di codice mostra come utilizzare`modify-instance-event-start-time`.
**AWS CLI**
**Come modificare l’ora di inizio dell’evento per un’istanza**
Il comando `modify-instance-event-start-time` seguente mostra come modificare l’ora di inizio dell’evento per l’istanza specificata. Specifica l’ID evento utilizzando il parametro `--instance-event-id`. Specifica la nuova data e ora utilizzando il parametro `--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
```
Output:
```
"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"
}
```
Per ulteriori informazioni, consulta Uso delle istanze per le quali è pianificato il riavvio nella *Guida per l’utente di Amazon Elastic Compute Cloud*.
+ Per i dettagli sull'API, consulta [ModifyInstanceEventStartTime AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-instance-event-start-time.html)*Command Reference*.
### `modify-instance-event-window`
Il seguente esempio di codice mostra come utilizzare`modify-instance-event-window`.
**AWS CLI**
**Esempio 1: come modificare l’intervallo temporale di una finestra di eventi**
L’esempio `modify-instance-event-window` seguente modifica l’intervallo temporale di una finestra di eventi. Specifica il parametro `time-range` per modificare l’intervallo di tempo. Non è possibile specificare anche il parametro `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
```
Output:
```
{
"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"
}
]
}
}
```
Per i vincoli relativi alla finestra di eventi, consulta [Considerazioni](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) nella sezione Eventi pianificati della *Guida per l’utente di Amazon EC2*.
**Esempio 2: come modificare un insieme di intervalli temporali di una finestra di eventi**
L’esempio `modify-instance-event-window` seguente modifica l’intervallo temporale di una finestra di eventi. Specifica il parametro `time-range` per modificare l’intervallo di tempo. Non è possibile specificare anche il parametro `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}]'
```
Output:
```
{
"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"
}
]
}
}
```
Per i vincoli relativi alla finestra di eventi, consulta [Considerazioni](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) nella sezione Eventi pianificati della *Guida per l’utente di Amazon EC2*.
**Esempio 3: come modificare l’espressione cron di una finestra di eventi**
L’esempio `modify-instance-event-window` seguente modifica l’espressione cron di una finestra di eventi. Specifica il parametro `cron-expression` per modificare l’espressione cron. Non è possibile specificare anche il parametro `time-range`.
```
aws ec2 modify-instance-event-window \
--region us-east-1 \
--instance-event-window-id iew-0abcdef1234567890 \
--cron-expression "* 21-23 * * 2,3"
```
Output:
```
{
"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"
}
]
}
}
```
Per i vincoli relativi alla finestra di eventi, consulta [Considerazioni](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html#event-windows-considerations) nella sezione Eventi pianificati della *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [ModifyInstanceEventWindow AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-instance-event-window.html)*Command Reference*.
### `modify-instance-maintenance-options`
Il seguente esempio di codice mostra come utilizzare`modify-instance-maintenance-options`.
**AWS CLI**
**Esempio 1: come disabilitare il comportamento di ripristino di un’istanza**
L’esempio `modify-instance-maintenance-options` seguente disabilita il recupero automatico semplificato per un’istanza in esecuzione o arrestata.
```
aws ec2 modify-instance-maintenance-options \
--instance-id i-0abcdef1234567890 \
--auto-recovery disabled
```
Output:
```
{
"InstanceId": "i-0abcdef1234567890",
"AutoRecovery": "disabled"
}
```
Per ulteriori informazioni, consulta [Configurazione del ripristino automatico semplificato](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-configuration-recovery.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come impostare il comportamento di ripristino di un’istanza come predefinito**
L’esempio `modify-instance-maintenance-options` seguente imposta il comportamento di ripristino automatico come predefinito, il che consente il ripristino automatico semplificato per i tipi di istanza supportati.
```
aws ec2 modify-instance-maintenance-options \
--instance-id i-0abcdef1234567890 \
--auto-recovery default
```
Output:
```
{
"InstanceId": "i-0abcdef1234567890",
"AutoRecovery": "default"
}
```
Per ulteriori informazioni, consulta [Configurazione del ripristino automatico semplificato](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-configuration-recovery.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [ModifyInstanceMaintenanceOptions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-instance-maintenance-options.html)*Command Reference*.
### `modify-instance-metadata-options`
Il seguente esempio di codice mostra come utilizzare`modify-instance-metadata-options`.
**AWS CLI**
**Esempio 1: abilitare IMDSv2**
L'`modify-instance-metadata-options`esempio seguente configura l'uso di IMDSv2 sull'istanza specificata.
```
aws ec2 modify-instance-metadata-options \
--instance-id i-1234567898abcdef0 \
--http-tokens required \
--http-endpoint enabled
```
Output:
```
{
"InstanceId": "i-1234567898abcdef0",
"InstanceMetadataOptions": {
"State": "pending",
"HttpTokens": "required",
"HttpPutResponseHopLimit": 1,
"HttpEndpoint": "enabled"
}
}
```
Per ulteriori informazioni, consulta [Metadati delle istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come disabilitare i metadati dell’istanza**
L’esempio `modify-instance-metadata-options` seguente disabilita l’uso di tutte le versioni dei metadati dell’istanza sull’istanza specificata.
```
aws ec2 modify-instance-metadata-options \
--instance-id i-1234567898abcdef0 \
--http-endpoint disabled
```
Output:
```
{
"InstanceId": "i-1234567898abcdef0",
"InstanceMetadataOptions": {
"State": "pending",
"HttpTokens": "required",
"HttpPutResponseHopLimit": 1,
"HttpEndpoint": "disabled"
}
}
```
Per ulteriori informazioni, consulta [Metadati delle istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 3: per abilitare l' IPv6 endpoint dei metadati dell'istanza per la tua istanza**
L'`modify-instance-metadata-options`esempio seguente mostra come attivare l' IPv6 endpoint per il servizio di metadati dell'istanza. Per impostazione predefinita, l' IPv6 endpoint è disabilitato. Questo è vero anche se hai avviato un'istanza in una sottorete IPv6 solo. L' IPv6 endpoint per IMDS è accessibile solo sulle istanze create sul sistema Nitro.
```
aws ec2 modify-instance-metadata-options \
--instance-id i-1234567898abcdef0 \
--http-protocol-ipv6 enabled \
--http-endpoint enabled
```
Output:
```
{
"InstanceId": "i-1234567898abcdef0",
"InstanceMetadataOptions": {
"State": "pending",
"HttpTokens": "required",
"HttpPutResponseHopLimit": 1,
"HttpEndpoint": "enabled",
HttpProtocolIpv6": "enabled"
}
}
```
Per ulteriori informazioni, consulta [Metadati delle istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) nella *Guida per l’utente di Amazon EC2*.
+ *Per i dettagli sull'API, consulta [ModifyInstanceMetadataOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-instance-metadata-options.html)Command Reference.AWS CLI *
### `modify-instance-placement`
Il seguente esempio di codice mostra come utilizzare`modify-instance-placement`.
**AWS CLI**
**Esempio 1: come rimuovere l’affinità di un’istanza con un host dedicato**
L’esempio `modify-instance-placement` seguente rimuove l’affinità di un’istanza con un host dedicato e consente di avviarla su qualsiasi host dedicato disponibile nell’account che supporti il relativo tipo di istanza.
```
aws ec2 modify-instance-placement \
--instance-id i-0e6ddf6187EXAMPLE \
--affinity default
```
Output:
```
{
"Return": true
}
```
**Esempio 2: come stabilire l’affinità tra un’istanza e l’host dedicato specificato**
L’esempio `modify-instance-placement` seguente stabilisce la relazione di avvio tra un’istanza e un host dedicato. L’istanza può essere eseguita solo sull’host dedicato specificato.
```
aws ec2 modify-instance-placement \
--instance-id i-0e6ddf6187EXAMPLE \
--affinity host \
--host-id i-0e6ddf6187EXAMPLE
```
Output:
```
{
"Return": true
}
```
**Esempio 3: come spostare un’istanza in un gruppo di posizionamento**
L’esempio `modify-instance-placement` seguente sposta un’istanza in un gruppo di posizionamento, interrompe l’istanza, modifica il posizionamento dell’istanza e quindi riavvia l’istanza.
```
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
```
**Esempio 4: come rimuovere un’istanza da un gruppo di posizionamento**
L’esempio `modify-instance-placement` seguente rimuove un’istanza da un gruppo di posizionamento arrestando l’istanza, modificando il posizionamento dell’istanza e quindi riavviando l’istanza. L’esempio seguente specifica una stringa vuota (“”) per il nome del gruppo di posizionamento per indicare che l’istanza non deve essere collocata in un gruppo di posizionamento.
Arresta l’istanza:
```
aws ec2 stop-instances \
--instance-ids i-0123a456700123456
```
Modifica il posizionamento (prompt dei comandi di Windows):
```
aws ec2 modify-instance-placement \
--instance-id i-0123a456700123456 \
--group-name ""
```
Modifica la posizione (Windows PowerShell, Linux e macOS):
```
aws ec2 modify-instance-placement `
--instance-id i-0123a456700123456 `
--group-name ''
```
Riavvia l’istanza:
```
aws ec2 start-instances \
--instance-ids i-0123a456700123456
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni, consulta [Modificare la tenancy e l’affinità degli host dedicati](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/moving-instances-dedicated-hosts.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [ModifyInstancePlacement AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-instance-placement.html)*Command Reference.*
### `modify-ipam-pool`
Il seguente esempio di codice mostra come utilizzare`modify-ipam-pool`.
**AWS CLI**
**Come modificare un pool IPAM**
L’esempio `modify-ipam-pool` seguente modifica un 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
```
Output:
```
{
"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"
}
]
}
}
```
Per ulteriori informazioni, consulta [Modifica di un pool](https://docs.aws.amazon.com/vpc/latest/ipam/mod-pool-ipam.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta [ModifyIpamPool AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-ipam-pool.html)*Command Reference*.
### `modify-ipam-resource-cidr`
Il seguente esempio di codice mostra come utilizzare`modify-ipam-resource-cidr`.
**AWS CLI**
**Come modificare il CIDR assegnato a una risorsa**
L’esempio `modify-ipam-resource-cidr` seguente modifica una risorsa CIDR.
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
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni sullo spostamento delle risorse, consulta [Move resource CIDRs between scope](https://docs.aws.amazon.com/vpc/latest/ipam/move-resource-ipam.html) nella *Amazon VPC IPAM* User Guide.
Per ulteriori informazioni sulla modifica degli stati di monitoraggio, consulta [Modifica dello stato di monitoraggio della risorsa CIDRs nella Guida](https://docs.aws.amazon.com/vpc/latest/ipam/change-monitoring-state-ipam.html) per l'utente *IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [ModifyIpamResourceCidr](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-ipam-resource-cidr.html)Reference*.
### `modify-ipam-resource-discovery`
Il seguente esempio di codice mostra come utilizzare`modify-ipam-resource-discovery`.
**AWS CLI**
**Come modificare le regioni operative di un rilevamento delle risorse**
In questo esempio, l’utente è un amministratore delegato IPAM che desidera modificare le Regioni operative di un rilevamento di risorse.
Per completare questa richiesta:
Non è possibile modificare un rilevamento di risorse predefinito ed è necessario essere il proprietario del rilevamento delle risorse. È necessario l'ID di rilevamento delle risorse, che è possibile utilizzare. [describe-ipam-resource-discoveries](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-ipam-resource-discoveries.html)
L'`modify-ipam-resource-discovery`esempio seguente modifica un rilevamento di risorse non predefinito nel tuo account. AWS
```
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
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Lavorare con il rilevamento delle risorse](https://docs.aws.amazon.com/vpc/latest/ipam/res-disc-work-with.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [ModifyIpamResourceDiscovery](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-ipam-resource-discovery.html)Reference*.
### `modify-ipam-scope`
Il seguente esempio di codice mostra come utilizzare`modify-ipam-scope`.
**AWS CLI**
**Come modificare la descrizione di un ambito**
In questo scenario, l’utente è un amministratore delegato IPAM che desidera modificare la descrizione di un ambito IPAM.
Per completare questa richiesta, è necessario l'ID dell'ambito, che è possibile utilizzare [describe-ipam-scopes](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-ipam-scopes.html).
L’esempio `modify-ipam-scope` seguente mostra come aggiornare la descrizione dell’ambito.
```
aws ec2 modify-ipam-scope \
--ipam-scope-id ipam-scope-0d3539a30b57dcdd1 \
--description example \
--region us-east-1
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni sugli ambiti, consulta [Funzionamento di IPAM](https://docs.aws.amazon.com/vpc/latest/ipam/how-it-works-ipam.html) nella *Guida per l’utente IPAM di Amazon VPC*.
+ Per i dettagli sull'API, consulta [ModifyIpamScope AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-ipam-scope.html)*Command Reference*.
### `modify-ipam`
Il seguente esempio di codice mostra come utilizzare`modify-ipam`.
**AWS CLI**
**Come modificare un IPAM**
L’esempio `modify-ipam` seguente modifica un’IPAM aggiungendo una Regione operativa.
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
```
Output:
```
{
"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"
}
}
```
+ Per i dettagli sull'API, consulta [ModifyIpam AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-ipam.html)*Command Reference*.
### `modify-launch-template`
Il seguente esempio di codice mostra come utilizzare`modify-launch-template`.
**AWS CLI**
**Come modificare la versione del modello di avvio predefinita**
Questo esempio specifica la versione 2 del modello di avvio specificato come versione predefinita.
Comando:
```
aws ec2 modify-launch-template --launch-template-id lt-0abcd290751193123 --default-version 2
```
Output:
```
{
"LaunchTemplate": {
"LatestVersionNumber": 2,
"LaunchTemplateId": "lt-0abcd290751193123",
"LaunchTemplateName": "WebServers",
"DefaultVersionNumber": 2,
"CreatedBy": "arn:aws:iam::123456789012:root",
"CreateTime": "2017-12-01T13:35:46.000Z"
}
}
```
+ Per i dettagli sull'API, consulta [ModifyLaunchTemplate AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-launch-template.html)*Command Reference*.
### `modify-managed-prefix-list`
Il seguente esempio di codice mostra come utilizzare`modify-managed-prefix-list`.
**AWS CLI**
**Come modificare un elenco di prefissi**
L’esempio `modify-managed-prefix-list` seguente aggiunge una voce all’elenco di prefissi specificato.
```
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
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Elenchi di prefissi gestiti](https://docs.aws.amazon.com/vpc/latest/userguide/managed-prefix-lists.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [ModifyManagedPrefixList AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-managed-prefix-list.html)*Command Reference*.
### `modify-network-interface-attribute`
Il seguente esempio di codice mostra come utilizzare`modify-network-interface-attribute`.
**AWS CLI**
**Come modificare l’attributo attachment di un’interfaccia di rete**
Questo comando di esempio modifica l’attributo `attachment` dell’interfaccia di rete specificata.
Comando:
```
aws ec2 modify-network-interface-attribute --network-interface-id eni-686ea200 --attachment AttachmentId=eni-attach-43348162,DeleteOnTermination=false
```
**Come modificare l’attributo description di un’interfaccia di rete**
Questo comando di esempio modifica l’attributo `description` dell’interfaccia di rete specificata.
Comando:
```
aws ec2 modify-network-interface-attribute --network-interface-id eni-686ea200 --description "My description"
```
**Come modificare l’attributo groupSet di un’interfaccia di rete**
Questo comando di esempio modifica l’attributo `groupSet` dell’interfaccia di rete specificata.
Comando:
```
aws ec2 modify-network-interface-attribute --network-interface-id eni-686ea200 --groups sg-903004f8 sg-1a2b3c4d
```
**Per modificare l' sourceDestCheck attributo di un'interfaccia di rete**
Questo comando di esempio modifica l’attributo `sourceDestCheck` dell’interfaccia di rete specificata.
Comando:
```
aws ec2 modify-network-interface-attribute --network-interface-id eni-686ea200 --no-source-dest-check
```
+ Per i dettagli sull'API, vedere [ModifyNetworkInterfaceAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-network-interface-attribute.html)in *AWS CLI Command Reference*.
### `modify-private-dns-name-options`
Il seguente esempio di codice mostra come utilizzare`modify-private-dns-name-options`.
**AWS CLI**
**Come modificare le opzioni per i nomi host delle istanze**
L’esempio `modify-private-dns-name-options` seguente disabilita l’opzione per rispondere alle query DNS, per nomi host delle istanze con record DNS A.
```
aws ec2 modify-private-dns-name-options \
--instance-id i-1234567890abcdef0 \
--no-enable-resource-name-dns-a-record
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni, consulta [Tipi di nomi host delle istanze Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [ModifyPrivateDnsNameOptions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-private-dns-name-options.html)*Command Reference*.
### `modify-reserved-instances`
Il seguente esempio di codice mostra come utilizzare`modify-reserved-instances`.
**AWS CLI**
**Come modificare le istanze riservate**
Questo comando di esempio sposta un’istanza riservata in un’altra zona di disponibilità nella stessa Regione.
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
```
Output:
```
{
"ReservedInstancesModificationId": "rimod-d3ed4335-b1d3-4de6-ab31-0f13aaf46687"
}
```
**Come modificare la piattaforma di rete delle istanze riservate**
Questo comando di esempio converte le istanze riservate EC2-Classic in 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
```
Output:
```
{
"ReservedInstancesModificationId": "rimod-82fa9020-668f-4fb6-945d-61537009d291"
}
```
Per ulteriori informazioni, consulta Modifica delle istanze riservate nella *Guida per l’utente di Amazon EC2*.
**Come modificare le dimensioni delle istanze riservate**
Questo comando di esempio modifica un'istanza riservata che ha 10 istanze m1.small in us-west-1c in modo che 8 Linux/UNIX istanze m1.small diventino 2 istanze m1.large e le restanti 2 istanze m1.small diventino 1 istanza m1.medium nella stessa zona di disponibilità. 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
```
Output:
```
{
"ReservedInstancesModificationId": "rimod-acc5f240-080d-4717-b3e3-1c6b11fa00b6"
}
```
Per ulteriori informazioni, consulta Modifica della dimensione dell’istanza delle prenotazioni nella *Guida per l’utente di Amazon EC2*.
+ *Per i dettagli sull'API, consulta Command Reference. [ModifyReservedInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-reserved-instances.html)AWS CLI *
### `modify-security-group-rules`
Il seguente esempio di codice mostra come utilizzare`modify-security-group-rules`.
**AWS CLI**
**Modificare le regole di un gruppo di sicurezza per aggiornare la descrizione della regola, il protocollo IP e l'intervallo di CidrIpv 4 indirizzi**
L'`modify-security-group-rules`esempio seguente aggiorna la descrizione, il protocollo IP e l'intervallo IPV4 CIDR di una regola del gruppo di sicurezza specificato. Utilizza il parametro `security-group-rules` per immettere gli aggiornamenti per le regole del gruppo di sicurezza specificato. `-1` specifica tutti i protocolli.
```
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}'
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni sulle regole del gruppo di sicurezza, consulta [Regole del gruppo di sicurezza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, vedere [ModifySecurityGroupRules](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-security-group-rules.html)in *AWS CLI Command Reference.*
### `modify-snapshot-attribute`
Il seguente esempio di codice mostra come utilizzare`modify-snapshot-attribute`.
**AWS CLI**
**Esempio 1: come modificare un attributo snapshot**
L’esempio `modify-snapshot-attribute` seguente aggiorna l’attributo `createVolumePermission` per lo snapshot specificato, rimuovendo le autorizzazioni di volume per l’utente specificato.
```
aws ec2 modify-snapshot-attribute \
--snapshot-id snap-1234567890abcdef0 \
--attribute createVolumePermission \
--operation-type remove \
--user-ids 123456789012
```
**Esempio 2: come rendere pubblico uno snapshot**
L’esempio `modify-snapshot-attribute` seguente rende pubblico lo snapshot specificato.
```
aws ec2 modify-snapshot-attribute \
--snapshot-id snap-1234567890abcdef0 \
--attribute createVolumePermission \
--operation-type add \
--group-names all
```
+ Per i dettagli sull'API, consulta [ModifySnapshotAttribute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-snapshot-attribute.html)*Command Reference*.
### `modify-snapshot-tier`
Il seguente esempio di codice mostra come utilizzare`modify-snapshot-tier`.
**AWS CLI**
**Come archiviare uno snapshot**
L’esempio `modify-snapshot-tier` seguente archivia lo snapshot specificato. Il parametro di risposta `TieringStartTime` indica la data e l’ora in cui è stato avviato il processo di archiviazione, in formato ora UTC (YYYYY-MM-DTHH:MM:SSZ).
```
aws ec2 modify-snapshot-tier \
--snapshot-id snap-01234567890abcedf \
--storage-tier archive
```
Output:
```
{
"SnapshotId": "snap-01234567890abcedf",
"TieringStartTime": "2021-09-15T16:44:37.574Z"
}
```
Per ulteriori informazioni sull’archiviazione degli snapshot, consulta [Archiviazione degli snapshot Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/snapshot-archive.html) nella *Guida per l’utente di Amazon EBS*.
+ Per i dettagli sull'API, consulta [ModifySnapshotTier AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-snapshot-tier.html)*Command Reference*.
### `modify-spot-fleet-request`
Il seguente esempio di codice mostra come utilizzare`modify-spot-fleet-request`.
**AWS CLI**
**Come modificare una richiesta di parco istanze spot**
Questo comando di esempio aggiorna la capacità di destinazione della richiesta del parco istanze spot specificata.
Comando:
```
aws ec2 modify-spot-fleet-request --target-capacity 20 --spot-fleet-request-id sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE
```
Output:
```
{
"Return": true
}
```
Questo comando di esempio diminuisce la capacità di destinazione del parco istanze spot specificata senza terminare le istanze spot.
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
```
Output:
```
{
"Return": true
}
```
+ Per i dettagli sull'API, consulta [ModifySpotFleetRequest AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-spot-fleet-request.html)*Command Reference*.
### `modify-subnet-attribute`
Il seguente esempio di codice mostra come utilizzare`modify-subnet-attribute`.
**AWS CLI**
**Per modificare il comportamento di IPv4 indirizzamento pubblico di una sottorete**
Questo esempio modifica subnet-1a2b3c4d per specificare che a tutte le istanze avviate in questa sottorete viene assegnato un indirizzo pubblico. IPv4 Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 modify-subnet-attribute --subnet-id subnet-1a2b3c4d --map-public-ip-on-launch
```
**Per modificare il comportamento di IPv6 indirizzamento di una sottorete**
Questo esempio modifica subnet-1a2b3c4d per specificare che a tutte le istanze avviate in questa sottorete viene assegnato un indirizzo compreso nell'intervallo della sottorete. IPv6
Comando:
```
aws ec2 modify-subnet-attribute --subnet-id subnet-1a2b3c4d --assign-ipv6-address-on-creation
```
Per ulteriori informazioni, consulta Assegnazione degli indirizzi IP nel VPC nella *Guida per l’utente di AWS Virtual Private Cloud*.
+ Per i dettagli sull'API, [ModifySubnetAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-subnet-attribute.html)vedere *AWS CLI in* Command Reference.
### `modify-traffic-mirror-filter-network-services`
Il seguente esempio di codice mostra come utilizzare`modify-traffic-mirror-filter-network-services`.
**AWS CLI**
**Come aggiungere servizi di rete a un filtro di mirroring del traffico**
L’esempio `modify-traffic-mirror-filter-network-services` seguente aggiunge i servizi di rete Amazon DNS al filtro specificato.
```
aws ec2 modify-traffic-mirror-filter-network-services \
--traffic-mirror-filter-id tmf-04812ff784EXAMPLE \
--add-network-service amazon-dns
```
Output:
```
{
"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"
}
]
}
}
```
Per ulteriori informazioni, consulta [Modificare i servizi di rete per i filtri di mirroring del traffico](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-filter.html#modify-traffic-mirroring-filter-network-services) nella *Guida di Mirroring del traffico AWS *.
+ Per i dettagli sull'API, consulta [ModifyTrafficMirrorFilterNetworkServices AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-traffic-mirror-filter-network-services.html)*Command Reference*.
### `modify-traffic-mirror-filter-rule`
Il seguente esempio di codice mostra come utilizzare`modify-traffic-mirror-filter-rule`.
**AWS CLI**
**Come modificare una regola di filtro di mirroring del traffico**
L’esempio `modify-traffic-mirror-filter-rule` seguente modifica la descrizione della regola di filtro di mirroring del traffico specificata.
```
aws ec2 modify-traffic-mirror-filter-rule \
--traffic-mirror-filter-rule-id tmfr-0ca76e0e08EXAMPLE \
--description "TCP Rule"
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Modificare le regole di filtro del mirroring del traffico](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-filter.html#modify-traffic-mirroring-filter-rules) nella *Guida di Mirroring del traffico AWS *.
+ Per i dettagli sull'API, consulta [ModifyTrafficMirrorFilterRule AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-traffic-mirror-filter-rule.html)*Command Reference*.
### `modify-traffic-mirror-session`
Il seguente esempio di codice mostra come utilizzare`modify-traffic-mirror-session`.
**AWS CLI**
**Come modificare una sessione di mirroring del traffico**
L’esempio `modify-traffic-mirror-session` seguente modifica la descrizione della sessione di mirroring del traffico e il numero di pacchetti di cui eseguire il mirroring.
```
aws ec2 modify-traffic-mirror-session \
--description "Change packet length" \
--traffic-mirror-session-id tms-08a33b1214EXAMPLE \
--remove-fields "packet-length"
```
Output:
```
{
"TrafficMirrorSession": {
"TrafficMirrorSessionId": "tms-08a33b1214EXAMPLE",
"TrafficMirrorTargetId": "tmt-07f75d8feeEXAMPLE",
"TrafficMirrorFilterId": "tmf-04812ff784EXAMPLE",
"NetworkInterfaceId": "eni-070203f901EXAMPLE",
"OwnerId": "111122223333",
"SessionNumber": 1,
"VirtualNetworkId": 7159709,
"Description": "Change packet length",
"Tags": []
}
}
```
Per ulteriori informazioni, consulta [Modificare la sessione di mirroring del traffico](https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-session.html#modify-traffic-mirroring-session) nella *Guida di Mirroring del traffico*.
+ Per i dettagli sull'API, consulta [ModifyTrafficMirrorSession AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-traffic-mirror-session.html)*Command Reference*.
### `modify-transit-gateway-prefix-list-reference`
Il seguente esempio di codice mostra come utilizzare`modify-transit-gateway-prefix-list-reference`.
**AWS CLI**
**Come modificare un riferimento a un elenco di prefissi**
L’esempio `modify-transit-gateway-prefix-list-reference` seguente modifica il riferimento all’elenco di prefissi nella tabella di routing specificata cambiando il collegamento a cui viene instradato il traffico.
```
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
```
Output:
```
{
"TransitGatewayPrefixListReference": {
"TransitGatewayRouteTableId": "tgw-rtb-0123456789abcd123",
"PrefixListId": "pl-11111122222222333",
"PrefixListOwnerId": "123456789012",
"State": "modifying",
"Blackhole": false,
"TransitGatewayAttachment": {
"TransitGatewayAttachmentId": "tgw-attach-aabbccddaabbccaab",
"ResourceType": "vpc",
"ResourceId": "vpc-112233445566aabbc"
}
}
}
```
Per ulteriori informazioni, consulta [Riferimenti elenco dei prefissi](https://docs.aws.amazon.com/vpc/latest/tgw/create-prefix-list-reference.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [ModifyTransitGatewayPrefixListReference AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-transit-gateway-prefix-list-reference.html)*Command Reference*.
### `modify-transit-gateway-vpc-attachment`
Il seguente esempio di codice mostra come utilizzare`modify-transit-gateway-vpc-attachment`.
**AWS CLI**
**Come modificare un collegamento VPC del gateway di transito**
L’esempio `modify-transit-gateway-vpc-attachment` seguente aggiunge una sottorete al collegamento VPC del gateway di transito specificato.
```
aws ec2 modify-transit-gateway-vpc-attachment \
--transit-gateway-attachment-id tgw-attach-09fbd47ddfEXAMPLE \
--add-subnet-ids subnet-0e51f45802EXAMPLE
```
Output:
```
{
"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"
}
}
}
```
Per ulteriori informazioni, consulta [Collegamenti del gateway di transito alla VPN a un VPC](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [ModifyTransitGatewayVpcAttachment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-transit-gateway-vpc-attachment.html)*Command Reference*.
### `modify-transit-gateway`
Il seguente esempio di codice mostra come utilizzare`modify-transit-gateway`.
**AWS CLI**
**Come modificare un gateway di transito**
L’esempio `modify-transit-gateway` seguente modifica il gateway di transito specificato abilitando il supporto ECMP per gli allegati VPN.
```
aws ec2 modify-transit-gateway \
--transit-gateway-id tgw-111111222222aaaaa \
--options VpnEcmpSupport=enable
```
Output:
```
{
"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"
}
}
}
```
Per ulteriori informazioni, consulta [Gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-transit-gateways.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [ModifyTransitGateway AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-transit-gateway.html)*Command Reference*.
### `modify-verified-access-endpoint-policy`
Il seguente esempio di codice mostra come utilizzare`modify-verified-access-endpoint-policy`.
**AWS CLI**
**Come configurare la policy di accesso verificato per un endpoint**
L’esempio `modify-verified-access-endpoint-policy` seguente aggiunge la policy di accesso verificato specificata all’endpoint di accesso verificato specificato.
```
aws ec2 modify-verified-access-endpoint-policy \
--verified-access-endpoint-id vae-066fac616d4d546f2 \
--policy-enabled \
--policy-document file://policy.txt
```
Contenuto di `policy.txt`:
```
permit(principal,action,resource)
when {
context.identity.groups.contains("finance") &&
context.identity.email.verified == true
};
```
Output:
```
{
"PolicyEnabled": true,
"PolicyDocument": "permit(principal,action,resource)\nwhen {\n context.identity.groups.contains(\"finance\") &&\n context.identity.email_verified == true\n};"
}
```
Per ulteriori informazioni, consulta [Policy di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/auth-policies.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [ModifyVerifiedAccessEndpointPolicy AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-verified-access-endpoint-policy.html)*Command Reference*.
### `modify-verified-access-endpoint`
Il seguente esempio di codice mostra come utilizzare`modify-verified-access-endpoint`.
**AWS CLI**
**Come modificare la configurazione di un endpoint di accesso verificato**
L’esempio `modify-verified-access-endpoint` seguente aggiunge la descrizione specificata all’endpoint di accesso verificato specificato.
```
aws ec2 modify-verified-access-endpoint \
--verified-access-endpoint-id vae-066fac616d4d546f2 \
--description 'Testing Verified Access'
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Endpoint di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-endpoints.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [ModifyVerifiedAccessEndpoint AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-verified-access-endpoint.html)*Command Reference*.
### `modify-verified-access-group-policy`
Il seguente esempio di codice mostra come utilizzare`modify-verified-access-group-policy`.
**AWS CLI**
**Come configurare una policy di accesso verificato per un gruppo**
L’esempio `modify-verified-access-group-policy` seguente aggiunge la policy di accesso verificato specificata al gruppo di accesso verificato specificato.
```
aws ec2 modify-verified-access-group-policy \
--verified-access-group-id vagr-0dbe967baf14b7235 \
--policy-enabled \
--policy-document file://policy.txt
```
Contenuto di `policy.txt`:
```
permit(principal,action,resource)
when {
context.identity.groups.contains("finance") &&
context.identity.email.verified == true
};
```
Output:
```
{
"PolicyEnabled": true,
"PolicyDocument": "permit(principal,action,resource)\nwhen {\n context.identity.groups.contains(\"finance\") &&\n context.identity.email_verified == true\n};"
}
```
Per ulteriori informazioni, consulta [Gruppi di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-groups.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [ModifyVerifiedAccessGroupPolicy AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-verified-access-group-policy.html)*Command Reference*.
### `modify-verified-access-group`
Il seguente esempio di codice mostra come utilizzare`modify-verified-access-group`.
**AWS CLI**
**Come modificare la configurazione di un gruppo di accesso verificato**
L’esempio `modify-verified-access-group` seguente aggiunge la descrizione specificata al gruppo di accesso verificato specificato.
```
aws ec2 modify-verified-access-group \
--verified-access-group-id vagr-0dbe967baf14b7235 \
--description "Testing Verified Access"
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Gruppi di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-groups.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [ModifyVerifiedAccessGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-verified-access-group.html)*Command Reference*.
### `modify-verified-access-instance-logging-configuration`
Il seguente esempio di codice mostra come utilizzare`modify-verified-access-instance-logging-configuration`.
**AWS CLI**
**Come abilitare la registrazione per un’istanza di accesso verificato**
L’esempio `modify-verified-access-instance-logging-configuration` seguente abilita la registrazione dell’accesso per l’istanza di accesso verificato specificata. I log verranno consegnati al gruppo di CloudWatch log Logs specificato.
```
aws ec2 modify-verified-access-instance-logging-configuration \
--verified-access-instance-id vai-0ce000c0b7643abea \
--access-logs CloudWatchLogs={Enabled=true,LogGroup=my-log-group}
```
Output:
```
{
"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
}
}
}
```
Per ulteriori informazioni, consulta [Log di accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/access-logs.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, vedere [ModifyVerifiedAccessInstanceLoggingConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-verified-access-instance-logging-configuration.html)in *AWS CLI Command Reference*.
### `modify-verified-access-instance`
Il seguente esempio di codice mostra come utilizzare`modify-verified-access-instance`.
**AWS CLI**
**Come modificare la configurazione di un’istanza di accesso verificato**
L’esempio `modify-verified-access-instance` seguente aggiunge la descrizione specificata all’istanza di accesso verificato specificata.
```
aws ec2 modify-verified-access-instance \
--verified-access-instance-id vai-0ce000c0b7643abea \
--description "Testing Verified Access"
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Istanze di Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/verified-access-instances.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [ModifyVerifiedAccessInstance AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-verified-access-instance.html)*Command Reference*.
### `modify-verified-access-trust-provider`
Il seguente esempio di codice mostra come utilizzare`modify-verified-access-trust-provider`.
**AWS CLI**
**Come modificare la configurazione di un provider di attendibilità di accesso verificato**
L’esempio `modify-verified-access-trust-provider` seguente aggiunge la descrizione specificata al provider di attendibilità di accesso verificato.
```
aws ec2 modify-verified-access-trust-provider \
--verified-access-trust-provider-id vatp-0bb32de759a3e19e7 \
--description "Testing Verified Access"
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Provider di attendibilità per Accesso verificato](https://docs.aws.amazon.com/verified-access/latest/ug/trust-providers.html) nella *Guida per l’utente di Accesso verificato da AWS *.
+ Per i dettagli sull'API, consulta [ModifyVerifiedAccessTrustProvider AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-verified-access-trust-provider.html)*Command Reference*.
### `modify-volume-attribute`
Il seguente esempio di codice mostra come utilizzare`modify-volume-attribute`.
**AWS CLI**
**Come modificare un attributo del volume**
Questo esempio imposta l’attributo `autoEnableIo` del volume con l’ID `vol-1234567890abcdef0` su `true`. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 modify-volume-attribute --volume-id vol-1234567890abcdef0 --auto-enable-io
```
+ Per i dettagli sull'API, consulta [ModifyVolumeAttribute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-volume-attribute.html)*Command Reference*.
### `modify-volume`
Il seguente esempio di codice mostra come utilizzare`modify-volume`.
**AWS CLI**
**Esempio 1: come modificare un volume cambiando le dimensioni**
L’esempio `modify-volume` seguente modifica le dimensioni del volume specificato in 150 GB.
Comando:
```
aws ec2 modify-volume --size 150 --volume-id vol-1234567890abcdef0
```
Output:
```
{
"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
}
}
```
**Esempio 2: come modificare un volume cambiando tipo, dimensioni e valore IOPS**
L’esempio `modify-volume` seguente modifica il tipo di volume in SSD capacità di IOPS allocata, imposta la velocità IOPS target su 10000 e imposta le dimensioni del volume su 350 GB.
```
aws ec2 modify-volume \
--volume-type io1 \
--iops 10000 \
--size 350 \
--volume-id vol-1234567890abcdef0
```
Output:
```
{
"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
}
}
```
+ Per i dettagli sull'API, consulta [ModifyVolume AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-volume.html)*Command Reference*.
### `modify-vpc-attribute`
Il seguente esempio di codice mostra come utilizzare`modify-vpc-attribute`.
**AWS CLI**
**Per modificare l' enableDnsSupport attributo**
Questo esempio modifica l’attributo `enableDnsSupport`. Questo attributo indica se la risoluzione DNS è abilitata per il VPC. Se questo attributo è `true`, il server Amazon DNS risolve i nomi host DNS per le istanze negli indirizzi IP corrispondenti, ma solo in quel caso. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 modify-vpc-attribute --vpc-id vpc-a01106c2 --enable-dns-support "{\"Value\":false}"
```
**Per modificare l' enableDnsHostnames attributo**
Questo esempio modifica l’attributo `enableDnsHostnames`. Questo attributo indica se le istanze avviate nel VPC ricevono nomi host DNS. Se questo attributo è `true`, le istanze nel VPC ottengono nomi host DNS, altrimenti no. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 modify-vpc-attribute --vpc-id vpc-a01106c2 --enable-dns-hostnames "{\"Value\":false}"
```
+ Per i dettagli sull'API, consulta [ModifyVpcAttribute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpc-attribute.html)*Command Reference*.
### `modify-vpc-endpoint-connection-notification`
Il seguente esempio di codice mostra come utilizzare`modify-vpc-endpoint-connection-notification`.
**AWS CLI**
**Come modificare una notifica della connessione endpoint**
Questo esempio modifica l’argomento SNS per la notifica della connessione endpoint specificata.
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
```
Output:
```
{
"ReturnValue": true
}
```
+ Per i dettagli sull'API, consulta [ModifyVpcEndpointConnectionNotification AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpc-endpoint-connection-notification.html)*Command Reference*.
### `modify-vpc-endpoint-service-configuration`
Il seguente esempio di codice mostra come utilizzare`modify-vpc-endpoint-service-configuration`.
**AWS CLI**
**Come modificare una configurazione di servizio endpoint**
Questo esempio modifica il requisito di accettazione per il servizio endpoint specificato.
Comando:
```
aws ec2 modify-vpc-endpoint-service-configuration --service-id vpce-svc-09222513e6e77dc86 --no-acceptance-required
```
Output:
```
{
"ReturnValue": true
}
```
+ Per i dettagli sull'API, consulta [ModifyVpcEndpointServiceConfiguration AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpc-endpoint-service-configuration.html)*Command Reference*.
### `modify-vpc-endpoint-service-payer-responsibility`
Il seguente esempio di codice mostra come utilizzare`modify-vpc-endpoint-service-payer-responsibility`.
**AWS CLI**
**Come modificare la responsabilità del pagante**
L’esempio `modify-vpc-endpoint-service-payer-responsibility` seguente modifica la responsabilità del pagante del servizio endpoint specificato.
```
aws ec2 modify-vpc-endpoint-service-payer-responsibility \
--service-id vpce-svc-071afff70666e61e0 \
--payer-responsibility ServiceOwner
```
Questo comando non produce alcun output.
+ Per i dettagli sull'API, consulta [ModifyVpcEndpointServicePayerResponsibility AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpc-endpoint-service-payer-responsibility.html)*Command Reference*.
### `modify-vpc-endpoint-service-permissions`
Il seguente esempio di codice mostra come utilizzare`modify-vpc-endpoint-service-permissions`.
**AWS CLI**
**Come modificare le autorizzazioni del servizio endpoint**
Questo esempio aggiunge l'autorizzazione per la connessione di un AWS account al servizio endpoint specificato.
Comando:
```
aws ec2 modify-vpc-endpoint-service-permissions --service-id vpce-svc-03d5ebb7d9579a2b3 --add-allowed-principals '["arn:aws:iam::123456789012:root"]'
```
Output:
```
{
"ReturnValue": true
}
```
Questo esempio aggiunge l’autorizzazione per un utente IAM specifico (`admin`) per connettersi al servizio endpoint specificato.
Comando:
```
aws ec2 modify-vpc-endpoint-service-permissions --service-id vpce-svc-03d5ebb7d9579a2b3 --add-allowed-principals '["arn:aws:iam::123456789012:user/admin"]'
```
+ Per i dettagli sull'API, vedere [ModifyVpcEndpointServicePermissions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpc-endpoint-service-permissions.html)in *AWS CLI Command Reference.*
### `modify-vpc-endpoint`
Il seguente esempio di codice mostra come utilizzare`modify-vpc-endpoint`.
**AWS CLI**
**Come modificare un endpoint del gateway**
Questo esempio modifica l’endpoint del gateway `vpce-1a2b3c4d` associando la tabella di routing `rtb-aaa222bb` all’endpoint e reimpostando il documento di policy.
Comando:
```
aws ec2 modify-vpc-endpoint --vpc-endpoint-id vpce-1a2b3c4d --add-route-table-ids rtb-aaa222bb --reset-policy
```
Output:
```
{
"Return": true
}
```
**Come modificare un endpoint di interfaccia**
Questo esempio modifica l’endpoint di interfaccia `vpce-0fe5b17a0707d6fa5` aggiungendo una sottorete `subnet-d6fcaa8d` all’endpoint.
Comando:
```
aws ec2 modify-vpc-endpoint --vpc-endpoint-id vpce-0fe5b17a0707d6fa5 --add-subnet-id subnet-d6fcaa8d
```
Output:
```
{
"Return": true
}
```
+ Per i dettagli sull'API, consulta [ModifyVpcEndpoint AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpc-endpoint.html)*Command Reference*.
### `modify-vpc-peering-connection-options`
Il seguente esempio di codice mostra come utilizzare`modify-vpc-peering-connection-options`.
**AWS CLI**
**Per abilitare la comunicazione tramite una connessione peering VPC dalla connessione locale ClassicLink **
In questo esempio, per la connessione peering`pcx-aaaabbb`, il proprietario del VPC richiedente modifica le opzioni di connessione peering VPC per consentire a una connessione ClassicLink locale di comunicare con il VPC peer.
Comando:
```
aws ec2 modify-vpc-peering-connection-options --vpc-peering-connection-id pcx-aaaabbbb --requester-peering-connection-options AllowEgressFromLocalClassicLinkToRemoteVpc=true
```
Output:
```
{
"RequesterPeeringConnectionOptions": {
"AllowEgressFromLocalClassicLinkToRemoteVpc": true
}
}
```
**Per abilitare la comunicazione tramite una connessione peering VPC dal VPC locale a una connessione remota ClassicLink **
In questo esempio, il proprietario del VPC accettante modifica le opzioni di connessione peering VPC per consentire al VPC locale di comunicare con la connessione nel VPC peer. ClassicLink
Comando:
```
aws ec2 modify-vpc-peering-connection-options --vpc-peering-connection-id pcx-aaaabbbb --accepter-peering-connection-options AllowEgressFromLocalVpcToRemoteClassicLink=true
```
Output:
```
{
"AccepterPeeringConnectionOptions": {
"AllowEgressFromLocalVpcToRemoteClassicLink": true
}
}
```
**Come abilitare il supporto della risoluzione DNS per una connessione peering VPC**
In questo esempio, il proprietario del VPC richiedente modifica le opzioni di connessione peering VPC per `pcx-aaaabbbb` per consentire al VPC di risolvere nomi host DNS pubblici in indirizzi IP privati quando viene interrogato da istanze nel VPC peer.
Comando:
```
aws ec2 modify-vpc-peering-connection-options --vpc-peering-connection-id pcx-aaaabbbb --requester-peering-connection-options AllowDnsResolutionFromRemoteVpc=true
```
Output:
```
{
"RequesterPeeringConnectionOptions": {
"AllowDnsResolutionFromRemoteVpc": true
}
}
```
+ *Per i dettagli sull'API, vedere in Command Reference. [ModifyVpcPeeringConnectionOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpc-peering-connection-options.html)AWS CLI *
### `modify-vpc-tenancy`
Il seguente esempio di codice mostra come utilizzare`modify-vpc-tenancy`.
**AWS CLI**
**Come modificare la tenancy di un VPC**
Questo esempio modifica la tenancy del VPC `vpc-1a2b3c4d` in `default`.
Comando:
```
aws ec2 modify-vpc-tenancy --vpc-id vpc-1a2b3c4d --instance-tenancy default
```
Output:
```
{
"Return": true
}
```
+ Per i dettagli sull'API, consulta [ModifyVpcTenancy AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpc-tenancy.html)*Command Reference*.
### `modify-vpn-connection-options`
Il seguente esempio di codice mostra come utilizzare`modify-vpn-connection-options`.
**AWS CLI**
**Come modificare le opzioni di connessione VPN**
L'`modify-vpn-connection-options`esempio seguente modifica il IPv4 CIDR locale sul lato gateway del cliente della connessione VPN specificata.
```
aws ec2 modify-vpn-connection-options \
--vpn-connection-id vpn-1122334455aabbccd \
--local-ipv4-network-cidr 10.0.0.0/16
```
Output:
```
{
"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": ""
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Modifica delle opzioni di connessione Site-to-Site VPN nella Guida per](https://docs.aws.amazon.com/vpn/latest/s2svpn/modify-vpn-connection-options.html) l'utente *AWS Site-to-Site VPN*.
+ Per i dettagli sull'API, consulta [ModifyVpnConnectionOptions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpn-connection-options.html)*Command Reference.*
### `modify-vpn-connection`
Il seguente esempio di codice mostra come utilizzare`modify-vpn-connection`.
**AWS CLI**
**Come modificare una connessione VPN**
L’esempio `modify-vpn-connection` seguente modifica il gateway di destinazione per la connessione VPN `vpn-12345678901234567` nel gateway privato virtuale `vgw-11223344556677889`:
```
aws ec2 modify-vpn-connection \
--vpn-connection-id vpn-12345678901234567 \
--vpn-gateway-id vgw-11223344556677889
```
Output:
```
{
"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"
}
]
}
}
```
+ Per i dettagli sull'API, consulta [ModifyVpnConnection AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpn-connection.html)*Command Reference*.
### `modify-vpn-tunnel-certificate`
Il seguente esempio di codice mostra come utilizzare`modify-vpn-tunnel-certificate`.
**AWS CLI**
**Come ruotare un certificato del tunnel VPN**
L’esempio `modify-vpn-tunnel-certificate` seguente ruota il certificato del tunnel specificato per una connessione VPN
```
aws ec2 modify-vpn-tunnel-certificate \
--vpn-tunnel-outside-ip-address 203.0.113.17 \
--vpn-connection-id vpn-12345678901234567
```
Output:
```
{
"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"
}
]
}
}
```
+ Per i dettagli sull'API, consulta [ModifyVpnTunnelCertificate AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpn-tunnel-certificate.html)*Command Reference*.
### `modify-vpn-tunnel-options`
Il seguente esempio di codice mostra come utilizzare`modify-vpn-tunnel-options`.
**AWS CLI**
**Come modificare le opzioni tunnel per una connessione VPN**
L’esempio `modify-vpn-tunnel-options` seguente aggiorna i gruppi Diffie-Hellman consentiti per il tunnel e la connessione VPN specificati.
```
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}]
```
Output:
```
{
"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"
}
]
}
}
```
+ Per i dettagli sull'API, consulta [ModifyVpnTunnelOptions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/modify-vpn-tunnel-options.html)*Command Reference*.
### `monitor-instances`
Il seguente esempio di codice mostra come utilizzare`monitor-instances`.
**AWS CLI**
**Come abilitare il monitoraggio dettagliato per un’istanza**
Questo comando di esempio abilita il monitoraggio dettagliato per l’istanza specificata.
Comando:
```
aws ec2 monitor-instances --instance-ids i-1234567890abcdef0
```
Output:
```
{
"InstanceMonitorings": [
{
"InstanceId": "i-1234567890abcdef0",
"Monitoring": {
"State": "pending"
}
}
]
}
```
+ Per i dettagli sull'API, consulta [MonitorInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/monitor-instances.html)*Command Reference*.
### `move-address-to-vpc`
Il seguente esempio di codice mostra come utilizzare`move-address-to-vpc`.
**AWS CLI**
**Come spostare un indirizzo su EC2-VPC**
L’esempio seguente sposta l’indirizzo IP elastico 54.123.4.56 nella piattaforma EC2-VPC.
Comando:
```
aws ec2 move-address-to-vpc --public-ip 54.123.4.56
```
Output:
```
{
"Status": "MoveInProgress"
}
```
+ Per i dettagli sull'API, consulta [MoveAddressToVpc AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/move-address-to-vpc.html)*Command Reference*.
### `move-byoip-cidr-to-ipam`
Il seguente esempio di codice mostra come utilizzare`move-byoip-cidr-to-ipam`.
**AWS CLI**
**Come trasferire un CIDR BYOIP in IPAM**
L’esempio `move-byoip-cidr-to-ipam` seguente trasferisce un CIDR BYOIP in 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
```
Output:
```
{
"ByoipCidr": {
"Cidr": "130.137.249.0/24",
"State": "pending-transfer"
}
}
```
Per ulteriori informazioni, consulta [Tutorial: trasferimento di un IPv4 CIDR BYOIP esistente a IPAM nella Amazon *VPC* IPAM](https://docs.aws.amazon.com/vpc/latest/ipam/tutorials-byoip-ipam-transfer-ipv4.html) User Guide.
+ *Per i dettagli sull'API, consulta Command Reference. [MoveByoipCidrToIpam](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/move-byoip-cidr-to-ipam.html)AWS CLI *
### `network-insights-access-scope`
Il seguente esempio di codice mostra come utilizzare`network-insights-access-scope`.
**AWS CLI**
**Come creare gli ambiti di accesso alle informazioni di rete**
L'`create-network-insights-access-scope`esempio seguente crea un ambito di accesso a Network Insights nel tuo AWS account.
```
aws ec2 create-network-insights-access-scope \
--cli-input-json file://access-scope-file.json
```
Contenuto di `access-scope-file.json`:
```
{
{
"MatchPaths": [
{
"Source": {
"ResourceStatement": {
"Resources": [
"vpc-abcd12e3"
]
}
}
}
],
"ExcludePaths": [
{
"Source": {
"ResourceStatement": {
"ResourceTypes": [
"AWS::EC2::InternetGateway"
]
}
}
}
]
}
}
```
Output:
```
{
"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"
]
}
}
}
]
}
}
```
Per ulteriori informazioni, consulta [Guida introduttiva a Network Access Analyzer utilizzando la AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli-naa.html) *nella Guida Network Access* Analyzer.
+ *Per i dettagli sull'API, consulta Command [NetworkInsightsAccessScope](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/network-insights-access-scope.html)Reference AWS CLI .*
### `provision-byoip-cidr`
Il seguente esempio di codice mostra come utilizzare`provision-byoip-cidr`.
**AWS CLI**
**Come effettuare il provisioning di un intervallo di indirizzi**
L'`provision-byoip-cidr`esempio seguente fornisce un intervallo di indirizzi IP pubblici da utilizzare con AWS.
```
aws ec2 provision-byoip-cidr \
--cidr 203.0.113.25/24 \
--cidr-authorization-context Message="$text_message",Signature="$signed_message"
```
Output:
```
{
"ByoipCidr": {
"Cidr": "203.0.113.25/24",
"State": "pending-provision"
}
}
```
Per ulteriori informazioni sulla creazione delle stringhe di messaggi per il contesto di autorizzazione, consulta [Indirizzi BYOIP](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, vedere [ProvisionByoipCidr](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/provision-byoip-cidr.html)in *AWS CLI Command Reference*.
### `provision-ipam-pool-cidr`
Il seguente esempio di codice mostra come utilizzare`provision-ipam-pool-cidr`.
**AWS CLI**
**Come effettuare il provisioning di un CIDR a un pool IPAM**
L’esempio `provision-ipam-pool-cidr` seguente effettua il provisioning di un CIDR a un pool 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
```
Output:
```
{
"IpamPoolCidr": {
"Cidr": "10.0.0.0/24",
"State": "pending-provision"
}
}
```
Per ulteriori informazioni, consulta [Provision CIDRs to a pool](https://docs.aws.amazon.com/vpc/latest/ipam/prov-cidr-ipam.html) nella *Amazon VPC IPAM* User Guide.
+ Per i dettagli sull'API, consulta *AWS CLI Command [ProvisionIpamPoolCidr](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/provision-ipam-pool-cidr.html)Reference*.
### `purchase-host-reservation`
Il seguente esempio di codice mostra come utilizzare`purchase-host-reservation`.
**AWS CLI**
**Come acquistare una prenotazione dell’host dedicato**
Questo esempio acquista l’offerta di prenotazione dell’host dedicato per l’host dedicato specificato nell’account.
Comando:
```
aws ec2 purchase-host-reservation --offering-id hro-03f707bf363b6b324 --host-id-set h-013abcd2a00cbd123
```
Output:
```
{
"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"
}
```
+ Per i dettagli sull'API, consulta [PurchaseHostReservation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/purchase-host-reservation.html)*Command Reference*.
### `purchase-reserved-instances-offering`
Il seguente esempio di codice mostra come utilizzare`purchase-reserved-instances-offering`.
**AWS CLI**
**Come acquistare un’offerta di istanza riservata**
Questo comando di esempio illustra l’acquisto di un’offerta di istanza riservata, specificando l’ID dell’offerta e il numero di istanze.
Comando:
```
aws ec2 purchase-reserved-instances-offering --reserved-instances-offering-id ec06327e-dd07-46ee-9398-75b5fexample --instance-count 3
```
Output:
```
{
"ReservedInstancesId": "af9f760e-6f91-4559-85f7-4980eexample"
}
```
+ Per i dettagli sull'API, consulta [PurchaseReservedInstancesOffering AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/purchase-reserved-instances-offering.html)*Command Reference*.
### `purchase-scheduled-instances`
Il seguente esempio di codice mostra come utilizzare`purchase-scheduled-instances`.
**AWS CLI**
**Come acquistare un’istanza pianificata**
Questo esempio acquista un’istanza pianificata.
Comando:
```
aws ec2 purchase-scheduled-instances --purchase-requests file://purchase-request.json
```
Purchase-request.json:
```
[
{
"PurchaseToken": "eyJ2IjoiMSIsInMiOjEsImMiOi...",
"InstanceCount": 1
}
]
```
Output:
```
{
"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"
}
]
}
```
+ Per i dettagli sull'API, consulta [PurchaseScheduledInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/purchase-scheduled-instances.html)*Command Reference*.
### `reboot-instances`
Il seguente esempio di codice mostra come utilizzare`reboot-instances`.
**AWS CLI**
**Come riavviare un’istanza Amazon EC2**
Questo esempio riavvia l’istanza specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 reboot-instances --instance-ids i-1234567890abcdef5
```
Per ulteriori informazioni, consulta Riavvio dell’istanza nella *Guida per l’utente di Amazon Elastic Compute Cloud*.
+ Per i dettagli sull'API, consulta [RebootInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reboot-instances.html)*Command Reference*.
### `register-image`
Il seguente esempio di codice mostra come utilizzare`register-image`.
**AWS CLI**
**Esempio 1: come registrare un’AMI utilizzando un file manifesto**
L’esempio `register-image` seguente registra un’AMI utilizzando il file manifesto specificato in Amazon S3.
```
aws ec2 register-image \
--name my-image \
--image-location amzn-s3-demo-bucket/myimage/image.manifest.xml
```
Output:
```
{
"ImageId": "ami-1234567890EXAMPLE"
}
```
Per ulteriori informazioni, consulta [Amazon Machine Images (AMI)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come registrare un’AMI utilizzando uno snapshot di un dispositivo root**
L’esempio `register-image` seguente registra un’AMI utilizzando lo snapshot specificato di un volume root EBS come dispositivo `/dev/xvda`. La mappatura dei dispositivi a blocchi include anche un volume EBS vuoto da 100 GiB come 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}
```
Output:
```
{
"ImageId": "ami-1a2b3c4d5eEXAMPLE"
}
```
Per ulteriori informazioni, consulta [Amazon Machine Image (AMI)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [RegisterImage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/register-image.html)*Command Reference*.
### `register-instance-event-notification-attributes`
Il seguente esempio di codice mostra come utilizzare`register-instance-event-notification-attributes`.
**AWS CLI**
**Esempio 1: come includere tutti i tag nelle notifiche di eventi**
L’esempio `register-instance-event-notification-attributes` seguente include tutti i tag nelle notifiche di eventi.
```
aws ec2 register-instance-event-notification-attributes \
--instance-tag-attribute IncludeAllTagsOfInstance=true
```
Output:
```
{
"InstanceTagAttribute": {
"InstanceTagKeys": [],
"IncludeAllTagsOfInstance": true
}
}
```
Per ulteriori informazioni, consulta [Eventi pianificati per le istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come includere tag specifici nelle notifiche di eventi**
L’esempio `register-instance-event-notification-attributes` seguente include i tag specificati nelle notifiche di eventi. Non è possibile specificare tag se `IncludeAllTagsOfInstance` è `true`.
```
aws ec2 register-instance-event-notification-attributes \
--instance-tag-attribute InstanceTagKeys="tag-key1","tag-key2"
```
Output:
```
{
"InstanceTagAttribute": {
"InstanceTagKeys": [
"tag-key1",
"tag-key2"
],
"IncludeAllTagsOfInstance": false
}
}
```
Per ulteriori informazioni, consulta [Eventi pianificati per le istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [RegisterInstanceEventNotificationAttributes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/register-instance-event-notification-attributes.html)*Command Reference*.
### `register-transit-gateway-multicase-group-sources`
Il seguente esempio di codice mostra come utilizzare`register-transit-gateway-multicase-group-sources`.
**AWS CLI**
**Come registrare un’origine con un gruppo multicast (trasmissione uno a molti) del gateway di transito.**
L’esempio `register-transit-gateway-multicast-group-sources` seguente registra l’origine del gruppo di interfacce di rete specificato con un gruppo multicast (trasmissione uno a molti).
```
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
```
Output:
```
{
"RegisteredMulticastGroupSources": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-0c4905cef79d6e597",
"RegisteredNetworkInterfaceIds": [
"eni-07f290fc3c090cbae"
],
"GroupIpAddress": "224.0.1.0"
}
}
```
Per ulteriori informazioni, consulta [Registrare le origini con un gruppo multicast (trasmissione uno a molti)](https://docs.aws.amazon.com/vpc/latest/tgw/working-with-multicast.html#add-source-multicast-group) nella *Guida per l’utente di AWS Transit Gateway*.
+ Per i dettagli sull'API, consulta [RegisterTransitGatewayMulticaseGroupSources AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/register-transit-gateway-multicase-group-sources.html)*Command Reference*.
### `register-transit-gateway-multicast-group-members`
Il seguente esempio di codice mostra come utilizzare`register-transit-gateway-multicast-group-members`.
**AWS CLI**
**Come visualizzare le informazioni sulle associazioni per un dominio multicast (trasmissione uno a molti) del gateway di transito**
L’esempio `register-transit-gateway-multicast-group-members` seguente restituisce le associazioni per il dominio multicast (trasmissione uno a molti) specificato.
```
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
```
Output:
```
{
"RegisteredMulticastGroupMembers": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-0c4905cef79d6e597",
"RegisteredNetworkInterfaceIds": [
"eni-0e246d32695012e81"
],
"GroupIpAddress": "224.0.1.0"
}
}
```
Per ulteriori informazioni, consulta [Domini multicast (trasmissione uno a molti)](https://docs.aws.amazon.com/vpc/latest/tgw/multicast-domains-about.html) nella *Guida per l’utente di Transit Gateway*.
+ Per i dettagli sull'API, consulta [RegisterTransitGatewayMulticastGroupMembers AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/register-transit-gateway-multicast-group-members.html)*Command Reference*.
### `register-transit-gateway-multicast-group-sources`
Il seguente esempio di codice mostra come utilizzare`register-transit-gateway-multicast-group-sources`.
**AWS CLI**
**Come registrare un’origine con un gruppo multicast (trasmissione uno a molti) del gateway di transito.**
L’esempio `register-transit-gateway-multicast-group-sources` seguente registra l’origine del gruppo di interfacce di rete specificato con un gruppo multicast (trasmissione uno a molti).
```
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
```
Output:
```
{
"RegisteredMulticastGroupSources": {
"TransitGatewayMulticastDomainId": "tgw-mcast-domain-0c4905cef79d6e597",
"RegisteredNetworkInterfaceIds": [
"eni-07f290fc3c090cbae"
],
"GroupIpAddress": "224.0.1.0"
}
}
```
Per ulteriori informazioni, consulta [Domini multicast (trasmissione uno a molti)](https://docs.aws.amazon.com/vpc/latest/tgw/multicast-domains-about.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [RegisterTransitGatewayMulticastGroupSources AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/register-transit-gateway-multicast-group-sources.html)*Command Reference*.
### `reject-transit-gateway-peering-attachment`
Il seguente esempio di codice mostra come utilizzare`reject-transit-gateway-peering-attachment`.
**AWS CLI**
**Come rifiutare un collegamento peering del gateway di transito**
L’esempio `reject-transit-gateway-peering-attachment` seguente rifiuta la richiesta di accessorio di peering del gateway di transito specificato. Il parametro `--region` specifica la Regione in cui si trova il gateway di transito accettante.
```
aws ec2 reject-transit-gateway-peering-attachment \
--transit-gateway-attachment-id tgw-attach-4455667788aabbccd \
--region us-east-2
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Accessori di peering del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-peering.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [RejectTransitGatewayPeeringAttachment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reject-transit-gateway-peering-attachment.html)*Command Reference*.
### `reject-transit-gateway-vpc-attachment`
Il seguente esempio di codice mostra come utilizzare`reject-transit-gateway-vpc-attachment`.
**AWS CLI**
**Come rifiutare un collegamento VPC del gateway di transito**
L’esempio `reject-transit-gateway-vpc-attachment` seguente rifiuta il collegamento VPC del gateway di transito specificato.
```
aws ec2 reject-transit-gateway-vpc-attachment \
--transit-gateway-attachment-id tgw-attach-0a34fe6b4fEXAMPLE
```
Output:
```
{
"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"
}
}
}
```
Per ulteriori informazioni, consulta [Collegamenti del gateway di transito alla VPN a un VPC](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [RejectTransitGatewayVpcAttachment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reject-transit-gateway-vpc-attachment.html)*Command Reference*.
### `reject-transit-gateway-vpc-attachments`
Il seguente esempio di codice mostra come utilizzare`reject-transit-gateway-vpc-attachments`.
**AWS CLI**
**Come rifiutare un collegamento VPC del gateway di transito**
L’esempio `reject-transit-gateway-vpc-attachment` seguente rifiuta il collegamento VPC del gateway di transito specificato.
```
aws ec2 reject-transit-gateway-vpc-attachment \
--transit-gateway-attachment-id tgw-attach-0a34fe6b4fEXAMPLE
```
Output:
```
{
"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"
}
}
}
```
Per ulteriori informazioni, consulta [Collegamenti del gateway di transito alla VPN a un VPC](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [RejectTransitGatewayVpcAttachments AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reject-transit-gateway-vpc-attachments.html)*Command Reference*.
### `reject-vpc-endpoint-connections`
Il seguente esempio di codice mostra come utilizzare`reject-vpc-endpoint-connections`.
**AWS CLI**
**Come rifiutare le richieste di connessione endpoint dell’interfaccia**
Questo esempio rifiuta la richiesta di connessione endpoint specificata per il servizio endpoint specificato.
Comando:
```
aws ec2 reject-vpc-endpoint-connections --service-id vpce-svc-03d5ebb7d9579a2b3 --vpc-endpoint-ids vpce-0c1308d7312217abc
```
Output:
```
{
"Unsuccessful": []
}
```
+ Per i dettagli sull'API, consulta [RejectVpcEndpointConnections AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reject-vpc-endpoint-connections.html)*Command Reference*.
### `reject-vpc-peering-connection`
Il seguente esempio di codice mostra come utilizzare`reject-vpc-peering-connection`.
**AWS CLI**
**Come rifiutare una connessione peering VPC**
Questo esempio rifiuta la richiesta di connessione peering VPC specificata.
Comando:
```
aws ec2 reject-vpc-peering-connection --vpc-peering-connection-id pcx-1a2b3c4d
```
Output:
```
{
"Return": true
}
```
+ Per i dettagli sull'API, consulta [RejectVpcPeeringConnection AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reject-vpc-peering-connection.html)*Command Reference*.
### `release-address`
Il seguente esempio di codice mostra come utilizzare`release-address`.
**AWS CLI**
**Come rilasciare un indirizzo IP elastico per EC2-Classic**
Nell’esempio seguente viene rilasciato un indirizzo IP elastico per l’utilizzo con le istanze in EC2-Classic. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 release-address --public-ip 198.51.100.0
```
**Come rilasciare un indirizzo IP elastico per EC2-VPC**
Nell’esempio seguente viene rilasciato un indirizzo IP elastico per l’utilizzo con le istanze in un VPC. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 release-address --allocation-id eipalloc-64d5890a
```
+ Per i dettagli sull'API, consulta [ReleaseAddress AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/release-address.html)*Command Reference*.
### `release-hosts`
Il seguente esempio di codice mostra come utilizzare`release-hosts`.
**AWS CLI**
**Come rilasciare un host dedicato dall’account**
Come rilasciare un host dedicato dall’account. Le istanze presenti sull’host devono essere arrestate o terminate prima che l’host possa essere rilasciato.
Comando:
```
aws ec2 release-hosts --host-id=h-0029d6e3cacf1b3da
```
Output:
```
{
"Successful": [
"h-0029d6e3cacf1b3da"
],
"Unsuccessful": []
}
```
+ Per i dettagli sull'API, consulta [ReleaseHosts AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/release-hosts.html)*Command Reference*.
### `release-ipam-pool-allocation`
Il seguente esempio di codice mostra come utilizzare`release-ipam-pool-allocation`.
**AWS CLI**
**Come rilasciare un’allocazione del pool IPAM**
In questo esempio, l’utente è un amministratore delegato IPAM che ha cercato di eliminare un pool IPAM, ma ha ricevuto un errore che indica che non è possibile eliminare il pool mentre il pool contiene allocazioni. Questo comando viene utilizzato per rilasciare un’allocazione del pool.
Tenere presente quanto segue:
È possibile utilizzare questo comando solo per le allocazioni personalizzate. Per rimuovere un'allocazione per una risorsa senza eliminarla, impostane lo stato monitorato su false utilizzando [modify-ipam-resource-cidr](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-ipam-resource-cidr.html).Per completare questa richiesta, avrai bisogno dell'ID del pool IPAM, che puoi utilizzare. [describe-ipam-pools](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-ipam-pools.html) È inoltre necessario l'ID di allocazione, che è possibile ottenere con [get-ipam-pool-allocations](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-ipam-pool-allocations.html). Se non si desidera rimuovere le allocazioni una per una, è possibile utilizzare `--cascade option` quando si elimina un pool IPAM per rilasciare automaticamente tutte le allocazioni nel pool prima di eliminarlo. Esistono diversi prerequisiti prima di eseguire questo comando. Per ulteriori informazioni, consulta [Rilasciare un’assegnazione](https://docs.aws.amazon.com/vpc/latest/ipam/release-alloc-ipam.html) nella *Guida per l’utente IPAM di Amazon VPC*. La `--region` in cui si esegue questo comando deve essere la l’impostazione locale del pool IPAM in cui si trova l’allocazione.
L’esempio `release-ipam-pool-allocation` seguente rilascia un’allocazione del 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
```
Output:
```
{
"Success": true
}
```
Dopo aver rilasciato un'allocazione, potresti voler eseguirla. [delete-ipam-pool](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-ipam-pool.html)
+ Per i dettagli sull'API, consulta [ReleaseIpamPoolAllocation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/release-ipam-pool-allocation.html)*Command Reference.*
### `replace-iam-instance-profile-association`
Il seguente esempio di codice mostra come utilizzare`replace-iam-instance-profile-association`.
**AWS CLI**
**Come sostituire un profilo dell’istanza IAM per un’istanza**
In questo esempio il profilo dell’istanza IAM rappresentato dall’associazione `iip-assoc-060bae234aac2e7fa` viene sostituito con il profilo dell’istanza IAM denominato `AdminRole`.
```
aws ec2 replace-iam-instance-profile-association \
--iam-instance-profile Name=AdminRole \
--association-id iip-assoc-060bae234aac2e7fa
```
Output:
```
{
"IamInstanceProfileAssociation": {
"InstanceId": "i-087711ddaf98f9489",
"State": "associating",
"AssociationId": "iip-assoc-0b215292fab192820",
"IamInstanceProfile": {
"Id": "AIPAJLNLDX3AMYZNWYYAY",
"Arn": "arn:aws:iam::123456789012:instance-profile/AdminRole"
}
}
}
```
+ Per i dettagli sull'API, consulta [ReplaceIamInstanceProfileAssociation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/replace-iam-instance-profile-association.html)*Command Reference*.
### `replace-network-acl-association`
Il seguente esempio di codice mostra come utilizzare`replace-network-acl-association`.
**AWS CLI**
**Come sostituire la lista di controllo degli accessi alla rete (ACL) associata a una sottorete**
Questo esempio associa la lista di controllo degli accessi alla rete (ACL) specificata alla sottorete dell’associazione lista di controllo degli accessi alla rete (ACL) specificata.
Comando:
```
aws ec2 replace-network-acl-association --association-id aclassoc-e5b95c8c --network-acl-id acl-5fb85d36
```
Output:
```
{
"NewAssociationId": "aclassoc-3999875b"
}
```
+ Per i dettagli sull'API, consulta [ReplaceNetworkAclAssociation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/replace-network-acl-association.html)*Command Reference*.
### `replace-network-acl-entry`
Il seguente esempio di codice mostra come utilizzare`replace-network-acl-entry`.
**AWS CLI**
**Come sostituire una voce della lista di controllo degli accessi alla rete (ACL)**
Questo esempio sostituisce una voce per la lista di controllo degli accessi alla rete (ACL) specificata. La nuova regola 100 consente il traffico in entrata da 203.0.113.12/24 sulla porta UDP 53 (DNS) in qualsiasi sottorete associata.
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
```
+ Per i dettagli sull'API, consulta [ReplaceNetworkAclEntry AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/replace-network-acl-entry.html)*Command Reference*.
### `replace-route-table-association`
Il seguente esempio di codice mostra come utilizzare`replace-route-table-association`.
**AWS CLI**
**Come sostituire una tabella di routing associata a una sottorete**
Questo esempio associa la tabella di routing specificata alla sottorete per l’associazione di tabelle di routing specificata.
Comando:
```
aws ec2 replace-route-table-association --association-id rtbassoc-781d0d1a --route-table-id rtb-22574640
```
Output:
```
{
"NewAssociationId": "rtbassoc-3a1f0f58"
}
```
+ Per i dettagli sull'API, consulta [ReplaceRouteTableAssociation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/replace-route-table-association.html)*Command Reference*.
### `replace-route`
Il seguente esempio di codice mostra come utilizzare`replace-route`.
**AWS CLI**
**Come sostituire una route**
Questo esempio sostituisce la route specificata per la tabella di routing specificata. La nuova route corrisponde al CIDR specificato e invia il traffico al gateway privato virtuale specificato. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 replace-route --route-table-id rtb-22574640 --destination-cidr-block 10.0.0.0/16 --gateway-id vgw-9a4cacf3
```
+ Per i dettagli sull'API, consulta [ReplaceRoute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/replace-route.html)*Command Reference*.
### `replace-transit-gateway-route`
Il seguente esempio di codice mostra come utilizzare`replace-transit-gateway-route`.
**AWS CLI**
**Come sostituire la route specificata nella tabella di routing del gateway di transito specificata**
L’esempio `replace-transit-gateway-route` seguente sostituisce la route nella tabella di routing del gateway di transito specificata.
```
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
```
Output:
```
{
"Route": {
"DestinationCidrBlock": "10.0.2.0/24",
"TransitGatewayAttachments": [
{
"ResourceId": "vpc-4EXAMPLE",
"TransitGatewayAttachmentId": "tgw-attach-09b52ccdb5EXAMPLE",
"ResourceType": "vpc"
}
],
"Type": "static",
"State": "active"
}
}
```
Per ulteriori informazioni, consulta [Tabelle di routing del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [ReplaceTransitGatewayRoute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/replace-transit-gateway-route.html)*Command Reference*.
### `report-instance-status`
Il seguente esempio di codice mostra come utilizzare`report-instance-status`.
**AWS CLI**
**Come segnalare il feedback sullo stato di un’istanza**
Questo comando di esempio restituisce il feedback sullo stato per l’istanza specificata.
Comando:
```
aws ec2 report-instance-status --instances i-1234567890abcdef0 --status impaired --reason-codes unresponsive
```
+ Per i dettagli sull'API, consulta [ReportInstanceStatus AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/report-instance-status.html)*Command Reference*.
### `request-spot-fleet`
Il seguente esempio di codice mostra come utilizzare`request-spot-fleet`.
**AWS CLI**
**Come richiedere un parco istanze spot nella sottorete al prezzo più basso**
Questo comando di esempio crea una richiesta di parco istanze spot con due specifiche di avvio che differiscono solo a livello di sottorete. Il parco istanze spot avvia le istanze nella sottorete specificata con il prezzo più basso. Se le istanze vengono avviate in un VPC predefinito, esse ricevono un indirizzo IP pubblico per impostazione predefinita. Se le istanze vengono avviate in un VPC non predefinito, non ricevono un indirizzo IP pubblico per impostazione predefinita.
Nota che in una richiesta di parco istanze spot non è possibile specificare sottoreti diverse nella stessa zona di disponibilità.
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"
}
}
]
}
```
Output:
```
{
"SpotFleetRequestId": "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE"
}
```
**Come richiedere un parco istanze spot nella zona di disponibilità al prezzo più basso**
Questo comando di esempio crea una richiesta di parco istanze spot con due specifiche di avvio che differiscono solo a livello di zona di disponibilità. Il parco istanze spot avvia le istanze nella zona di disponibilità specificata con il prezzo più basso. Se l’account in uso supporta esclusivamente EC2-VPC, Amazon EC2 avvia le istanze spot nella sottorete predefinita della zona di disponibilità. Se l’account in uso supporta EC2-Classic, Amazon EC2 avvia le istanze in EC2-Classic nella zona di disponibilità.
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"
}
}
]
}
```
**Come avviare istanze spot in una sottorete e assegnare loro indirizzi IP pubblici**
Questo comando di esempio assegna indirizzi pubblici alle istanze avviate in un VPC non predefinito. Nota che quando si specifica un’interfaccia di rete, bisogna includere l’ID della sottorete e l’ID del gruppo di sicurezza utilizzando l’interfaccia di rete.
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"
}
}
]
}
```
**Come richiedere un parco istanze spot utilizzando la strategia di allocazione diversificata**
Questo comando di esempio crea una richiesta di parco istanze spot che avvia 30 istanze utilizzando la strategia di allocazione diversificata. Le specifiche di avvio differiscono in base al tipo di istanza. Il parco istanze spot distribuisce le istanze tra le specifiche di avvio, in modo che ci siano 10 istanze di ogni 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"
}
]
}
```
Per ulteriori informazioni, consulta Richieste di parchi istanze spot nella *Guida per l’utente di Amazon Elastic Compute Cloud*.
+ Per i dettagli sull'API, consulta [RequestSpotFleet AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/request-spot-fleet.html)*Command Reference*.
### `request-spot-instances`
Il seguente esempio di codice mostra come utilizzare`request-spot-instances`.
**AWS CLI**
**Come richiedere istanze spot**
Questo comando di esempio crea una richiesta una tantum di istanze spot per cinque istanze nella zona di disponibilità specificata. Se l’account in uso supporta esclusivamente EC2-VPC, Amazon EC2 avvia le istanze spot nella sottorete predefinita della zona di disponibilità specificata. Se l’account in uso supporta EC2-Classic, Amazon EC2 avvia le istanze in EC2-Classic nella zona di disponibilità specificata.
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"
}
}
```
Output:
```
{
"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"
},
...
]
}
```
Questo comando di esempio crea una richiesta una tantum di istanze spot per cinque istanze nella sottorete specificata. Amazon EC2 avvia le istanze nella sottorete specificata. Se il VPC corrente non è un VPC predefinito, le istanze non ricevono un indirizzo IP pubblico per impostazione predefinita.
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"
}
}
```
Output:
```
{
"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"
},
...
]
}
```
Questo esempio assegna un indirizzo IP pubblico alle istanze spot avviate in un VPC non predefinito. Nota che quando si specifica un’interfaccia di rete, bisogna includere l’ID della sottorete e l’ID del gruppo di sicurezza utilizzando l’interfaccia di rete.
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"
}
}
```
+ Per i dettagli sull'API, consulta [RequestSpotInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/request-spot-instances.html)*Command Reference*.
### `reset-address-attribute`
Il seguente esempio di codice mostra come utilizzare`reset-address-attribute`.
**AWS CLI**
**Come ripristinare l’attributo del nome di dominio associato a un indirizzo IP elastico**
Gli esempi `reset-address-attribute` seguenti ripristinano l’attributo del nome di dominio di un indirizzo IP elastico.
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
```
Output:
```
{
"Addresses": [
{
"PublicIp": "192.0.2.0",
"AllocationId": "eipalloc-abcdef01234567890",
"PtrRecord": "example.com."
"PtrRecordUpdate": {
"Value": "example.net.",
"Status": "PENDING"
}
]
}
```
Per monitorare la modifica in sospeso, consulta [describe-addresses-attribute](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-addresses-attribute.html)il riferimento ai *AWS comandi CLI*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [ResetAddressAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reset-address-attribute.html)Reference*.
### `reset-ebs-default-kms-key-id`
Il seguente esempio di codice mostra come utilizzare`reset-ebs-default-kms-key-id`.
**AWS CLI**
**Come reimpostare la chiave gestita dal cliente (CMK) predefinita per la crittografia EBS**
L'`reset-ebs-default-kms-key-id`esempio seguente reimposta la crittografia CMK predefinita per EBS per il tuo AWS account nella regione corrente.
```
aws ec2 reset-ebs-default-kms-key-id
```
Output:
```
{
"KmsKeyId": "arn:aws:kms:us-west-2:123456789012:key/8c5b2c63-b9bc-45a3-a87a-5513eEXAMPLE"
}
```
+ *Per i dettagli sull'API, consulta Command [ResetEbsDefaultKmsKeyId](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reset-ebs-default-kms-key-id.html)Reference AWS CLI .*
### `reset-fpga-image-attribute`
Il seguente esempio di codice mostra come utilizzare`reset-fpga-image-attribute`.
**AWS CLI**
**Come reimpostare gli attributi di un’immagine FPGA di Amazon (AFI)**
Questo esempio ripristina le autorizzazioni di caricamento per l’AFI specificato.
Comando:
```
aws ec2 reset-fpga-image-attribute --fpga-image-id afi-0d123e123bfc85abc --attribute loadPermission
```
Output:
```
{
"Return": true
}
```
+ Per i dettagli sull'API, consulta [ResetFpgaImageAttribute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reset-fpga-image-attribute.html)*Command Reference*.
### `reset-image-attribute`
Il seguente esempio di codice mostra come utilizzare`reset-image-attribute`.
**AWS CLI**
**Come reimpostare l’attributo launchPermission**
Questo esempio ripristina il valore predefinito dell’attributo `launchPermission` per l’AMI specificata. Per impostazione predefinita, AMIs sono private. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 reset-image-attribute --image-id ami-5731123e --attribute launchPermission
```
+ Per i dettagli sull'API, consulta [ResetImageAttribute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reset-image-attribute.html)*Command Reference*.
### `reset-instance-attribute`
Il seguente esempio di codice mostra come utilizzare`reset-instance-attribute`.
**AWS CLI**
**Per reimpostare l' sourceDestCheck attributo**
Questo esempio ripristina l’attributo `sourceDestCheck` dell’istanza specificata. L’istanza deve trovarsi in un VPC. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 reset-instance-attribute --instance-id i-1234567890abcdef0 --attribute sourceDestCheck
```
**Come reimpostare l’attributo kernel**
Questo esempio ripristina l’attributo `kernel` dell’istanza specificata. L’istanza deve essere nello stato `stopped`. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 reset-instance-attribute --instance-id i-1234567890abcdef0 --attribute kernel
```
**Come reimpostare l’attributo ramdisk**
Questo esempio ripristina l’attributo `ramdisk` dell’istanza specificata. L’istanza deve essere nello stato `stopped`. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 reset-instance-attribute --instance-id i-1234567890abcdef0 --attribute ramdisk
```
+ Per i dettagli sull'API, consulta [ResetInstanceAttribute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reset-instance-attribute.html)*Command Reference*.
### `reset-network-interface-attribute`
Il seguente esempio di codice mostra come utilizzare`reset-network-interface-attribute`.
**AWS CLI**
**Come reimpostare un attributo dell’interfaccia di rete**
L'`reset-network-interface-attribute`esempio seguente reimposta il valore dell'attributo source/destination `true` checking su.
```
aws ec2 reset-network-interface-attribute \
--network-interface-id eni-686ea200 \
--source-dest-check
```
Questo comando non produce alcun output.
+ Per i dettagli sull'API, vedere [ResetNetworkInterfaceAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reset-network-interface-attribute.html)in *AWS CLI Command Reference.*
### `reset-snapshot-attribute`
Il seguente esempio di codice mostra come utilizzare`reset-snapshot-attribute`.
**AWS CLI**
**Come reimpostare un attributo dello snapshot**
Questo esempio ripristina le autorizzazioni di creazione del volume per lo snapshot `snap-1234567890abcdef0`. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 reset-snapshot-attribute --snapshot-id snap-1234567890abcdef0 --attribute createVolumePermission
```
+ Per i dettagli sull'API, consulta [ResetSnapshotAttribute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/reset-snapshot-attribute.html)*Command Reference*.
### `restore-address-to-classic`
Il seguente esempio di codice mostra come utilizzare`restore-address-to-classic`.
**AWS CLI**
**Come ripristinare un indirizzo su EC2-Classic**
Questo esempio ripristina l’indirizzo IP elastico 198.51.100.0 sulla piattaforma EC2-VPC.
Comando:
```
aws ec2 restore-address-to-classic --public-ip 198.51.100.0
```
Output:
```
{
"Status": "MoveInProgress",
"PublicIp": "198.51.100.0"
}
```
+ Per i dettagli sull'API, consulta [RestoreAddressToClassic AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/restore-address-to-classic.html)*Command Reference*.
### `restore-image-from-recycle-bin`
Il seguente esempio di codice mostra come utilizzare`restore-image-from-recycle-bin`.
**AWS CLI**
**Come ripristinare un’immagine dal Cestino**
Il comando `restore-image-from-recycle-bin` seguente ripristina l’AMI ami-0111222333444abcd dal Cestino.
```
aws ec2 restore-image-from-recycle-bin \
--image-id ami-0111222333444abcd
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni, consulta [Recover deleted AMIs from the Recycle Bin](https://docs.aws.amazon.com/ebs/latest/userguide/recycle-bin-working-with-amis.html) nella *Amazon EBS User* Guide.
+ Per i dettagli sull'API, consulta *AWS CLI Command [RestoreImageFromRecycleBin](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/restore-image-from-recycle-bin.html)Reference*.
### `restore-managed-prefix-list-version`
Il seguente esempio di codice mostra come utilizzare`restore-managed-prefix-list-version`.
**AWS CLI**
US-west-2\$1\$1 Per ripristinare una versione dell’elenco di prefissi\$1\$1
Il comando `restore-managed-prefix-list-version` seguente ripristina le voci della versione 1 dell’elenco di prefissi specificato.
```
aws ec2 restore-managed-prefix-list-version \
--prefix-list-id pl-0123456abcabcabc1 \
--current-version 2 \
--previous-version 1
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Elenchi di prefissi gestiti](https://docs.aws.amazon.com/vpc/latest/userguide/managed-prefix-lists.html) nella *Guida per l’utente di Amazon VPC*.
+ Per i dettagli sull'API, consulta [RestoreManagedPrefixListVersion AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/restore-managed-prefix-list-version.html)*Command Reference*.
### `restore-snapshot-from-recycle-bin`
Il seguente esempio di codice mostra come utilizzare`restore-snapshot-from-recycle-bin`.
**AWS CLI**
**Come ripristinare gli snapshot dal Cestino**
Il comando `restore-snapshot-from-recycle-bin` seguente ripristina uno snapshot dal Cestino. Quando si ripristina uno snapshot dal Cestino di riciclaggio, lo snapshot diventa immediatamente disponibile per l’uso e viene rimosso dal Cestino. Dopo averlo ripristinato, potrà essere utilizzato nello stesso modo in cui qualsiasi altro snapshot viene utilizzato nel proprio account.
```
aws ec2 restore-snapshot-from-recycle-bin \
--snapshot-id snap-01234567890abcdef
```
Questo comando non produce alcun output.
Per ulteriori informazioni sul Cestino, consulta [Ripristino degli snapshot dal Cestino](https://docs.aws.amazon.com/ebs/latest/userguide/recycle-bin-working-with-snaps.html) nella *Guida per l’utente di Amazon EBS*.
+ Per i dettagli sull'API, consulta [RestoreSnapshotFromRecycleBin AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/restore-snapshot-from-recycle-bin.html)*Command Reference*.
### `restore-snapshot-tier`
Il seguente esempio di codice mostra come utilizzare`restore-snapshot-tier`.
**AWS CLI**
**Esempio 1: come ripristinare definitivamente uno snapshot archiviato**
Il comando `restore-snapshot-tier` seguente ripristina definitivamente lo snapshot specificato. Specifica `--snapshot-id` e includi l’opzione `permanent-restore`.
```
aws ec2 restore-snapshot-tier \
--snapshot-id snap-01234567890abcedf \
--permanent-restore
```
Output:
```
{
"SnapshotId": "snap-01234567890abcedf",
"IsPermanentRestore": true
}
```
Per ulteriori informazioni sull’archiviazione degli snapshot, consulta [Archiviazione degli snapshot Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/snapshot-archive.html) nella *Guida per l’utente di Amazon EBS*.
**Esempio 2: come ripristinare temporaneamente uno snapshot archiviato**
L’esempio `restore-snapshot-tier` seguente ripristina temporaneamente lo snapshot specificato. Omettere l’opzione `--permanent-restore`. Specifica `--snapshot-id` e, per `temporary-restore-days`, specifica il numero di giorni durante i quali ripristinare lo snapshot. `temporary-restore-days` deve essere specificato in giorni. L’intervallo consentito è `1` - `180`. Se non si specifica un valore, sarà impostato su `1` giorno.
```
aws ec2 restore-snapshot-tier \
--snapshot-id snap-01234567890abcedf \
--temporary-restore-days 5
```
Output:
```
{
"SnapshotId": "snap-01234567890abcedf",
"RestoreDuration": 5,
"IsPermanentRestore": false
}
```
Per ulteriori informazioni sull’archiviazione degli snapshot, consulta [Archiviazione degli snapshot Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/snapshot-archive.html) nella *Guida per l’utente di Amazon EBS*.
**Esempio 3: come modificare il periodo di ripristino**
L’esempio `restore-snapshot-tier` seguente modifica il periodo di ripristino per lo snapshot specificato su `10` giorni.
```
aws ec2 restore-snapshot-tier \
--snapshot-id snap-01234567890abcedf
--temporary-restore-days 10
```
Output:
```
{
"SnapshotId": "snap-01234567890abcedf",
"RestoreDuration": 10,
"IsPermanentRestore": false
}
```
Per ulteriori informazioni sull’archiviazione degli snapshot, consulta [Archiviazione degli snapshot Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/snapshot-archive.html) nella *Guida per l’utente di Amazon EBS*.
**Esempio 4: come modificare il tipo di ripristino**
Il comando `restore-snapshot-tier` seguente modifica il tipo di ripristino per lo snapshot specificato da temporaneo a permanente.
```
aws ec2 restore-snapshot-tier \
--snapshot-id snap-01234567890abcedf
--permanent-restore
```
Output:
```
{
"SnapshotId": "snap-01234567890abcedf",
"IsPermanentRestore": true
}
```
Per ulteriori informazioni sull’archiviazione degli snapshot, consulta [Archiviazione degli snapshot Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/snapshot-archive.html) nella *Guida per l’utente di Amazon EBS*.
+ Per i dettagli sull'API, consulta [RestoreSnapshotTier AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/restore-snapshot-tier.html)*Command Reference*.
### `revoke-client-vpn-ingress`
Il seguente esempio di codice mostra come utilizzare`revoke-client-vpn-ingress`.
**AWS CLI**
**Come revocare una regola di autorizzazione per un endpoint VPN Client**
L’esempio `revoke-client-vpn-ingress` seguente revoca una regola per l’accesso a Internet (`0.0.0.0/0`) per tutti i gruppi.
```
aws ec2 revoke-client-vpn-ingress \
--client-vpn-endpoint-id cvpn-endpoint-123456789123abcde \
--target-network-cidr 0.0.0.0/0 --revoke-all-groups
```
Output:
```
{
"Status": {
"Code": "revoking"
}
}
```
Per ulteriori informazioni, consulta [Regole di autorizzazione](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-rules.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [RevokeClientVpnIngress AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/revoke-client-vpn-ingress.html)*Command Reference*.
### `revoke-security-group-egress`
Il seguente esempio di codice mostra come utilizzare`revoke-security-group-egress`.
**AWS CLI**
**Esempio 1: come rimuovere la regola che consente il traffico in uscita verso un intervallo di indirizzi specifico**
L’esempio `revoke-security-group-egress` seguente rimuove la regola che concede l’accesso agli intervalli di indirizzi specificati sulla 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}]
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Gruppi di sicurezza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come rimuovere una regola che consente il traffico in uscita verso un gruppo di sicurezza specifico**
L’esempio `revoke-security-group-egress` seguente rimuove la regola che concede l’accesso al gruppo di sicurezza specificato sulla 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"}]}]'
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Gruppi di sicurezza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [RevokeSecurityGroupEgress AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/revoke-security-group-egress.html)*Command Reference*.
### `revoke-security-group-ingress`
Il seguente esempio di codice mostra come utilizzare`revoke-security-group-ingress`.
**AWS CLI**
**Esempio 1: come rimuovere una regola da un gruppo di sicurezza**
L’esempio `revoke-security-group-ingress` seguente rimuove l’accesso alla porta TCP 22 per l’intervallo di indirizzi `203.0.113.0/24` dal gruppo di sicurezza specificato per un VPC predefinito.
```
aws ec2 revoke-security-group-ingress \
--group-name mySecurityGroup
--protocol tcp \
--port 22 \
--cidr 203.0.113.0/24
```
Questo comando non produce alcun output se ha esito positivo.
Per ulteriori informazioni, consulta [Gruppi di sicurezza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come rimuovere una regola utilizzando il set di autorizzazioni IP**
L’esempio `revoke-security-group-ingress` seguente utilizza il parametro `ip-permissions` per aggiungere una regola in entrata che consenta il messaggio ICMP `Destination Unreachable: Fragmentation Needed and Don't Fragment was Set` (tipo 3, codice 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}]
```
Questo comando non produce alcun output se ha esito positivo.
Per ulteriori informazioni, consulta [Gruppi di sicurezza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [RevokeSecurityGroupIngress AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/revoke-security-group-ingress.html)*Command Reference*.
### `run-instances`
Il seguente esempio di codice mostra come utilizzare`run-instances`.
**AWS CLI**
**Esempio 1: come avviare un’istanza in una sottorete predefinita**
Nell’esempio di `run-instances` seguente viene avviata una singola istanza di tipo `t2.micro` nella sottorete predefinita per la regione attuale e viene associata alla sottorete predefinita per il VPC predefinito per la regione. La coppia di chiavi è opzionale se non si desidera collegare l’istanza tramite SSH (Linux) o RDP (Windows).
```
aws ec2 run-instances \
--image-id ami-0abcdef1234567890 \
--instance-type t2.micro \
--key-name MyKeyPair
```
Output:
```
{
"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"
}
```
**Esempio 2: come avviare un’istanza in una sottorete non predefinita e aggiungere un indirizzo IP pubblico**
Nell’esempio di `run-instances` seguente viene richiesto un indirizzo IP pubblico per un’istanza avviata in una sottorete non predefinita. L’istanza è associata al gruppo di sicurezza specificato.
```
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
```
Per un esempio dell’output di `run-instances`, consulta l’Esempio 1.
**Esempio 3: come avviare un’istanza con volumi aggiuntivi**
Nell’esempio di `run-instances` seguente viene utilizzata una mappatura dei dispositivi a blocchi, specificata in mapping.json, per collegare volumi aggiuntivi al momento del lancio. Una mappatura dei dispositivi a blocchi può specificare volumi EBS, oppure sia volumi EBS e volumi di archivio dell’istanza.
```
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
```
Contenuto di `mapping.json`. In questo esempio viene aggiunto `/dev/sdh`, un volume EBS vuoto della dimensione di 100 GiB.
```
[
{
"DeviceName": "/dev/sdh",
"Ebs": {
"VolumeSize": 100
}
}
]
```
Contenuto di `mapping.json`. In questo esempio viene aggiunto `ephemeral1`, un volume di archivio dell’istanza.
```
[
{
"DeviceName": "/dev/sdc",
"VirtualName": "ephemeral1"
}
]
```
Per un esempio dell’output di `run-instances`, consulta l’Esempio 1.
Per ulteriori informazioni sulle mappature dei dispositivi a blocchi, consulta [Mappatura dei dispositivi a blocchi](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 4: come avviare un’istanza e aggiungere tag al momento della creazione**
Nell’esempio di `run-instances` seguente viene aggiunto un tag con una chiave `webserver` e un valore `production` all’istanza. Il comando avvia applica inoltre un tag con una chiave `cost-center` e un valore `cc123` a qualsiasi volume EBS creato, in questo caso il volume root.
```
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}]'
```
Per un esempio dell’output di `run-instances`, consulta l’Esempio 1.
**Esempio 5: come avviare un’istanza con dati utente**
Nell’esempio di `run-instances` seguente i dati utente vengono trasferiti in un file denominato `my_script.txt` che contiene uno script di configurazione per l’istanza. Lo script viene eseguito al momento dell’avvio.
```
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
```
Per un esempio dell’output di `run-instances`, consulta l’Esempio 1.
Per ulteriori informazioni sui dati utente dell’istanza, consulta [Utilizzo dei dati utente dell’istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-add-user-data.html) nella *Guida per l’utente di Amazon EC2*.
**Esempio 6: come avviare un’istanza a prestazioni espandibili**
Nell’esempio di `run-instances` seguente viene avviata un’istanza t2.micro con l’opzione di credito `unlimited`. All’avvio di un’istanza T2, se non si specifica `--credit-specification`, l’opzione di credito predefinita `standard`. All’avvio di un’istanza T3, l’opzione di credito predefinita è `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
```
Per un esempio dell’output di `run-instances`, vedi l’Esempio 1.
Per ulteriori informazioni sulle istanze a prestazioni espandibili, consulta [Istanze a prestazioni espandibili](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, consulta [RunInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/run-instances.html)*Command Reference*.
### `run-scheduled-instances`
Il seguente esempio di codice mostra come utilizzare`run-scheduled-instances`.
**AWS CLI**
**Come avviare un’istanza pianificata**
Questo esempio avvia l’istanza pianificata specificata in un 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"
}
}
```
Output:
```
{
"InstanceIdSet": [
"i-1234567890abcdef0"
]
}
```
Questo esempio avvia l’istanza pianificata specificata in 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"
}
}
```
Output:
```
{
"InstanceIdSet": [
"i-1234567890abcdef0"
]
}
```
+ Per i dettagli sull'API, consulta [RunScheduledInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/run-scheduled-instances.html)*Command Reference*.
### `search-local-gateway-routes`
Il seguente esempio di codice mostra come utilizzare`search-local-gateway-routes`.
**AWS CLI**
**Come ricercare le route in una tabella di routing del gateway locale**
L’esempio `search-local-gateway-routes` seguente ricerca route statiche nella tabella di routing specificata per il gateway locale.
```
aws ec2 search-local-gateway-routes \
--local-gateway-route-table-id lgw-rtb-059615ef7dEXAMPLE \
--filters "Name=type,Values=static"
```
Output:
```
{
"Route": {
"DestinationCidrBlock": "0.0.0.0/0",
"LocalGatewayVirtualInterfaceGroupId": "lgw-vif-grp-07145b276bEXAMPLE",
"Type": "static",
"State": "deleted",
"LocalGatewayRouteTableId": "lgw-rtb-059615ef7EXAMPLE"
}
}
```
+ Per i dettagli sull'API, consulta [SearchLocalGatewayRoutes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/search-local-gateway-routes.html)*Command Reference*.
### `search-transit-gateway-multicast-groups`
Il seguente esempio di codice mostra come utilizzare`search-transit-gateway-multicast-groups`.
**AWS CLI**
**Come cercare uno o più gruppi multicast (trasmissione uno a molti) di gateway di transito e restituire le informazioni sull’appartenenza al gruppo**
L’esempio `search-transit-gateway-multicast-groups` seguente restituisce l’appartenenza al gruppo del gruppo multicast (trasmissione uno a molti) specificato.
```
aws ec2 search-transit-gateway-multicast-groups \
--transit-gateway-multicast-domain-id tgw-mcast-domain-000fb24d04EXAMPLE
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Multicast (trasmissione uno a molti) sui gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-multicast-overview.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [SearchTransitGatewayMulticastGroups AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/search-transit-gateway-multicast-groups.html)*Command Reference*.
### `search-transit-gateway-routes`
Il seguente esempio di codice mostra come utilizzare`search-transit-gateway-routes`.
**AWS CLI**
**Come ricercare le route nella tabella di routing specificata del gateway di transito**
L’esempio `search-transit-gateway-routes` seguente restituisce tutte le route che sono di tipo `static` nella tabella di routing specificata.
```
aws ec2 search-transit-gateway-routes \
--transit-gateway-route-table-id tgw-rtb-0a823edbdeEXAMPLE \
--filters "Name=type,Values=static"
```
Output:
```
{
"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
}
```
Per ulteriori informazioni, consulta [Tabelle di routing del gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html) nella *Guida di Transit Gateway*.
+ Per i dettagli sull'API, consulta [SearchTransitGatewayRoutes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/search-transit-gateway-routes.html)*Command Reference*.
### `send-diagnostic-interrupt`
Il seguente esempio di codice mostra come utilizzare`send-diagnostic-interrupt`.
**AWS CLI**
**Come inviare un’interruzione della diagnostica**
L’esempio `send-diagnostic-interrupt` seguente invia un’interruzione della diagnostica all’istanza specificata.
```
aws ec2 send-diagnostic-interrupt \
--instance-id i-1234567890abcdef0
```
Questo comando non produce alcun output.
+ Per i dettagli sull'API, consulta [SendDiagnosticInterrupt AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/send-diagnostic-interrupt.html)*Command Reference*.
### `start-instances`
Il seguente esempio di codice mostra come utilizzare`start-instances`.
**AWS CLI**
**Come avviare un’istanza Amazon EC2**
In questo esempio viene avviata l’istanza supportata da Amazon EBS specificata.
Comando:
```
aws ec2 start-instances --instance-ids i-1234567890abcdef0
```
Output:
```
{
"StartingInstances": [
{
"InstanceId": "i-1234567890abcdef0",
"CurrentState": {
"Code": 0,
"Name": "pending"
},
"PreviousState": {
"Code": 80,
"Name": "stopped"
}
}
]
}
```
Per ulteriori informazioni, consulta Arrestare e avviare un’istanza nella *Guida per l’utente di Amazon Elastic Compute Cloud*.
+ Per i dettagli sull'API, consulta [StartInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/start-instances.html)*Command Reference*.
### `start-network-insights-access-scope-analysis`
Il seguente esempio di codice mostra come utilizzare`start-network-insights-access-scope-analysis`.
**AWS CLI**
**Come avviare un’analisi dell’ambito di accesso alle informazioni di rete**
L'`start-network-insights-access-scope-analysis`esempio seguente avvia l'analisi dell'ambito nel tuo AWS account.
```
aws ec2 start-network-insights-access-scope-analysis \
--region us-east-1 \
--network-insights-access-scope-id nis-123456789111
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Guida introduttiva a Network Access Analyzer utilizzando la AWS CLI](https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/getting-started-cli.html) *nella Guida Network Access* Analyzer.
+ *Per i dettagli sull'API, consulta Command [StartNetworkInsightsAccessScopeAnalysis](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/start-network-insights-access-scope-analysis.html)Reference AWS CLI .*
### `start-network-insights-analysis`
Il seguente esempio di codice mostra come utilizzare`start-network-insights-analysis`.
**AWS CLI**
**Come analizzare un percorso**
L’esempio `start-network-insights-analysis` seguente analizza il percorso tra l’origine e la destinazione. Per visualizzare i risultati dell’analisi del percorso, utilizza il comando `describe-network-insights-analyses`.
```
aws ec2 start-network-insights-analysis \
--network-insights-path-id nip-0b26f224f1d131fa8
```
Output:
```
{
"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"
}
}
```
Per ulteriori informazioni, consulta [Guida introduttiva all'uso della AWS CLI](https://docs.aws.amazon.com/vpc/latest/reachability/getting-started-cli.html) nella Reachability *Analyzer Guide*.
+ *Per i dettagli sull'API, consulta Command [StartNetworkInsightsAnalysis](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/start-network-insights-analysis.html)Reference AWS CLI .*
### `start-vpc-endpoint-service-private-dns-verification`
Il seguente esempio di codice mostra come utilizzare`start-vpc-endpoint-service-private-dns-verification`.
**AWS CLI**
**Come avviare il processo di verifica DNS**
L’esempio `start-vpc-endpoint-service-private-dns-verification` seguente avvia il processo di verifica DNS per il servizio endpoint specificato.
```
aws ec2 start-vpc-endpoint-service-private-dns-verification \
--service-id vpce-svc-071afff70666e61e0
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Gestire i nomi DNS](https://docs.aws.amazon.com/vpc/latest/privatelink/manage-dns-names.html) nella *Guida per l'AWS PrivateLink utente*.
+ Per i dettagli sull'API, consulta [StartVpcEndpointServicePrivateDnsVerification AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/start-vpc-endpoint-service-private-dns-verification.html)*Command Reference.*
### `stop-instances`
Il seguente esempio di codice mostra come utilizzare`stop-instances`.
**AWS CLI**
**Esempio 1: come interrompere un’istanza Amazon EC2**
Nell’esempio di `stop-instances` seguente viene interrotta l’istanza supportata da Amazon EBS specificata.
```
aws ec2 stop-instances \
--instance-ids i-1234567890abcdef0
```
Output:
```
{
"StoppingInstances": [
{
"InstanceId": "i-1234567890abcdef0",
"CurrentState": {
"Code": 64,
"Name": "stopping"
},
"PreviousState": {
"Code": 16,
"Name": "running"
}
}
]
}
```
Per ulteriori informazioni, consulta [Arrestare e avviare un’istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Stop_Start.html) nella *Guida per l’utente di Amazon Elastic Compute Cloud*.
**Esempio 2: come ibernare un’istanza Amazon EC2**
Nell’esempio di `stop-instances` seguente viene ibernata un’istanza supportata da Amazon EBS se tale istanza è abilitata per l’ibernazione e soddisfa i prerequisiti di ibernazione. Dopo l’ibernazione dell’istanza, questa viene arrestata.
```
aws ec2 stop-instances \
--instance-ids i-1234567890abcdef0 \
--hibernate
```
Output:
```
{
"StoppingInstances": [
{
"CurrentState": {
"Code": 64,
"Name": "stopping"
},
"InstanceId": "i-1234567890abcdef0",
"PreviousState": {
"Code": 16,
"Name": "running"
}
}
]
}
```
Per ulteriori informazioni, consulta [Ibernazione di un’istanza Linux on demand](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html) nella *Guida per l’utente di Amazon Elastic Cloud Compute*.
+ Per i dettagli sull'API, consulta [StopInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/stop-instances.html)*Command Reference*.
### `terminate-client-vpn-connections`
Il seguente esempio di codice mostra come utilizzare`terminate-client-vpn-connections`.
**AWS CLI**
**Come terminare una connessione a un endpoint VPN Client**
L’esempio `terminate-client-vpn-connections` seguente termina la connessione specificata all’endpoint VPN Client.
```
aws ec2 terminate-client-vpn-connections \
--client-vpn-endpoint-id vpn-endpoint-123456789123abcde \
--connection-id cvpn-connection-04edd76f5201e0cb8
```
Output:
```
{
"ClientVpnEndpointId": "vpn-endpoint-123456789123abcde",
"ConnectionStatuses": [
{
"ConnectionId": "cvpn-connection-04edd76f5201e0cb8",
"PreviousStatus": {
"Code": "active"
},
"CurrentStatus": {
"Code": "terminating"
}
}
]
}
```
Per ulteriori informazioni, consulta [Connessioni client](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/cvpn-working-connections.html) nella *Guida per l’amministratore di VPN Client di AWS *.
+ Per i dettagli sull'API, consulta [TerminateClientVpnConnections AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/terminate-client-vpn-connections.html)*Command Reference*.
### `terminate-instances`
Il seguente esempio di codice mostra come utilizzare`terminate-instances`.
**AWS CLI**
**Come terminare un’istanza Amazon EC2**
Questo esempio termina l’istanza specificata.
Comando:
```
aws ec2 terminate-instances --instance-ids i-1234567890abcdef0
```
Output:
```
{
"TerminatingInstances": [
{
"InstanceId": "i-1234567890abcdef0",
"CurrentState": {
"Code": 32,
"Name": "shutting-down"
},
"PreviousState": {
"Code": 16,
"Name": "running"
}
}
]
}
```
Per ulteriori informazioni, consulta Utilizzo delle istanze Amazon EC2 nella *Guida per l’utente dell’Interfaccia a riga di comando AWS *.
+ Per i dettagli sull'API, consulta [TerminateInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/terminate-instances.html)*Command Reference*.
### `unassign-ipv6-addresses`
Il seguente esempio di codice mostra come utilizzare`unassign-ipv6-addresses`.
**AWS CLI**
**Per annullare l'assegnazione di un IPv6 indirizzo da un'interfaccia di rete**
Questo esempio annulla l'assegnazione dell' IPv6 indirizzo specificato dall'interfaccia di rete specificata.
Comando:
```
aws ec2 unassign-ipv6-addresses --ipv6-addresses 2001:db8:1234:1a00:3304:8879:34cf:4071 --network-interface-id eni-23c49b68
```
Output:
```
{
"NetworkInterfaceId": "eni-23c49b68",
"UnassignedIpv6Addresses": [
"2001:db8:1234:1a00:3304:8879:34cf:4071"
]
}
```
+ *Per i dettagli sull'API, consulta [UnassignIpv6Addresses](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/unassign-ipv6-addresses.html) in AWS CLI Command Reference.*
### `unassign-private-ip-addresses`
Il seguente esempio di codice mostra come utilizzare`unassign-private-ip-addresses`.
**AWS CLI**
**Come annullare l’assegnazione a un’interfaccia di rete di un indirizzo IP privato secondario**
Questo esempio annulla l’assegnazione dell’indirizzo IP privato specificato all’interfaccia di rete specificata. Se il comando va a buon fine, non viene restituito alcun output.
Comando:
```
aws ec2 unassign-private-ip-addresses --network-interface-id eni-e5aa89a3 --private-ip-addresses 10.0.0.82
```
+ Per i dettagli sull'API, consulta [UnassignPrivateIpAddresses AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/unassign-private-ip-addresses.html)*Command Reference*.
### `unassign-private-nat-gateway-address`
Il seguente esempio di codice mostra come utilizzare`unassign-private-nat-gateway-address`.
**AWS CLI**
**Come annullare l’assegnazione di un indirizzo IP al gateway NAT privato**
L'`unassign-private-nat-gateway-address`esempio seguente annulla l'assegnazione dell'indirizzo IP specificato dal gateway NAT privato specificato.
```
aws ec2 unassign-private-nat-gateway-address \
--nat-gateway-id nat-1234567890abcdef0 \
--private-ip-addresses 10.0.20.197
```
Output:
```
{
"NatGatewayId": "nat-0ee3edd182361f662",
"NatGatewayAddresses": [
{
"NetworkInterfaceId": "eni-0065a61b324d1897a",
"PrivateIp": "10.0.20.197",
"IsPrimary": false,
"Status": "unassigning"
}
]
}
```
Per ulteriori informazioni, consulta [Gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) nella *Guida per l’utente di Amazon VPC*.
+ *Per i dettagli sull'API, vedere [UnassignPrivateNatGatewayAddress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/unassign-private-nat-gateway-address.html)in AWS CLI Command Reference.*
### `unlock-snapshot`
Il seguente esempio di codice mostra come utilizzare`unlock-snapshot`.
**AWS CLI**
**Come sbloccare uno snapshot**
L’esempio `unlock-snapshot` seguente sblocca lo snapshot specificato.
```
aws ec2 unlock-snapshot \
--snapshot-id snap-0b5e733b4a8df6e0d
```
Output:
```
{
"SnapshotId": "snap-0b5e733b4a8df6e0d"
}
```
Per ulteriori informazioni, consulta [Snapshot Lock](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-snapshot-lock.html) nella *Guida per l’utente di Amazon EBS*.
+ Per i dettagli sull'API, consulta [UnlockSnapshot AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/unlock-snapshot.html)*Command Reference*.
### `unmonitor-instances`
Il seguente esempio di codice mostra come utilizzare`unmonitor-instances`.
**AWS CLI**
**Come disabilitare il monitoraggio dettagliato per un’istanza**
Questo comando di esempio disabilita il monitoraggio dettagliato per l’istanza specificata.
Comando:
```
aws ec2 unmonitor-instances --instance-ids i-1234567890abcdef0
```
Output:
```
{
"InstanceMonitorings": [
{
"InstanceId": "i-1234567890abcdef0",
"Monitoring": {
"State": "disabling"
}
}
]
}
```
+ Per i dettagli sull'API, consulta [UnmonitorInstances AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/unmonitor-instances.html)*Command Reference*.
### `update-security-group-rule-descriptions-egress`
Il seguente esempio di codice mostra come utilizzare`update-security-group-rule-descriptions-egress`.
**AWS CLI**
**Come aggiornare la descrizione di una regola in uscita del gruppo di sicurezza**
L'`update-security-group-rule-descriptions-egress`esempio seguente aggiorna la descrizione della regola del gruppo di sicurezza per la porta e l'intervallo di IPv4 indirizzi specificati. La descrizione “`Outbound HTTP access to server 2`” sostituisce qualsiasi descrizione esistente per la regola.
```
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"}]
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni, consulta [Regole del gruppo di sicurezza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html#security-group-rules) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, vedere [UpdateSecurityGroupRuleDescriptionsEgress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/update-security-group-rule-descriptions-egress.html)in *AWS CLI Command Reference*.
### `update-security-group-rule-descriptions-ingress`
Il seguente esempio di codice mostra come utilizzare`update-security-group-rule-descriptions-ingress`.
**AWS CLI**
**Esempio 1: come aggiornare la descrizione di una regola del gruppo di sicurezza in entrata con un’origine CIDR**
L'`update-security-group-rule-descriptions-ingress`esempio seguente aggiorna la descrizione della regola del gruppo di sicurezza per la porta e l'intervallo di IPv4 indirizzi specificati. La descrizione “`SSH access from ABC office`” sostituisce qualsiasi descrizione esistente per la regola.
```
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"}]'
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni, consulta [Regole del gruppo di sicurezza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html#security-group-rules) nella *Guida per l’utente di Amazon EC2*.
**Esempio 2: come aggiornare la descrizione di una regola del gruppo di sicurezza in entrata con un’origine dell’elenco di prefissi**
L’esempio `update-security-group-rule-descriptions-ingress` seguente aggiorna la descrizione della regola del gruppo di sicurezza per la porta e l’elenco di prefissi specificati. La descrizione “`SSH access from ABC office`” sostituisce qualsiasi descrizione esistente per la regola.
```
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"}]'
```
Output:
```
{
"Return": true
}
```
Per ulteriori informazioni, consulta [Regole del gruppo di sicurezza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html#security-group-rules) nella *Guida per l’utente di Amazon EC2*.
+ Per i dettagli sull'API, vedere [UpdateSecurityGroupRuleDescriptionsIngress](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/update-security-group-rule-descriptions-ingress.html)in *AWS CLI Command Reference*.
### `withdraw-byoip-cidr`
Il seguente esempio di codice mostra come utilizzare`withdraw-byoip-cidr`.
**AWS CLI**
**Come smettere di pubblicizzare un intervallo di indirizzi**
L’esempio `withdraw-byoip-cidr` seguente smette di pubblicizzare l’intervallo di indirizzi specificato.
```
aws ec2 withdraw-byoip-cidr
--cidr 203.0.113.25/24
```
Output:
```
{
"ByoipCidr": {
"Cidr": "203.0.113.25/24",
"StatusMessage": "ipv4pool-ec2-1234567890abcdef0",
"State": "advertised"
}
}
```
+ Per i dettagli sull'API, consulta [WithdrawByoipCidr AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/withdraw-byoip-cidr.html)*Command Reference*.