Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utiliser EBS direct APIs pour accéder au contenu d'un instantané EBS
Vous pouvez utiliser les API Amazon Elastic Block Store (Amazon EBS) directes pour créer des instantanés EBS, écrire des données directement sur vos instantanés, lire des données sur vos instantanés et identifier les différences ou les modifications entre deux instantanés. Si vous êtes un fournisseur indépendant de logiciel (FIL) qui offre des services de sauvegarde pour Amazon EBS, il est plus rentable et efficace d’utiliser les API directes EBS pour de suivre les modifications incrémentielles sur vos volumes EBS via des instantanés EBS à l’aide des instantanés. Pour ce faire, vous n’avez pas besoin de créer des volumes à partir d’instantanés, puis d’utiliser des instances Amazon Elastic Compute Cloud (Amazon EC2) pour comparer leurs différences.
Vous pouvez créer des instantanés incrémentiels directement à partir de données locales dans des volumes EBS et dans le cloud afin de les utiliser pour une reprise après sinistre rapide. Avec la possibilité d’écrire et de lire des instantanés, vous pouvez écrire vos données locales dans un instantané EBS lors d’un sinistre. Ensuite, après la restauration, vous pouvez le restaurer vers AWS ou sur site à partir du snapshot. Vous n’avez plus besoin de créer et de gérer des mécanismes complexes pour copier des données depuis et vers Amazon EBS.
Ce guide de l'utilisateur fournit une vue d'ensemble des éléments qui constituent l'EBS direct APIs, ainsi que des exemples de leur utilisation efficace. Pour plus d'informations sur les actions, les types de données, les paramètres et les erreurs du APIs, consultez la [ APIs référence directe EBS](https://docs.aws.amazon.com/ebs/latest/APIReference/). Pour plus d'informations sur les AWS régions, les points de terminaison et les quotas de service pris en charge pour EBS direct APIs, consultez la section [Points de terminaison et quotas Amazon EBS](https://docs.aws.amazon.com/general/latest/gr/ebs-service.html) dans le. *Références générales AWS*
**Topics**
+ [Tarification](ebsapi-pricing.md)
+ [Concepts](ebsapi-elements.md)
+ [Contrôle d'accès](ebsapi-permissions.md)
+ [Lire les instantanés](readsnapshots.md)
+ [Écrire des instantanés](writesnapshots.md)
+ [Résultats du chiffrement](ebsapis-using-encryption.md)
+ [Valider les données de capture](ebsapis-using-checksums.md)
+ [Garantir l'idempuissance](ebs-direct-api-idempotency.md)
+ [Tentatives d’erreurs](error-retries.md)
+ [Optimiser les performances](ebsapi-performance.md)
+ [Points de terminaison de service](using-endpoints.md)
+ [Exemples de code SDK](sdk.md)
+ [Points de terminaison de VPC d’Interface](ebs-apis-vpc-endpoints.md)
+ [CloudTrail journaux](logging-ebs-apis-using-cloudtrail.md)
+ [FAQs](ebsapi-faq.md)
# Tarification d'EBS Direct APIs
## Tarification pour APIs
Le prix que vous payez pour utiliser l'EBS direct APIs dépend des demandes que vous faites. Pour plus d’informations, consultez la section [Tarification d’Amazon EBS](https://aws.amazon.com/ebs/pricing/).
+ **ListChangedBlocks**et ListSnapshotBlocks APIs sont facturés par demande. Par exemple, si vous effectuez 100 000 demandes d' ListSnapshotBlocks API dans une région qui facture 0,0006\$1 par 1 000 demandes, vous serez facturé 0,06\$1 (0,0006\$1 par 1 000 demandes x 100).
+ **GetSnapshotBlock**est facturé par bloc retourné. Par exemple, si vous effectuez 100 000 demandes d' GetSnapshotBlock API dans une région qui facture 0,003\$1 par 1 000 blocs renvoyés, vous serez facturé 0,30\$1 (0,003\$1 par 1 000 blocs renvoyés x 100).
+ **PutSnapshotBlock**est facturé par bloc écrit. Par exemple, si vous effectuez 100 000 demandes d' PutSnapshotBlock API dans une région qui facture 0,006\$1 par 1 000 blocs écrits, vous serez facturé 0,60\$1 (0,006\$1 par 1 000 blocs écrits x 100).
## Coûts de mise en réseau
**Coûts de transfert des données**
Les données transférées directement entre les API directes EBS et les instances Amazon EC2 d'une AWS même région sont gratuites lorsque vous [utilisez](https://docs.aws.amazon.com/general/latest/gr/ebs-service.html#ebs_direct_apis) des points de terminaison non FIPS. Pour plus d’informations, consultez [Points de terminaison du service AWS](https://docs.aws.amazon.com/general/latest/gr/rande.html). Si d'autres AWS services sont en cours de transfert de données, les frais de traitement des données associés vous seront facturés. Ces services incluent, sans toutefois s'y limiter, les PrivateLink points de terminaison, NAT Gateway et Transit Gateway.
**Points de terminaison de l’interface d’un VPC**
Si vous utilisez des API directes EBS à partir d'instances Amazon EC2 AWS Lambda ou des fonctions dans des sous-réseaux privés, vous pouvez utiliser des points de terminaison d'interface VPC, au lieu d'utiliser des passerelles NAT, afin de réduire les coûts de transfert de données réseau. Pour de plus amples informations, veuillez consulter [Création d'une connexion privée entre un VPC et EBS direct APIs](ebs-apis-vpc-endpoints.md).
# Concepts pour EBS direct APIs
Voici les concepts clés que vous devez comprendre avant de commencer à utiliser l'EBS direct APIs.
## Instantanés
Les instantanés représentent le principal moyen de sauvegarde des données de vos volumes EBS. Avec EBS direct APIs, vous pouvez également sauvegarder les données de vos disques locaux sur des instantanés. Afin d’économiser les frais de stockage, les instantanés successifs sont incrémentiels ; ils contiennent uniquement les données du volume ayant changé depuis l’instantané précédent. Pour de plus amples informations, veuillez consulter [Instantanés Amazon EBS](ebs-snapshots.md).
**Note**
EBS direct APIs ne prend pas en charge les instantanés publics et les instantanés locaux activés. AWS Outposts
## Blocs
Un bloc est un fragment de données au sein d’un instantané. Chaque instantané peut contenir des milliers de blocs. Tous les blocs d’un instantané sont de taille fixe.
## Index de bloc
Un index de blocs est un index logique en unités de `512` blocs Kio. Pour identifier l’index de blocs, divisez le décalage logique des données dans le volume logique par la taille de bloc (décalage logique des données/`524288`). Le décalage logique des données doit être `512` aligné en Kio.
## Jetons de bloc
Un jeton de bloc est le hachage d’identification d’un bloc dans un instantané. Il est utilisé pour localiser les données de bloc. Les jetons de blocage renvoyés par EBS direct APIs sont temporaires. Ils changent à l'heure d'expiration spécifiée pour eux, ou si vous en exécutez un autre ListSnapshotBlocks ou si vous ListChangedBlocks demandez le même instantané.
## Total de contrôle
Une somme de contrôle est une référence de petite taille dérivée d’un bloc de données dans le but de détecter les erreurs introduites lors de sa transmission ou de son stockage. L'EBS Direct APIs utilise des checksums pour valider l'intégrité des données. Lorsque vous lisez des données à partir d'un instantané EBS, le service fournit des SHA256 sommes de contrôle codées en Base64 pour chaque bloc de données transmis, que vous pouvez utiliser pour la validation. Lorsque vous écrivez des données dans un instantané EBS, vous devez fournir une SHA256 somme de contrôle codée en Base64 pour chaque bloc de données transmis. Le service valide les données reçues à l’aide de la somme de contrôle fournie. Pour plus d’informations, consultez [Utilisez les APIs checksums directs d'EBS pour valider les données des instantanés](ebsapis-using-checksums.md) plus loin dans ce guide.
## Chiffrement
Le chiffrement protège vos données en les convertissant en code illisible qui ne peut être déchiffré que par les personnes ayant accès à la clé KMS utilisée pour les chiffrer. Vous pouvez utiliser l'EBS direct APIs pour lire et écrire des instantanés chiffrés, mais il existe certaines limites. Pour plus d’informations, consultez [Résultats du chiffrement pour EBS Direct APIs](ebsapis-using-encryption.md) plus loin dans ce guide.
## Actions d’API
L'EBS direct APIs comprend six actions. Il y a trois actions de lecture et trois actions d’écriture. Les actions de lecture sont :
+ **ListSnapshotBlocks**— renvoie les index des blocs et les jetons des blocs dans l'instantané spécifié
+ **ListChangedBlocks**— renvoie les index de blocs et les jetons de blocs qui sont différents entre deux instantanés spécifiés du même volume et de la même lignée d'instantanés.
+ **GetSnapshotBlock**— renvoie les données dans un bloc pour l'ID d'instantané, l'index de bloc et le jeton de bloc spécifiés.
Les actions d’écriture sont :
+ **StartSnapshot**— démarre un instantané, soit en tant que capture incrémentielle d'un instantané existant, soit en tant que nouvel instantané. Le snapshot démarré reste en attente jusqu'à ce qu'il soit terminé à l'aide de l' CompleteSnapshot action.
+ **PutSnapshotBlock**— ajoute des données à un instantané démarré sous forme de blocs individuels. Vous devez spécifier une SHA256 somme de contrôle codée en Base64 pour le bloc de données transmis. Le service valide le total de contrôle après la fin de la transmission des données. La requête échoue lorsque le total de contrôle calculé par le service ne correspond pas à la valeur que vous avez spécifiée.
+ **CompleteSnapshot**— termine un instantané démarré qui est en attente. L’instantané passe alors à l’état terminé.
## Signature Version 4 : signature
Signature Version 4 est le processus permettant d'ajouter des informations d'authentification aux AWS demandes envoyées par HTTP. Pour des raisons de sécurité, la plupart des demandes AWS doivent être signées avec une clé d'accès, qui consiste en un identifiant de clé d'accès et une clé d'accès secrète. Ces deux clés sont généralement appelées informations d’identification de sécurité. Pour plus d’informations sur la façon d’obtenir les informations d’identification permettant d’accéder à votre compte, reportez-vous à [Informations d’identification de sécurité AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds.html).
Si vous avez l’intention de créer manuellement des requêtes HTTP, vous devez apprendre à les signer. Lorsque vous utilisez le AWS Command Line Interface (AWS CLI) ou l'un des AWS SDKs pour faire des demandes AWS, ces outils signent automatiquement les demandes à votre place avec la clé d'accès que vous spécifiez lors de la configuration des outils. Lorsque vous utilisez ces derniers, vous n’avez pas besoin d’apprendre à signer vous-même les demandes.
Pour plus d'informations, consultez la section [Signature des demandes AWS d'API](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) dans le *guide de l'utilisateur IAM*.
# Contrôlez l'accès à EBS direct à APIs l'aide d'IAM
Un utilisateur doit disposer des politiques suivantes pour utiliser l'EBS direct APIs. Pour plus d’informations, consultez [Modification des autorisations d’un utilisateur](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html).
Pour plus d'informations sur les APIs ressources directes, les actions et les clés contextuelles de condition EBS à utiliser dans les politiques d'autorisation IAM, consultez la section [Actions, ressources et clés de condition pour Amazon Elastic Block Store](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonelasticblockstore.html) dans le *Service Authorization Reference*.
**Important**
Soyez prudent lorsque vous affectez les stratégies suivantes aux utilisateurs . En attribuant ces politiques, vous pouvez donner accès à un utilisateur qui se voit refuser l'accès à la même ressource par le biais d'Amazon APIs EC2, par exemple CopySnapshot les CreateVolume actions or.
## Autorisations de lire des instantanés
La politique suivante permet d'utiliser la *lecture* directe APIs EBS sur tous les instantanés d'une région spécifique AWS . Dans la politique, remplacez ** par la région de l'instantané.
La politique suivante permet d'utiliser la *lecture* directe EBS sur APIs les instantanés dotés d'une balise clé-valeur spécifique. Dans la politique, remplacez ** par la valeur clé de la balise et ** par la valeur de la balise.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ebs:ListSnapshotBlocks",
"ebs:ListChangedBlocks",
"ebs:GetSnapshotBlock"
],
"Resource": "arn:aws:ec2:*::snapshot/*",
"Condition": {
"StringEqualsIgnoreCase": {
"aws:ResourceTag/": ""
}
}
}
]
}
```
------
La politique suivante permet d'utiliser l'intégralité de la *lecture* directe APIs EBS sur tous les instantanés du compte uniquement dans un intervalle de temps spécifique. Cette politique autorise l'utilisation de l'EBS direct sur la APIs base de la clé de condition `aws:CurrentTime` globale. Dans la politique, veillez à remplacer la plage de dates et d’heures affichée par la plage de dates et d’heures de votre politique.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ebs:ListSnapshotBlocks",
"ebs:ListChangedBlocks",
"ebs:GetSnapshotBlock"
],
"Resource": "arn:aws:ec2:*::snapshot/*",
"Condition": {
"DateGreaterThan": {
"aws:CurrentTime": "2018-05-29T00:00:00Z"
},
"DateLessThan": {
"aws:CurrentTime": "2020-05-29T23:59:59Z"
}
}
}
]
}
```
------
Pour plus d’informations, consultez [Modification des autorisations d’un utilisateur](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html) dans le *Guide de l’utilisateur IAM*.
## Autorisations d’écrire des instantanés
La politique suivante permet d'utiliser l'*écriture* directe APIs EBS sur tous les instantanés d'une région spécifique AWS . Dans la politique, remplacez ** par la région de l'instantané.
La politique suivante permet d'utiliser l'*écriture* directe EBS sur APIs les instantanés dotés d'une balise clé-valeur spécifique. Dans la politique, remplacez ** par la valeur clé de la balise et ** par la valeur de la balise.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ebs:StartSnapshot",
"ebs:PutSnapshotBlock",
"ebs:CompleteSnapshot"
],
"Resource": "arn:aws:ec2:*::snapshot/*",
"Condition": {
"StringEqualsIgnoreCase": {
"aws:ResourceTag/": ""
}
}
}
]
}
```
------
La politique suivante autorise l'utilisation de tous les EBS Direct APIs . Elle n’autorise également l’action `StartSnapshot` que si un ID d’instantané parent est spécifié. Par conséquent, cette politique bloque la possibilité de démarrer de nouveaux instantanés sans utiliser un instantané parent.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ebs:*",
"Resource": "*",
"Condition": {
"StringEquals": {
"ebs:ParentSnapshot": "arn:aws:ec2:*::snapshot/*"
}
}
}
]
}
```
------
La politique suivante autorise l'utilisation de tous les EBS Direct APIs . Il permet également de créer uniquement la clé de balise `user` pour un nouvel instantané. Cette politique garantit également que l’utilisateur dispose de l’accès approprié pour créer des balises. L’action `StartSnapshot` est la seule action qui peut spécifier des balises.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ebs:*",
"Resource": "*",
"Condition": {
"ForAllValues:StringEquals": {
"aws:TagKeys": "user"
}
}
},
{
"Effect": "Allow",
"Action": "ec2:CreateTags",
"Resource": "*"
}
]
}
```
------
La politique suivante permet d'utiliser l'intégralité de l'*écriture* directe APIs EBS sur tous les instantanés du compte uniquement dans un intervalle de temps spécifique. Cette politique autorise l'utilisation de l'EBS direct sur la APIs base de la clé de condition `aws:CurrentTime` globale. Dans la politique, veillez à remplacer la plage de dates et d’heures affichée par la plage de dates et d’heures de votre politique.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ebs:StartSnapshot",
"ebs:PutSnapshotBlock",
"ebs:CompleteSnapshot"
],
"Resource": "arn:aws:ec2:*::snapshot/*",
"Condition": {
"DateGreaterThan": {
"aws:CurrentTime": "2018-05-29T00:00:00Z"
},
"DateLessThan": {
"aws:CurrentTime": "2020-05-29T23:59:59Z"
}
}
}
]
}
```
------
Pour plus d’informations, consultez [Modification des autorisations d’un utilisateur](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html) dans le *Guide de l’utilisateur IAM*.
## Autorisations d'utilisation AWS KMS keys
La politique suivante accorde les autorisations permettant de déchiffrer un instantané chiffré à l’aide d’une clé KMS spécifique. Elle permet également de chiffrer de nouveaux instantanés à l’aide de la clé KMS par défaut pour le chiffrement EBS. Dans la politique, remplacez ** par la région de la clé KMS, ** par l'ID du AWS compte associé à la clé KMS et ** par l'ID de la clé KMS.
**Note**
Par défaut, tous les principaux du compte ont accès à la clé KMS AWS gérée par défaut pour le chiffrement Amazon EBS, et ils peuvent l'utiliser pour les opérations de chiffrement et de déchiffrement EBS. Si vous utilisez une clé gérée par le client, vous devez créer une nouvelle politique de clé ou modifier la politique de clé existante pour la clé gérée par le client afin d’accorder au principal l’accès à la clé gérée par le client. Pour plus d’informations, consultez [Politiques de clé dans AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) dans le *Guide du développeur AWS Key Management Service *.
**Astuce**
Pour suivre le principe du moindre privilège, n’autorisez pas l’accès complet à `kms:CreateGrant`. Utilisez plutôt la clé de `kms:GrantIsForAWSResource` condition pour autoriser l'utilisateur à créer des autorisations sur la clé KMS uniquement lorsque l'autorisation est créée en son nom par un AWS service, comme indiqué dans l'exemple suivant.
Pour plus d’informations, consultez [Modification des autorisations d’un utilisateur](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html) dans le *Guide de l’utilisateur IAM*.
# Lisez les instantanés d'Amazon EBS avec EBS direct APIs
Les étapes suivantes décrivent comment utiliser l'EBS direct APIs pour lire des instantanés :
1. Utilisez cette ListSnapshotBlocks action pour afficher tous les index de blocs et les jetons de bloc des blocs dans un instantané. Vous pouvez également utiliser cette ListChangedBlocks action pour afficher uniquement les index de blocs et les jetons de blocs différents entre deux instantanés du même volume et de la même lignée de clichés. Ces actions vous aident à identifier les jetons de bloc et les index de bloc des blocs pour lesquels vous pouvez obtenir des données.
1. Utilisez l' GetSnapshotBlock action et spécifiez l'index du bloc et le jeton de bloc du bloc pour lequel vous souhaitez obtenir des données.
**Note**
Vous ne pouvez pas utiliser EBS direct APIs avec des instantanés archivés.
Les exemples suivants montrent comment lire des instantanés à l'aide d'EBS direct. APIs
**Topics**
+ [Liste des blocs dans un instantané](#list-blocks)
+ [Liste des blocs qui sont différents entre deux instantanés](#list-different-blocks)
+ [Obtenir des données de bloc à partir d’un instantané](#get-block-data)
## Liste des blocs dans un instantané
------
#### [ AWS CLI ]
L'[list-snapshot-blocks](https://docs.aws.amazon.com/cli/latest/reference/ebs/list-snapshot-blocks.html)exemple de commande suivant renvoie les index de blocs et les jetons de bloc des blocs qui se trouvent dans un instantané`snap-0987654321`. Le paramètre `--starting-block-index` limite les résultats aux index de blocs supérieurs à `1000`, et le paramètre `--max-results` limite les résultats aux premiers blocs `100`.
```
aws ebs list-snapshot-blocks --snapshot-id snap-0987654321 --starting-block-index 1000 --max-results 100
```
L’exemple de réponse suivant pour la commande précédente répertorie les index de bloc et les jetons de bloc dans l’instantané. Utilisez la commande `get-snapshot-block` et spécifiez l'index de bloc et le jeton de bloc du bloc pour lequel vous souhaitez obtenir des données. Les jetons de bloc sont valides jusqu'au délai d'expiration indiqué.
```
{
"Blocks": [
{
"BlockIndex": 1001,
"BlockToken": "AAABAV3/PNhXOynVdMYHUpPsetaSvjLB1dtIGfbJv5OJ0sX855EzGTWos4a4"
},
{
"BlockIndex": 1002,
"BlockToken": "AAABATGQIgwr0WwIuqIMjCA/Sy7e/YoQFZsHejzGNvjKauzNgzeI13YHBfQB"
},
{
"BlockIndex": 1007,
"BlockToken": "AAABAZ9CTuQtUvp/dXqRWw4d07eOgTZ3jvn6hiW30W9duM8MiMw6yQayzF2c"
},
{
"BlockIndex": 1012,
"BlockToken": "AAABAQdzxhw0rVV6PNmsfo/YRIxo9JPR85XxPf1BLjg0Hec6pygYr6laE1p0"
},
{
"BlockIndex": 1030,
"BlockToken": "AAABAaYvPax6mv+iGWLdTUjQtFWouQ7Dqz6nSD9L+CbXnvpkswA6iDID523d"
},
{
"BlockIndex": 1031,
"BlockToken": "AAABATgWZC0XcFwUKvTJbUXMiSPg59KVxJGL+BWBClkw6spzCxJVqDVaTskJ"
},
...
],
"ExpiryTime": 1576287332.806,
"VolumeSize": 32212254720,
"BlockSize": 524288
}
```
------
#### [ AWS API ]
L'[ListSnapshotBlocks](https://docs.aws.amazon.com/ebs/latest/APIReference/API_ListSnapshotBlocks.html)exemple de demande suivant renvoie les index de blocs et les jetons de bloc des blocs qui se trouvent dans un instantané`snap-0acEXAMPLEcf41648`. Le paramètre `startingBlockIndex` limite les résultats aux index de blocs supérieurs à `1000`, et le paramètre `maxResults` limite les résultats aux premiers blocs `100`.
```
GET /snapshots/snap-0acEXAMPLEcf41648/blocks?maxResults=100&startingBlockIndex=1000 HTTP/1.1
Host: ebs.us-east-2.amazonaws.com
Accept-Encoding: identity
User-Agent:
X-Amz-Date: 20200617T231953Z
Authorization:
```
L’exemple de réponse suivant pour la demande précédente répertorie les index de bloc et les jetons de bloc dans l’instantané. Utilisez l' GetSnapshotBlock action et spécifiez l'index de bloc et le jeton de bloc du bloc pour lequel vous souhaitez obtenir des données. Les jetons de bloc sont valides jusqu'au délai d'expiration indiqué.
```
HTTP/1.1 200 OK
x-amzn-RequestId: d6e5017c-70a8-4539-8830-57f5557f3f27
Content-Type: application/json
Content-Length: 2472
Date: Wed, 17 Jun 2020 23:19:56 GMT
Connection: keep-alive
{
"BlockSize": 524288,
"Blocks": [
{
"BlockIndex": 0,
"BlockToken": "AAUBAcuWqOCnDNuKle11s7IIX6jp6FYcC/q8oT93913HhvLvA+3JRrSybp/0"
},
{
"BlockIndex": 1536,
"BlockToken": "AAUBAWudwfmofcrQhGVlLwuRKm2b8ZXPiyrgoykTRC6IU1NbxKWDY1pPjvnV"
},
{
"BlockIndex": 3072,
"BlockToken": "AAUBAV7p6pC5fKAC7TokoNCtAnZhqq27u6YEXZ3MwRevBkDjmMx6iuA6tsBt"
},
{
"BlockIndex": 3073,
"BlockToken": "AAUBAbqt9zpqBUEvtO2HINAfFaWToOwlPjbIsQOlx6JUN/0+iMQl0NtNbnX4"
},
...
],
"ExpiryTime": 1.59298379649E9,
"VolumeSize": 3
}
```
------
## Liste des blocs qui sont différents entre deux instantanés
Tenez compte des points suivants lorsque vous effectuez des **demandes paginées** pour répertorier les blocs modifiés entre deux instantanés :
+ La réponse peut inclure un ou plusieurs tableaux `ChangedBlocks` vides. Par exemple :
+ Instantané 1 – instantané complet avec 1 000 blocs avec des index de blocs `0` – `999`.
+ Instantané 2 – instantané incrémentiel avec un seul bloc modifié avec l’index de bloc `999`.
La liste des blocs modifiés pour ces instantanés avec `StartingBlockIndex = 0` et `MaxResults = 100` renvoie un tableau vide de `ChangedBlocks`. Vous devez demander les autres résultats en utilisant `nextToken` jusqu’à ce que le bloc modifié soit retourné dans le dixième jeu de résultats, qui comprend les blocs avec les index de bloc `900` – `999`.
+ La réponse peut ignorer les blocs non écrits dans les instantanés. Par exemple :
+ Instantané 1 – instantané complet avec 1 000 blocs avec des index de blocs `2000` – `2999`.
+ Instantané 2 – instantané incrémentiel avec un seul bloc modifié avec l’index de bloc `2000`.
En listant les blocs modifiés pour ces instantanés avec `StartingBlockIndex = 0` et `MaxResults = 100`, la réponse ignore les index de bloc `0` – `1999` et inclut l’index de bloc `2000`. La réponse n’inclura pas les tableaux `ChangedBlocks` vides.
------
#### [ AWS CLI ]
L'[list-changed-blocks](https://docs.aws.amazon.com/cli/latest/reference/ebs/list-changed-blocks.html)exemple de commande suivant renvoie les index de blocs et les jetons de bloc des blocs qui sont différents entre les instantanés `snap-1234567890` et. `snap-0987654321` Le paramètre `--starting-block-index` limite les résultats aux index de blocs supérieurs à `0`, et le paramètre `--max-results` limite les résultats aux premiers blocs `500`.
```
aws ebs list-changed-blocks --first-snapshot-id snap-1234567890 --second-snapshot-id snap-0987654321 --starting-block-index 0 --max-results 500
```
L’exemple de réponse suivant pour la commande précédente montre que les index de bloc 0, 6000, 6001, 6002 et 6003 sont différents entre les deux instantanés. De plus, les index de bloc 6001, 6002 et 6003 existent uniquement dans le premier ID d’instantané spécifié, et pas dans le second ID d’instantané car la réponse ne répertorie aucun second jeton de bloc.
Utilisez la commande `get-snapshot-block` et spécifiez l’index de bloc et le jeton de bloc du bloc pour lequel vous souhaitez obtenir des données. Les jetons de bloc sont valides jusqu'au délai d'expiration indiqué.
```
{
"ChangedBlocks": [
{
"BlockIndex": 0,
"FirstBlockToken": "AAABAVahm9SO60Dyi0ORySzn2ZjGjW/KN3uygGlS0QOYWesbzBbDnX2dGpmC",
"SecondBlockToken": "AAABAf8o0o6UFi1rDbSZGIRaCEdDyBu9TlvtCQxxoKV8qrUPQP7vcM6iWGSr"
},
{
"BlockIndex": 6000,
"FirstBlockToken": "AAABAbYSiZvJ0/R9tz8suI8dSzecLjN4kkazK8inFXVintPkdaVFLfCMQsKe",
"SecondBlockToken": "AAABAZnqTdzFmKRpsaMAsDxviVqEI/3jJzI2crq2eFDCgHmyNf777elD9oVR"
},
{
"BlockIndex": 6001,
"FirstBlockToken": "AAABASBpSJ2UAD3PLxJnCt6zun4/T4sU25Bnb8jB5Q6FRXHFqAIAqE04hJoR"
},
{
"BlockIndex": 6002,
"FirstBlockToken": "AAABASqX4/NWjvNceoyMUljcRd0DnwbSwNnes1UkoP62CrQXvn47BY5435aw"
},
{
"BlockIndex": 6003,
"FirstBlockToken": "AAABASmJ0O5JxAOce25rF4P1sdRtyIDsX12tFEDunnePYUKOf4PBROuICb2A"
},
...
],
"ExpiryTime": 1576308931.973,
"VolumeSize": 32212254720,
"BlockSize": 524288,
"NextToken": "AAADARqElNng/sV98CYk/bJDCXeLJmLJHnNSkHvLzVaO0zsPH/QM3Bi3zF//O6Mdi/BbJarBnp8h"
}
```
------
#### [ AWS API ]
L'[ListChangedBlocks](https://docs.aws.amazon.com/ebs/latest/APIReference/API_ListChangedBlocks.html)exemple de demande suivant renvoie les index de blocs et les jetons de bloc des blocs qui sont différents entre les instantanés `snap-0acEXAMPLEcf41648` et. `snap-0c9EXAMPLE1b30e2f` Le paramètre `startingBlockIndex` limite les résultats aux index de blocs supérieurs à `0`, et le paramètre `maxResults` limite les résultats aux premiers blocs `500`.
```
GET /snapshots/snap-0c9EXAMPLE1b30e2f/changedblocks?firstSnapshotId=snap-0acEXAMPLEcf41648&maxResults=500&startingBlockIndex=0 HTTP/1.1
Host: ebs.us-east-2.amazonaws.com
Accept-Encoding: identity
User-Agent:
X-Amz-Date: 20200617T232546Z
Authorization:
```
L’exemple de réponse suivant pour la requête précédente montre que les index de bloc `0`, `3072`, `6002` et `6003` sont différents entre les deux instantanés. De plus, les index de bloc `6002` et `6003` existent uniquement dans le premier ID d’instantané spécifié, et pas dans le second ID d’instantané car la réponse ne répertorie aucun second jeton de bloc.
Utilisez l’action `GetSnapshotBlock` et spécifiez l’index de bloc et le jeton de bloc du bloc pour lequel vous souhaitez obtenir des données. Les jetons de bloc sont valides jusqu’au délai d’expiration indiqué.
```
HTTP/1.1 200 OK
x-amzn-RequestId: fb0f6743-6d81-4be8-afbe-db11a5bb8a1f
Content-Type: application/json
Content-Length: 1456
Date: Wed, 17 Jun 2020 23:25:47 GMT
Connection: keep-alive
{
"BlockSize": 524288,
"ChangedBlocks": [
{
"BlockIndex": 0,
"FirstBlockToken": "AAUBAVaWqOCnDNuKle11s7IIX6jp6FYcC/tJuVT1GgP23AuLntwiMdJ+OJkL",
"SecondBlockToken": "AAUBASxzy0Y0b33JVRLoYm3NOresCxn5RO+HVFzXW3Y/RwfFaPX2Edx8QHCh"
},
{
"BlockIndex": 3072,
"FirstBlockToken": "AAUBAcHp6pC5fKAC7TokoNCtAnZhqq27u6fxRfZOLEmeXLmHBf2R/Yb24MaS",
"SecondBlockToken": "AAUBARGCaufCqBRZC8tEkPYGGkSv3vqvOjJ2xKDi3ljDFiytUxBLXYgTmkid"
},
{
"BlockIndex": 6002,
"FirstBlockToken": "AAABASqX4/NWjvNceoyMUljcRd0DnwbSwNnes1UkoP62CrQXvn47BY5435aw"
},
{
"BlockIndex": 6003,
"FirstBlockToken": "AAABASmJ0O5JxAOce25rF4P1sdRtyIDsX12tFEDunnePYUKOf4PBROuICb2A"
},
...
],
"ExpiryTime": 1.592976647009E9,
"VolumeSize": 3
}
```
------
## Obtenir des données de bloc à partir d’un instantané
------
#### [ AWS CLI ]
L'[get-snapshot-block](https://docs.aws.amazon.com/cli/latest/reference/ebs/get-snapshot-block.html)exemple de commande suivant renvoie les données de l'index du bloc `6001` avec le jeton de bloc`AAABASBpSJ2UAD3PLxJnCt6zun4/T4sU25Bnb8jB5Q6FRXHFqAIAqE04hJoR`, sous forme d'instantané`snap-1234567890`. Les données binaires seront générées dans le fichier `data` dans le répertoire `C:\Temp` sur un ordinateur Windows. Si vous exécutez la commande sur un ordinateur Linux ou Unix, remplacez le chemin de sortie par `/tmp/data` pour générer les données dans le fichier `data` du répertoire `/tmp`.
```
aws ebs get-snapshot-block --snapshot-id snap-1234567890 --block-index 6001 --block-token AAABASBpSJ2UAD3PLxJnCt6zun4/T4sU25Bnb8jB5Q6FRXHFqAIAqE04hJoR C:/Temp/data
```
L’exemple de réponse suivant pour la commande précédente montre la taille des données renvoyées, la somme de contrôle pour valider les données et l’algorithme de la somme de contrôle. Les données binaires sont automatiquement enregistrées dans le répertoire et le fichier que vous avez spécifiés dans la commande de demande.
```
{
"DataLength": "524288",
"Checksum": "cf0Y6/Fn0oFa4VyjQPOa/iD0zhTflPTKzxGv2OKowXc=",
"ChecksumAlgorithm": "SHA256"
}
```
------
#### [ AWS API ]
L'[GetSnapshotBlock](https://docs.aws.amazon.com/ebs/latest/APIReference/API_GetSnapshotBlock.html)exemple de demande suivant renvoie les données de l'index du bloc `3072` avec le jeton de bloc`AAUBARGCaufCqBRZC8tEkPYGGkSv3vqvOjJ2xKDi3ljDFiytUxBLXYgTmkid`, sous forme d'instantané`snap-0c9EXAMPLE1b30e2f`.
```
GET /snapshots/snap-0c9EXAMPLE1b30e2f/blocks/3072?blockToken=AAUBARGCaufCqBRZC8tEkPYGGkSv3vqvOjJ2xKDi3ljDFiytUxBLXYgTmkid HTTP/1.1
Host: ebs.us-east-2.amazonaws.com
Accept-Encoding: identity
User-Agent:
X-Amz-Date: 20200617T232838Z
Authorization:
```
L’exemple de réponse suivant pour la demande précédente montre la taille des données renvoyées, la somme de contrôle pour valider les données et l’algorithme utilisé pour générer la somme de contrôle. Les données binaires sont transmises dans le corps de la réponse et sont représentées comme *BlockData* dans l'exemple suivant.
```
HTTP/1.1 200 OK
x-amzn-RequestId: 2d0db2fb-bd88-474d-a137-81c4e57d7b9f
x-amz-Data-Length: 524288
x-amz-Checksum: Vc0yY2j3qg8bUL9I6GQuI2orTudrQRBDMIhcy7bdEsw=
x-amz-Checksum-Algorithm: SHA256
Content-Type: application/octet-stream
Content-Length: 524288
Date: Wed, 17 Jun 2020 23:28:38 GMT
Connection: keep-alive
BlockData
```
------
# Rédigez des instantanés Amazon EBS avec EBS direct APIs
Les étapes suivantes décrivent comment utiliser l'EBS direct pour écrire des APIs instantanés incrémentiels :
1. Utilisez cette StartSnapshot action et spécifiez un ID de cliché parent pour démarrer un instantané en tant que capture incrémentielle d'un instantané existant, ou omettez l'ID de cliché parent pour démarrer un nouveau cliché. Cette action renvoie le nouvel ID d’instantané, qui est en attente.
1. Utilisez l' PutSnapshotBlock action et spécifiez l'ID de l'instantané en attente pour y ajouter des données sous forme de blocs individuels. Vous devez spécifier une SHA256 somme de contrôle codée en Base64 pour le bloc de données transmis. Le service calcule la somme de contrôle des données reçues et la valide avec la somme de contrôle que vous avez spécifiée. L’action échoue si les sommes de contrôle ne correspondent pas.
1. Lorsque vous avez terminé d'ajouter des données à l'instantané en attente, utilisez cette CompleteSnapshot action pour démarrer un flux de travail asynchrone qui scelle l'instantané et le fait passer à l'état terminé.
Répétez ces étapes pour créer un nouvel instantané incrémentiel à l’aide de l’instantané précédemment créé en tant que parent.
Par exemple, dans le diagramme suivant, l’instantané A est le premier nouvel instantané démarré. L’instantané A est utilisé comme instantané parent pour démarrer l’instantané B. L’instantané B est utilisé comme instantané parent pour démarrer et créer l’instantané C. Les instantanés A, B et C sont des instantanés incrémentiels. L’instantané A est utilisé pour créer le volume EBS 1. L’instantané D est créé à partir du volume EBS 1. L’instantané D est un instantané incrémentiel de A ; et non un instantané incrémentiel de B ou C.
![\[EBS direct APIs utilisé pour créer des instantanés incrémentiels.\]](http://docs.aws.amazon.com/fr_fr/ebs/latest/userguide/images/ebs-apis-write.png)
Les exemples suivants montrent comment écrire des instantanés à l'aide de l'EBS direct. APIs
**Topics**
+ [Démarrer un instantané](#start-snapshot)
+ [Ajouter des données dans un instantané](#put-data)
+ [Terminer un instantané](#complete-snapshot)
## Démarrer un instantané
------
#### [ AWS CLI ]
L’exemple de commande [start-snapshot](https://docs.aws.amazon.com/cli/latest/reference/ebs/start-snapshot.html) suivant démarre un instantané `8` Gio en utilisant l’instantané `snap-123EXAMPLE1234567` comme instantané parent. Le nouvel instantané sera un instantané incrémentiel de l’instantané parent. L’instantané passe à un état d’erreur s’il n’y a pas de demande d’ajout ou d’exécution pour l’instantané pendant la période de `60` minutes spécifiée. Le jeton client `550e8400-e29b-41d4-a716-446655440000` garantit l’idempotence pour la demande. Si le jeton client est omis, le AWS SDK en génère un automatiquement pour vous. Pour plus d’informations sur l’idempotence, consultez [Garantir l'idempuissance des demandes d'API StartSnapshot](ebs-direct-api-idempotency.md).
```
aws ebs start-snapshot --volume-size 8 --parent-snapshot snap-123EXAMPLE1234567 --timeout 60 --client-token 550e8400-e29b-41d4-a716-446655440000
```
L’exemple de réponse suivant pour la commande précédente indique l’ID du snapshot, l’ID du compte AWS , l’état, la taille du volume en Gio et la taille des blocs dans l’instantané. L’instantané est démarré dans un état `pending`. Spécifiez l’ID d’instantané dans les commandes `put-snapshot-block` suivantes pour écrire des données dans l’instantané, puis utilisez la commande `complete-snapshot` pour terminer l’instantané et modifier son état sur `completed`.
```
{
"SnapshotId": "snap-0aaEXAMPLEe306d62",
"OwnerId": "111122223333",
"Status": "pending",
"VolumeSize": 8,
"BlockSize": 524288
}
```
------
#### [ AWS API ]
L'[StartSnapshot](https://docs.aws.amazon.com/ebs/latest/APIReference/API_StartSnapshot.html)exemple de demande suivant démarre un instantané `8` GiB, en utilisant l'instantané `snap-123EXAMPLE1234567` comme instantané parent. Le nouvel instantané sera un instantané incrémentiel de l’instantané parent. L’instantané passe à un état d’erreur s’il n’y a pas de demande d’ajout ou d’exécution pour l’instantané pendant la période de `60` minutes spécifiée. Le jeton client `550e8400-e29b-41d4-a716-446655440000` garantit l’idempotence pour la demande. Si le jeton client est omis, le AWS SDK en génère un automatiquement pour vous. Pour plus d’informations sur l’idempotence, consultez [Garantir l'idempuissance des demandes d'API StartSnapshot](ebs-direct-api-idempotency.md).
```
POST /snapshots HTTP/1.1
Host: ebs.us-east-2.amazonaws.com
Accept-Encoding: identity
User-Agent:
X-Amz-Date: 20200618T040724Z
Authorization:
{
"VolumeSize": 8,
"ParentSnapshot": snap-123EXAMPLE1234567,
"ClientToken": "550e8400-e29b-41d4-a716-446655440000",
"Timeout": 60
}
```
L’exemple de réponse suivant pour la demande précédente indique l’ID d’instantané, l’ID de compte AWS , l’état, la taille du volume en Gio et la taille des blocs dans l’instantané. L’instantané est démarré dans un état en attente. Spécifiez l’ID d’instantané dans une demande `PutSnapshotBlocks` ultérieure d’écriture de données dans l’instantané .
```
HTTP/1.1 201 Created
x-amzn-RequestId: 929e6eb9-7183-405a-9502-5b7da37c1b18
Content-Type: application/json
Content-Length: 181
Date: Thu, 18 Jun 2020 04:07:29 GMT
Connection: keep-alive
{
"BlockSize": 524288,
"Description": null,
"OwnerId": "138695307491",
"Progress": null,
"SnapshotId": "snap-052EXAMPLEc85d8dd",
"StartTime": null,
"Status": "pending",
"Tags": null,
"VolumeSize": 8
}
```
------
## Ajouter des données dans un instantané
------
#### [ AWS CLI ]
L'[put-snapshot-block](https://docs.aws.amazon.com/cli/latest/reference/ebs/put-snapshot-block.html)exemple de commande suivant écrit des `524288` octets de données pour bloquer l'index `1000` sur un instantané`snap-0aaEXAMPLEe306d62`. La somme de contrôle `QOD3gmEQOXATfJx2Aa34W4FU2nZGyXfqtsUuktOw8DM=` codée en Base64 a été générée à l'aide de l'algorithme `SHA256`. Les données transmises se trouvent dans le fichier `/tmp/data`.
```
aws ebs put-snapshot-block --snapshot-id snap-0aaEXAMPLEe306d62 --block-index 1000 --data-length 524288 --block-data /tmp/data --checksum QOD3gmEQOXATfJx2Aa34W4FU2nZGyXfqtsUuktOw8DM= --checksum-algorithm SHA256
```
L’exemple de réponse suivant pour la commande précédente confirme la longueur des données, la somme de contrôle et l’algorithme de somme de contrôle pour les données reçues par le service.
```
{
"DataLength": "524288",
"Checksum": "QOD3gmEQOXATfJx2Aa34W4FU2nZGyXfqtsUuktOw8DM=",
"ChecksumAlgorithm": "SHA256"
}
```
------
#### [ AWS API ]
L'[PutSnapshot](https://docs.aws.amazon.com/ebs/latest/APIReference/API_PutSnapshotBlock.html)exemple de demande suivant écrit des `524288` octets de données pour bloquer l'index `1000` sur un instantané`snap-052EXAMPLEc85d8dd`. La somme de contrôle `QOD3gmEQOXATfJx2Aa34W4FU2nZGyXfqtsUuktOw8DM=` codée en Base64 a été générée à l’aide de l’algorithme `SHA256`. Les données sont transmises dans le corps de la demande et sont représentées comme *BlockData* dans l'exemple suivant.
```
PUT /snapshots/snap-052EXAMPLEc85d8dd/blocks/1000 HTTP/1.1
Host: ebs.us-east-2.amazonaws.com
Accept-Encoding: identity
x-amz-Data-Length: 524288
x-amz-Checksum: QOD3gmEQOXATfJx2Aa34W4FU2nZGyXfqtsUuktOw8DM=
x-amz-Checksum-Algorithm: SHA256
User-Agent:
X-Amz-Date: 20200618T042215Z
X-Amz-Content-SHA256: UNSIGNED-PAYLOAD
Authorization:
BlockData
```
Voici un exemple de réponse pour la demande précédente, qui confirme la longueur des données, la somme de contrôle et l’algorithme de somme de contrôle pour les données que le service reçoit.
```
HTTP/1.1 201 Created
x-amzn-RequestId: 643ac797-7e0c-4ad0-8417-97b77b43c57b
x-amz-Checksum: QOD3gmEQOXATfJx2Aa34W4FU2nZGyXfqtsUuktOw8DM=
x-amz-Checksum-Algorithm: SHA256
Content-Type: application/json
Content-Length: 2
Date: Thu, 18 Jun 2020 04:22:12 GMT
Connection: keep-alive
{}
```
------
## Terminer un instantané
------
#### [ AWS CLI ]
L’exemple de commande [complete-snapshot](https://docs.aws.amazon.com/cli/latest/reference/ebs/complete-snapshot.html) suivant termine l’instantané `snap-0aaEXAMPLEe306d62`. La commande spécifie que les blocs `5` ont été écrits dans l'instantané. La somme de contrôle `6D3nmwi5f2F0wlh7xX8QprrJBFzDX8aacdOcA3KCM3c=` représente la somme de contrôle de l'ensemble complet des données écrites dans un instantané. Pour plus d’informations sur les sommes de contrôle, consultez [Utilisez les APIs checksums directs d'EBS pour valider les données des instantanés](ebsapis-using-checksums.md) plus haut dans ce guide.
```
aws ebs complete-snapshot --snapshot-id snap-0aaEXAMPLEe306d62 --changed-blocks-count 5 --checksum 6D3nmwi5f2F0wlh7xX8QprrJBFzDX8aacdOcA3KCM3c= --checksum-algorithm SHA256 --checksum-aggregation-method LINEAR
```
Voici un exemple de réponse pour la commande précédente.
```
{
"Status": "pending"
}
```
------
#### [ AWS API ]
L'[CompleteSnapshot](https://docs.aws.amazon.com/ebs/latest/APIReference/API_CompleteSnapshot.html)exemple de demande suivant permet de terminer le snapshot`snap-052EXAMPLEc85d8dd`. La commande spécifie que les blocs `5` ont été écrits dans l’instantané. La somme de contrôle `6D3nmwi5f2F0wlh7xX8QprrJBFzDX8aacdOcA3KCM3c=` représente la somme de contrôle de l’ensemble complet des données écrites dans un instantané.
```
POST /snapshots/completion/snap-052EXAMPLEc85d8dd HTTP/1.1
Host: ebs.us-east-2.amazonaws.com
Accept-Encoding: identity
x-amz-ChangedBlocksCount: 5
x-amz-Checksum: 6D3nmwi5f2F0wlh7xX8QprrJBFzDX8aacdOcA3KCM3c=
x-amz-Checksum-Algorithm: SHA256
x-amz-Checksum-Aggregation-Method: LINEAR
User-Agent:
X-Amz-Date: 20200618T043158Z
Authorization:
```
Voici un exemple de réponse pour la demande précédente.
```
HTTP/1.1 202 Accepted
x-amzn-RequestId: 06cba5b5-b731-49de-af40-80333ac3a117
Content-Type: application/json
Content-Length: 20
Date: Thu, 18 Jun 2020 04:31:50 GMT
Connection: keep-alive
{"Status":"pending"}
```
------
# Résultats du chiffrement pour EBS Direct APIs
Lorsque vous démarrez un nouvel instantané en utilisant [ StartSnapshot](https://docs.aws.amazon.com/ebs/latest/APIReference/API_StartSnapshot.html), l'état du chiffrement dépend des valeurs que vous spécifiez pour **Chiffré **KmsKeyArn****, et **ParentSnapshotId**, et du fait que votre AWS compte est activé pour [le chiffrement par défaut](encryption-by-default.md).
**Note**
Vous aurez peut-être besoin d'autorisations IAM supplémentaires pour utiliser l'EBS direct APIs avec le chiffrement. Pour plus d’informations, consultez [Autorisations d'utilisation AWS KMS keys](ebsapi-permissions.md#ebsapi-kms-permissions).
Si le chiffrement Amazon EBS est activé par défaut sur votre AWS compte, vous ne pouvez pas créer de snapshots non chiffrés.
Si le chiffrement Amazon EBS est activé par défaut sur votre AWS compte, vous ne pouvez pas créer un nouvel instantané à l'aide d'un instantané parent non chiffré. Vous devez d’abord chiffrer l’instantané parent en le copiant. Pour plus d’informations, consultez [Copier un instantané Amazon EBS](ebs-copy-snapshot.md).
**Topics**
+ [Résultats du chiffrement : instantané parent non chiffré](#ebs-direct-api-unencr-outcomes-parent)
+ [Résultats du chiffrement : instantané parent chiffré](#ebs-direct-api-encr-outcomes-parent)
+ [Résultats du chiffrement : aucun instantané parent](#ebs-direct-api-encr-outcomes-noparent)
## Résultats du chiffrement : instantané parent non chiffré
Le tableau suivant décrit le résultat du chiffrement pour chaque combinaison possible de paramètres lors de la spécification d’un instantané parent non chiffré.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/ebs/latest/userguide/ebsapis-using-encryption.html)
## Résultats du chiffrement : instantané parent chiffré
Le tableau suivant décrit le résultat du chiffrement pour chaque combinaison possible de paramètres lors de la spécification d’un instantané parent chiffré.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/ebs/latest/userguide/ebsapis-using-encryption.html)
## Résultats du chiffrement : aucun instantané parent
Les tableaux suivants décrivent le résultat du chiffrement pour chaque combinaison possible de paramètres en l’absence d’utilisation d’un instantané parent.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/ebs/latest/userguide/ebsapis-using-encryption.html)
\$1 Cette clé KMS par défaut peut être une clé gérée par le client ou la clé KMS AWS gérée par défaut pour le chiffrement Amazon EBS.
# Utilisez les APIs checksums directs d'EBS pour valider les données des instantanés
L' GetSnapshotBlock action renvoie des données qui se trouvent dans un bloc d'un instantané, et l' PutSnapshotBlock action ajoute des données à un bloc d'un instantané. Les données de bloc transmises ne sont pas signées dans le cadre du processus de signature de la version 4. Par conséquent, les sommes de contrôle sont utilisées pour valider l’intégrité des données comme suit :
+ **Lorsque vous utilisez l' GetSnapshotBlock action, la réponse fournit une somme de SHA256 contrôle codée en Base64 pour les données du bloc à l'aide de l'en-tête X-AMZ-Checksum, et l'algorithme de **somme de contrôle utilisant l'en-tête X-AMZ-Checksum-Algorithm**.** Utilisez la somme de contrôle renvoyée pour valider l’intégrité des données. Si la somme de contrôle que vous générez ne correspond pas à celle fournie par Amazon EBS, vous devez considérer les données non valides et réessayer votre demande.
+ **Lorsque vous utilisez l' PutSnapshotBlock action, votre demande doit fournir une somme de SHA256 contrôle codée en Base64 pour les données du bloc à l'aide de l'en-tête X-AMZ-Checksum, et l'algorithme de **somme de contrôle utilisant l'en-tête X-AMZ-Checksum-Algorithm**.** La somme de contrôle que vous fournissez est validée par rapport à une somme de contrôle générée par Amazon EBS pour valider l’intégrité des données. Si les sommes de contrôle ne correspondent pas, la demande échoue.
+ Lorsque vous utilisez l' CompleteSnapshot action, votre demande peut éventuellement fournir une SHA256 somme de contrôle agrégée codée en Base64 pour l'ensemble complet des données ajoutées à l'instantané. Fournissez la somme de contrôle à l’aide de l’en-tête **x-amz-Checksum**, l’algorithme de somme de contrôle à l’aide de l’en-tête **x-amz-Checksum-Algorithm** et la méthode d’agrégation de somme de contrôle à l’aide de l’en-tête **x-amz-Checksum-Aggregation-Method**. Pour générer la somme de contrôle agrégée à l'aide de la méthode d'agrégation linéaire, organisez les sommes de contrôle pour chaque bloc écrit dans l'ordre croissant de son index de bloc, concaténez-les pour former une chaîne unique, puis générez la somme de contrôle sur la chaîne entière à l'aide de l'algorithme. SHA256
Les sommes de contrôle de ces actions font partie du processus de signature de la version 4.
# Garantir l'idempuissance des demandes d'API StartSnapshot
L’idempotence garantit qu’une requête API n’est exécutée qu’une seule fois. Avec une demande idempotente, si la demande d’origine se termine avec succès, les tentatives suivantes renvoient le résultat de la demande d’origine réussie et elles n’ont aucun effet supplémentaire.
L'[ StartSnapshot](https://docs.aws.amazon.com/ebs/latest/APIReference/API_StartSnapshot.html)API prend en charge l'idempotencie à l'aide d'un jeton *client*. Un jeton client est une chaîne unique que vous spécifiez lorsque vous effectuez une demande d’API. Si vous réessayez une demande d’API avec le même jeton client et les mêmes paramètres de requête une fois qu’elle est terminée correctement, le résultat de la demande d’origine est renvoyé. Si vous réessayez une demande avec le même jeton client, mais que vous modifiez un ou plusieurs paramètres de requête, l’erreur `ConflictException` est renvoyée.
Si vous ne spécifiez pas votre propre jeton client, un jeton client est AWS SDKs automatiquement généré pour la demande afin de s'assurer qu'elle est idempotente.
Un jeton client peut être n’importe quelle chaîne qui comprend jusqu’à 64 caractères ASCII. Vous ne devez pas réutiliser les mêmes jetons client pour différentes demandes.
**Pour effectuer une StartSnapshot demande idempotente avec votre propre jeton client à l'aide de l'API**
Spécifiez le paramètre de demande `ClientToken`.
```
POST /snapshots HTTP/1.1
Host: ebs.us-east-2.amazonaws.com
Accept-Encoding: identity
User-Agent:
X-Amz-Date: 20200618T040724Z
Authorization:
{
"VolumeSize": 8,
"ParentSnapshot": snap-123EXAMPLE1234567,
"ClientToken": "550e8400-e29b-41d4-a716-446655440000",
"Timeout": 60
}
```
**Pour effectuer une StartSnapshot demande idempotente avec votre propre jeton client à l'aide du AWS CLI**
Spécifiez le paramètre de demande `client-token`.
```
$ C:\> aws ebs start-snapshot --region us-east-2 --volume-size 8 --parent-snapshot snap-123EXAMPLE1234567 --timeout 60 --client-token 550e8400-e29b-41d4-a716-446655440000
```
# Rétentatives d'erreur pour EBS Direct APIs
Ils **AWS SDKs**implémentent une logique de nouvelle tentative automatique pour les demandes renvoyant des réponses d'erreur. Vous pouvez configurer les paramètres de nouvelle tentative pour le AWS SDKs. Pour plus d’informations, consultez la documentation de votre kit SDK.
Vous pouvez configurer **AWS CLI** pour réessayer automatiquement certaines demandes qui ont échoué. Pour plus d'informations sur la configuration des tentatives pour le AWS CLI, consultez la section [AWS CLI Rétentatives](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-retries.html) dans le Guide de l'*AWS Command Line Interface utilisateur*.
L’**AWS API de requête** ne prend pas en charge la logique de nouvelle tentative pour les demandes ayant échoué. Si vous utilisez des requêtes HTTP ou HTTPS, vous devez implémenter une logique de nouvelle tentative dans votre application cliente.
Le tableau suivant présente les réponses possibles aux erreurs de l’API. Certaines erreurs de l’API peuvent faire l’objet d’une nouvelle tentative. Votre application client doit toujours relancer les demandes qui ont échoué et qui reçoivent une erreur récupérable.
| Erreur | Code de réponse | Description | Lancé par | Récupérable ? |
| --- | --- | --- | --- | --- |
| InternalServerException | 500 | La demande a échoué en raison d'un problème réseau ou AWS côté serveur. | Tout APIs | Oui |
| ThrottlingException | 400 | Le nombre de demandes d’API a dépassé la limite maximale de limitation des demandes d’API autorisée pour le compte. | Tout APIs | Oui |
| RequestThrottleException | 400 | Le nombre de demandes d’API a dépassé la limite maximale de limitation des demandes d’API autorisée pour l’instantané. | GetSnapshotBlock \$1 PutSnapshotBlock | Oui |
| ValidationException avec le message « Failed to read block data » | 400 | Le bloc de données fourni n’était pas lisible. | PutSnapshotBlock | Oui |
| ValidationException avec tout autre message | 400 | La syntaxe de la demande est mal formée, ou l’entrée ne satisfait pas aux contraintes spécifiées par Service AWS. | Tout APIs | Non |
| ResourceNotFoundException | 404 | L’ID de l’instantané spécifié n’existe pas. | Tout APIs | Non |
| ConflictException | 409 | Le jeton client spécifié a déjà été utilisé dans une demande similaire dont les paramètres étaient différents. Pour de plus amples informations, veuillez consulter [Garantir l'idempuissance des demandes d'API StartSnapshot](ebs-direct-api-idempotency.md). | StartSnapshot | Non |
| AccessDeniedException | 403 | Vous n’avez pas l’autorisation d’effectuer l’opération demandée. | Tout APIs | Non |
| ServiceQuotaExceededException | 402 | La demande a échoué, car son exécution dépasserait un ou plusieurs quotas de services dépendants pour votre compte. | Tout APIs | Non |
| InvalidSignatureException | 403 | La signature d’autorisation de la demande a expiré. Vous ne pouvez réessayer la demande qu’après avoir actualisé la signature d’autorisation. | Tout APIs | Non |
# Optimisez les performances pour EBS Direct APIs
Vous pouvez exécuter des demandes d’API simultanément. En supposant que la PutSnapshotBlock latence est de 100 ms, un thread peut traiter 10 requêtes en une seconde. En outre, en supposant que votre application cliente crée plusieurs threads et connexions (par exemple, 100 connexions), elle peut faire 1000 (10 \$1 100) demandes par seconde au total. Cela correspondra à un débit d’environ 500 Mo par seconde.
La liste suivante contient quelques éléments à rechercher dans votre application :
+ Chaque thread utilise-t-il une connexion séparée ? Si les connexions sont limitées sur l’application, plusieurs threads attendront que la connexion soit disponible et vous remarquerez un débit inférieur.
+ Y a-t-il un temps d’attente dans l’application entre deux demandes d’ajout ? Cela réduira le débit effectif d’un thread.
+ La limite de bande passante de l'instance : si la bande passante de l'instance est partagée par d'autres applications, cela peut limiter le débit disponible pour les PutSnapshotBlock demandes.
Veillez à prendre note des autres charges de travail qui peuvent être exécutées dans le compte pour éviter les goulots d’étranglement. Vous devez également intégrer des mécanismes de nouvelle tentative dans vos APIs flux de travail directs EBS pour gérer les ralentissements, les délais d'expiration et l'indisponibilité des services.
Passez en revue les quotas de APIs service direct EBS pour déterminer le nombre maximal de demandes d'API que vous pouvez exécuter par seconde. Pour plus d’informations, consultez [Points de terminaison et quotas Amazon Elastic Block Store](https://docs.aws.amazon.com/general/latest/gr/ebs-service.html#w542aab9d130b7c15) dans *AWS General Reference*.
# Points de terminaison de service pour EBS Direct APIs
Un *point de terminaison* est une URL qui sert de point d'entrée à un service AWS Web. EBS direct APIs prend en charge les types de terminaux suivants :
+ IPv4 points de terminaison
+ Des terminaux à double pile qui prennent en charge à la fois et IPv4 IPv6
+ Points de terminaison FIPS
Lorsque vous faites une demande, vous pouvez spécifier le point de terminaison et la région à utiliser. Si vous ne spécifiez aucun point de IPv4 terminaison, celui-ci est utilisé par défaut. Pour utiliser un autre type de point de terminaison, vous devez le spécifier dans votre demande. Pour obtenir un exemple de la façon de procéder, consultez [Spécification des points de terminaison](#examples).
Pour plus d'informations sur les régions, consultez [Régions et zones de disponibilité](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) dans le guide de l'*utilisateur Amazon EC2*. Pour obtenir la liste des points de terminaison pour EBS direct APIs, voir [Points de terminaison pour l'EBS direct dans le](https://docs.aws.amazon.com/general/latest/gr/ebs-service.html#ebs_direct_apis). APIs *Référence générale d'Amazon Web Services*
**Topics**
+ [IPv4 points de terminaison](#ipv4)
+ [Points de terminaison à double pile (IPv4 et IPv6)](#ipv6)
+ [Points de terminaison FIPS](#fips)
+ [Spécification des points de terminaison](#examples)
## IPv4 points de terminaison
IPv4 les terminaux ne prennent en charge que IPv4 le trafic. IPv4 les points de terminaison sont disponibles pour toutes les régions.
EBS direct ne APIs prend en charge que les IPv4 points de terminaison régionaux que vous pouvez utiliser pour effectuer vos demandes. Vous devez spécifier la région dans le nom du point de terminaison. Les noms des points de terminaison utilisent la convention de dénomination suivante :
+ `ebs.region.amazonaws.com`
Par exemple, pour diriger vos demandes vers le `us-east-2` IPv4 point de terminaison, vous devez le spécifier `ebs.us-east-2.amazonaws.com` comme point de terminaison. Pour obtenir la liste des points de terminaison pour EBS direct APIs, voir [Points de terminaison pour l'EBS direct dans le](https://docs.aws.amazon.com/general/latest/gr/ebs-service.html#ebs_direct_apis). APIs *Référence générale d'Amazon Web Services*
**Tarification**
Les données transférées directement entre les API directes d'EBS et les instances Amazon EC2 à l'aide d' IPv4 un point de terminaison situé dans la même région ne vous sont pas facturées. Toutefois, s'il existe des services intermédiaires, tels que des AWS PrivateLink points de terminaison, une passerelle NAT ou des passerelles Amazon VPC Transit, leurs coûts associés vous sont facturés.
## Points de terminaison à double pile (IPv4 et IPv6)
Les terminaux à double pile prennent en charge à la fois le trafic IPv4 et IPv6 le trafic. Les points de terminaison à double pile sont disponibles pour toutes les régions.
Pour l'utiliser IPv6, vous devez utiliser un point de terminaison à double pile. Lorsque vous envoyez une demande à un point de terminaison à double pile, l'URL du point de terminaison correspond à une IPv4 adresse IPv6 ou à une adresse, selon le protocole utilisé par votre réseau et votre client.
EBS Direct ne APIs prend en charge que les points de terminaison régionaux à double pile, ce qui signifie que vous devez spécifier la région dans le nom du point de terminaison. Les noms des points de terminaison à double pile utilisent la convention d’affectation de noms suivante :
+ `ebs.region.api.aws`
Par exemple, le nom du point de terminaison à double pile de la région `eu-west-1` est `ebs.eu-west-1.api.aws`. Pour obtenir la liste des points de terminaison pour EBS direct APIs, voir [Points de terminaison pour l'EBS direct dans le](https://docs.aws.amazon.com/general/latest/gr/ebs-service.html#ebs_direct_apis). APIs *Référence générale d'Amazon Web Services*
**Tarification**
Vous n’êtes pas facturé pour les données transférées directement entre les API directes EBS et les instances Amazon EC2 utilisant un point de terminaison à double pile dans la même région. Toutefois, s'il existe des services intermédiaires, tels que des AWS PrivateLink points de terminaison, une passerelle NAT ou des passerelles Amazon VPC Transit, leurs coûts associés vous sont facturés.
## Points de terminaison FIPS
EBS direct APIs fournit des points de terminaison à double pile ( IPv4 et IPv6) validés FIPS pour IPv4 les régions suivantes :
+ `us-east-1` : USA Est (Virginie du Nord)
+ `us-east-2` : USA Est (Ohio)
+ `us-west-1` : USA Ouest (Californie du Nord)
+ `us-west-2` : USA Ouest (Oregon)
+ `ca-central-1` : Canada (Centre)
+ `ca-west-1`— Canada Ouest (Calgary)
Les ** IPv4 points de terminaison FIPS** utilisent la convention de dénomination suivante :. `ebs-fips.region.amazonaws.com` Par exemple, le point de IPv4 terminaison FIPS pour `us-east-1` est`ebs-fips.us-east-1.amazonaws.com`.
**Les points de terminaison FIPS à double pile** utilisent la convention d’affectation de noms suivante : `ebs-fips.region.api.aws`. Par exemple, le point de terminaison à double pile FIPS pour `us-east-1` est `ebs-fips.us-east-1.api.aws`.
Pour plus d’informations sur les points de terminaison FIPS, consultez [Points de terminaison FIPS](https://docs.aws.amazon.com/general/latest/gr/rande.html#FIPS-endpoints) dans le *Référence générale d'Amazon Web Services*.
## Spécification des points de terminaison
Cette section fournit quelques exemples sur la manière de spécifier un point de terminaison lors de l’envoi d’une demande.
------
#### [ AWS CLI ]
Les exemples suivants montrent comment spécifier un point de terminaison pour la région `us-east-2` à l’aide de AWS CLI.
+ **Double pile**
```
aws ebs list-snapshot-blocks --snapshot-id snap-0987654321 --starting-block-index 1000 --endpoint-url https://ebs.us-east-2.api.aws
```
+ **IPv4**
```
aws ebs list-snapshot-blocks --snapshot-id snap-0987654321 --starting-block-index 1000 --endpoint-url https://ebs.us-east-2.amazonaws.com
```
------
#### [ AWS SDK for Java 2.x ]
Les exemples suivants montrent comment spécifier un point de terminaison pour la région `us-east-2` à l’aide de AWS SDK for Java 2.x.
+ **Double pile**
```
AwsClientBuilder.EndpointConfiguration config = new AwsClientBuilder.EndpointConfiguration("https://ebs.us-east-2.api.aws", "us-east-2");
AmazonEBS ebs = AmazonEBSClientBuilder.standard()
.withEndpointConfiguration(config)
.build();
```
+ **IPv4**
```
AwsClientBuilder.EndpointConfiguration config = new AwsClientBuilder.EndpointConfiguration("https://ebs.us-east-2.amazonaws.com", "us-east-2");
AmazonEBS ebs = AmazonEBSClientBuilder.standard()
.withEndpointConfiguration(config)
.build();
```
------
#### [ AWS SDK for Go ]
Les exemples suivants montrent comment spécifier un point de terminaison pour la région `us-east-2` à l’aide de AWS SDK pour Go.
+ **Double pile**
```
sess := session.Must(session.NewSession())
svc := ebs.New(sess, &aws.Config{
Region: aws.String(endpoints.UsEast2RegionID),
Endpoint: aws.String("https://ebs.us-east-2.api.aws")
})
```
+ **IPv4**
```
sess := session.Must(session.NewSession())
svc := ebs.New(sess, &aws.Config{
Region: aws.String(endpoints.UsEast2RegionID),
Endpoint: aws.String("https://ebs.us-east-2.amazonaws.com")
})
```
------
# AWS Exemples de code SDK pour EBS direct APIs
Les exemples de code suivants montrent comment utiliser EBS direct APIs avec un kit de développement AWS logiciel (SDK).
**Topics**
+ [StartSnapshot](#sdk-StartSnapshot)
+ [PutSnapshotBlock](#sdk-PutSnapshotBlock)
+ [CompleteSnapshot](#sdk-CompleteSnapshot)
## Utilisation `StartSnapshot` avec un AWS SDK ou une CLI
L'exemple de code suivant montre comment utiliser`StartSnapshot`.
------
#### [ Rust ]
**SDK pour Rust**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ebs#code-examples).
```
async fn start(client: &Client, description: &str) -> Result {
let snapshot = client
.start_snapshot()
.description(description)
.encrypted(false)
.volume_size(1)
.send()
.await?;
Ok(snapshot.snapshot_id.unwrap())
}
```
+ Pour plus de détails sur l'API, voir [StartSnapshot](https://docs.rs/aws-sdk-ebs/latest/aws_sdk_ebs/client/struct.Client.html#method.start_snapshot)la section de *référence de l'API AWS SDK for Rust*.
------
## Utilisation `PutSnapshotBlock` avec un AWS SDK ou une CLI
L'exemple de code suivant montre comment utiliser`PutSnapshotBlock`.
------
#### [ Rust ]
**SDK pour Rust**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ebs#code-examples).
```
async fn add_block(
client: &Client,
id: &str,
idx: usize,
block: Vec,
checksum: &str,
) -> Result<(), Error> {
client
.put_snapshot_block()
.snapshot_id(id)
.block_index(idx as i32)
.block_data(ByteStream::from(block))
.checksum(checksum)
.checksum_algorithm(ChecksumAlgorithm::ChecksumAlgorithmSha256)
.data_length(EBS_BLOCK_SIZE as i32)
.send()
.await?;
Ok(())
}
```
+ Pour plus de détails sur l'API, voir [PutSnapshotBlock](https://docs.rs/aws-sdk-ebs/latest/aws_sdk_ebs/client/struct.Client.html#method.put_snapshot_block)la section de *référence de l'API AWS SDK for Rust*.
------
## Utilisation `CompleteSnapshot` avec un AWS SDK ou une CLI
L'exemple de code suivant montre comment utiliser`CompleteSnapshot`.
------
#### [ Rust ]
**SDK pour Rust**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ebs#code-examples).
```
async fn finish(client: &Client, id: &str) -> Result<(), Error> {
client
.complete_snapshot()
.changed_blocks_count(2)
.snapshot_id(id)
.send()
.await?;
println!("Snapshot ID {}", id);
println!("The state is 'completed' when all of the modified blocks have been transferred to Amazon S3.");
println!("Use the get-snapshot-state code example to get the state of the snapshot.");
Ok(())
}
```
+ Pour plus de détails sur l'API, voir [CompleteSnapshot](https://docs.rs/aws-sdk-ebs/latest/aws_sdk_ebs/client/struct.Client.html#method.complete_snapshot)la section de *référence de l'API AWS SDK for Rust*.
------
# Création d'une connexion privée entre un VPC et EBS direct APIs
Vous pouvez établir une connexion privée entre votre VPC et EBS directement en créant un point de terminaison *VPC* d'interface, alimenté APIs par. [AWS PrivateLink](https://aws.amazon.com/privatelink/) Vous pouvez accéder à EBS directement APIs comme s'il se trouvait dans votre VPC, sans utiliser de passerelle Internet, de périphérique NAT, de connexion VPN ou de connexion. AWS Direct Connect Les instances de votre VPC n'ont pas besoin d'adresses IP publiques pour communiquer directement avec EBS. APIs
Nous créons une interface réseau de point de terminaison dans chaque sous-réseau que vous activez pour le point de terminaison d’interface.
Pour plus d'informations, consultez la section [Accès Services AWS par AWS PrivateLink le biais](https://docs.aws.amazon.com/vpc/latest/privatelink/privatelink-access-aws-services.html) du *AWS PrivateLink guide*.
## Considérations relatives aux points de terminaison APIs VPC directs EBS
*Avant de configurer un point de terminaison VPC d'interface pour EBS direct APIs, consultez les [considérations](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#considerations-interface-endpoints) du guide.AWS PrivateLink *
Par défaut, l'accès complet à EBS direct APIs est autorisé via le point de terminaison. Vous pouvez contrôler l'accès au point de terminaison de l'interface à l'aide des politiques de point de terminaison VPC. Vous pouvez associer une politique de point de terminaison à votre point de terminaison VPC qui contrôle l'accès direct à EBS. APIs La politique spécifie les informations suivantes :
+ Le **principal** qui peut effectuer des actions.
+ Les **actions** qui peuvent être effectuées.
+ Les **ressources** sur lesquelles les actions peuvent être effectuées.
Pour de plus amples informations, veuillez consulter [Contrôle de l'accès aux services avec points de terminaison d'un VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html) dans le *Amazon VPC Guide de l'utilisateur*.
Voici un exemple de politique de point de terminaison pour EBS Direct APIs. Lorsqu'elle est attachée à un point de terminaison, cette politique donne accès à toutes les APIs actions directes d'EBS sur toutes les ressources, à l'exception des instantanés marqués d'une clé `Environment` et d'une valeur. `Test`
```
{
"Statement": [
{
"Effect": "Deny",
"Action": "ebs:*",
"Principal": "*",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Environment": "Test"
}
}
},
{
"Effect": "Allow",
"Action": "ebs:*",
"Principal": "*",
"Resource": "*"
}
]
}
```
## Création d'un point de terminaison VPC d'interface pour EBS direct APIs
Vous pouvez créer un point de terminaison VPC pour EBS direct à APIs l'aide de la console Amazon VPC ou du (). AWS Command Line Interface AWS CLI Pour plus d’informations, consultez [Créer un point de terminaison d’un VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint-aws) dans le *Guide AWS PrivateLink *.
Créez un point de terminaison VPC pour EBS direct APIs en utilisant l'un des noms de service suivants :
+ `com.amazonaws.region.ebs`
+ `com.amazonaws.region.ebs-fips`— Pour créer un point de terminaison VPC d'interface conforme à la publication 140-2 du Federal Information Processing Standard (FIPS), norme gouvernementale américaine.
**Note**
Des points de terminaison VPC d'interface conformes à la norme FIPS peuvent être créés pour les régions suivantes : `us-east-1` \$1 \$1 \$1 \$1 \$1. `us-east-2` `us-west-1` `us-west-2` `ca-central-1` `ca-west-1` Les points de terminaison VPC d'interface conformes à la norme FIPS prennent en charge à la fois le trafic et le trafic. IPv4 IPv6
Si vous activez le DNS privé pour le point de terminaison, vous pouvez envoyer des demandes d'API à EBS directement APIs en utilisant son nom DNS par défaut pour la région, par exemple,`ebs.us-east-1.amazonaws.com`.
# Enregistrez les APIs appels directs EBS à l'aide de AWS CloudTrail
EBS Direct APIs est intégré à AWS CloudTrail un service qui fournit un enregistrement des actions entreprises par un utilisateur, un rôle ou un AWS service. CloudTrail capture les appels passés à l'EBS directement APIs sous forme d'événements. Les appels capturés incluent des appels provenant d'appels à code AWS Management Console et adressés à l'EBS direct APIs. À l'aide des informations collectées par CloudTrail, vous pouvez déterminer la demande qui a été faite à EBS directement APIs, l'adresse IP à partir de laquelle la demande a été faite, la date à laquelle elle a été faite et des informations supplémentaires.
Chaque événement ou entrée de journal contient des informations sur la personne ayant initié la demande. Les informations relatives à l’identité permettent de déterminer :
+ Si la demande a été effectuée avec des informations d’identification d’utilisateur root ou d’utilisateur root.
+ Si la demande a été faite au nom d'un utilisateur du centre d'identité IAM.
+ Si la demande a été effectuée avec les informations d’identification de sécurité temporaires d’un rôle ou d’un utilisateur fédéré.
+ Si la requête a été effectuée par un autre Service AWS.
CloudTrail est actif dans votre compte Compte AWS lorsque vous créez le compte et vous avez automatiquement accès à l'**historique des CloudTrail événements**. L'**historique des CloudTrail événements** fournit un enregistrement consultable, consultable, téléchargeable et immuable des 90 derniers jours des événements de gestion enregistrés dans un. Région AWS Pour plus d'informations, consultez la section [Utilisation de l'historique des CloudTrail événements](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html) dans le *guide de AWS CloudTrail l'utilisateur*. La consultation de CloudTrail l'**historique des événements est gratuite**.
Pour un enregistrement continu des événements de vos 90 Compte AWS derniers jours, créez un magasin de données sur les événements de Trail ou [CloudTrailLake](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-lake.html).
**CloudTrail sentiers**
Un *suivi* permet CloudTrail de fournir des fichiers journaux à un compartiment Amazon S3. Tous les sentiers créés à l'aide du AWS Management Console sont multirégionaux. Vous ne pouvez créer un journal de suivi en une ou plusieurs régions à l'aide de l' AWS CLI. Il est recommandé de créer un parcours multirégional, car vous capturez l'activité dans l'ensemble Régions AWS de votre compte. Si vous créez un journal de suivi pour une seule région, il convient de n'afficher que les événements enregistrés dans le journal de suivi pour une seule région Région AWS. Pour plus d'informations sur les journaux de suivi, consultez [Créez un journal de suivi dans vos Compte AWS](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html) et [Création d'un journal de suivi pour une organisation](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/creating-trail-organization.html) dans le *AWS CloudTrail Guide de l'utilisateur*.
Vous pouvez envoyer une copie de vos événements de gestion en cours dans votre compartiment Amazon S3 gratuitement CloudTrail en créant un journal. Toutefois, des frais de stockage Amazon S3 sont facturés. Pour plus d'informations sur la CloudTrail tarification, consultez la section [AWS CloudTrail Tarification](https://aws.amazon.com/cloudtrail/pricing/). Pour obtenir des informations sur la tarification Amazon S3, consultez [Tarification Amazon S3](https://aws.amazon.com/s3/pricing/).
**CloudTrail Stockages de données sur les événements du lac**
*CloudTrail Lake* vous permet d'exécuter des requêtes SQL sur vos événements. CloudTrail Lake convertit les événements existants au format JSON basé sur les lignes au format [Apache ORC](https://orc.apache.org/). ORC est un format de stockage en colonnes qui est optimisé pour une récupération rapide des données. Les événements sont agrégés dans des *magasins de données d’événement*. Ceux-ci constituent des collections immuables d’événements basées sur des critères que vous sélectionnez en appliquant des [sélecteurs d’événements avancés](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-lake-concepts.html#adv-event-selectors). Les sélecteurs que vous appliquez à un magasin de données d’événement contrôlent les événements qui persistent et que vous pouvez interroger. Pour plus d'informations sur CloudTrail Lake, consultez la section [Travailler avec AWS CloudTrail Lake](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-lake.html) dans le *guide de AWS CloudTrail l'utilisateur*.
CloudTrail Les stockages et requêtes de données sur les événements de Lake entraînent des coûts. Lorsque vous créez un magasin de données d’événement, vous choisissez l’[option de tarification](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-lake-manage-costs.html#cloudtrail-lake-manage-costs-pricing-option) que vous voulez utiliser pour le magasin de données d’événement. L’option de tarification détermine le coût d’ingestion et de stockage des événements, ainsi que les périodes de conservation par défaut et maximale pour le magasin de données d’événement. Pour plus d'informations sur la CloudTrail tarification, consultez la section [AWS CloudTrail Tarification](https://aws.amazon.com/cloudtrail/pricing/).
## Événements de APIs données directs EBS dans CloudTrail
[Les événements de données](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html#logging-data-events) fournissent des informations sur les opérations de ressource effectuées sur ou dans une ressource. Ils sont également connus sous le nom opérations de plans de données. Les événements de données sont souvent des activités à fort volume. Par défaut, CloudTrail n'enregistre pas les événements liés aux données. L'**historique des CloudTrail événements** n'enregistre pas les événements liés aux données.
Des frais supplémentaires s’appliquent pour les événements de données. Pour plus d'informations sur la CloudTrail tarification, consultez la section [AWS CloudTrail Tarification](https://aws.amazon.com/cloudtrail/pricing/).
Vous pouvez enregistrer les événements de données pour les types de APIs ressources directes EBS à l'aide de la CloudTrail console ou des AWS CLI opérations de CloudTrail l'API. Pour plus d’informations sur la façon de journaliser les événements de données, consultez [Journalisation des événements de données avec la AWS Management Console](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html#logging-data-events-console) et [Journalisation des événements de données avec l’ AWS Command Line Interface](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html#creating-data-event-selectors-with-the-AWS-CLI) dans le *Guide de l’utilisateur AWS CloudTrail *.
Vous pouvez enregistrer les APIs opérations directes EBS suivantes en tant qu'événements de données.
+ [ListSnapshotBlocks](https://docs.aws.amazon.com/ebs/latest/APIReference/API_ListSnapshotBlocks.html)
+ [ListChangedBlocks](https://docs.aws.amazon.com/ebs/latest/APIReference/API_ListChangedBlocks.html)
+ [ GetSnapshotBlock](https://docs.aws.amazon.com/ebs/latest/APIReference/API_GetSnapshotBlock.html)
+ [PutSnapshotBlock](https://docs.aws.amazon.com/ebs/latest/APIReference/API_PutSnapshotBlock.html)
**Note**
Si vous effectuez une action sur un instantané partagé avec vous, les événements de données ne sont pas envoyés au AWS compte propriétaire de l'instantané.
## Événements de APIs gestion directe d'EBS dans CloudTrail
[Les événements de gestion](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-management-events-with-cloudtrail.html#logging-management-events) fournissent des informations sur les opérations de gestion effectuées sur les ressources de votre Compte AWS. Ils sont également connus sous le nom opérations de plan de contrôle. Par défaut, CloudTrail enregistre les événements de gestion.
Le APIs service EBS direct enregistre les opérations du plan de contrôle suivantes en CloudTrail tant qu'événements de gestion.
+ [ StartSnapshot](https://docs.aws.amazon.com/ebs/latest/APIReference/API_StartSnapshot.html)
+ [ CompleteSnapshot](https://docs.aws.amazon.com/ebs/latest/APIReference/API_CompleteSnapshot.html)
## Exemples d' APIs événements directs EBS
Un événement représente une demande unique provenant de n'importe quelle source et inclut des informations sur l'opération d'API demandée, la date et l'heure de l'opération, les paramètres de la demande, etc. CloudTrail les fichiers journaux ne constituent pas une trace ordonnée des appels d'API publics. Les événements n'apparaissent donc pas dans un ordre spécifique.
Voici des exemples d' CloudTrail événements pour l'EBS direct APIs.
------
#### [ StartSnapshot ]
```
{
"eventVersion": "1.05",
"userIdentity": {
"type": "IAMUser",
"principalId": "123456789012",
"arn": "arn:aws:iam::123456789012:root",
"accountId": "123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "user"
},
"eventTime": "2020-07-03T23:27:26Z",
"eventSource": "ebs.amazonaws.com",
"eventName": "StartSnapshot",
"awsRegion": "eu-west-1",
"sourceIPAddress": "192.0.2.0",
"userAgent": "PostmanRuntime/7.25.0",
"requestParameters": {
"volumeSize": 8,
"clientToken": "token",
"encrypted": true
},
"responseElements": {
"snapshotId": "snap-123456789012",
"ownerId": "123456789012",
"status": "pending",
"startTime": "Jul 3, 2020 11:27:26 PM",
"volumeSize": 8,
"blockSize": 524288,
"kmsKeyArn": "HIDDEN_DUE_TO_SECURITY_REASONS"
},
"requestID": "be112233-1ba5-4ae0-8e2b-1c302EXAMPLE",
"eventID": "6e12345-2a4e-417c-aa78-7594fEXAMPLE",
"eventType": "AwsApiCall",
"recipientAccountId": "123456789012"
}
```
------
#### [ CompleteSnapshot ]
```
{
"eventVersion": "1.05",
"userIdentity": {
"type": "IAMUser",
"principalId": "123456789012",
"arn": "arn:aws:iam::123456789012:root",
"accountId": "123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "user"
},
"eventTime": "2020-07-03T23:28:24Z",
"eventSource": "ebs.amazonaws.com",
"eventName": "CompleteSnapshot",
"awsRegion": "eu-west-1",
"sourceIPAddress": "192.0.2.0",
"userAgent": "PostmanRuntime/7.25.0",
"requestParameters": {
"snapshotId": "snap-123456789012",
"changedBlocksCount": 5
},
"responseElements": {
"status": "completed"
},
"requestID": "be112233-1ba5-4ae0-8e2b-1c302EXAMPLE",
"eventID": "6e12345-2a4e-417c-aa78-7594fEXAMPLE",
"eventType": "AwsApiCall",
"recipientAccountId": "123456789012"
}
```
------
#### [ ListSnapshotBlocks ]
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "IAMUser",
"principalId": "AIDAT4HPB2AO3JEXAMPLE",
"arn": "arn:aws:iam::123456789012:user/user",
"accountId": "123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "user"
},
"eventTime": "2021-06-03T00:32:46Z",
"eventSource": "ebs.amazonaws.com",
"eventName": "ListSnapshotBlocks",
"awsRegion": "us-east-1",
"sourceIPAddress": "111.111.111.111",
"userAgent": "PostmanRuntime/7.28.0",
"requestParameters": {
"snapshotId": "snap-abcdef01234567890",
"maxResults": 100,
"startingBlockIndex": 0
},
"responseElements": null,
"requestID": "example6-0e12-4aa9-b923-1555eexample",
"eventID": "example4-218b-4f69-a9e0-2357dexample",
"readOnly": true,
"resources": [
{
"accountId": "123456789012",
"type": "AWS::EC2::Snapshot",
"ARN": "arn:aws:ec2:us-west-2::snapshot/snap-abcdef01234567890"
}
],
"eventType": "AwsApiCall",
"managementEvent": false,
"recipientAccountId": "123456789012",
"eventCategory": "Data",
"tlsDetails": {
"tlsVersion": "TLSv1.2",
"cipherSuite": "ECDHE-RSA-AES128-SHA",
"clientProvidedHostHeader": "ebs.us-west-2.amazonaws.com"
}
}
```
------
#### [ ListChangedBlocks ]
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "IAMUser",
"principalId": "AIDAT4HPB2AO3JEXAMPLE",
"arn": "arn:aws:iam::123456789012:user/user",
"accountId": "123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "user"
},
"eventTime": "2021-06-02T21:11:46Z",
"eventSource": "ebs.amazonaws.com",
"eventName": "ListChangedBlocks",
"awsRegion": "us-east-1",
"sourceIPAddress": "111.111.111.111",
"userAgent": "PostmanRuntime/7.28.0",
"requestParameters": {
"firstSnapshotId": "snap-abcdef01234567890",
"secondSnapshotId": "snap-9876543210abcdef0",
"maxResults": 100,
"startingBlockIndex": 0
},
"responseElements": null,
"requestID": "example0-f4cb-4d64-8d84-72e1bexample",
"eventID": "example3-fac4-4a78-8ebb-3e9d3example",
"readOnly": true,
"resources": [
{
"accountId": "123456789012",
"type": "AWS::EC2::Snapshot",
"ARN": "arn:aws:ec2:us-west-2::snapshot/snap-abcdef01234567890"
},
{
"accountId": "123456789012",
"type": "AWS::EC2::Snapshot",
"ARN": "arn:aws:ec2:us-west-2::snapshot/snap-9876543210abcdef0"
}
],
"eventType": "AwsApiCall",
"managementEvent": false,
"recipientAccountId": "123456789012",
"eventCategory": "Data",
"tlsDetails": {
"tlsVersion": "TLSv1.2",
"cipherSuite": "ECDHE-RSA-AES128-SHA",
"clientProvidedHostHeader": "ebs.us-west-2.amazonaws.com"
}
}
```
------
#### [ GetSnapshotBlock ]
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "IAMUser",
"principalId": "AIDAT4HPB2AO3JEXAMPLE",
"arn": "arn:aws:iam::123456789012:user/user",
"accountId": "123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "user"
},
"eventTime": "2021-06-02T20:43:05Z",
"eventSource": "ebs.amazonaws.com",
"eventName": "GetSnapshotBlock",
"awsRegion": "us-east-1",
"sourceIPAddress": "111.111.111.111",
"userAgent": "PostmanRuntime/7.28.0",
"requestParameters": {
"snapshotId": "snap-abcdef01234567890",
"blockIndex": 1,
"blockToken": "EXAMPLEiL5E3pMPFpaDWjExM2/mnSKh1mQfcbjwe2mM7EwhrgCdPAEXAMPLE"
},
"responseElements": null,
"requestID": "examplea-6eca-4964-abfd-fd9f0example",
"eventID": "example6-4048-4365-a275-42e94example",
"readOnly": true,
"resources": [
{
"accountId": "123456789012",
"type": "AWS::EC2::Snapshot",
"ARN": "arn:aws:ec2:us-west-2::snapshot/snap-abcdef01234567890"
}
],
"eventType": "AwsApiCall",
"managementEvent": false,
"recipientAccountId": "123456789012",
"eventCategory": "Data",
"tlsDetails": {
"tlsVersion": "TLSv1.2",
"cipherSuite": "ECDHE-RSA-AES128-SHA",
"clientProvidedHostHeader": "ebs.us-west-2.amazonaws.com"
}
}
```
------
#### [ PutSnapshotBlock ]
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "IAMUser",
"principalId": "AIDAT4HPB2AO3JEXAMPLE",
"arn": "arn:aws:iam::123456789012:user/user",
"accountId": "123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "user"
},
"eventTime": "2021-06-02T21:09:17Z",
"eventSource": "ebs.amazonaws.com",
"eventName": "PutSnapshotBlock",
"awsRegion": "us-east-1",
"sourceIPAddress": "111.111.111.111",
"userAgent": "PostmanRuntime/7.28.0",
"requestParameters": {
"snapshotId": "snap-abcdef01234567890",
"blockIndex": 1,
"dataLength": 524288,
"checksum": "exampleodSGvFSb1e3kxWUgbOQ4TbzPurnsfVexample",
"checksumAlgorithm": "SHA256"
},
"responseElements": {
"checksum": "exampleodSGvFSb1e3kxWUgbOQ4TbzPurnsfVexample",
"checksumAlgorithm": "SHA256"
},
"requestID": "example3-d5e0-4167-8ee8-50845example",
"eventID": "example8-4d9a-4aad-b71d-bb31fexample",
"readOnly": false,
"resources": [
{
"accountId": "123456789012",
"type": "AWS::EC2::Snapshot",
"ARN": "arn:aws:ec2:us-west-2::snapshot/snap-abcdef01234567890"
}
],
"eventType": "AwsApiCall",
"managementEvent": false,
"recipientAccountId": "123456789012",
"eventCategory": "Data",
"tlsDetails": {
"tlsVersion": "TLSv1.2",
"cipherSuite": "ECDHE-RSA-AES128-SHA",
"clientProvidedHostHeader": "ebs.us-west-2.amazonaws.com"
}
}
```
------
Pour plus d'informations sur le contenu des CloudTrail enregistrements, voir [le contenu des CloudTrail enregistrements](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-record-contents.html) dans le *Guide de AWS CloudTrail l'utilisateur*.
# Questions fréquemment posées sur EBS direct APIs
**Est-il possible d'accéder à un instantané à l'aide de l'EBS direct APIs s'il est en attente ?**
Non. L’instantané n’est accessible que si son statut est terminé.
**Les index des blocs sont-ils renvoyés par l'EBS directement APIs dans l'ordre numérique ?**
Oui. Les index de bloc renvoyés sont uniques et classés par ordre numérique.
**Puis-je soumettre une demande avec une valeur de MaxResults paramètre inférieure à 100 ?**
Non. La valeur de MaxResult paramètre minimale que vous pouvez utiliser est de 100. Si vous soumettez une demande avec une valeur de MaxResult paramètre inférieure à 100 et que l'instantané contient plus de 100 blocs, l'API renverra au moins 100 résultats.
**Puis-je exécuter des demandes d’API simultanément ?**
Vous pouvez exécuter des demandes d’API simultanément. Veillez à prendre note des autres charges de travail qui peuvent être exécutées dans le compte pour éviter les goulots d’étranglement. Vous devez également intégrer des mécanismes de nouvelle tentative dans vos APIs flux de travail directs EBS pour gérer les ralentissements, les délais d'expiration et l'indisponibilité des services. Pour de plus amples informations, veuillez consulter [Optimisez les performances pour EBS Direct APIs](ebsapi-performance.md).
Passez en revue les quotas de APIs service direct EBS pour déterminer les demandes d'API que vous pouvez exécuter par seconde. Pour plus d’informations, consultez [Points de terminaison et quotas Amazon Elastic Block Store](https://docs.aws.amazon.com/general/latest/gr/ebs-service.html#w542aab9d130b7c15) dans *AWS General Reference*.
**Lors de l'exécution de l' ListChangedBlocks action, est-il possible d'obtenir une réponse vide même s'il y a des blocs dans l'instantané ?**
Oui. Si les blocs modifiés sont rares dans l’instantané, la réponse peut être vide, mais l’API renverra une valeur de jeton de page suivante. Utilisez la valeur de jeton de page suivante pour passer à la page suivante des résultats. Vous pouvez confirmer que vous avez atteint la dernière page de résultats lorsque l’API renvoie une valeur de jeton de page suivante nulle.
**Si le NextToken paramètre est spécifié en même temps qu'un StartingBlockIndex paramètre, lequel des deux est utilisé ?**
Le NextToken est utilisé et StartingBlockIndex est ignoré.
**Quelle est la durée de validité des jetons de bloc et des jetons suivants ?**
Les jetons de bloc sont valides pendant sept jours et les jetons suivants sont valides pendant 60 minutes.
**Les instantanés chiffrés sont-ils pris en charge ?**
Oui. Les instantanés chiffrés sont accessibles à l'aide de l'EBS direct. APIs
Pour accéder à un instantané chiffré, l'utilisateur doit avoir accès à la clé KMS utilisée pour chiffrer le cliché et à l'action de AWS KMS déchiffrement. Consultez la [Contrôlez l'accès à EBS direct à APIs l'aide d'IAM](ebsapi-permissions.md) section précédente de ce guide pour connaître la AWS KMS politique à attribuer à un utilisateur.
**Les instantanés publics sont-ils pris en charge ?**
Les instantanés publics ne sont pas pris en charge.
**Les instantanés locaux d'Amazon EBS sont-ils pris en charge ? AWS Outposts **
Les instantanés locaux Amazon EBS activés ne AWS Outposts sont pas pris en charge.
**L’opération ListSnapshotBlocks renvoie-t-elle tous les index de bloc et tous les jetons de bloc d’un instantané, ou seulement ceux dans lesquels des données ont été écrites ?**
Elle renvoie uniquement les index de bloc et les jetons de bloc dans lesquels des données ont été écrites.
**Puis-je obtenir un historique des appels d'API effectués par EBS directement APIs sur mon compte à des fins d'analyse de sécurité et de résolution des problèmes opérationnels ?**
Oui. Pour recevoir l'historique des appels d' APIs API directs EBS effectués sur votre compte, activez AWS CloudTrail le AWS Management Console. Pour de plus amples informations, veuillez consulter [Enregistrez les APIs appels directs EBS à l'aide de AWS CloudTrail](logging-ebs-apis-using-cloudtrail.md).