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à.
# Accesso programmatico ad Amazon EC2
Puoi creare e gestire le tue EC2 risorse Amazon utilizzando Console di gestione AWS o un'interfaccia programmatica. Per informazioni sull'uso della EC2 console Amazon, consulta la [Amazon EC2 User Guide](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
**Come funziona**
+ [ EC2 Endpoint Amazon](ec2-endpoints.md)
+ [Coerenza finale](eventual-consistency.md)
+ [Idempotenza](ec2-api-idempotency.md)
+ [Limitazione delle richieste](ec2-api-throttling.md)
+ [Paginazione](ec2-api-pagination.md)
**Interfacce programmatiche**
+ [AWS Command Line Interface (AWS CLI)](ec2-aws-cli.md)
+ [AWS CloudFormation](ec2-cloudformation.md)
+ [AWS SDKs](sdk-general-information-section.md)
+ [API di basso livello](ec2-low-level-api.md)
**Nozioni di base**
+ [Esempi di codice](service_code_examples.md)
+ [Console-to-Code](console-to-code.md)
**Monitoraggio**
+ [AWS CloudTrail](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitor-with-cloudtrail.html)
+ [Monitora le richieste](monitor.md)
# Endpoint del servizio Amazon EC2
Un endpoint è un URL che funge da punto di ingresso per un servizio Web. AWS Amazon EC2 supporta i seguenti tipi di endpoint:
+ [IPv4 endpoint](#ipv4)
+ [Endpoint dual-stack](#ipv6) (supportano entrambi e) IPv4 IPv6
+ [Endpoint FIPS](https://docs.aws.amazon.com/general/latest/gr/rande.html#FIPS-endpoints)
Quando si effettua una richiesta, è possibile specificare l’endpoint da utilizzare. Se non si specifica un endpoint, l'endpoint viene utilizzato per impostazione IPv4 predefinita. Per utilizzare un tipo di endpoint diverso, devi specificarlo nella richiesta. Per esempi su come eseguire questa operazione, consulta [Specificazione degli endpoint](#examples). Per una tabella degli endpoint disponibili, vedere. [Endpoint di servizio per regione](#service-endpoints)
## IPv4 endpoint
IPv4 gli endpoint supportano solo il IPv4 traffico. IPv4 gli endpoint sono disponibili per tutte le regioni.
Se specifichi l'endpoint generico, `ec2.amazonaws.com`, utilizziamo l'endpoint per `us-east-1`. Per utilizzare una Regione diversa, specifica l'endpoint associato. Ad esempio, se specifichi `ec2.us-east-2.amazonaws.com` come endpoint, indirizzeremo la tua richiesta all'endpoint `us-east-2`.
IPv4 i nomi degli endpoint utilizzano la seguente convenzione di denominazione:
+ `service.region.amazonaws.com`
Ad esempio, il nome dell' IPv4 endpoint per la regione è`eu-west-1`. `ec2.eu-west-1.amazonaws.com`
## Endpoint dual-stack (e) IPv4 IPv6
Gli endpoint dual-stack supportano sia il traffico che il traffico. IPv4 IPv6 Quando effettui una richiesta a un endpoint dual-stack, l'URL dell'endpoint si risolve in un indirizzo IPv6 o in un IPv4 indirizzo, a seconda del protocollo utilizzato dalla rete e dal client.
Amazon EC2 supporta solo endpoint dual-stack regionali, il che significa che è necessario specificare la regione come parte del nome dell'endpoint. I nomi degli endpoint dual-stack usano la seguente convenzione di denominazione:
+ `ec2.region.api.aws`
Ad esempio, il nome dell'endpoint dual-stack per la Regione `eu-west-1` è `ec2.eu-west-1.api.aws`.
## Endpoint di servizio per regione
Di seguito sono riportati gli endpoint del servizio per Amazon EC2. Per ulteriori informazioni sulle regioni, 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*.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/ec2/latest/devguide/ec2-endpoints.html)
## Specificazione degli endpoint
Questa sezione fornisce alcuni esempi di come specificare un endpoint quando si effettua una richiesta.
------
#### [ AWS CLI ]
I seguenti esempi mostrano come specificare un endpoint per la `us-east-2` regione utilizzando. AWS CLI
+ **Dual-stack**
```
aws ec2 describe-regions --region us-east-2 --endpoint-url https://ec2.us-east-2.api.aws
```
+ **IPv4**
```
aws ec2 describe-regions --region us-east-2 --endpoint-url https://ec2.us-east-2.amazonaws.com
```
------
#### [ AWS SDK for Java 2.x ]
Gli esempi seguenti mostrano come specificare un endpoint per la `us-east-2` Regione utilizzando. AWS SDK for Java 2.x
+ **Dual-stack**
```
Ec2Client client = Ec2Client.builder()
.region(Region.US_EAST_2)
.endpointOverride(URI.create("https://ec2.us-east-2.api.aws"))
.build();
```
+ **IPv4**
```
Ec2Client client = Ec2Client.builder()
.region(Region.US_EAST_2)
.endpointOverride(URI.create("https://ec2.us-east-2.amazonaws.com"))
.build();
```
------
#### [ AWS SDK per Java 1.x ]
Gli esempi seguenti mostrano come specificare un endpoint per la `eu-west-1` Regione utilizzando 1.x. AWS SDK per Java
+ **Dual-stack**
```
AmazonEC2 s3 = AmazonEC2ClientBuilder.standard()
.withEndpointConfiguration(new EndpointConfiguration(
"https://ec2.eu-west-1.api.aws",
"eu-west-1"))
.build();
```
+ **IPv4**
```
AmazonEC2 s3 = AmazonEC2ClientBuilder.standard()
.withEndpointConfiguration(new EndpointConfiguration(
"https://ec2.eu-west-1.amazonaws.com",
"eu-west-1"))
.build();
```
------
#### [ AWS SDK for Go ]
Gli esempi seguenti mostrano come specificare un endpoint per la `us-east-1` Regione utilizzando. AWS SDK per Go
+ **Dual-stack**
```
sess := session.Must(session.NewSession())
svc := ec2.New(sess, &aws.Config{
Region: aws.String(endpoints.UsEast1RegionID),
Endpoint: aws.String("https://ec2.us-east-1.api.aws")
})
```
+ **IPv4**
```
sess := session.Must(session.NewSession())
svc := ec2.New(sess, &aws.Config{
Region: aws.String(endpoints.UsEast1RegionID),
Endpoint: aws.String("https://ec2.us-east-1.amazonaws.com")
})
```
------
# Eventuale coerenza nell'API Amazon EC2
L' EC2 API Amazon segue un eventuale modello di coerenza, dovuto alla natura distribuita del sistema che supporta l'API. Ciò significa che il risultato di un comando API che esegui che influisce sulle tue EC2 risorse Amazon potrebbe non essere immediatamente visibile a tutti i comandi successivi che esegui. È necessario tenerlo a mente quando si esegue un comando API che segue immediatamente un comando API precedente.
L'eventuale coerenza può influire sul modo in cui gestisci le tue risorse. Ad esempio, se si esegue un comando per creare una risorsa, alla fine questa sarà visibile agli altri comandi. Ciò significa che se si esegue un comando per modificare o descrivere la risorsa appena creata, è possibile che il relativo ID non si sia propagato in tutto il sistema e si verificherà un errore che indica che la risorsa non esiste.
Per gestire la coerenza finale, procedi nel modo seguente:
+ Confermate lo stato della risorsa prima di eseguire un comando per modificarla. Esegui il comando `Describe` appropriato utilizzando un algoritmo di backoff esponenziale per assicurarti di concedere tempo sufficiente per la propagazione del comando precedente nel sistema. A tale scopo, esegui il `Describe` comando ripetutamente, iniziando con un paio di secondi di attesa e aumentando gradualmente fino a qualche minuto di attesa.
+ Aggiungi il tempo di attesa tra i comandi successivi, anche se un comando `Describe` restituisce una risposta accurata. Applica un algoritmo di backoff esponenziale a partire da un paio di secondi di attesa e aumenta gradualmente fino a qualche minuto di attesa.
**Eventuali esempi di errori di coerenza**
Di seguito sono riportati alcuni esempi di codici di errore che potrebbero verificarsi a causa dell'eventuale coerenza.
+ `InvalidInstanceID.NotFound`
Se si esegue correttamente il `RunInstances` comando e quindi si esegue immediatamente un altro comando utilizzando l'ID di istanza fornito nella risposta di`RunInstances`, è possibile che venga restituito un `InvalidInstanceID.NotFound` errore. Ciò non significa che l'istanza non esista.
Alcuni comandi specifici che potrebbero essere interessati sono:
+ `DescribeInstances`: per confermare lo stato effettivo dell'istanza, esegui questo comando utilizzando un algoritmo di backoff esponenziale.
+ `TerminateInstances`: per confermare lo stato dell'istanza, eseguite innanzitutto il `DescribeInstances` comando utilizzando un algoritmo di backoff esponenziale.
**Importante**
Se si `InvalidInstanceID.NotFound` verifica un errore dopo l'esecuzione`TerminateInstances`, ciò non significa che l'istanza sia o verrà terminata. L'istanza potrebbe essere ancora in esecuzione. Questo è il motivo per cui è importante confermare innanzitutto lo stato dell'istanza utilizzando`DescribeInstances`.
+ `InvalidGroup.NotFound`
Se si esegue correttamente il `CreateSecurityGroup` comando e quindi si esegue immediatamente un altro comando utilizzando l'ID del gruppo di sicurezza fornito nella risposta di`CreateSecurityGroup`, è possibile che venga restituito un `InvalidGroup.NotFound` errore. Per confermare lo stato del gruppo di sicurezza, esegui il `DescribeSecurityGroups` comando utilizzando un algoritmo di backoff esponenziale.
+ `InstanceLimitExceeded`
Hai richiesto un numero di istanze superiore a quello consentito dal limite di istanze corrente per il tipo di istanza specificato. Potresti raggiungere questo limite in modo imprevisto se avvii e chiudi le istanze rapidamente, poiché le istanze terminate contano ai fini del limite di istanze per un certo periodo dopo la loro chiusura.
# Garantire l'idempotenza nelle richieste di API Amazon EC2
Quando si effettua una richiesta API mutante, di solito restituisce un risultato prima del completamento dei flussi di lavoro asincroni dell'operazione. Le operazioni potrebbero inoltre scadere o riscontrare altri problemi relativi al server prima del completamento, anche se la richiesta ha già restituito un risultato. Ciò potrebbe rendere difficile determinare l'esito della richiesta e potrebbe comportare più tentativi per garantire che l'operazione venga completata correttamente. Tuttavia, se la richiesta originale e i tentativi successivi hanno esito positivo, l'operazione viene completata più volte, Ciò significa che potresti creare più risorse del previsto.
L'*idempotenza* assicura che una richiesta API venga completata solo una volta. Quando si utilizza una richiesta idempotente, se la richiesta originale viene completata correttamente, tutti i tentativi successivi vengono completati correttamente senza alcuna azione aggiuntiva. Tuttavia, il risultato potrebbe contenere informazioni aggiornate, come lo stato di creazione corrente.
**Topics**
+ [
## Idempotenza in Amazon EC2
](#client-tokens)
+ [
## RunInstances idempotenza
](#run-instances-idempotency)
+ [
## Esempi
](#Run_Instance_Idempotency_CLI)
+ [
## Riprova i consigli per le richieste idempotenti
](#recommended-actions)
## Idempotenza in Amazon EC2
Le seguenti azioni API sono idempotenti per impostazione predefinita e non richiedono una configurazione aggiuntiva. Per impostazione predefinita, AWS CLI i comandi corrispondenti supportano anche l'idempotenza.
**Idempotente per impostazione predefinita**
+ AssociateAddress
+ CreateVpnConnection
+ DisassociateAddress
+ ReplaceNetworkAclAssociation
+ TerminateInstances
*Le seguenti azioni API supportano opzionalmente l'idempotenza utilizzando un token client.* I AWS CLI comandi corrispondenti supportano anche l'idempotenza utilizzando un token client. Un token client è una stringa unica, con distinzione tra maiuscole e minuscole, composta da un massimo di 64 caratteri ASCII. Per effettuare una richiesta API idempotente utilizzando una di queste azioni, specifica un token client nella richiesta. Non dovresti riutilizzare lo stesso token client per altre richieste API. Se riprovi una richiesta completata correttamente utilizzando lo stesso token client e gli stessi parametri, il nuovo tentativo ha esito positivo senza eseguire ulteriori azioni. Se si riprova una richiesta riuscita utilizzando lo stesso token client, ma uno o più parametri sono diversi, diversi dalla regione o dalla zona di disponibilità, il nuovo tentativo fallisce e viene restituito un errore. `IdempotentParameterMismatch`
**Idempotente utilizzando un token client**
+ AllocateHosts
+ AllocateIpamPoolCidr
+ AssociateClientVpnTargetNetwork
+ AssociateIpamResourceDiscovery
+ AttachVerifiedAccessTrustProvider
+ AuthorizeClientVpnIngress
+ CopyFpgaImage
+ CopyImage
+ CreateCapacityReservation
+ CreateCapacityReservationFleet
+ CreateClientVpnEndpoint
+ CreateClientVpnRoute
+ CreateEgressOnlyInternetGateway
+ CreateFleet
+ CreateFlowLogs
+ CreateFpgaImage
+ CreateInstanceConnectEndpoint
+ CreateIpam
+ CreateIpamPool
+ CreateIpamResourceDiscovery
+ CreateIpamScope
+ CreateLaunchTemplate
+ CreateLaunchTemplateVersion
+ CreateManagedPrefixList
+ CreateNatGateway
+ CreateNetworkAcl
+ CreateNetworkInsightsAccessScope
+ CreateNetworkInsightsPath
+ CreateNetworkInterface
+ CreateReplaceRootVolumeTask
+ CreateReservedInstancesListing
+ CreateRouteTable
+ CreateTrafficMirrorFilter
+ CreateTrafficMirrorFilterRule
+ CreateTrafficMirrorSession
+ CreateTrafficMirrorTarget
+ CreateVerifiedAccessEndpoint
+ CreateVerifiedAccessGroup
+ CreateVerifiedAccessInstance
+ CreateVerifiedAccessTrustProvider
+ CreateVolume
+ CreateVpcEndpoint
+ CreateVpcEndpointConnectionNotification
+ CreateVpcEndpointServiceConfiguration
+ DeleteVerifiedAccessEndpoint
+ DeleteVerifiedAccessGroup
+ DeleteVerifiedAccessInstance
+ DeleteVerifiedAccessTrustProvider
+ DetachVerifiedAccessTrustProvider
+ ExportImage
+ ImportImage
+ ImportSnapshot
+ ModifyInstanceCreditSpecification
+ ModifyLaunchTemplate
+ ModifyReservedInstances
+ ModifyVerifiedAccessEndpoint
+ ModifyVerifiedAccessEndpointPolicy
+ ModifyVerifiedAccessGroup
+ ModifyVerifiedAccessGroupPolicy
+ ModifyVerifiedAccessInstance
+ ModifyVerifiedAccessInstanceLoggingConfiguration
+ ModifyVerifiedAccessTrustProvider
+ ProvisionIpamPoolCidr
+ PurchaseHostReservation
+ RequestSpotFleet
+ RequestSpotInstances
+ RunInstances
+ StartNetworkInsightsAccessScopeAnalysis
+ StartNetworkInsightsAnalysis
**Tipi di idempotenza**
+ Regionale: le richieste sono idempotenti in ogni regione. Tuttavia, puoi utilizzare la stessa richiesta, incluso lo stesso token client, in una regione diversa.
+ Zonale: le richieste sono idempotenti in ogni zona di disponibilità di una regione. Ad esempio, se si specifica lo stesso token client in due chiamate nella stessa regione, le chiamate hanno esito positivo se specificano valori diversi per il parametro. **AllocateHosts** **AvailabilityZone**
## RunInstances idempotenza
L'azione [RunInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html)API utilizza l'idempotenza regionale e zonale.
Il tipo di idempotenza utilizzato dipende da come si specifica la zona di disponibilità nella richiesta API. RunInstances La richiesta utilizza l'**idempotenza zonale** nei seguenti casi:
+ **Se specificate esplicitamente una zona di disponibilità utilizzando il **AvailabilityZone**parametro nel tipo di dati Placement**
+ Se si specifica implicitamente una zona di disponibilità utilizzando il parametro **SubnetId**
**Se non si specifica esplicitamente o implicitamente una zona di disponibilità, la richiesta utilizza l'idempotenza regionale.**
### Idempotenza zonale
L'idempotenza zonale garantisce che una richiesta RunInstances API sia idempotente in ogni zona di disponibilità di una regione. Ciò garantisce che una richiesta con lo stesso token client possa essere completata una sola volta all'interno di ciascuna zona di disponibilità di una regione. Tuttavia, lo stesso token client può essere utilizzato per avviare istanze in altre zone di disponibilità della regione.
Ad esempio, se invii una richiesta idempotente per avviare un'istanza nella zona di `us-east-1a` disponibilità e quindi utilizzi lo stesso token client in una richiesta nella zona di `us-east-1b` disponibilità, lanciamo istanze in ciascuna di quelle zone di disponibilità. Se uno o più parametri sono diversi, i tentativi successivi con lo stesso token client in quelle zone di disponibilità vengono restituiti correttamente senza eseguire ulteriori azioni o falliscono con un errore. `IdempotentParameterMismatch`
### Idempotenza regionale
L'idempotenza regionale garantisce che una richiesta RunInstances API sia idempotente in una regione. Ciò garantisce che una richiesta con lo stesso token client possa essere completata solo una volta all'interno di una regione. Tuttavia, la stessa identica richiesta, con lo stesso token client, può essere utilizzata per avviare istanze in una regione diversa.
Ad esempio, se invii una richiesta idempotente per avviare un'istanza nella `us-east-1` regione e poi utilizzi lo stesso token client in una richiesta nella `eu-west-1` regione, lanciamo istanze in ognuna di quelle regioni. Se uno o più parametri sono diversi, i tentativi successivi con lo stesso token client in quelle regioni vengono restituiti correttamente senza eseguire ulteriori azioni o hanno esito negativo con un errore. `IdempotentParameterMismatch`
**Suggerimento**
Se una delle zone di disponibilità nella regione richiesta non è disponibile, RunInstances le richieste che utilizzano l'idempotenza regionale potrebbero non riuscire. Per sfruttare le funzionalità della zona di disponibilità offerte dall' AWS infrastruttura, consigliamo di utilizzare l'idempotenza zonale all'avvio delle istanze. RunInstances le richieste che utilizzano l'idempotenza zonale e hanno come target una zona di disponibilità disponibile hanno esito positivo anche se un'altra zona di disponibilità nella regione richiesta non è disponibile.
## Esempi
### AWS CLI esempi di comandi
Per rendere un AWS CLI comando idempotente, aggiungete l'opzione. `--client-token`
**Esempio 1: idempotenza**
Il seguente comando [allocate-hosts](https://docs.aws.amazon.com/cli/latest/reference/ec2/allocate-hosts.html) utilizza l'idempotenza in quanto include un token client.
```
aws ec2 allocate-hosts --instance-type m5.large --availability-zone eu-west-1a --auto-placement on --quantity 1 --client-token 550e8400-e29b-41d4-a716-446655440000
```
**Esempio 2: idempotenza regionale di run-instances**
Il seguente comando [run-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/run-instances.html) utilizza l'idempotenza regionale in quanto include un token client ma non specifica in modo esplicito o implicito una zona di disponibilità.
```
aws ec2 run-instances --image-id ami-b232d0db --count 1 --key-name my-key-pair --client-token 550e8400-e29b-41d4-a716-446655440000
```
**Esempio 3: idempotenza zonale di run-instances**
Il seguente comando [run-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/run-instances.html) utilizza l'idempotenza zonale in quanto include un token client e una zona di disponibilità specificata in modo esplicito.
```
aws ec2 run-instances --placement "AvailabilityZone=us-east-1a" --image-id ami-b232d0db --count 1 --key-name my-key-pair --client-token 550e8400-e29b-41d4-a716-446655440000
```
### Esempi di richieste API
Per rendere idempotente una richiesta API, aggiungi il parametro. `ClientToken`
**Esempio 1: idempotenza**
La seguente richiesta [AllocateHosts](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AllocateHosts.html)API utilizza l'idempotenza in quanto include un token client.
```
https://ec2.amazonaws.com/?Action=AllocateHosts
&AvailabilityZone=us-east-1b
&InstanceType=m5.large
&Quantity=1
&AutoPlacement=off
&ClientToken=550e8400-e29b-41d4-a716-446655440000
&AUTHPARAMS
```
**Esempio 2: idempotenza regionale RunInstances**
La seguente richiesta [RunInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html)API utilizza l'idempotenza regionale in quanto include un token client ma non specifica in modo esplicito o implicito una zona di disponibilità.
```
https://ec2.amazonaws.com/?Action=RunInstances
&ImageId=ami-3ac33653
&MaxCount=1
&MinCount=1
&KeyName=my-key-pair
&ClientToken=550e8400-e29b-41d4-a716-446655440000
&AUTHPARAMS
```
**Esempio 3: idempotenza zonale RunInstances**
La seguente richiesta [RunInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html)API utilizza l'idempotenza zonale in quanto include un token client e una zona di disponibilità specificata in modo esplicito.
```
https://ec2.amazonaws.com/?Action=RunInstances
&Placement.AvailabilityZone=us-east-1d
&ImageId=ami-3ac33653
&MaxCount=1
&MinCount=1
&KeyName=my-key-pair
&ClientToken=550e8400-e29b-41d4-a716-446655440000
&AUTHPARAMS
```
## Riprova i consigli per le richieste idempotenti
La tabella seguente mostra alcune risposte comuni che si potrebbero ricevere per richieste API idempotenti e fornisce consigli per effettuare nuovi tentativi.
| Risposta | Raccomandazione | Commenti |
| --- | --- | --- |
| 200 (OK) | Non riprovare | La richiesta originale è stata completata con successo. Qualsiasi tentativo successivo ottiene esito positivo. |
| [Codici di risposta della serie 400 (errori del client)](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/errors-overview.html#CommonErrors) | Non riprovare | La richiesta presenta uno dei problemi seguenti: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/ec2/latest/devguide/ec2-api-idempotency.html) Se la richiesta riguarda una risorsa che sta cambiando stato, un nuovo tentativo potrebbe avere esito positivo. |
| [Codici di risposta della serie 500 (errori del server)](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/errors-overview.html#api-error-codes-table-server) | Riprova | L'errore è causato da un problema AWS sul lato server ed è generalmente temporaneo. Ripeti la richiesta con una strategia di backoff appropriata. |
# Limitazione delle richieste per l'API Amazon EC2
Amazon EC2 limita le richieste EC2 API per ogni AWS account in base alla regione. Lo facciamo per migliorare le prestazioni del servizio e garantire un utilizzo equo per tutti i EC2 clienti Amazon. La limitazione garantisce che le richieste all' EC2 API Amazon non superino i limiti massimi consentiti per le richieste API. Le richieste API sono soggette ai limiti di richiesta indipendentemente dal fatto che provengano da:
+ Un'applicazione di terze parti
+ Uno strumento da riga di comando
+ La EC2 console Amazon
Se superi un limite di limitazione delle API, ricevi il codice di `RequestLimitExceeded` errore.
**Topics**
+ [
## Come viene applicata la limitazione
](#throttling-how)
+ [Richiedi limiti per i token](#throttling-limits-rate-based)
+ [Limiti dei token di risorsa](#throttling-limits-cost-based)
+ [
## Monitora la limitazione delle API
](#throttling-monitor)
+ [
## Tentativi e backoff esponenziale
](#api-backoff)
+ [
## Richiedere un aumento del limite della
](#throttling-increase)
## Come viene applicata la limitazione
Amazon EC2 utilizza l'[algoritmo token bucket](https://en.wikipedia.org/wiki/Token_bucket) per implementare il throttling delle API. *Con questo algoritmo, il tuo account dispone di un *bucket* che contiene un numero specifico di token.* Il numero di token nel bucket rappresenta il limite di throttling in un dato secondo.
Amazon EC2 implementa due tipi di limitazione delle API:
**Topics**
+ [
### Limitazione del tasso di richiesta
](#throttling-rate-based)
+ [
### Limitazione della frequenza delle risorse
](#throttling-cost-based)
### Limitazione del tasso di richiesta
Con la limitazione della frequenza delle richieste, ogni API viene valutata singolarmente e il numero di richieste effettuate per ogni API è limitato. Ogni richiesta effettuata rimuove un token dal bucket dell'API. Ad esempio, la dimensione del bucket di token per `DescribeHosts` un'azione API *non mutante* è di 100 token. Puoi effettuare fino a 100 `DescribeHosts` richieste in un secondo. Se superi le 100 richieste in un secondo, vieni limitato da quell'API e le richieste rimanenti entro quel secondo falliscono, tuttavia, le richieste per altre API non ne risentono.
I bucket si ricaricano automaticamente a una velocità prestabilita. Se il bucket è al di sotto della sua capacità massima, gli viene aggiunto un determinato numero di token ogni secondo fino a raggiungere la capacità massima. Se il secchio è pieno quando arrivano i gettoni di ricarica, questi vengono scartati. Il bucket non può contenere più del numero massimo di token. Ad esempio, la dimensione del bucket per `DescribeHosts` un'azione API *non mutante* è di 100 token e la frequenza di ricarica è di 20 token al secondo. Se si effettuano 100 `DescribeHosts` richieste in un secondo, il bucket viene ridotto a zero (0) token. Il bucket viene quindi ricaricato di 20 token ogni secondo, fino a raggiungere la capacità massima di 100 token. Ciò significa che un bucket vuoto raggiunge la sua capacità massima dopo 5 secondi se non vengono effettuate richieste durante tale periodo.
Non è necessario attendere che il bucket sia completamente pieno prima di poter effettuare richieste API. Puoi utilizzare i token di ricarica man mano che vengono aggiunti al bucket. Se si utilizzano immediatamente i gettoni di ricarica, il secchio non raggiunge la sua capacità massima. Ad esempio, la dimensione del bucket per `DescribeHosts` un'azione API *non mutante* è di 100 token e la frequenza di ricarica è di 20 token al secondo. Se esaurisci il bucket effettuando 100 richieste API in un secondo, puoi continuare a fare 20 richieste API al secondo utilizzando i token di ricarica man mano che vengono aggiunti al bucket. Il bucket può essere ricaricato fino alla capacità massima solo se effettui meno di 20 richieste API al secondo.
Per ulteriori informazioni, consulta [Richiedi le dimensioni dei bucket di token e le tariffe di ricarica](#throttling-limits-rate-based).
### Limitazione della frequenza delle risorse
Alcune azioni API, come `RunInstances` e`TerminateInstances`, come descritto nella tabella che segue, utilizzano la limitazione della velocità delle risorse oltre alla limitazione della velocità delle richieste. Queste azioni API hanno un bucket di token di risorse separato che si esaurisce in base al numero di risorse interessate dalla richiesta. Analogamente ai bucket di token di richiesta, i bucket di token di risorse hanno un numero massimo di bucket che consente di eseguire il burst e una frequenza di ricarica che consente di mantenere una frequenza costante di richieste per tutto il tempo necessario. Se superi un limite di bucket specifico per un'API, incluso quando un bucket non è stato ancora riempito per supportare la successiva richiesta API, l'azione dell'API è limitata anche se non hai raggiunto il limite totale di limitazione dell'API.
Ad esempio, la dimensione del bucket di token di risorse `RunInstances` è di 1000 token e la frequenza di ricarica è di due token al secondo. Pertanto, è possibile avviare immediatamente 1000 istanze, utilizzando un numero qualsiasi di richieste API, ad esempio una richiesta per 1000 istanze o quattro richieste per 250 istanze. Dopo che il bucket di token di risorse è vuoto, puoi avviare fino a due istanze al secondo, utilizzando una richiesta per due istanze o due richieste per un'istanza.
Per ulteriori informazioni, consulta [Dimensioni dei Resource Token Bucket e tassi di ricarica](#throttling-limits-cost-based).
## Richiedi le dimensioni dei bucket di token e le tariffe di ricarica
Ai fini della limitazione della frequenza delle richieste, le azioni API sono raggruppate nelle seguenti categorie:
+ Azioni **non mutanti: azioni** API che recuperano dati sulle risorse. Questa categoria include generalmente tutte le azioni `Describe*``List*`,`Search*`, e `Get*` API, come`DescribeRouteTables`, `SearchTransitGatewayRoutes` e. `GetIpamPoolCidrs` Queste azioni API in genere hanno i limiti di limitazione delle API più elevati.
+ [https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-pagination.html](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-pagination.html) Si consiglia di utilizzare l'impaginazione e il filtraggio in modo che i token vengano detratti dal bucket di token standard (più grande).
+ Azioni **mutanti: azioni** API che creano, modificano o eliminano risorse. Questa categoria include in genere tutte le azioni API che non sono classificate come *azioni non mutanti*, ad esempio, e. `AllocateHosts` `ModifyHosts` `CreateCapacityReservation` Queste azioni hanno un limite di limitazione inferiore rispetto alle azioni API non mutanti.
+ Azioni che **richiedono molte risorse: azioni** API mutanti che richiedono più tempo e più risorse per essere completate. *Queste azioni hanno un limite di limitazione ancora più basso rispetto alle azioni di mutazione.* *Vengono limitate separatamente dalle altre azioni mutanti.*
+ Azioni **non mutanti della console: azioni** API non mutanti richieste dalla console Amazon. EC2 Queste azioni API vengono limitate separatamente dalle altre azioni API non mutanti.
+ **Azioni non categorizzate**: si tratta di azioni API che ricevono le proprie dimensioni di token e frequenze di ricarica, anche se per definizione rientrano in una delle altre categorie.
| Categoria di azioni API | Azioni | Capacità massima bucket | Frequenza di ricarica del secchio |
| --- | --- | --- | --- |
| Azioni non mutanti | Le azioni `Describe*``List*`,`Search*`, e `Get*` API che non sono incluse in un'altra categoria. | 100 | 20 |
| Azioni non mutanti non filtrate e non impaginate | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/ec2/latest/devguide/ec2-api-throttling.html) | 50 | 10 |
| Azioni mutanti | *Tutte le azioni API mutanti che non sono azioni che richiedono un uso intensivo di *risorse o azioni non categorizzate*.* | 50 | 5 |
| Azioni che richiedono molte risorse | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/ec2/latest/devguide/ec2-api-throttling.html) | 50 | 5 |
| Azioni non mutanti della console | Le azioni `Describe*``List*`,`Search*`, e `Get*` API richiamate dalla EC2 console Amazon, ma non incluse in un'altra categoria. | 100 | 10 |
| Azioni non categorizzate | Capacità massima bucket | Frequenza di ricarica del secchio |
| --- | --- | --- |
| AcceptVpcEndpointConnections | 10 | 1 |
| AdvertiseByoipCidr | 1 | 0.1 |
| AssignIpv6Addresses | 100 | 5 |
| AssignPrivateIpAddresses | 100 | 5 |
| AssignPrivateNatGatewayAddress | 10 | 1 |
| AssociateCapacityReservationBillingOwner | 1 | 0,5 |
| AssociateEnclaveCertificateIamRole | 10 | 1 |
| AssociateIamInstanceProfile | 100 | 5 |
| AssociateNatGatewayAddress | 10 | 1 |
| AttachVerifiedAccessTrustProvider | 10 | 2 |
| AuthorizeClientVpnIngress | 5 | 2 |
| CancelDeclarativePoliciesReport | 1 | 1 |
| CopyImage | 100 | 1 |
| CreateClientVpnRoute | 5 | 2 |
| CreateCoipCidr | 5 | 1 |
| CreateCoipPool | 5 | 1 |
| CreateDefaultSubnet | 1 | 1 |
| CreateDefaultVpc | 1 | 1 |
| CreateLaunchTemplateVersion | 100 | 5 |
| CreateNatGateway | 10 | 1 |
| CreateNetworkInterface | 100 | 5 |
| CreateRestoreImageTask | 50 | 0.1 |
| CreateSnapshot | 100 | 5 |
| CreateSnapshots | 100 | 5 |
| CreateSpotDatafeedSubscription | 50 | 3 |
| CreateStoreImageTask | 50 | 0.1 |
| CreateSubnetCidrReservation | 5 | 1 |
| CreateTags | 100 | 10 |
| CreateVerifiedAccessEndpoint | 20 | 4 |
| CreateVerifiedAccessGroup | 10 | 2 |
| CreateVerifiedAccessInstance | 10 | 2 |
| CreateVerifiedAccessTrustProvider | 10 | 2 |
| CreateVolume | 100 | 5 |
| CreateVpcEndpoint | 4 | 0.3 |
| CreateVpcEndpointServiceConfiguration | 10 | 1 |
| DeleteClientVpnRoute | 5 | 2 |
| DeleteCoipCidr | 5 | 1 |
| DeleteCoipPool | 5 | 1 |
| DeleteCoipPoolPermission | 5 | 1 |
| DeleteNatGateway | 10 | 1 |
| DeleteNetworkInterface | 100 | 5 |
| DeleteSnapshot | 100 | 5 |
| DeleteSpotDatafeedSubscription | 50 | 3 |
| DeleteSubnetCidrReservation | 5 | 1 |
| DeleteQueuedReservedInstances | 5 | 5 |
| DeleteTags | 100 | 10 |
| DeleteVerifiedAccessEndpoint | 20 | 4 |
| DeleteVerifiedAccessGroup | 10 | 2 |
| DeleteVerifiedAccessInstance | 10 | 2 |
| DeleteVerifiedAccessTrustProvider | 10 | 2 |
| DeleteVolume | 100 | 5 |
| DeleteVpcEndpoints | 4 | 0.3 |
| DeleteVpcEndpointServiceConfigurations | 10 | 1 |
| DeprovisionByoipCidr | 1 | 0.1 |
| DeregisterImage | 100 | 5 |
| DescribeAggregateIdFormat | 10 | 10 |
| DescribeByoipCidrs | 1 | 0,5 |
| DescribeCapacityBlockExtensionOfferings | 10 | 0,15 |
| DescribeCapacityBlockOfferings | 10 | 0,15 |
| DescribeDeclarativePoliciesReports | 5 | 5 |
| DescribeHostReservations | 5 | 2 |
| DescribeHostReservationOfferings | 5 | 2 |
| DescribeIdentityIdFormat | 10 | 10 |
| DescribeIdFormat | 10 | 10 |
| DescribeInstanceTopology | 1 | 1 |
| DescribeMovingAddresses | 1 | 1 |
| DescribePrincipalIdFormat | 10 | 10 |
| DescribeReservedInstancesOfferings | 10 | 10 |
| DescribeSecurityGroupReferences | 20 | 5 |
| DescribeSpotDatafeedSubscription | 100 | 13 |
| DescribeSpotFleetInstances | 100 | 5 |
| DescribeSpotFleetRequestHistory | 100 | 5 |
| DescribeSpotFleetRequests | 50 | 3 |
| DescribeStaleSecurityGroups | 20 | 5 |
| DescribeStoreImageTasks | 50 | 0,5 |
| DescribeVerifiedAccessInstanceLoggingConfigurations | 10 | 2 |
| DetachVerifiedAccessTrustProvider | 10 | 2 |
| DisableFastLaunch | 5 | 2 |
| DisableImageBlockPublicAccess | 1 | 0.1 |
| DisableSnapshotBlockPublicAccess | 1 | 0.1 |
| DisassociateCapacityReservationBillingOwner | 1 | 0,5 |
| DisassociateEnclaveCertificateIamRole | 10 | 1 |
| DisassociateIamInstanceProfile | 100 | 5 |
| DisassociateNatGatewayAddress | 10 | 1 |
| EnableFastLaunch | 5 | 2 |
| EnableImageBlockPublicAccess | 1 | 0.1 |
| EnableSnapshotBlockPublicAccess | 1 | 0.1 |
| GetAssociatedEnclaveCertificateIamRoles | 10 | 1 |
| GetDeclarativePoliciesReportSummary | 5 | 5 |
| GetHostReservationPurchasePreview | 5 | 2 |
| ModifyImageAttribute | 100 | 5 |
| ModifyInstanceMetadataDefaults | 2 | 2 |
| ModifyInstanceMetadataOptions | 100 | 5 |
| ModifyLaunchTemplate | 100 | 5 |
| ModifyNetworkInterfaceAttribute | 100 | 5 |
| ModifySnapshotAttribute | 100 | 5 |
| ModifyVerifiedAccessEndpoint | 20 | 4 |
| ModifyVerifiedAccessEndpointPolicy | 20 | 4 |
| ModifyVerifiedAccessGroup | 10 | 2 |
| ModifyVerifiedAccessGroupPolicy | 20 | 4 |
| ModifyVerifiedAccessInstance | 10 | 2 |
| ModifyVerifiedAccessInstanceLoggingConfiguration | 10 | 2 |
| ModifyVerifiedAccessTrustProvider | 10 | 2 |
| ModifyVpcEndpoint | 4 | 0.3 |
| ModifyVpcEndpointServiceConfiguration | 10 | 1 |
| MoveAddressToVpc | 1 | 1 |
| ProvisionByoipCidr | 1 | 0.1 |
| PurchaseCapacityBlock | 10 | 0,15 |
| PurchaseCapacityBlockExtension | 10 | 0,15 |
| PurchaseHostReservation | 5 | 2 |
| PurchaseReservedInstancesOffering | 5 | 5 |
| RejectVpcEndpointConnections | 10 | 1 |
| RestoreAddressToClassic | 1 | 1 |
| RevokeClientVpnIngress | 5 | 2 |
| RunInstances | 5 | 2 |
| StartDeclarativePoliciesReport | 1 | 1 |
| StartInstances | 5 | 2 |
| TerminateInstances | 100 | 5 |
| UnassignPrivateIpAddresses | 100 | 5 |
| UnassignPrivateNatGatewayAddress | 10 | 1 |
| WithdrawByoipCidr | 1 | 0.1 |
## Dimensioni dei Resource Token Bucket e tassi di ricarica
La tabella seguente elenca le dimensioni dei bucket di risorse e le frequenze di ricarica per le azioni API che utilizzano la limitazione della velocità delle risorse.
| Azione API | Capacità massima bucket | Frequenza di ricarica del secchio |
| --- | --- | --- |
| RunInstances | 1000 | 2 |
| TerminateInstances | 1000 | 20 |
| StartInstances | 1000 | 2 |
| StopInstances | 1000 | 20 |
## Monitora la limitazione delle API
Puoi utilizzare Amazon CloudWatch per monitorare le tue richieste EC2 API Amazon e raccogliere e tracciare i parametri relativi alla limitazione delle API. Puoi anche creare un allarme per avvisarti quando stai per raggiungere i limiti di limitazione delle API. Per ulteriori informazioni, consulta [Monitora le richieste EC2 API Amazon utilizzando Amazon CloudWatchMonitora le richieste API utilizzando CloudWatch](monitor.md).
## Tentativi e backoff esponenziale
L'applicazione potrebbe dover ripetere una richiesta API. Esempio:
+ Per verificare la presenza di un aggiornamento dello stato di una risorsa
+ Per enumerare un gran numero di risorse (ad esempio, tutti i volumi)
+ Riprovare una richiesta dopo che ha avuto esito negativo con un errore del server (5xx) o un errore di limitazione
Tuttavia, per un errore del client (4xx), è necessario modificare la richiesta per correggere il problema prima di riprovare la richiesta.
**Modifiche allo stato delle risorse**
Prima di iniziare i sondaggi per verificare la presenza di aggiornamenti sullo stato, attendi il tempo necessario per completare la richiesta. Ad esempio, attendi qualche minuto prima di verificare se l'istanza è attiva. Quando inizi il polling, utilizza un intervallo di sospensione appropriato tra le richieste successive per ridurre la frequenza delle richieste API. Per ottimizzare i risultati, utilizzare un intervallo di attesa incrementale o variabile.
In alternativa, puoi utilizzare Amazon EventBridge per informarti sullo stato di alcune risorse. Ad esempio, puoi utilizzare l'evento **EC2 Instance State-change Notification** per notificarti una modifica dello stato di un'istanza. Per ulteriori informazioni, consulta [Automatizza l' EC2 utilizzo EventBridge di Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/automating_with_eventbridge.html).
**Tentativi**
Quando devi eseguire il polling o riprovare una richiesta API, ti consigliamo di utilizzare un algoritmo di backoff esponenziale per calcolare l'intervallo di sospensione tra le richieste API. L'idea che sottende al backoff esponenziale è di utilizzare attese progressivamente più lunghe tra i tentativi per le risposte di errore consecutive. È consigliabile implementare un intervallo di ritardo massimo, nonché un numero massimo di tentativi. Puoi anche usare il jitter (ritardo casuale) per prevenire collisioni successive. Per maggiori informazioni, consulta [Timeout, nuovi tentativi e backoff con jitter](https://aws.amazon.com/builders-library/timeouts-retries-and-backoff-with-jitter/).
Ogni AWS SDK implementa la logica di ripetizione automatica. Per ulteriori informazioni, consulta [Retry behavior nella *AWS SDKs and* Tools Reference](https://docs.aws.amazon.com/sdkref/latest/guide/feature-retry-behavior.html) Guide.
## Richiedere un aumento del limite della
Puoi richiedere un aumento dei limiti di limitazione delle API per il tuo. Account AWS
**Raccomandazioni**
+ Richiedi un massimo di tre volte il limite esistente in un'unica richiesta.
+ Dai priorità all'aumento della velocità di ricarica delle benne prima di aumentarne la capacità massima.
+ Se la velocità di ricarica della benna richiesta supera la capacità massima della benna, aumenta contemporaneamente la capacità massima della benna.
+ Fornisci tutte le azioni API che richiedono un aumento. I limiti vengono applicati alle singole azioni API, non alle categorie di azioni API.
+ Esistono limiti sia alla frequenza delle richieste che alla frequenza delle risorse per le seguenti azioni API: `RunInstances``StartInstances`,`StopInstances`, e`TerminateInstances`. Assicurati di indicare quale limite deve essere aumentato
**Per richiedere l'accesso a questa funzionalità**
1. Open [Supporto AWS Center](https://console.aws.amazon.com/support/home#/).
1. Scegli **Crea caso**.
1. Scegli **Account e fatturazione**.
1. Per **Assistenza**, scegli **Informazioni generali e Guida introduttiva**.
1. Per **Categoria**, scegli **Uso AWS e servizi**.
1. Scegli **Fase successiva: informazioni aggiuntive**.
1. Per **Subject (Oggetto)**, immettere **Request an increase in my Amazon EC2 API throttling limits**.
1. Per **Descrizione**, copia il seguente modello e fornisci le informazioni richieste.
```
Please increase the API throttling limits for my account.
Related page: https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-throttling.html
Description: Brief notes about your use case. If available, include the IDs
of a few Amazon EC2 requests that were throttled.
Time window: One-hour window when peak throttling or usage occurred.
region_1 request rate increases:
action: new_bucket_maximum_capacity
action: new_bucket_refill_rate
action: new_bucket_maximum_capacity|new_bucket_refill_rate
region_1 resource rate increases:
action: new_bucket_maximum_capacity
action: new_bucket_refill_rate
action: new_bucket_maximum_capacity|new_bucket_refill_rate
region_2 request rate increases:
action: new_bucket_maximum_capacity
action: new_bucket_refill_rate
action: new_bucket_maximum_capacity|new_bucket_refill_rate
region_2 resource rate increases:
action: new_bucket_maximum_capacity
action: new_bucket_refill_rate
action: new_bucket_maximum_capacity|new_bucket_refill_rate
```
1. Scegli **Passaggio successivo: risolvi ora o contattaci**.
1. Nella scheda **Contattaci**, scegli la lingua e il metodo di contatto preferiti.
1. Seleziona **Invia**.
# Impaginazione nell'API Amazon EC2
Ti consigliamo di utilizzare l'impaginazione quando richiami azioni di descrizione che possono potenzialmente restituire un gran numero di risultati, ad esempio. `DescribeInstances` L'utilizzo della paginazione limita il numero di elementi restituiti da una chiamata di descrizione e il tempo necessario per la restituzione della chiamata. Se si dispone di un numero elevato di risorse, le chiamate non impaginate potrebbero essere limitate e potrebbero scadere. Pertanto, la latenza complessiva è migliore con le chiamate impaginate che con le chiamate non impaginate, perché le chiamate impaginate hanno sempre esito positivo.
Per ulteriori informazioni, consulta [Pagination](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Query-Requests.html#api-pagination) nell'*Amazon EC2 API Reference.*
## Best practice
Se possibile, specifica un elenco di risorse IDs nelle chiamate di descrizione. Questo è il modo più veloce per descrivere un gran numero di risorse. Tieni presente che non devi specificare più di 1.000 IDs in una singola chiamata. Di seguito è riportato un esempio.
```
private List describeMyInstances(List ids){
if (ids == null || ids.isEmpty()) {
return ImmutableList.of();
}
final DescribeInstancesRequest request = new DescribeInstancesRequest()
.withInstanceIds(ids);
return ec2.describeInstances(request).getReservations();
}
```
Se non riesci a specificare la risorsa IDs nelle chiamate di descrizione, ti consigliamo vivamente di utilizzare la paginazione. Di seguito è riportato un esempio.
```
private List describeMyInstances(final Collection filters){
final DescribeInstancesRequest request = new DescribeInstancesRequest()
.withFilters(filters)
.withMaxResults(1000);
List reservations = new ArrayList<>();
String nextToken = null;
do {
request.setNextToken(nextToken);
final DescribeInstancesResult response = ec2.describeInstances(request);
reservations.addAll(response.getReservations());
nextToken = response.getNextToken();
} while (nextToken != null);
return reservations;
}
```
Se devi riprovare una chiamata impaginata, usa il back-off [esponenziale](ec2-api-throttling.md#api-backoff) con jitter.
## Problemi comuni
Di seguito sono riportati alcuni esempi di codice che effettua inavvertitamente chiamate non impaginate.
**Example Esempio di problema: passaggio di un elenco vuoto di risorse IDs**
Il codice seguente utilizza un elenco di IDs. Tuttavia, se l'elenco è vuoto, il risultato è una chiamata non impaginata.
```
private List describeMyInstances(List ids){
final DescribeInstancesRequest request = new DescribeInstancesRequest()
.withInstanceIds(ids);
return ec2.describeInstances(request).getReservations();
}
```
Per risolvere questo problema, assicurati che l'elenco non sia vuoto prima di effettuare la chiamata describe.
```
private List describeMyInstances(List ids){
if (ids == null || ids.isEmpty()) {
return ImmutableList.of();
// OR
return Lists.newArrayList();
// OR
return new ArrayList<>();
}
final DescribeInstancesRequest request = new DescribeInstancesRequest()
.withInstanceIds(ids);
return ec2.describeInstances(request).getReservations();
}
```
**Example Esempio di problema: mancata impostazione MaxResults**
Il codice seguente controlla e utilizza`nextToken`, ma non imposta`MaxResults`.
```
private List describeMyInstances(final Collection filters){
final DescribeInstancesRequest request = new DescribeInstancesRequest()
.withFilters(filters);
List reservations = new ArrayList<>();
String nextToken = null;
do {
request.setNextToken(nextToken);
final DescribeInstancesResult response = ec2.describeInstances(request);
reservations.addAll(response.getReservations());
nextToken = response.getNextToken();
} while (nextToken != null);
return reservations;
}
```
Per correggere questo problema, aggiungi `withMaxResults` quanto segue.
```
private List describeMyInstances(final Collection filters){
final DescribeInstancesRequest request = new DescribeInstancesRequest()
.withFilters(filters)
.withMaxResults(1000);
List reservations = new ArrayList<>();
String nextToken = null;
do {
request.setNextToken(nextToken);
final DescribeInstancesResult response = ec2.describeInstances(request);
reservations.addAll(response.getReservations());
nextToken = response.getNextToken();
} while (nextToken != null);
return reservations;
}
```