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.
# Sécurité dans Amazon VPC Lattice
La sécurité du cloud AWS est la priorité absolue. En tant que AWS client, vous bénéficiez de centres de données et d'architectures réseau conçus pour répondre aux exigences des entreprises les plus sensibles en matière de sécurité.
La gestion du contrôle de votre contenu hébergé sur cette infrastructure relève de votre responsabilité. Le [modèle de responsabilité partagée](https://aws.amazon.com/compliance/shared-responsibility-model/) décrit ceci comme la sécurité *du* cloud et la sécurité *dans* le cloud :
+ **Sécurité du cloud** : AWS est chargée de protéger l'infrastructure qui exécute les AWS services dans le AWS Cloud. AWS vous fournit également des services que vous pouvez utiliser en toute sécurité. Des auditeurs tiers testent et vérifient régulièrement l'efficacité de notre sécurité dans le cadre des programmes de [AWS conformité Programmes](https://aws.amazon.com/compliance/programs/) de de conformité. Pour en savoir plus sur les programmes de conformité qui s'appliquent à Amazon VPC Lattice, consultez la section [AWS Services concernés par programme de conformitéAWS Services concernés par programme](https://aws.amazon.com/compliance/services-in-scope/) .
+ **Sécurité dans le cloud** : vous êtes responsable de garder le contrôle sur votre contenu hébergé sur cette infrastructure. Vous êtes également responsable d’autres facteurs, y compris de la sensibilité de vos données, des exigences de votre entreprise, ainsi que de la législation et de la réglementation applicables.
Cette documentation vous aide à comprendre comment appliquer le modèle de responsabilité partagée lors de l'utilisation de VPC Lattice. Les rubriques suivantes expliquent comment configurer VPC Lattice pour atteindre vos objectifs de sécurité et de conformité. Vous apprenez également à utiliser d'autres AWS services qui vous aident à surveiller et à sécuriser votre service VPC Lattice, vos réseaux de services et vos configurations de ressources.
**Topics**
+ [Gérer l'accès aux services VPC Lattice](access-management-overview.md)
+ [Protection des données dans Amazon VPC Lattice](data-protection.md)
+ [Gestion des identités et des accès pour Amazon VPC Lattice](security-iam.md)
+ [Validation de conformité pour Amazon VPC Lattice](compliance-validation.md)
+ [Accédez à Amazon VPC Lattice à l'aide des points de terminaison d'interface ()AWS PrivateLink](vpc-interface-endpoints.md)
+ [Résilience dans Amazon VPC Lattice](disaster-recovery-resiliency.md)
+ [Sécurité de l'infrastructure dans Amazon VPC Lattice](infrastructure-security.md)
# Gérer l'accès aux services VPC Lattice
VPC Lattice est sécurisé par défaut car vous devez indiquer clairement les services et les configurations de ressources auxquels vous souhaitez fournir un accès et avec lesquels. VPCs Vous pouvez accéder aux services via une association VPC ou un point de terminaison VPC de type réseau de services. Pour les scénarios multicomptes, vous pouvez utiliser [AWS Resource Access Manager](sharing.md)pour partager des services, des configurations de ressources et des réseaux de services au-delà des limites des comptes.
VPC Lattice fournit un cadre qui vous permet de mettre en œuvre une defense-in-depth stratégie sur plusieurs couches du réseau.
+ **Première couche** : association du service, de la ressource, du VPC et du point de terminaison du VPC avec un réseau de services. Un VPC peut être connecté à un réseau de services via une association ou via un point de terminaison VPC. Si un VPC n'est pas connecté à un réseau de services, les clients du VPC ne peuvent pas accéder aux configurations de service et de ressources associées au réseau de services.
+ **Deuxième couche** : protections de sécurité optionnelles au niveau du réseau pour le réseau de service, telles que les groupes de sécurité et le réseau. ACLs En les utilisant, vous pouvez autoriser l'accès à des groupes spécifiques de clients dans un VPC plutôt qu'à tous les clients du VPC.
+ **Troisième couche** : politique d'authentification VPC Lattice optionnelle. Vous pouvez appliquer une politique d'authentification aux réseaux de services et aux services individuels. Généralement, la politique d'authentification sur le réseau de service est gérée par l'administrateur du réseau ou du cloud, qui met en œuvre une autorisation grossière. Par exemple, autoriser uniquement les demandes authentifiées provenant d'une organisation spécifique dans AWS Organizations. Pour une politique d'authentification au niveau du service, le propriétaire du service définit généralement des contrôles précis, qui peuvent être plus restrictifs que l'autorisation grossière appliquée au niveau du réseau de service.
**Note**
La politique d'authentification du réseau de service ne s'applique pas aux configurations de ressources du réseau de service.
**Méthodes de contrôle d'accès**
+ [Politiques d'authentification](auth-policies.md)
+ [Groupes de sécurité](security-groups.md)
+ [Réseau ACLs](network-acls.md)
# Contrôlez l'accès aux services VPC Lattice à l'aide de politiques d'authentification
Les politiques d'authentification VPC Lattice sont des documents de politique IAM que vous attachez à des réseaux de services ou à des services pour contrôler si un principal spécifié a accès à un groupe de services ou à un service spécifique. Vous pouvez associer une politique d’authentification à chaque réseau de services ou à chaque service dont vous souhaitez contrôler l’accès.
**Note**
La politique d'authentification du réseau de service ne s'applique pas aux configurations de ressources du réseau de service.
Les politiques d'authentification sont différentes des politiques basées sur l'identité IAM. Les politiques basées sur l'identité IAM sont associées aux utilisateurs, groupes ou rôles IAM et définissent les actions que ces identités peuvent effectuer sur quelles ressources. Les politiques d'authentification sont associées aux services et aux réseaux de services. Pour que l'autorisation réussisse, les politiques d'authentification et les politiques basées sur l'identité doivent comporter des instructions d'autorisation explicites. Pour de plus amples informations, veuillez consulter [Comment fonctionne l'autorisation](#auth-policies-evaluation-logic).
Vous pouvez utiliser la console AWS CLI et pour afficher, ajouter, mettre à jour ou supprimer des politiques d'authentification sur les services et les réseaux de services. Lorsque vous ajoutez, mettez à jour ou supprimez une politique d'authentification, la préparation peut prendre quelques minutes. Lorsque vous utilisez le AWS CLI, assurez-vous que vous vous trouvez dans la bonne région. Vous pouvez soit modifier la région par défaut de votre profil, soit utiliser le `--region` paramètre avec la commande.
**Topics**
+ [Éléments communs d'une politique d'authentification](#auth-policies-common-elements)
+ [Format de ressource pour les politiques d'authentification](#auth-policies-resource-format)
+ [Clés de condition pouvant être utilisées dans les politiques d'authentification](#auth-policies-condition-keys)
+ [Balises de ressources](#resource-tags)
+ [Balises principales](#principal-tags)
+ [Principaux anonymes (non authentifiés)](#anonymous-unauthenticated-principals)
+ [Exemples de politiques d'authentification](#example-auth-policies)
+ [Comment fonctionne l'autorisation](#auth-policies-evaluation-logic)
Pour commencer à utiliser les politiques d'authentification, suivez la procédure de création d'une politique d'authentification qui s'applique à un réseau de services. Pour des autorisations plus restrictives que vous ne souhaitez pas appliquer à d'autres services, vous pouvez éventuellement définir des politiques d'authentification pour des services individuels.
## Gérez l'accès à un réseau de services à l'aide de politiques d'authentification
Les AWS CLI tâches suivantes vous montrent comment gérer l'accès à un réseau de services à l'aide de politiques d'authentification. Pour obtenir des instructions relatives à l'utilisation de la console, reportez-vous à[Réseaux de service en VPC Lattice](service-networks.md).
**Topics**
+ [Ajouter une politique d'authentification à un réseau de service](#add-service-network-auth-policy)
+ [Modifier le type d'authentification d'un réseau de services](#change-service-network-auth-type)
+ [Supprimer une politique d'authentification d'un réseau de service](#remove-service-network-auth-policy)
### Ajouter une politique d'authentification à un réseau de service
Suivez les étapes décrites dans cette section pour utiliser le AWS CLI pour :
+ Activez le contrôle d'accès sur un réseau de service à l'aide d'IAM.
+ Ajoutez une politique d'authentification au réseau de service. Si vous n'ajoutez pas de politique d'authentification, tout le trafic recevra un message d'erreur de refus d'accès.
**Pour activer le contrôle d'accès et ajouter une politique d'authentification à un nouveau réseau de service**
1. Pour activer le contrôle d'accès sur un réseau de service afin qu'il puisse utiliser une politique d'authentification, utilisez la **create-service-network** commande avec l'`--auth-type`option et la valeur de`AWS_IAM`.
```
aws vpc-lattice create-service-network --name Name --auth-type AWS_IAM [--tags TagSpecification]
```
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"arn": "arn",
"authType": "AWS_IAM",
"id": "sn-0123456789abcdef0",
"name": "Name"
}
```
1. Utilisez la **put-auth-policy** commande en spécifiant l'ID du réseau de service sur lequel vous souhaitez ajouter la politique d'authentification et la politique d'authentification que vous souhaitez ajouter.
Par exemple, utilisez la commande suivante pour créer une politique d'authentification pour le réseau de service avec l'ID*`sn-0123456789abcdef0`*.
```
aws vpc-lattice put-auth-policy --resource-identifier sn-0123456789abcdef0 --policy file://policy.json
```
Utilisez le JSON pour créer une définition de politique. Pour de plus amples informations, veuillez consulter [Éléments communs d'une politique d'authentification](#auth-policies-common-elements).
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"policy": "policy",
"state": "Active"
}
```
**Pour activer le contrôle d'accès et ajouter une politique d'authentification à un réseau de service existant**
1. Pour activer le contrôle d'accès sur un réseau de service afin qu'il puisse utiliser une politique d'authentification, utilisez la **update-service-network** commande avec l'`--auth-type`option et la valeur de`AWS_IAM`.
```
aws vpc-lattice update-service-network --service-network-identifier sn-0123456789abcdef0 --auth-type AWS_IAM
```
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"arn": "arn",
"authType": "AWS_IAM",
"id": "sn-0123456789abcdef0",
"name": "Name"
}
```
1. Utilisez la **put-auth-policy** commande en spécifiant l'ID du réseau de service sur lequel vous souhaitez ajouter la politique d'authentification et la politique d'authentification que vous souhaitez ajouter.
```
aws vpc-lattice put-auth-policy --resource-identifier sn-0123456789abcdef0 --policy file://policy.json
```
Utilisez le JSON pour créer une définition de politique. Pour de plus amples informations, veuillez consulter [Éléments communs d'une politique d'authentification](#auth-policies-common-elements).
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"policy": "policy",
"state": "Active"
}
```
### Modifier le type d'authentification d'un réseau de services
**Pour désactiver la politique d'authentification pour un réseau de service**
Utilisez la **update-service-network** commande avec l'`--auth-type`option et la valeur de`NONE`.
```
aws vpc-lattice update-service-network --service-network-identifier sn-0123456789abcdef0 --auth-type NONE
```
Si vous devez réactiver la politique d'authentification ultérieurement, exécutez cette commande avec l'`--auth-type`option `AWS_IAM` spécifiée.
### Supprimer une politique d'authentification d'un réseau de service
**Pour supprimer une politique d'authentification d'un réseau de service**
Utilisez la commande **delete-auth-policy**.
```
aws vpc-lattice delete-auth-policy --resource-identifier sn-0123456789abcdef0
```
La demande échoue si vous supprimez une politique d'authentification avant de changer le type d'authentification d'un réseau de service en. `NONE`
## Gérer l'accès à un service à l'aide de politiques d'authentification
Les AWS CLI tâches suivantes vous montrent comment gérer l'accès à un service à l'aide de politiques d'authentification. Pour obtenir des instructions relatives à l'utilisation de la console, reportez-vous à[Services en VPC Lattice](services.md).
**Topics**
+ [Ajouter une politique d'authentification à un service](#add-service-auth-policy)
+ [Modifier le type d'authentification d'un service](#change-service-auth-type)
+ [Supprimer une politique d'authentification d'un service](#remove-service-auth-policy)
### Ajouter une politique d'authentification à un service
Procédez comme suit pour utiliser le AWS CLI pour :
+ Activez le contrôle d'accès sur un service à l'aide d'IAM.
+ Ajoutez une politique d'authentification au service. Si vous n'ajoutez pas de politique d'authentification, tout le trafic recevra un message d'erreur de refus d'accès.
**Pour activer le contrôle d'accès et ajouter une politique d'authentification à un nouveau service**
1. Pour activer le contrôle d'accès sur un service afin qu'il puisse utiliser une politique d'authentification, utilisez la **create-service** commande avec l'`--auth-type`option et la valeur de`AWS_IAM`.
```
aws vpc-lattice create-service --name Name --auth-type AWS_IAM [--tags TagSpecification]
```
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"arn": "arn",
"authType": "AWS_IAM",
"dnsEntry": {
...
},
"id": "svc-0123456789abcdef0",
"name": "Name",
"status": "CREATE_IN_PROGRESS"
}
```
1. Utilisez la **put-auth-policy** commande en spécifiant l'ID du service auquel vous souhaitez ajouter la politique d'authentification et la politique d'authentification que vous souhaitez ajouter.
Par exemple, utilisez la commande suivante pour créer une politique d'authentification pour le service avec l'ID*svc-0123456789abcdef0*.
```
aws vpc-lattice put-auth-policy --resource-identifier svc-0123456789abcdef0 --policy file://policy.json
```
Utilisez le JSON pour créer une définition de politique. Pour de plus amples informations, veuillez consulter [Éléments communs d'une politique d'authentification](#auth-policies-common-elements).
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"policy": "policy",
"state": "Active"
}
```
**Pour activer le contrôle d'accès et ajouter une politique d'authentification à un service existant**
1. Pour activer le contrôle d'accès sur un service afin qu'il puisse utiliser une politique d'authentification, utilisez la **update-service** commande avec l'`--auth-type`option et la valeur de`AWS_IAM`.
```
aws vpc-lattice update-service --service-identifier svc-0123456789abcdef0 --auth-type AWS_IAM
```
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"arn": "arn",
"authType": "AWS_IAM",
"id": "svc-0123456789abcdef0",
"name": "Name"
}
```
1. Utilisez la **put-auth-policy** commande en spécifiant l'ID du service auquel vous souhaitez ajouter la politique d'authentification et la politique d'authentification que vous souhaitez ajouter.
```
aws vpc-lattice put-auth-policy --resource-identifier svc-0123456789abcdef0 --policy file://policy.json
```
Utilisez le JSON pour créer une définition de politique. Pour de plus amples informations, veuillez consulter [Éléments communs d'une politique d'authentification](#auth-policies-common-elements).
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"policy": "policy",
"state": "Active"
}
```
### Modifier le type d'authentification d'un service
**Pour désactiver la politique d'authentification d'un service**
Utilisez la **update-service** commande avec l'`--auth-type`option et la valeur de`NONE`.
```
aws vpc-lattice update-service --service-identifier svc-0123456789abcdef0 --auth-type NONE
```
Si vous devez réactiver la politique d'authentification ultérieurement, exécutez cette commande avec l'`--auth-type`option `AWS_IAM` spécifiée.
### Supprimer une politique d'authentification d'un service
**Pour supprimer une politique d'authentification d'un service**
Utilisez la commande **delete-auth-policy**.
```
aws vpc-lattice delete-auth-policy --resource-identifier svc-0123456789abcdef0
```
La demande échoue si vous supprimez une politique d'authentification avant de changer le type d'authentification du service en. `NONE`
Si vous activez les politiques d'authentification qui nécessitent des demandes authentifiées adressées à un service, toutes les demandes adressées à ce service doivent contenir une signature de demande valide calculée à l'aide de la version 4 de signature (SigV4). Pour de plus amples informations, veuillez consulter [SIGv4 demandes authentifiées pour Amazon VPC Lattice](sigv4-authenticated-requests.md).
## Éléments communs d'une politique d'authentification
Les politiques d'authentification VPC Lattice sont spécifiées à l'aide de la même syntaxe que les politiques IAM. *Pour plus d'informations, consultez les sections Politiques basées sur l'[identité et politiques basées sur les ressources dans le Guide de l'](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html)utilisateur IAM.*
Une politique d'authentification contient les éléments suivants :
+ **Principal** : personne ou application autorisée à accéder aux actions et aux ressources de la déclaration. Dans une politique d'authentification, le principal est l'entité IAM destinataire de cette autorisation. Le principal est authentifié en tant qu'entité IAM pour envoyer des demandes à une ressource spécifique, ou à un groupe de ressources, comme dans le cas des services d'un réseau de services.
Vous devez spécifier un principal dans une politique basée sur les ressources. Les principaux peuvent inclure des comptes, des utilisateurs, des rôles, des utilisateurs fédérés ou AWS des services. Pour plus d'informations, voir [Éléments de politique AWS JSON : Principal](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html) dans le *guide de l'utilisateur IAM*.
+ **Effet** : effet lorsque le principal spécifié demande l'action spécifique. Il peut correspondre à `Allow` ou `Deny`. Par défaut, lorsque vous activez le contrôle d'accès sur un service ou un réseau de services à l'aide d'IAM, les principaux ne sont pas autorisés à envoyer des demandes au service ou au réseau de services.
+ **Actions** : action d'API spécifique pour laquelle vous accordez ou refusez l'autorisation. VPC Lattice prend en charge les actions qui utilisent le préfixe. `vpc-lattice-svcs` Pour plus d'informations, consultez la section [Actions définies par Amazon VPC Lattice Services](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonvpclatticeservices.html#amazonvpclatticeservices-actions-as-permissions) dans le *Service* Authorization Reference.
+ **Ressources** : services concernés par l'action.
+ **État** — Les conditions sont facultatives. Vous pouvez les utiliser pour contrôler le moment où votre politique est en vigueur. Pour plus d'informations, consultez la section [Clés de condition pour Amazon VPC Lattice Services](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonvpclatticeservices.html#amazonvpclatticeservices-policy-keys) dans la référence d'autorisation des *services*.
Lorsque vous créez et gérez des politiques d'authentification, vous souhaiterez peut-être utiliser le générateur de [politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-generator).
**Exigence**
La politique au format JSON ne doit pas contenir de nouvelles lignes ou de lignes vides.
## Format de ressource pour les politiques d'authentification
Vous pouvez restreindre l'accès à des ressources spécifiques en créant une politique d'authentification qui utilise un schéma correspondant avec un `/` modèle et en codant l'`Resource`élément, comme indiqué dans les exemples suivants.
| Protocole | Exemples |
| --- | --- |
| HTTP | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/vpc-lattice/latest/ug/auth-policies.html) |
| gRPC | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/vpc-lattice/latest/ug/auth-policies.html) |
Utilisez le format de ressource Amazon Resource Name (ARN) suivant pour `` :
```
arn:aws:vpc-lattice:region:account-id:service/service-id
```
Par exemple :
```
"Resource": "arn:aws:vpc-lattice:us-west-2:123456789012:service/svc-0123456789abcdef0"
```
## Clés de condition pouvant être utilisées dans les politiques d'authentification
L'accès peut également être contrôlé par des clés de condition dans l'élément **Condition** des politiques d'authentification. Ces clés de condition sont présentes à des fins d'évaluation en fonction du protocole et du fait que la demande soit signée avec [Signature Version 4 (SigV4)](sigv4-authenticated-requests.md) ou anonyme. Les clés de condition sont sensibles à la casse.
AWS fournit des clés de condition globales que vous pouvez utiliser pour contrôler l'accès, telles que `aws:PrincipalOrgID` et`aws:SourceIp`. Pour consulter la liste des clés de condition AWS globales, voir les clés de [contexte de condition AWS globales](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) dans le *guide de l'utilisateur IAM*.
Le tableau suivant répertorie les clés de condition du réseau VPC. Pour plus d'informations, consultez la section [Clés de condition pour Amazon VPC Lattice Services](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonvpclatticeservices.html#amazonvpclatticeservices-policy-keys) dans la référence d'autorisation des *services*.
| Clés de condition | Description | Exemple | Disponible pour les appelants anonymes (non authentifiés) ? | Disponible pour le gRPC ? |
| --- | --- | --- | --- | --- |
| vpc-lattice-svcs:Port | Filtre l'accès par le port de service auquel la demande est envoyée | 80 | Oui | Oui |
| vpc-lattice-svcs:RequestMethod | Filtre l'accès en fonction de la méthode de la requête | GET | Oui | Publiez toujours |
| vpc-lattice-svcs:RequestPath | Filtre l'accès en fonction de la partie chemin de l'URL de demande | /path | Oui | Oui |
| vpc-lattice-svcs:RequestHeader/header-name: value | Filtre l'accès en fonction d'une paire nom-valeur dans les en-têtes de la demande | content-type: application/json | Oui | Oui |
| vpc-lattice-svcs:RequestQueryString/key-name: value | Filtre l'accès en fonction des paires clé-valeur de la chaîne de requête dans l'URL de la demande | quux: [corge, grault] | Oui | Non |
| vpc-lattice-svcs:ServiceNetworkArn | Filtre l'accès par l'ARN du réseau de service du service qui reçoit la demande | arn:aws:vpc-lattice:us-west-2:123456789012:servicenetwork/sn-0123456789abcdef0 | Oui | Oui |
| vpc-lattice-svcs:ServiceArn | Filtre l'accès par l'ARN du service qui reçoit la demande | arn:aws:vpc-lattice:us-west-2:123456789012:service/svc-0123456789abcdef0 | Oui | Oui |
| vpc-lattice-svcs:SourceVpc | Filtre l'accès en fonction du VPC d'où provient la requête | vpc-1a2b3c4d | Oui | Oui |
| vpc-lattice-svcs:SourceVpcOwnerAccount | Filtre l'accès en fonction du compte propriétaire du VPC d'où provient la requête | 123456789012 | Oui | Oui |
## Balises de ressources
Une *balise* est une étiquette de métadonnées que vous attribuez ou que vous AWS attribuez à une AWS ressource. Chaque balise se compose de deux parties :
+ Une *clé de balise* (par exemple, `CostCenter`, `Environment` ou `Project`). Les clés de balises sont sensibles à la casse.
+ Un champ facultatif appelé *valeur de balise* (par exemple, `111122223333` ou `Production`). Si la valeur de balise est identique à l’utilisation d’une chaîne vide. Tout comme les clés de balises, les valeurs de balises sont sensibles à la casse.
Pour plus d'informations sur le balisage, voir [Contrôle de l'accès aux AWS ressources à l'aide](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) de balises
Vous pouvez utiliser des balises dans vos politiques d'authentification à l'aide de la clé de contexte de condition `aws:ResourceTag/key` AWS globale.
L'exemple de politique suivant accorde l'accès aux services dotés de cette balise`Environment=Gamma`. Cette politique vous permet de faire référence à des services sans les coder en dur ou. ARNs IDs
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowGammaAccess",
"Effect": "Allow",
"Principal": "*",
"Action": "vpc-lattice-svcs:Invoke",
"Resource": "arn:aws:vpc-lattice:us-west-2:123456789012:service/svc-0124446789abcdef0/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Environment": "Gamma",
}
}
}
]
}
```
## Balises principales
Vous pouvez contrôler l'accès à vos services et ressources en fonction des balises associées à l'identité de l'appelant. VPC Lattice prend en charge le contrôle d'accès en fonction des balises principales de l'utilisateur, du rôle ou des balises de session à l'aide des variables. `aws:PrincipalTag/context` Pour plus d'informations, consultez la section [Contrôle de l'accès pour les principaux IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_iam-tags.html#access_iam-tags_control-principals).
L'exemple de politique suivant accorde l'accès uniquement aux identités dotées du tag`Team=Payments`. Cette politique vous permet de contrôler l'accès sans avoir à coder en dur le compte IDs ou le rôle. ARNs
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowPaymentsTeam",
"Effect": "Allow",
"Principal": "*",
"Action": "vpc-lattice-svcs:Invoke",
"Resource": "arn:aws:vpc-lattice:us-west-2:123456789012:service/svc-0123456789abcdef0/*",
"Condition": {
"StringEquals": {
"aws:PrincipalTag/Team": "Payments",
}
}
}
]
}
```
## Principaux anonymes (non authentifiés)
Les principaux anonymes sont des appelants qui ne signent pas leurs AWS demandes avec [Signature Version 4 (SigV4)](sigv4-authenticated-requests.md) et qui se trouvent au sein d'un VPC connecté au réseau de service. Les principaux anonymes peuvent envoyer des demandes non authentifiées aux services du réseau de services si une politique d'authentification le permet.
## Exemples de politiques d'authentification
Voici des exemples de politiques d'authentification qui exigent que les demandes soient effectuées par des principaux authentifiés.
Tous les exemples utilisent la `us-west-2` Région et contiennent un compte fictif. IDs
**Exemple 1 : Restreindre l'accès aux services d'une AWS organisation spécifique**
L'exemple de politique d'authentification suivant accorde des autorisations à toute demande authentifiée pour accéder à tous les services du réseau de services auquel s'applique la politique. Cependant, la demande doit émaner de directeurs appartenant à l' AWS organisation spécifiée dans la condition.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": "vpc-lattice-svcs:Invoke",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:PrincipalOrgID": [
"o-123456example"
]
}
}
}
]
}
```
------
**Exemple 2 : Restreindre l'accès à un service par un rôle IAM spécifique**
L'exemple de politique d'authentification suivant accorde des autorisations à toute demande authentifiée utilisant le rôle IAM `rates-client` pour effectuer des requêtes HTTP GET sur le service spécifié dans l'élément. `Resource` La ressource contenue dans l'`Resource`élément est identique au service auquel la politique est attachée.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::123456789012:role/rates-client"
]
},
"Action": "vpc-lattice-svcs:Invoke",
"Resource": [
"arn:aws:vpc-lattice:us-west-2:123456789012:service/svc-0123456789abcdef0/*"
],
"Condition": {
"StringEquals": {
"vpc-lattice-svcs:RequestMethod": "GET"
}
}
}
]
}
```
------
**Exemple 3 : Restreindre l'accès aux services par des personnes authentifiées dans un VPC spécifique**
L'exemple de politique d'authentification suivant autorise uniquement les demandes authentifiées provenant des principaux du VPC dont l'ID de VPC est. `vpc-1a2b3c4d`
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": "vpc-lattice-svcs:Invoke",
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:PrincipalType": "Anonymous"
},
"StringEquals": {
"vpc-lattice-svcs:SourceVpc": "vpc-1a2b3c4d"
}
}
}
]
}
```
------
## Comment fonctionne l'autorisation
Lorsqu'un service VPC Lattice reçoit une demande, le code d' AWS application évalue ensemble toutes les politiques d'autorisation pertinentes afin de déterminer s'il convient d'autoriser ou de refuser la demande. Il évalue toutes les politiques basées sur l'identité IAM et les politiques d'authentification applicables dans le contexte de la demande lors de l'autorisation. Par défaut, toutes les demandes sont implicitement refusées lorsque le type d'authentification est défini comme tel. `AWS_IAM` Une autorisation explicite émanant de toutes les politiques pertinentes remplace la valeur par défaut.
L'autorisation inclut :
+ Collecte de toutes les politiques basées sur l'identité IAM et des politiques d'authentification pertinentes.
+ Évaluation de l'ensemble de politiques qui en résulte :
+ Vérifier que le demandeur (tel qu'un utilisateur ou un rôle IAM) est autorisé à effectuer l'opération depuis le compte auquel il appartient. S'il n'y a aucune instruction d'autorisation explicite, AWS cela n'autorise pas la demande.
+ Vérifier que la demande est autorisée par la politique d'authentification du réseau de service. Si une politique d'authentification est activée, mais qu'il n'existe aucune instruction d'autorisation explicite, AWS cela n'autorise pas la demande. S'il existe une instruction d'autorisation explicite, ou si le type d'authentification est le cas`NONE`, le code continue.
+ Vérifier que la demande est autorisée par la politique d'authentification du service. Si une politique d'authentification est activée, mais qu'il n'existe aucune instruction d'autorisation explicite, AWS cela n'autorise pas la demande. S'il existe une instruction d'autorisation explicite, ou si le type d'authentification est le cas`NONE`, le code d'application renvoie la décision finale **Allow**.
+ Un refus explicite dans n'importe quelle stratégie remplace toutes les autorisations.
Le schéma montre le flux de travail d'autorisation. Lorsqu'une demande est faite, les politiques pertinentes autorisent ou refusent à la demande l'accès à un service donné.
![\[Flux de travail d'autorisation\]](http://docs.aws.amazon.com/fr_fr/vpc-lattice/latest/ug/images/authpolicy.png)
# Contrôlez le trafic dans VPC Lattice à l'aide de groupes de sécurité
AWS les groupes de sécurité agissent comme des pare-feux virtuels, contrôlant le trafic réseau à destination et en provenance des entités auxquelles ils sont associés. Avec VPC Lattice, vous pouvez créer des groupes de sécurité et les attribuer à l'association VPC qui connecte un VPC à un réseau de services afin d'appliquer des protections de sécurité supplémentaires au niveau du réseau pour votre réseau de services. Si vous connectez un VPC à un réseau de services à l'aide d'un point de terminaison VPC, vous pouvez également attribuer des groupes de sécurité au point de terminaison VPC. De même, vous pouvez attribuer des groupes de sécurité aux passerelles de ressources que vous créez pour permettre l'accès aux ressources de votre VPC.
**Topics**
+ [Liste de préfixes gérée](#managed-prefix-list)
+ [Règles des groupes de sécurité](#security-groups-rules)
+ [Gérer les groupes de sécurité pour une association VPC](#service-network-security-group)
## Liste de préfixes gérée
VPC Lattice fournit des listes de préfixes gérées qui incluent les adresses IP utilisées pour acheminer le trafic sur le réseau VPC Lattice lorsque vous utilisez une association de services pour connecter votre VPC à un réseau de services à l'aide d'une association VPC. Il s' IPs agit soit de liens privés locaux, soit de liens publics non IPs routables. IPs
Vous pouvez faire référence aux listes de préfixes gérées par VPC Lattice dans les règles de votre groupe de sécurité. Cela permet au trafic de circuler depuis les clients, via le réseau de services VPC Lattice, et vers les cibles du service VPC Lattice.
Supposons, par exemple, qu'une instance EC2 soit enregistrée comme cible dans la région USA Ouest (Oregon) (`us-west-2`). Vous pouvez ajouter une règle au groupe de sécurité d'instance qui autorise l'accès HTTPS entrant à partir de la liste de préfixes gérés par VPC Lattice, afin que le trafic VPC Lattice de cette région puisse atteindre l'instance. Si vous supprimez toutes les autres règles entrantes du groupe de sécurité, vous pouvez empêcher tout trafic autre que le trafic VPC Lattice d'atteindre l'instance.
Les noms des listes de préfixes gérées pour VPC Lattice sont les suivants :
+ com.amazonaws. *region*.vpc en treillis
+ com.amazonaws. *region*.ipv6.vp-lattice
Pour plus d’informations, consultez les [listes de préfixes gérés par AWS](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-aws-managed-prefix-lists.html#available-aws-managed-prefix-lists) dans le *Guide de l’utilisateur Amazon VPC*.
**Clients Windows et macOS**
Les adresses figurant dans les listes de préfixes VPC Lattice sont des adresses locales de lien et des adresses publiques non routables. Si vous vous connectez à VPC Lattice à partir de ces clients, vous devez mettre à jour leurs configurations afin qu'il transfère les adresses IP de la liste de préfixes gérés vers l'adresse IP principale du client. Voici un exemple de commande qui met à jour la configuration du client Windows, où se 169.254.171.0 trouve l'une des adresses de la liste des préfixes gérés.
```
C:\> route add 169.254.171.0 mask 255.255.255.0 primary-ip-address
```
Voici un exemple de commande qui met à jour la configuration du client macOS, où se 169.254.171.0 trouve l'une des adresses de la liste des préfixes gérés.
```
sudo route -n add -net 169.254.171.0 primary-ip-address 255.255.255.0
```
Pour éviter de créer un itinéraire statique, nous vous recommandons d'utiliser un point de terminaison de réseau de services dans un VPC pour établir la connectivité. Pour de plus amples informations, veuillez consulter [Gérer les associations de points de terminaison VPC du réseau de services](service-network-associations.md#service-network-vpc-endpoint-associations).
## Règles des groupes de sécurité
L'utilisation de VPC Lattice avec ou sans groupes de sécurité n'aura aucune incidence sur la configuration de votre groupe de sécurité VPC existant. Vous pouvez toutefois ajouter vos propres groupes de sécurité à tout moment.
**Considérations clés**
+ Les règles de groupe de sécurité pour les clients contrôlent le trafic sortant vers VPC Lattice.
+ Les règles de groupe de sécurité pour les cibles contrôlent le trafic entrant depuis le VPC Lattice vers les cibles, y compris le trafic de contrôle de santé.
+ Les règles du groupe de sécurité pour l'association entre le réseau de service et le VPC contrôlent les clients qui peuvent accéder au réseau de service VPC Lattice.
+ Les règles de groupe de sécurité pour la passerelle de ressources contrôlent le trafic sortant de la passerelle de ressources vers les ressources.
**Règles sortantes recommandées pour le trafic circulant d'une passerelle de ressources vers une ressource de base de données**
Pour que le trafic circule de la passerelle de ressources vers les ressources, vous devez créer des règles de sortie pour les ports ouverts et des protocoles d'écoute acceptés pour les ressources.
| Destination | Protocole | Plage de ports | Comment |
| --- | --- | --- | --- |
| CIDR range for resource | TCP | 3306 | Autoriser le trafic de la passerelle de ressources vers les bases de données |
**Règles d'entrée recommandées pour les associations de réseaux de services et de VPC**
Pour que le trafic circule du client VPCs vers les services associés au réseau de services, vous devez créer des règles entrantes pour les ports d'écoute et des protocoles d'écoute pour les services.
| Source | Protocole | Plage de ports | Comment |
| --- | --- | --- | --- |
| VPC CIDR | listener | listener | Autoriser le trafic des clients vers VPC Lattice |
**Règles sortantes recommandées pour le trafic circulant des instances clientes vers VPC Lattice**
Par défaut, les groupes de sécurité autorisent la totalité du trafic sortant. Toutefois, si vous avez des règles de sortie personnalisées, vous devez autoriser le trafic sortant vers le préfixe VPC Lattice pour les ports et protocoles d'écoute afin que les instances clientes puissent se connecter à tous les services associés au réseau de services VPC Lattice. Vous pouvez autoriser ce trafic en référençant l'ID de la liste de préfixes pour VPC Lattice.
| Destination | Protocole | Plage de ports | Comment |
| --- | --- | --- | --- |
| ID of the VPC Lattice prefix list | listener | listener | Autoriser le trafic des clients vers VPC Lattice |
**Règles entrantes recommandées pour le trafic circulant entre VPC Lattice et les instances cibles**
Vous ne pouvez pas utiliser le groupe de sécurité client comme source pour les groupes de sécurité de votre cible, car le trafic provient de VPC Lattice. Vous pouvez référencer l'ID de la liste de préfixes pour VPC Lattice.
| Source | Protocole | Plage de ports | Comment |
| --- | --- | --- | --- |
| ID of the VPC Lattice prefix list | target | target | Autoriser le trafic du VPC Lattice vers les cibles |
| ID of the VPC Lattice prefix list | health check | health check | Autoriser le trafic de vérification de l'état du VPC Lattice vers les cibles |
## Gérer les groupes de sécurité pour une association VPC
Vous pouvez utiliser le AWS CLI pour afficher, ajouter ou mettre à jour des groupes de sécurité sur le VPC afin de desservir l'association réseau. Lorsque vous utilisez le AWS CLI, n'oubliez pas que vos commandes s'exécutent dans la Région AWS configuration adaptée à votre profil. Si vous souhaitez exécuter les commandes dans une autre région, modifiez la région par défaut pour votre profil, ou utilisez le paramètre `--region` avec la commande.
Avant de commencer, vérifiez que vous avez créé le groupe de sécurité dans le même VPC que le VPC que vous souhaitez ajouter au réseau de service. Pour plus d'informations, consultez la section [Contrôler le trafic vers vos ressources à l'aide de groupes de sécurité](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-security-groups.html) dans le guide de l'*utilisateur Amazon VPC*
**Pour ajouter un groupe de sécurité lorsque vous créez une association VPC à l'aide de la console**
1. Ouvrez la console Amazon VPC à l’adresse [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. **Dans le volet de navigation, sous **VPC Lattice**, choisissez Service networks.**
1. Sélectionnez le nom du réseau de service pour ouvrir sa page de détails.
1. **Dans l'onglet **Associations VPC**, choisissez Create **VPC associations, puis choisissez Add VPC association**.**
1. Sélectionnez un VPC et jusqu'à cinq groupes de sécurité.
1. Sélectionnez **Enregistrer les modifications**.
**Pour ajouter ou mettre à jour des groupes de sécurité pour une association VPC existante à l'aide de la console**
1. Ouvrez la console Amazon VPC à l’adresse [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. **Dans le volet de navigation, sous **VPC Lattice**, choisissez Service networks.**
1. Sélectionnez le nom du réseau de service pour ouvrir sa page de détails.
1. Dans l'onglet **Associations VPC**, cochez la case correspondant à l'association, puis choisissez **Actions**, **Modifier les groupes de sécurité**.
1. Ajoutez et supprimez des groupes de sécurité selon vos besoins.
1. Sélectionnez **Enregistrer les modifications**.
**Pour ajouter un groupe de sécurité lorsque vous créez une association VPC à l'aide du AWS CLI**
Utilisez la commande [create-service-network-vpc-association](https://docs.aws.amazon.com/cli/latest/reference/vpc-lattice/create-service-network-vpc-association.html), en spécifiant l'ID du VPC pour l'association VPC et l'ID des groupes de sécurité à ajouter.
```
aws vpc-lattice create-service-network-vpc-association \
--service-network-identifier sn-0123456789abcdef0 \
--vpc-identifier vpc-1a2b3c4d \
--security-group-ids sg-7c2270198example
```
Si elle aboutit, la commande renvoie un résultat semblable au suivant :
```
{
"arn": "arn",
"createdBy": "464296918874",
"id": "snva-0123456789abcdef0",
"status": "CREATE_IN_PROGRESS",
"securityGroupIds": ["sg-7c2270198example"]
}
```
**Pour ajouter ou mettre à jour des groupes de sécurité pour une association VPC existante à l'aide du AWS CLI**
Utilisez la commande [update-service-network-vpc-association](https://docs.aws.amazon.com/cli/latest/reference/vpc-lattice/update-service-network-vpc-association.html), en spécifiant l'ID du réseau de service et celui IDs des groupes de sécurité. Ces groupes de sécurité remplacent tous les groupes de sécurité précédemment associés. Définissez au moins un groupe de sécurité lors de la mise à jour de la liste.
```
aws vpc-lattice update-service-network-vpc-association
--service-network-vpc-association-identifier sn-903004f88example \
--security-group-ids sg-7c2270198example sg-903004f88example
```
**Avertissement**
Vous ne pouvez pas supprimer tous les groupes de sécurité. Au lieu de cela, vous devez d'abord supprimer l'association VPC, puis recréer l'association VPC sans aucun groupe de sécurité. Soyez prudent lorsque vous supprimez l'association VPC. Cela empêche le trafic d'atteindre les services qui se trouvent dans ce réseau de services.
# Contrôlez le trafic vers VPC Lattice à l'aide du réseau ACLs
Une liste de contrôle d'accès (ACL) réseau autorise ou refuse un trafic entrant ou sortant spécifique au niveau du sous-réseau. L'ACL réseau par défaut permet tout le trafic entrant et sortant. Vous pouvez créer un réseau personnalisé ACLs pour vos sous-réseaux afin de fournir une couche de sécurité supplémentaire. Pour plus d'informations, consultez la section [Réseau ACLs](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html) dans le guide de l'*utilisateur Amazon VPC*.
**Topics**
+ [Réseau ACLs pour les sous-réseaux de vos clients](#network-acl-client-subnets)
+ [Réseau ACLs pour vos sous-réseaux cibles](#network-acl-target-subnets)
## Réseau ACLs pour les sous-réseaux de vos clients
Le réseau ACLs pour les sous-réseaux clients doit autoriser le trafic entre les clients et VPC Lattice. Vous pouvez obtenir les plages d'adresses IP à autoriser dans la [liste des préfixes gérés](security-groups.md#managed-prefix-list) pour VPC Lattice.
Voici un exemple de règle entrante.
| Source | Protocole | Plage de ports | Comment |
| --- | --- | --- | --- |
| vpc\$1lattice\$1cidr\$1block | TCP | 1025-65535 | Autoriser le trafic entre VPC Lattice et les clients |
Voici un exemple de règle sortante.
| Destination | Protocole | Plage de ports | Comment |
| --- | --- | --- | --- |
| vpc\$1lattice\$1cidr\$1block | listener | listener | Autoriser le trafic des clients vers VPC Lattice |
## Réseau ACLs pour vos sous-réseaux cibles
Le réseau ACLs des sous-réseaux cibles doit autoriser le trafic entre les cibles et le VPC Lattice à la fois sur le port cible et sur le port de contrôle de santé. Vous pouvez obtenir les plages d'adresses IP à autoriser dans la [liste des préfixes gérés](security-groups.md#managed-prefix-list) pour VPC Lattice.
Voici un exemple de règle entrante.
| Source | Protocole | Plage de ports | Comment |
| --- | --- | --- | --- |
| vpc\$1lattice\$1cidr\$1block | target | target | Autoriser le trafic du VPC Lattice vers les cibles |
| vpc\$1lattice\$1cidr\$1block | health check | health check | Autoriser le trafic de vérification de l'état du VPC Lattice vers les cibles |
Voici un exemple de règle sortante.
| Destination | Protocole | Plage de ports | Comment |
| --- | --- | --- | --- |
| vpc\$1lattice\$1cidr\$1block | target | 1024-65535 | Autoriser le trafic des cibles vers le VPC Lattice |
| vpc\$1lattice\$1cidr\$1block | health check | 1024-65535 | Autoriser le trafic de contrôle de santé entre les cibles et le VPC Lattice |
# SIGv4 demandes authentifiées pour Amazon VPC Lattice
VPC Lattice utilise la version de signature 4 (SIGv4) ou la version de signature 4A (SIGv4A) pour l'authentification du client. Pour plus d’informations, consultez [Signature AWS Version 4 pour les demandes d’API](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) dans le *Guide de l’utilisateur IAM*.
**Considérations**
+ VPC Lattice tente d'authentifier toute demande signée avec ou A. SIGv4 SIGv4 La demande échoue sans authentification.
+ VPC Lattice ne prend pas en charge la signature de la charge utile. Vous devez envoyer un `x-amz-content-sha256` en-tête dont la valeur est définie sur`"UNSIGNED-PAYLOAD"`.
**Topics**
+ [Python](#sigv4-authenticated-requests-python)
+ [Java](#sigv4-authenticated-requests-java-custom-interceptor)
+ [Node.js](#sigv4-authenticated-requests-nodejs)
+ [Golang](#sigv4-authenticated-requests-golang)
+ [Golang - GRPC](#sigv4-authenticated-requests-golang-grpc)
## Python
Cet exemple envoie les demandes signées via une connexion sécurisée à un service enregistré sur le réseau. Si vous préférez utiliser des [requêtes](https://requests.readthedocs.io/en/latest/), le package [botocore](https://github.com/boto/botocore) simplifie le processus d'authentification, mais n'est pas strictement obligatoire. Pour plus d'informations, consultez la section [Credentials](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) dans la documentation de Boto3.
Pour installer les `awscrt` packages `botocore` et, utilisez la commande suivante. Pour plus d'informations, consultez [AWS CRT Python.](https://pypi.org/project/awscrt/)
```
pip install botocore awscrt
```
Si vous exécutez l'application client sur Lambda, installez les modules requis à l'aide de [couches Lambda](https://docs.aws.amazon.com/lambda/latest/dg/python-layers.html) ou incluez-les dans votre package de déploiement.
Dans l'exemple suivant, remplacez les valeurs de l'espace réservé par vos propres valeurs.
------
#### [ SIGv4 ]
```
from botocore import crt
import requests
from botocore.awsrequest import AWSRequest
import botocore.session
if __name__ == '__main__':
session = botocore.session.Session()
signer = crt.auth.CrtSigV4Auth(session.get_credentials(), 'vpc-lattice-svcs', 'us-west-2')
endpoint = 'https://data-svc-022f67d3a42.1234abc.vpc-lattice-svcs.us-west-2.on.aws'
data = "some-data-here"
headers = {'Content-Type': 'application/json', 'x-amz-content-sha256': 'UNSIGNED-PAYLOAD'}
request = AWSRequest(method='POST', url=endpoint, data=data, headers=headers)
request.context["payload_signing_enabled"] = False
signer.add_auth(request)
prepped = request.prepare()
response = requests.post(prepped.url, headers=prepped.headers, data=data)
print(response.text)
```
------
#### [ SIGv4A ]
```
from botocore import crt
import requests
from botocore.awsrequest import AWSRequest
import botocore.session
if __name__ == '__main__':
session = botocore.session.Session()
signer = crt.auth.CrtSigV4AsymAuth(session.get_credentials(), 'vpc-lattice-svcs', '*')
endpoint = 'https://data-svc-022f67d3a42.1234abc.vpc-lattice-svcs.us-west-2.on.aws'
data = "some-data-here"
headers = {'Content-Type': 'application/json', 'x-amz-content-sha256': 'UNSIGNED-PAYLOAD'}
request = AWSRequest(method='POST', url=endpoint, data=data, headers=headers)
request.context["payload_signing_enabled"] = False
signer.add_auth(request)
prepped = request.prepare()
response = requests.post(prepped.url, headers=prepped.headers, data=data)
print(response.text)
```
------
## Java
Cet exemple montre comment vous pouvez effectuer la signature des demandes à l'aide d'intercepteurs personnalisés. Il utilise la classe de fournisseur d'informations d'identification par défaut from [AWS SDK for Java 2.x](https://github.com/aws/aws-sdk-java-v2), qui obtient les informations d'identification correctes pour vous. Si vous préférez utiliser un fournisseur d'informations d'identification spécifique, vous pouvez en sélectionner un parmi. [AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials.html) AWS SDK pour Java Autorise uniquement les charges utiles non signées via HTTPS. Cependant, vous pouvez étendre le signataire pour prendre en charge les charges utiles non signées via HTTP.
------
#### [ SIGv4 ]
```
package com.example;
import software.amazon.awssdk.http.auth.aws.signer.AwsV4HttpSigner;
import software.amazon.awssdk.http.auth.spi.signer.SignedRequest;
import software.amazon.awssdk.http.SdkHttpMethod;
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.identity.spi.AwsCredentialsIdentity;
import software.amazon.awssdk.http.SdkHttpRequest;
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.http.HttpExecuteRequest;
import software.amazon.awssdk.http.HttpExecuteResponse;
import java.io.IOException;
import java.net.URI;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
public class sigv4 {
public static void main(String[] args) {
AwsV4HttpSigner signer = AwsV4HttpSigner.create();
AwsCredentialsIdentity credentials = DefaultCredentialsProvider.create().resolveCredentials();
if (args.length < 2) {
System.out.println("Usage: sample ");
System.exit(1);
}
// Create the HTTP request to be signed
var url = args[0];
SdkHttpRequest httpRequest = SdkHttpRequest.builder()
.uri(URI.create(url))
.method(SdkHttpMethod.GET)
.build();
SignedRequest signedRequest = signer.sign(r -> r.identity(credentials)
.request(httpRequest)
.putProperty(AwsV4HttpSigner.SERVICE_SIGNING_NAME, "vpc-lattice-svcs")
.putProperty(AwsV4HttpSigner.PAYLOAD_SIGNING_ENABLED, false)
.putProperty(AwsV4HttpSigner.REGION_NAME, args[1]));
System.out.println("[*] Raw request headers:");
signedRequest.request().headers().forEach((key, values) -> {
values.forEach(value -> System.out.println(" " + key + ": " + value));
});
try (SdkHttpClient httpClient = ApacheHttpClient.create()) {
HttpExecuteRequest httpExecuteRequest = HttpExecuteRequest.builder()
.request(signedRequest.request())
.contentStreamProvider(signedRequest.payload().orElse(null))
.build();
System.out.println("[*] Sending request to: " + url);
HttpExecuteResponse httpResponse = httpClient.prepareRequest(httpExecuteRequest).call();
System.out.println("[*] Request sent");
System.out.println("[*] Response status code: " + httpResponse.httpResponse().statusCode());
// Read and print the response body
httpResponse.responseBody().ifPresent(inputStream -> {
try {
String responseBody = new String(inputStream.readAllBytes());
System.out.println("[*] Response body: " + responseBody);
} catch (IOException e) {
System.err.println("[*] Failed to read response body");
e.printStackTrace();
} finally {
try {
inputStream.close();
} catch (IOException e) {
System.err.println("[*] Failed to close input stream");
e.printStackTrace();
}
}
});
} catch (IOException e) {
System.err.println("[*] HTTP Request Failed.");
e.printStackTrace();
}
}
}
```
------
#### [ SIGv4A ]
Cet exemple nécessite une dépendance supplémentaire sur`software.amazon.awssdk:http-auth-aws-crt`.
```
package com.example;
import software.amazon.awssdk.http.auth.aws.signer.AwsV4aHttpSigner;
import software.amazon.awssdk.http.auth.aws.signer.RegionSet;
import software.amazon.awssdk.http.auth.spi.signer.SignedRequest;
import software.amazon.awssdk.http.SdkHttpMethod;
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.identity.spi.AwsCredentialsIdentity;
import software.amazon.awssdk.http.SdkHttpRequest;
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.http.HttpExecuteRequest;
import software.amazon.awssdk.http.HttpExecuteResponse;
import java.io.IOException;
import java.net.URI;
import java.util.Arrays;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
public class sigv4a {
public static void main(String[] args) {
AwsV4aHttpSigner signer = AwsV4aHttpSigner.create();
AwsCredentialsIdentity credentials = DefaultCredentialsProvider.create().resolveCredentials();
if (args.length < 2) {
System.out.println("Usage: sample ");
System.exit(1);
}
// Create the HTTP request to be signed
var url = args[0];
SdkHttpRequest httpRequest = SdkHttpRequest.builder()
.uri(URI.create(url))
.method(SdkHttpMethod.GET)
.build();
SignedRequest signedRequest = signer.sign(r -> r.identity(credentials)
.request(httpRequest)
.putProperty(AwsV4aHttpSigner.SERVICE_SIGNING_NAME, "vpc-lattice-svcs")
.putProperty(AwsV4aHttpSigner.PAYLOAD_SIGNING_ENABLED, false)
.putProperty(AwsV4aHttpSigner.REGION_SET, RegionSet.create(String.join(" ",Arrays.copyOfRange(args, 1, args.length)))));
System.out.println("[*] Raw request headers:");
signedRequest.request().headers().forEach((key, values) -> {
values.forEach(value -> System.out.println(" " + key + ": " + value));
});
try (SdkHttpClient httpClient = ApacheHttpClient.create()) {
HttpExecuteRequest httpExecuteRequest = HttpExecuteRequest.builder()
.request(signedRequest.request())
.contentStreamProvider(signedRequest.payload().orElse(null))
.build();
System.out.println("[*] Sending request to: " + url);
HttpExecuteResponse httpResponse = httpClient.prepareRequest(httpExecuteRequest).call();
System.out.println("[*] Request sent");
System.out.println("[*] Response status code: " + httpResponse.httpResponse().statusCode());
// Read and print the response body
httpResponse.responseBody().ifPresent(inputStream -> {
try {
String responseBody = new String(inputStream.readAllBytes());
System.out.println("[*] Response body: " + responseBody);
} catch (IOException e) {
System.err.println("[*] Failed to read response body");
e.printStackTrace();
} finally {
try {
inputStream.close();
} catch (IOException e) {
System.err.println("[*] Failed to close input stream");
e.printStackTrace();
}
}
});
} catch (IOException e) {
System.err.println("[*] HTTP Request Failed.");
e.printStackTrace();
}
}
}
```
------
## Node.js
Cet exemple utilise les liaisons [NodeJS aws-crt pour envoyer une demande signée](https://github.com/awslabs/aws-crt-nodejs) via HTTPS.
Pour installer le `aws-crt` package, utilisez la commande suivante.
```
npm -i aws-crt
```
Si la variable d'`AWS_REGION`environnement existe, l'exemple utilise la région spécifiée par`AWS_REGION`. La région par défaut est`us-east-1`.
------
#### [ SIGv4 ]
```
const https = require('https')
const crt = require('aws-crt')
const { HttpRequest } = require('aws-crt/dist/native/http')
function sigV4Sign(method, endpoint, service, algorithm) {
const host = new URL(endpoint).host
const request = new HttpRequest(method, endpoint)
request.headers.add('host', host)
// crt.io.enable_logging(crt.io.LogLevel.INFO)
const config = {
service: service,
region: process.env.AWS_REGION ? process.env.AWS_REGION : 'us-east-1',
algorithm: algorithm,
signature_type: crt.auth.AwsSignatureType.HttpRequestViaHeaders,
signed_body_header: crt.auth.AwsSignedBodyHeaderType.XAmzContentSha256,
signed_body_value: crt.auth.AwsSignedBodyValue.UnsignedPayload,
provider: crt.auth.AwsCredentialsProvider.newDefault()
}
return crt.auth.aws_sign_request(request, config)
}
if (process.argv.length === 2) {
console.error(process.argv[1] + ' ')
process.exit(1)
}
const algorithm = crt.auth.AwsSigningAlgorithm.SigV4;
sigV4Sign('GET', process.argv[2], 'vpc-lattice-svcs', algorithm).then(
httpResponse => {
var headers = {}
for (const sigv4header of httpResponse.headers) {
headers[sigv4header[0]] = sigv4header[1]
}
const options = {
hostname: new URL(process.argv[2]).host,
path: new URL(process.argv[2]).pathname,
method: 'GET',
headers: headers
}
req = https.request(options, res => {
console.log('statusCode:', res.statusCode)
console.log('headers:', res.headers)
res.on('data', d => {
process.stdout.write(d)
})
})
req.on('error', err => {
console.log('Error: ' + err)
})
req.end()
}
)
```
------
#### [ SIGv4A ]
```
const https = require('https')
const crt = require('aws-crt')
const { HttpRequest } = require('aws-crt/dist/native/http')
function sigV4Sign(method, endpoint, service, algorithm) {
const host = new URL(endpoint).host
const request = new HttpRequest(method, endpoint)
request.headers.add('host', host)
// crt.io.enable_logging(crt.io.LogLevel.INFO)
const config = {
service: service,
region: process.env.AWS_REGION ? process.env.AWS_REGION : 'us-east-1',
algorithm: algorithm,
signature_type: crt.auth.AwsSignatureType.HttpRequestViaHeaders,
signed_body_header: crt.auth.AwsSignedBodyHeaderType.XAmzContentSha256,
signed_body_value: crt.auth.AwsSignedBodyValue.UnsignedPayload,
provider: crt.auth.AwsCredentialsProvider.newDefault()
}
return crt.auth.aws_sign_request(request, config)
}
if (process.argv.length === 2) {
console.error(process.argv[1] + ' ')
process.exit(1)
}
const algorithm = crt.auth.AwsSigningAlgorithm.SigV4Asymmetric;
sigV4Sign('GET', process.argv[2], 'vpc-lattice-svcs', algorithm).then(
httpResponse => {
var headers = {}
for (const sigv4header of httpResponse.headers) {
headers[sigv4header[0]] = sigv4header[1]
}
const options = {
hostname: new URL(process.argv[2]).host,
path: new URL(process.argv[2]).pathname,
method: 'GET',
headers: headers
}
req = https.request(options, res => {
console.log('statusCode:', res.statusCode)
console.log('headers:', res.headers)
res.on('data', d => {
process.stdout.write(d)
})
})
req.on('error', err => {
console.log('Error: ' + err)
})
req.end()
}
)
```
------
## Golang
Cet exemple utilise les [générateurs de code Smithy pour Go](https://github.com/aws/smithy-go) et le [AWS SDK pour le langage de programmation Go pour gérer les](https://github.com/aws/aws-sdk-go) demandes de signature de demandes. L'exemple nécessite une version Go 1.21 ou supérieure.
------
#### [ SIGv4 ]
```
package main
import (
"context"
"flag"
"fmt"
"io"
"log"
"net/http"
"net/http/httputil"
"os"
"strings"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/smithy-go/aws-http-auth/credentials"
"github.com/aws/smithy-go/aws-http-auth/sigv4"
v4 "github.com/aws/smithy-go/aws-http-auth/v4"
)
type nopCloser struct {
io.ReadSeeker
}
func (nopCloser) Close() error {
return nil
}
type stringFlag struct {
set bool
value string
}
flag.PrintDefaults()
os.Exit(1)
}
func main() {
flag.Parse()
if !url.set || !region.set {
Usage()
}
cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithClientLogMode(aws.LogSigning))
if err != nil {
log.Fatalf("failed to load SDK configuration, %v", err)
}
if len(os.Args) < 2 {
log.Fatalf("Usage: go run main.go ")
}
// Retrieve credentials from an SDK source, such as the instance profile
sdkCreds, err := cfg.Credentials.Retrieve(context.TODO())
if err != nil {
log.Fatalf("Unable to retrieve credentials from SDK, %v", err)
}
creds := credentials.Credentials{
AccessKeyID: sdkCreds.AccessKeyID,
SecretAccessKey: sdkCreds.SecretAccessKey,
SessionToken: sdkCreds.SessionToken,
}
// Add a payload body, which will not be part of the signature calculation
body := nopCloser{strings.NewReader(`Example payload body`)}
req, _ := http.NewRequest(http.MethodPost, url.value, body)
// Create a sigv4a signer with specific options
signer := sigv4.New(func(o *v4.SignerOptions) {
o.DisableDoublePathEscape = true
// This will add the UNSIGNED-PAYLOAD sha256 header
o.AddPayloadHashHeader = true
o.DisableImplicitPayloadHashing = true
})
// Perform the signing on req, using the credentials we retrieved from the SDK
err = signer.SignRequest(&sigv4.SignRequestInput{
Request: req,
Credentials: creds,
Service: "vpc-lattice-svcs",
Region: region.String(),
})
if err != nil {
log.Fatalf("%s", err)
}
res, err := httputil.DumpRequest(req, true)
if err != nil {
log.Fatalf("%s", err)
}
log.Printf("[*] Raw request\n%s\n", string(res))
log.Printf("[*] Sending request to %s\n", url.value)
resp, err := http.DefaultClient.Do(req)
if err != nil {
log.Fatalf("%s", err)
}
log.Printf("[*] Request sent\n")
log.Printf("[*] Response status code: %d\n", resp.StatusCode)
respBody, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatalf("%s", err)
}
log.Printf("[*] Response body: \n%s\n", respBody)
}
```
------
#### [ SIGv4A ]
```
package main
import (
"context"
"flag"
"fmt"
"io"
"log"
"net/http"
"net/http/httputil"
"os"
"strings"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/smithy-go/aws-http-auth/credentials"
"github.com/aws/smithy-go/aws-http-auth/sigv4a"
v4 "github.com/aws/smithy-go/aws-http-auth/v4"
)
type nopCloser struct {
io.ReadSeeker
}
func (nopCloser) Close() error {
return nil
}
type stringFlag struct {
func main() {
flag.Parse()
if !url.set || !regionSet.set {
Usage()
}
cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithClientLogMode(aws.LogSigning))
if err != nil {
log.Fatalf("failed to load SDK configuration, %v", err)
}
if len(os.Args) < 2 {
log.Fatalf("Usage: go run main.go ")
}
// Retrieve credentials from an SDK source, such as the instance profile
sdkCreds, err := cfg.Credentials.Retrieve(context.TODO())
if err != nil {
log.Fatalf("Unable to retrieve credentials from SDK, %v", err)
}
creds := credentials.Credentials{
AccessKeyID: sdkCreds.AccessKeyID,
SecretAccessKey: sdkCreds.SecretAccessKey,
SessionToken: sdkCreds.SessionToken,
}
// Add a payload body, which will not be part of the signature calculation
body := nopCloser{strings.NewReader(`Example payload body`)}
req, _ := http.NewRequest(http.MethodPost, url.value, body)
// Create a sigv4a signer with specific options
signer := sigv4a.New(func(o *v4.SignerOptions) {
o.DisableDoublePathEscape = true
// This will add the UNSIGNED-PAYLOAD sha256 header
o.AddPayloadHashHeader = true
o.DisableImplicitPayloadHashing = true
})
// Create a slice out of the provided regionset
rs := strings.Split(regionSet.value, ",")
// Perform the signing on req, using the credentials we retrieved from the SDK
err = signer.SignRequest(&sigv4a.SignRequestInput{
Request: req,
Credentials: creds,
Service: "vpc-lattice-svcs",
RegionSet: rs,
})
if err != nil {
log.Fatalf("%s", err)
}
res, err := httputil.DumpRequest(req, true)
if err != nil {
log.Fatalf("%s", err)
}
log.Printf("[*] Raw request\n%s\n", string(res))
log.Printf("[*] Sending request to %s\n", url.value)
resp, err := http.DefaultClient.Do(req)
if err != nil {
log.Fatalf("%s", err)
}
log.Printf("[*] Request sent\n")
log.Printf("[*] Response status code: %d\n", resp.StatusCode)
respBody, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatalf("%s", err)
}
log.Printf("[*] Response body: \n%s\n", respBody)
}
```
------
## Golang - GRPC
Cet exemple utilise le [AWS SDK pour le langage de programmation Go](https://github.com/aws/aws-sdk-go-v2/) pour gérer la signature des demandes GRPC. Cela peut être utilisé avec le [serveur d'écho](https://github.com/grpc/grpc-go/tree/master/examples/features/proto/echo) depuis le référentiel d'exemples de code GRPC.
```
package main
import (
"context"
"crypto/tls"
"crypto/x509"
"flag"
"fmt"
"log"
"net/http"
"net/url"
"strings"
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
"github.com/aws/aws-sdk-go-v2/aws"
v4 "github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/config"
ecpb "google.golang.org/grpc/examples/features/proto/echo"
)
const (
headerContentSha = "x-amz-content-sha256"
headerSecurityToken = "x-amz-security-token"
headerDate = "x-amz-date"
headerAuthorization = "authorization"
unsignedPayload = "UNSIGNED-PAYLOAD"
)
type SigV4GrpcSigner struct {
service string
region string
credProvider aws.CredentialsProvider
signer *v4.Signer
}
func NewSigV4GrpcSigner(service string, region string, credProvider aws.CredentialsProvider) *SigV4GrpcSigner {
signer := v4.NewSigner()
return &SigV4GrpcSigner{
service: service,
region: region,
credProvider: credProvider,
signer: signer,
}
}
func (s *SigV4GrpcSigner) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) {
ri, _ := credentials.RequestInfoFromContext(ctx)
creds, err := s.credProvider.Retrieve(ctx)
if err != nil {
return nil, fmt.Errorf("failed to load credentials: %w", err)
}
// The URI we get here is scheme://authority/service/ - for siging we want to include the RPC name
// But RequestInfoFromContext only has the combined /service/rpc-name - so read the URI, and
// replace the Path with what we get from RequestInfo.
parsed, err := url.Parse(uri[0])
if err != nil {
return nil, err
}
parsed.Path = ri.Method
// Build a request for the signer.
bodyReader := strings.NewReader("")
req, err := http.NewRequest("POST", uri[0], bodyReader)
if err != nil {
return nil, err
}
date := time.Now()
req.Header.Set(headerContentSha, unsignedPayload)
req.Header.Set(headerDate, date.String())
if creds.SessionToken != "" {
req.Header.Set(headerSecurityToken, creds.SessionToken)
}
// The signer wants this as //authority/path
// So get this by triming off the scheme and the colon before the first slash.
req.URL.Opaque = strings.TrimPrefix(parsed.String(), parsed.Scheme+":")
err = s.signer.SignHTTP(context.Background(), creds, req, unsignedPayload, s.service, s.region, date)
if err != nil {
return nil, fmt.Errorf("failed to sign request: %w", err)
}
// Pull the relevant headers out of the signer, and return them to get
// included in the request we make.
reqHeaders := map[string]string{
headerContentSha: req.Header.Get(headerContentSha),
headerDate: req.Header.Get(headerDate),
headerAuthorization: req.Header.Get(headerAuthorization),
}
if req.Header.Get(headerSecurityToken) != "" {
reqHeaders[headerSecurityToken] = req.Header.Get(headerSecurityToken)
}
return reqHeaders, nil
}
func (c *SigV4GrpcSigner) RequireTransportSecurity() bool {
return true
}
var addr = flag.String("addr", "some-lattice-service:443", "the address to connect to")
var region = flag.String("region", "us-west-2", "region")
func callUnaryEcho(client ecpb.EchoClient, message string) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
resp, err := client.UnaryEcho(ctx, &ecpb.EchoRequest{Message: message})
if err != nil {
log.Fatalf("client.UnaryEcho(_) = _, %v: ", err)
}
fmt.Println("UnaryEcho: ", resp.Message)
}
func main() {
flag.Parse()
cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithClientLogMode(aws.LogSigning))
if err != nil {
log.Fatalf("failed to load SDK configuration, %v", err)
}
pool, _ := x509.SystemCertPool()
tlsConfig := &tls.Config{
RootCAs: pool,
}
authority, _, _ := strings.Cut(*addr, ":") // Remove the port from the addr
opts := []grpc.DialOption{
grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)),
// Lattice needs both the Authority to be set (without a port), and the SigV4 signer
grpc.WithAuthority(authority),
grpc.WithPerRPCCredentials(NewSigV4GrpcSigner("vpc-lattice-svcs", *region, cfg.Credentials)),
}
conn, err := grpc.Dial(*addr, opts...)
if err != nil {
log.Fatalf("did not connect: %v", err)
}
defer conn.Close()
rgc := ecpb.NewEchoClient(conn)
callUnaryEcho(rgc, "hello world")
}
```
# Protection des données dans Amazon VPC Lattice
Le modèle de [responsabilité AWS partagée Le modèle](https://aws.amazon.com/compliance/shared-responsibility-model/) s'applique à la protection des données dans Amazon VPC Lattice. Comme décrit dans ce modèle, AWS est chargé de protéger l'infrastructure mondiale qui gère tous les AWS Cloud. La gestion du contrôle de votre contenu hébergé sur cette infrastructure relève de votre responsabilité. Ce contenu comprend les tâches de configuration et de gestion de la sécurité des Services AWS que vous utilisez. Pour en savoir plus sur la confidentialité des données, consultez [Questions fréquentes (FAQ) sur la confidentialité des données](https://aws.amazon.com/compliance/data-privacy-faq/). Pour en savoir plus sur la protection des données en Europe, consultez le billet de blog [Modèle de responsabilité partagée d’AWS et RGPD (Règlement général sur la protection des données)](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) sur le *Blog de sécuritéAWS *.
## Chiffrement en transit
VPC Lattice est un service entièrement géré composé d'un plan de contrôle et d'un plan de données. Chaque avion a un objectif distinct dans le service. Le plan de contrôle fournit les informations administratives APIs utilisées pour créer, lire/décrire, mettre à jour, supprimer et répertorier les ressources (CRUDL) (par exemple, `CreateService` et). `UpdateService` Les communications avec le plan de contrôle VPC Lattice sont protégées en transit par le protocole TLS. Le plan de données est l'API VPC Lattice Invoke, qui assure l'interconnexion entre les services. Le protocole TLS chiffre les communications vers le plan de données VPC Lattice lorsque vous utilisez le protocole HTTPS ou le protocole TLS. La suite de chiffrement et la version du protocole utilisent les valeurs par défaut fournies par VPC Lattice et ne sont pas configurables. Pour de plus amples informations, veuillez consulter [Écouteurs HTTPS pour les services VPC Lattice](https-listeners.md).
## Chiffrement au repos
Par défaut, le chiffrement des données au repos permet de réduire la charge opérationnelle et la complexité liées à la protection des données sensibles. Dans le même temps, il vous permet de créer des applications sécurisées qui répondent aux exigences réglementaires et de conformité strictes en matière de chiffrement.
**Topics**
+ [Chiffrement côté serveur avec des clés gérées par Amazon S3 (SSE-S3)](#s3-managed-keys)
+ [Chiffrement côté serveur avec AWS KMS clés stockées dans AWS KMS (SSE-KMS)](#kms-managed-keys)
### Chiffrement côté serveur avec des clés gérées par Amazon S3 (SSE-S3)
Lorsque vous utilisez le chiffrement côté serveur avec des clés gérées par Amazon S3 (SSE-S3), chaque objet est chiffré à l'aide d'une clé unique. Comme mesure de protection supplémentaire, nous chiffrons la clé elle-même à l'aide d'une clé racine que nous changeons régulièrement. Le chiffrement côté serveur Amazon S3 utilise l'un des chiffrements par bloc les plus puissants qui existent, Advanced Encryption Standard 256 bits (AES-256) GCM, pour chiffrer vos données. Pour les objets chiffrés avant AES-GCM, AES-CBC est toujours pris en charge pour déchiffrer ces objets. Pour plus d'informations, consultez [Utilisation du chiffrement côté serveur avec des clés de chiffrement gérées par Amazon S3 (SSE-S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingServerSideEncryption.html)).
Si vous activez le chiffrement côté serveur avec des clés de chiffrement gérées par Amazon S3 (SSE-S3) pour votre compartiment S3 pour les journaux d'accès VPC Lattice, nous chiffrons automatiquement chaque fichier journal d'accès avant qu'il ne soit stocké dans votre compartiment S3. Pour plus d'informations, consultez la section [Logs envoyés à Amazon S3](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html#AWS-logs-infrastructure-S3) dans le *guide de CloudWatch l'utilisateur Amazon*.
### Chiffrement côté serveur avec AWS KMS clés stockées dans AWS KMS (SSE-KMS)
Le chiffrement par AWS KMS clés côté serveur (SSE-KMS) est similaire au SSE-S3, mais l'utilisation de ce service comporte des avantages et des frais supplémentaires. Il existe des autorisations distinctes pour la AWS KMS clé qui fournissent une protection supplémentaire contre l'accès non autorisé à vos objets dans Amazon S3. SSE-KMS vous fournit également une piste d'audit qui indique quand votre AWS KMS clé a été utilisée et par qui. Pour plus d'informations, consultez la section [Utilisation du chiffrement côté serveur avec AWS Key Management Service (SSE-KMS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html)).
**Topics**
+ [Chiffrement et déchiffrement de la clé privée de votre certificat](#private-key)
+ [Contexte de chiffrement pour VPC Lattice](#encryption-context)
+ [Surveillance de vos clés de chiffrement pour VPC Lattice](#monitoring-encryption-keys)
#### Chiffrement et déchiffrement de la clé privée de votre certificat
Votre certificat ACM et votre clé privée sont chiffrés à l'aide d'une clé KMS AWS gérée portant l'alias **aws/acm**. Vous pouvez consulter l'ID de clé avec cet alias dans la AWS KMS console sous **clés AWS gérées**.
VPC Lattice n'accède pas directement à vos ressources ACM. Il utilise le gestionnaire de connexion AWS TLS pour sécuriser et accéder aux clés privées de votre certificat. Lorsque vous utilisez votre certificat ACM pour créer un service VPC Lattice, VPC Lattice associe votre certificat au TLS Connection Manager. AWS Cela se fait en créant une subvention associée à votre AWS KMS clé AWS gérée avec le préfixe **aws/acm**. Une autorisation est un instrument de politique qui autorise TLS Connection Manager à utiliser des clés KMS dans les opérations de chiffrement. Elle permet au principal bénéficiaire (TLS Connection Manager) d’appeler les opérations d’autorisation spécifiées sur la clé KMS pour déchiffrer la clé privée de votre certificat. TLS Connection Manager utilise ensuite le certificat et la clé privée déchiffrée (texte brut) pour établir une connexion sécurisée (session SSL/TLS) avec les clients des services VPC Lattice. Lorsque le certificat est dissocié d'un service VPC Lattice, la subvention est retirée.
Si vous souhaitez supprimer l'accès à la clé KMS, nous vous recommandons de remplacer ou de supprimer le certificat du service à l'aide de la `update-service` commande AWS Management Console ou du AWS CLI.
#### Contexte de chiffrement pour VPC Lattice
Un [contexte de chiffrement](https://docs.aws.amazon.com/kms/latest/developerguide/encrypt_context.html) est un ensemble facultatif de paires clé-valeur contenant des informations contextuelles sur l'utilisation que votre clé privée est susceptible d'être utilisée. AWS KMS lie le contexte de chiffrement aux données chiffrées et les utilise comme données authentifiées supplémentaires pour prendre en charge le chiffrement authentifié.
Lorsque vos clés TLS sont utilisées avec VPC Lattice et le gestionnaire de connexions TLS, le nom de votre service VPC Lattice est inclus dans le contexte de chiffrement utilisé pour chiffrer votre clé au repos. Vous pouvez vérifier pour quel service VPC Lattice votre certificat et votre clé privée sont utilisés en consultant le contexte de chiffrement dans vos CloudTrail journaux, comme indiqué dans la section suivante, ou en consultant l'onglet **Ressources associées** de la console ACM.
Pour déchiffrer des données, le même contexte de chiffrement est inclus dans la demande. VPC Lattice utilise le même contexte de chiffrement dans toutes les opérations cryptographiques AWS KMS, où la clé `aws:vpc-lattice:arn` et la valeur sont le Amazon Resource Name (ARN) du service VPC Lattice.
L’exemple suivant présente le contexte de chiffrement dans la sortie d’une opération telle que `CreateGrant`.
```
"encryptionContextEquals": {
"aws:acm:arn": "arn:aws:acm:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"aws:vpc-lattice:arn": "arn:aws:vpc-lattice:us-west-2:111122223333:service/svc-0b23c1234567890ab"
}
```
#### Surveillance de vos clés de chiffrement pour VPC Lattice
Lorsque vous utilisez une clé AWS gérée avec votre service VPC Lattice, vous pouvez l'utiliser [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/)pour suivre les demandes auxquelles VPC Lattice envoie. AWS KMS
**CreateGrant**
Lorsque vous ajoutez votre certificat ACM à un service VPC Lattice, `CreateGrant` une demande est envoyée en votre nom pour que TLS Connection Manager puisse déchiffrer la clé privée associée à votre certificat ACM
Vous pouvez visualiser l'`CreateGrant`opération sous forme d'événement dans **CloudTrail**, **Historique des événements**, **CreateGrant**.
Voici un exemple d'enregistrement d'événement dans l'historique des CloudTrail événements de l'`CreateGrant`opération.
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "IAMUser",
"principalId": "EX_PRINCIPAL_ID",
"arn": "arn:aws:iam::111122223333:user/Alice",
"accountId": "111122223333",
"accessKeyId": "EXAMPLE_KEY_ID",
"sessionContext": {
"sessionIssuer": {
"type": "IAMUser",
"principalId": "EX_PRINCIPAL_ID",
"arn": "arn:aws:iam::111122223333:user/Alice",
"accountId": "111122223333",
"userName": "Alice"
},
"webIdFederationData": {},
"attributes": {
"creationDate": "2023-02-06T23:30:50Z",
"mfaAuthenticated": "false"
}
},
"invokedBy": "acm.amazonaws.com"
},
"eventTime": "2023-02-07T00:07:18Z",
"eventSource": "kms.amazonaws.com",
"eventName": "CreateGrant",
"awsRegion": "us-west-2",
"sourceIPAddress": "acm.amazonaws.com",
"userAgent": "acm.amazonaws.com",
"requestParameters": {
"granteePrincipal": "tlsconnectionmanager.amazonaws.com",
"keyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"operations": [
"Decrypt"
],
"constraints": {
"encryptionContextEquals": {
"aws:acm:arn": "arn:aws:acm:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"aws:vpc-lattice:arn": "arn:aws:vpc-lattice:us-west-2:111122223333:service/svc-0b23c1234567890ab"
}
},
"retiringPrincipal": "acm.us-west-2.amazonaws.com"
},
"responseElements": {
"grantId": "f020fe75197b93991dc8491d6f19dd3cebb24ee62277a05914386724f3d48758",
"keyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
},
"requestID": "ba178361-8ab6-4bdd-9aa2-0d1a44b2974a",
"eventID": "8d449963-1120-4d0c-9479-f76de11ce609",
"readOnly": false,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
}
],
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "111122223333",
"eventCategory": "Management"
}
```
Dans l'`CreateGrant`exemple ci-dessus, le bénéficiaire principal est TLS Connection Manager, et le contexte de chiffrement possède l'ARN du service VPC Lattice.
**ListGrants**
Vous pouvez utiliser votre identifiant de clé KMS et votre identifiant de compte pour appeler l'`ListGrants`API. Vous obtenez ainsi une liste de toutes les autorisations pour la clé KMS spécifiée. Pour de plus amples informations, veuillez consulter [ListGrants](https://docs.aws.amazon.com/kms/latest/APIReference/API_ListGrants.html).
Utilisez la `ListGrants` commande suivante dans le AWS CLI pour voir les détails de toutes les subventions.
```
aws kms list-grants —key-id your-kms-key-id
```
Voici un exemple de sortie.
```
{
"Grants": [
{
"Operations": [
"Decrypt"
],
"KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"Name": "IssuedThroughACM",
"RetiringPrincipal": "acm.us-west-2.amazonaws.com",
"GranteePrincipal": "tlsconnectionmanager.amazonaws.com",
"GrantId": "f020fe75197b93991dc8491d6f19dd3cebb24ee62277a05914386724f3d48758",
"IssuingAccount": "arn:aws:iam::111122223333:root",
"CreationDate": "2023-02-06T23:30:50Z",
"Constraints": {
"encryptionContextEquals": {
"aws:acm:arn": "arn:aws:acm:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"aws:vpc-lattice:arn": "arn:aws:vpc-lattice:us-west-2:111122223333:service/svc-0b23c1234567890ab"
}
}
}
]
}
```
Dans l'`ListGrants`exemple ci-dessus, le bénéficiaire principal est TLS Connection Manager et le contexte de chiffrement possède l'ARN du service VPC Lattice.
**Decrypt**
VPC Lattice utilise le gestionnaire de connexions TLS pour appeler l'`Decrypt`opération de déchiffrement de votre clé privée afin de servir les connexions TLS dans votre service VPC Lattice. Vous pouvez voir l'`Decrypt`opération comme un **CloudTrail****événement dans Historique** des événements, **Déchiffrer**.
Voici un exemple d'enregistrement d'événement dans l'historique des CloudTrail événements de l'`Decrypt`opération.
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "AWSService",
"invokedBy": "tlsconnectionmanager.amazonaws.com"
},
"eventTime": "2023-02-07T00:07:23Z",
"eventSource": "kms.amazonaws.com",
"eventName": "Decrypt",
"awsRegion": "us-west-2",
"sourceIPAddress": "tlsconnectionmanager.amazonaws.com",
"userAgent": "tlsconnectionmanager.amazonaws.com",
"requestParameters": {
"encryptionContext": {
"aws:acm:arn": "arn:aws:acm:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"aws:vpc-lattice:arn": "arn:aws:vpc-lattice:us-west-2:111122223333:service/svc-0b23c1234567890ab"
},
"encryptionAlgorithm": "SYMMETRIC_DEFAULT"
},
"responseElements": null,
"requestID": "12345126-30d5-4b28-98b9-9153da559963",
"eventID": "abcde202-ba1a-467c-b4ba-f729d45ae521",
"readOnly": true,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
}
],
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "111122223333",
"sharedEventID": "abcde202-ba1a-467c-b4ba-f729d45ae521",
"eventCategory": "Management"
}
```
# Gestion des identités et des accès pour Amazon VPC Lattice
Les sections suivantes décrivent comment vous pouvez utiliser Gestion des identités et des accès AWS (IAM) pour sécuriser vos ressources VPC Lattice, en contrôlant qui peut effectuer les actions de l'API VPC Lattice.
**Topics**
+ [Comment Amazon VPC Lattice fonctionne avec IAM](security_iam_service-with-iam.md)
+ [Autorisations relatives à l'API Amazon VPC Lattice](additional-api-permissions.md)
+ [Politiques basées sur l'identité pour Amazon VPC Lattice](security_iam_id-based-policies.md)
+ [Utilisation de rôles liés à un service pour Amazon VPC Lattice](using-service-linked-roles.md)
+ [AWS politiques gérées pour Amazon VPC Lattice](managed-policies.md)
# Comment Amazon VPC Lattice fonctionne avec IAM
Avant d'utiliser IAM pour gérer l'accès à VPC Lattice, découvrez quelles fonctionnalités IAM peuvent être utilisées avec VPC Lattice.
| Fonctionnalité IAM | Support en VPC Lattice |
| --- | --- |
| [Politiques basées sur l’identité](#security_iam_service-with-iam-id-based-policies) | Oui |
| [Politiques basées sur les ressources](#security_iam_service-with-iam-resource-based-policies) | Oui |
| [Actions de politique](#security_iam_service-with-iam-id-based-policies-actions) | Oui |
| [Ressources de politique](#security_iam_service-with-iam-id-based-policies-resources) | Oui |
| [Clés de condition de politique](#security_iam_service-with-iam-id-based-policies-conditionkeys) | Oui |
| [ACLs](#security_iam_service-with-iam-acls) | Non |
| [ABAC (étiquettes dans les politiques)](#security_iam_service-with-iam-tags) | Oui |
| [Informations d’identification temporaires](#security_iam_service-with-iam-roles-tempcreds) | Oui |
| [Rôles du service](#security_iam_service-with-iam-roles-service) | Non |
| [Rôles liés à un service](#security_iam_service-with-iam-roles-service-linked) | Oui |
*Pour obtenir une vue d'ensemble de la façon dont VPC Lattice et les autres AWS services fonctionnent avec la plupart des fonctionnalités IAM, consultez la section [AWS Services compatibles avec IAM dans le guide de l'utilisateur IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html).*
## Politiques basées sur l'identité pour VPC Lattice
**Prend en charge les politiques basées sur l’identité :** oui
Les politiques basées sur l’identité sont des documents de politique d’autorisations JSON que vous pouvez attacher à une identité telle qu’un utilisateur, un groupe d’utilisateurs ou un rôle IAM. Ces politiques contrôlent quel type d’actions des utilisateurs et des rôles peuvent exécuter, sur quelles ressources et dans quelles conditions. Pour découvrir comment créer une politique basée sur l’identité, consultez [Définition d’autorisations IAM personnalisées avec des politiques gérées par le client](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) dans le *Guide de l’utilisateur IAM*.
Avec les politiques IAM basées sur l’identité, vous pouvez spécifier des actions et ressources autorisées ou refusées, ainsi que les conditions dans lesquelles les actions sont autorisées ou refusées. Pour découvrir tous les éléments que vous utilisez dans une politique JSON, consultez [Références des éléments de politique JSON IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) dans le *Guide de l’utilisateur IAM*.
## Politiques basées sur les ressources au sein de VPC Lattice
**Prend en charge les politiques basées sur les ressources** : oui
Les politiques basées sur les ressources sont des documents de politique JSON que vous attachez à une ressource dans lesquels vous les associez. AWS Dans les AWS services qui prennent en charge les politiques basées sur les ressources, les administrateurs de services peuvent les utiliser pour contrôler l'accès à une ressource spécifique de ce AWS service. Pour la ressource dans laquelle se trouve la politique, cette dernière définit quel type d’actions un principal spécifié peut effectuer sur cette ressource et dans quelles conditions. Vous devez spécifier un principal dans une politique basée sur les ressources.
VPC Lattice prend en charge les *politiques d'authentification*, une politique basée sur les ressources qui vous permet de contrôler l'accès aux services de votre réseau de services. Pour de plus amples informations, veuillez consulter [Contrôlez l'accès aux services VPC Lattice à l'aide de politiques d'authentification](auth-policies.md).
VPC Lattice prend également en charge les politiques d'autorisation basées sur les ressources pour l'intégration avec. AWS Resource Access Manager Vous pouvez utiliser ces politiques basées sur les ressources pour autoriser la gestion de la connectivité à d'autres AWS comptes ou organisations pour les services, les configurations de ressources et les réseaux de services. Pour de plus amples informations, veuillez consulter [Partage de vos entités VPC Lattice](sharing.md).
## Actions politiques pour VPC Lattice
**Prend en charge les actions de politique :** oui
Dans une déclaration de politique IAM, vous pouvez spécifier une action d’API à partir de n’importe quel service prenant en charge IAM. Pour VPC Lattice, utilisez le préfixe suivant avec le nom de l'action d'API : `vpc-lattice:` Par exemple : `vpc-lattice:CreateService`, `vpc-lattice:CreateTargetGroup` et `vpc-lattice:PutAuthPolicy`.
Pour spécifier plusieurs actions dans une seule déclaration, séparez-les par des virgules, comme suit :
```
"Action": [ "vpc-lattice:action1", "vpc-lattice:action2" ]
```
Vous pouvez aussi spécifier plusieurs actions à l’aide de caractères génériques. Par exemple, vous pouvez spécifier toutes les actions dont le nom commence par `Get`, comme suit :
```
"Action": "vpc-lattice:Get*"
```
*Pour obtenir la liste complète des actions de l'API VPC Lattice, consultez la section Actions définies [par Amazon VPC Lattice](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonvpclattice.html#amazonvpclattice-actions-as-permissions) dans le Service Authorization Reference.*
## Ressources relatives aux politiques pour VPC Lattice
**Prend en charge les ressources de politique :** oui
Dans une instruction de politiqe IAM, l'élément `Resource` spécifie l'objet ou les objets couverts par l'instruction. Pour VPC Lattice, chaque déclaration de politique IAM s'applique aux ressources que vous spécifiez à l'aide de leur. ARNs
Le format Amazon Resource Name (ARN) spécifique dépend de la ressource. Lorsque vous fournissez un ARN, remplacez le *italicized* texte par les informations spécifiques à votre ressource.
+ **Abonnements aux journaux d'accès :**
```
"Resource": "arn:aws:vpc-lattice:region:account-id:accesslogsubscription/access-log-subscription-id"
```
+ **Auditeurs :**
```
"Resource": "arn:aws:vpc-lattice:region:account-id:service/service-id/listener/listener-id"
```
+ **Passerelles de ressources**
```
"Resource": "arn:aws:vpc-lattice:region:account-id:resourcegateway/resource-gateway-id"
```
+ **Configuration des ressources**
```
"Resource": "arn:aws:vpc-lattice:region:account-id:resourceconfiguration/resource-configuration-id"
```
+ **Règles :**
```
"Resource": "arn:aws:vpc-lattice:region:account-id:service/service-id/listener/listener-id/rule/rule-id"
```
+ **Services :**
```
"Resource": "arn:aws:vpc-lattice:region:account-id:service/service-id"
```
+ **Réseaux de services :**
```
"Resource": "arn:aws:vpc-lattice:region:account-id:servicenetwork/service-network-id"
```
+ **Associations de services du réseau de services :**
```
"Resource": "arn:aws:vpc-lattice:region:account-id:servicenetworkserviceassociation/service-network-service-association-id"
```
+ **Associations de configuration des ressources du réseau de services**
```
"Resource": "arn:aws:vpc-lattice:region:account-id:servicenetworkresourceassociation/service-network-resource-association-id"
```
+ **Associations VPC du réseau de services :**
```
"Resource": "arn:aws:vpc-lattice:region:account-id:servicenetworkvpcassociation/service-network-vpc-association-id"
```
+ **Groupes cibles :**
```
"Resource": "arn:aws:vpc-lattice:region:account-id:targetgroup/target-group-id"
```
## Clés de condition de politique pour VPC Lattice
**Prend en charge les clés de condition de politique spécifiques au service :** oui
Les administrateurs peuvent utiliser les politiques AWS JSON pour spécifier qui a accès à quoi. C’est-à-dire, quel **principal** peut effectuer **des actions** sur quelles **ressources** et dans quelles **conditions**.
L’élément `Condition` indique à quel moment les instructions s’exécutent en fonction de critères définis. Vous pouvez créer des expressions conditionnelles qui utilisent des [opérateurs de condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html), tels que les signes égal ou inférieur à, pour faire correspondre la condition de la politique aux valeurs de la demande. Pour voir toutes les clés de condition AWS globales, voir les clés de [contexte de condition AWS globales](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) dans le *guide de l'utilisateur IAM*.
*Pour consulter la liste des clés de condition VPC Lattice, consultez la section Clés de [condition pour Amazon VPC Lattice](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonvpclattice.html#amazonvpclattice-policy-keys) dans la référence d'autorisation de service.*
AWS prend en charge les clés de condition globales et les clés de condition spécifiques au service. Pour plus d'informations sur les clés de condition AWS globales, voir les [clés de contexte de condition AWS globales](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) dans le *guide de l'utilisateur IAM*.
## Listes de contrôle d'accès (ACLs) dans VPC Lattice
**Supports ACLs :** Non
Les listes de contrôle d'accès (ACLs) contrôlent les principaux (membres du compte, utilisateurs ou rôles) autorisés à accéder à une ressource. ACLs sont similaires aux politiques basées sur les ressources, bien qu'elles n'utilisent pas le format de document de politique JSON.
## Contrôle d'accès basé sur les attributs (ABAC) avec VPC Lattice
**Prise en charge d’ABAC (balises dans les politiques) :** Oui
Le contrôle d’accès par attributs (ABAC) est une stratégie d’autorisation qui définit les autorisations en fonction des attributs appelés balises. Vous pouvez associer des balises aux entités et aux AWS ressources IAM, puis concevoir des politiques ABAC pour autoriser les opérations lorsque la balise du principal correspond à la balise de la ressource.
Pour contrôler l’accès basé sur des étiquettes, vous devez fournir les informations d’étiquette dans l’[élément de condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) d’une politique utilisant les clés de condition `aws:ResourceTag/key-name`, `aws:RequestTag/key-name` ou `aws:TagKeys`.
Si un service prend en charge les trois clés de condition pour tous les types de ressources, alors la valeur pour ce service est **Oui**. Si un service prend en charge les trois clés de condition pour certains types de ressources uniquement, la valeur est **Partielle**.
Pour plus d’informations sur ABAC, consultez [Définition d’autorisations avec l’autorisation ABAC](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html) dans le *Guide de l’utilisateur IAM*. Pour accéder à un didacticiel décrivant les étapes de configuration de l’ABAC, consultez [Utilisation du contrôle d’accès par attributs (ABAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_attribute-based-access-control.html) dans le *Guide de l’utilisateur IAM*.
## Utilisation d'informations d'identification temporaires avec VPC Lattice
**Prend en charge les informations d’identification temporaires :** oui
Les informations d'identification temporaires fournissent un accès à court terme aux AWS ressources et sont automatiquement créées lorsque vous utilisez la fédération ou que vous changez de rôle. AWS recommande de générer dynamiquement des informations d'identification temporaires au lieu d'utiliser des clés d'accès à long terme. Pour plus d’informations, consultez [Informations d’identification de sécurité temporaires dans IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) et [Services AWS compatibles avec IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) dans le *Guide de l’utilisateur IAM*.
## Rôles de service pour VPC Lattice
**Prend en charge les rôles de service :** Non
Un rôle de service est un [rôle IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) qu’un service endosse pour accomplir des actions en votre nom. Un administrateur IAM peut créer, modifier et supprimer un rôle de service à partir d’IAM. Pour plus d’informations, consultez [Création d’un rôle pour la délégation d’autorisations à un Service AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) dans le *Guide de l’utilisateur IAM*.
**Avertissement**
La modification des autorisations pour un rôle de service peut interrompre les fonctionnalités de VPC Lattice. Modifiez les rôles de service uniquement lorsque VPC Lattice fournit des instructions à cet effet.
## Rôles liés à un service pour VPC Lattice
**Prend en charge les rôles liés à un service :** oui
Un rôle lié à un service est un type de rôle de service lié à un. Service AWS Le service peut endosser le rôle afin d’effectuer une action en votre nom. Les rôles liés au service apparaissent dans votre Compte AWS fichier et appartiennent au service. Un administrateur IAM peut consulter, mais ne peut pas modifier, les autorisations concernant les rôles liés à un service.
Pour plus d'informations sur la création ou la gestion de rôles liés à un service VPC Lattice, consultez. [Utilisation de rôles liés à un service pour Amazon VPC Lattice](using-service-linked-roles.md)
# Autorisations relatives à l'API Amazon VPC Lattice
Vous devez accorder aux identités IAM (telles que les utilisateurs ou les rôles) l'autorisation d'appeler les actions d'API VPC Lattice dont elles ont besoin, comme décrit dans. [Actions politiques pour VPC Lattice](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-actions) En outre, pour certaines actions VPC Lattice, vous devez autoriser les identités IAM à appeler des actions spécifiques depuis d'autres. AWS APIs
## Autorisations requises pour l'API
Lorsque vous appelez les actions suivantes depuis l'API, vous devez autoriser les utilisateurs IAM à appeler les actions spécifiées.
`CreateResourceConfiguration`
+ `vpc-lattice:CreateResourceConfiguration`
+ `ec2:DescribeSubnets`
+ `rds:DescribeDBInstances`
+ `rds:DescribeDBClusters`
`CreateResourceGateway`
+ `vpc-lattice:CreateResourceGateway`
+ `ec2:AssignPrivateIpAddresses`
+ `ec2:AssignIpv6Addresses`
+ `ec2:CreateNetworkInterface`
+ `ec2:CreateNetworkInterfacePermission`
+ `ec2:DeleteNetworkInterface`
+ `ec2:DescribeNetworkInterfaces`
+ `ec2:DescribeSecurityGroups`
+ `ec2:DescribeSubnets`
`DeleteResourceGateway`
+ `vpc-lattice:DeleteResourceGateway`
+ `ec2:DeleteNetworkInterface`
`UpdateResourceGateway`
+ `vpc-lattice:UpdateResourceGateway`
+ `ec2:AssignPrivateIpAddresses`
+ `ec2:AssignIpv6Addresses`
+ `ec2:UnassignPrivateIpAddresses`
+ `ec2:CreateNetworkInterface`
+ `ec2:CreateNetworkInterfacePermission`
+ `ec2:DeleteNetworkInterface`
+ `ec2:DescribeNetworkInterfaces`
+ `ec2:DescribeSecurityGroups`
+ `ec2:DescribeSubnets`
+ `ec2:ModifyNetworkInterfaceAttribute`
`CreateServiceNetworkResourceAssociation`
+ `vpc-lattice:CreateServiceNetworkResourceAssociation`
+ `ec2:AssignIpv6Addresses`
+ `ec2:CreateNetworkInterface`
+ `ec2:CreateNetworkInterfacePermission`
+ `ec2:DescribeNetworkInterfaces`
`CreateServiceNetworkVpcAssociation`
+ `vpc-lattice:CreateServiceNetworkVpcAssociation`
+ `ec2:DescribeVpcs`
+ `ec2:DescribeSecurityGroups`(Nécessaire uniquement lorsque des groupes de sécurité sont fournis)
`UpdateServiceNetworkVpcAssociation`
+ `vpc-lattice:UpdateServiceNetworkVpcAssociation`
+ `ec2:DescribeSecurityGroups`(Nécessaire uniquement lorsque des groupes de sécurité sont fournis)
`CreateTargetGroup`
+ `vpc-lattice:CreateTargetGroup`
+ `ec2:DescribeVpcs`
`RegisterTargets`
+ `vpc-lattice:RegisterTargets`
+ `ec2:DescribeInstances`(Nécessaire uniquement lorsqu'il `INSTANCE` s'agit du type de groupe cible)
+ `ec2:DescribeVpcs`(Nécessaire uniquement lorsque `INSTANCE` ou `IP` selon le type de groupe cible)
+ `ec2:DescribeSubnets`(Nécessaire uniquement lorsque `INSTANCE` ou `IP` selon le type de groupe cible)
+ `lambda:GetFunction`(Nécessaire uniquement lorsqu'il `LAMBDA` s'agit du type de groupe cible)
+ `lambda:AddPermission`(Nécessaire uniquement si le groupe cible n'est pas déjà autorisé à invoquer la fonction Lambda spécifiée)
`DeregisterTargets`
+ `vpc-lattice:DeregisterTargets`
`CreateAccessLogSubscription`
+ `vpc-lattice:CreateAccessLogSubscription`
+ `logs:GetLogDelivery`
+ `logs:CreateLogDelivery`
`DeleteAccessLogSubscription`
+ `vpc-lattice:DeleteAccessLogSubscription`
+ `logs:DeleteLogDelivery`
`UpdateAccessLogSubscription`
+ `vpc-lattice:UpdateAccessLogSubscription`
+ `logs:UpdateLogDelivery`
# Politiques basées sur l'identité pour Amazon VPC Lattice
Par défaut, les utilisateurs et les rôles ne sont pas autorisés à créer ou à modifier des ressources VPC Lattice. Pour octroyer aux utilisateurs des autorisations d’effectuer des actions sur les ressources dont ils ont besoin, un administrateur IAM peut créer des politiques IAM.
Pour apprendre à créer une politique basée sur l’identité IAM à l’aide de ces exemples de documents de politique JSON, consultez [Création de politiques IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) dans le *Guide de l’utilisateur IAM*.
*Pour plus de détails sur les actions et les types de ressources définis par VPC Lattice, y compris le format du ARNs pour chacun des types de ressources, consultez la section [Actions, ressources et clés de condition pour Amazon VPC Lattice](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonvpclattice.html) dans la référence d'autorisation de service.*
**Topics**
+ [Bonnes pratiques en matière de politiques](#security_iam_service-with-iam-policy-best-practices)
+ [Autorisations supplémentaires requises pour un accès complet](#security_iam_id-based-policy-additional-permissions)
+ [Exemples de politiques basées sur l'identité pour VPC Lattice](#security_iam_id-based-policy-examples)
## Bonnes pratiques en matière de politiques
Les politiques basées sur l'identité déterminent si quelqu'un peut créer, accéder ou supprimer des ressources VPC Lattice dans votre compte. Ces actions peuvent entraîner des frais pour votre Compte AWS. Lorsque vous créez ou modifiez des politiques basées sur l’identité, suivez ces instructions et recommandations :
+ **Commencez AWS par les politiques gérées et passez aux autorisations du moindre privilège : pour commencer à accorder des autorisations** à vos utilisateurs et à vos charges de travail, utilisez les *politiques AWS gérées* qui accordent des autorisations pour de nombreux cas d'utilisation courants. Ils sont disponibles dans votre Compte AWS. Nous vous recommandons de réduire davantage les autorisations en définissant des politiques gérées par les AWS clients spécifiques à vos cas d'utilisation. Pour plus d’informations, consultez [politiques gérées par AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) ou [politiques gérées par AWS pour les activités professionnelles](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) dans le *Guide de l’utilisateur IAM*.
+ **Accordez les autorisations de moindre privilège** : lorsque vous définissez des autorisations avec des politiques IAM, accordez uniquement les autorisations nécessaires à l’exécution d’une seule tâche. Pour ce faire, vous définissez les actions qui peuvent être entreprises sur des ressources spécifiques dans des conditions spécifiques, également appelées *autorisations de moindre privilège*. Pour plus d’informations sur l’utilisation d’IAM pour appliquer des autorisations, consultez [politiques et autorisations dans IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) dans le *Guide de l’utilisateur IAM*.
+ **Utilisez des conditions dans les politiques IAM pour restreindre davantage l’accès** : vous pouvez ajouter une condition à vos politiques afin de limiter l’accès aux actions et aux ressources. Par exemple, vous pouvez écrire une condition de politique pour spécifier que toutes les demandes doivent être envoyées via SSL. Vous pouvez également utiliser des conditions pour accorder l'accès aux actions de service si elles sont utilisées par le biais d'un service spécifique Service AWS, tel que CloudFormation. Pour plus d’informations, consultez [Conditions pour éléments de politique JSON IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) dans le *Guide de l’utilisateur IAM*.
+ **Utilisez l’Analyseur d’accès IAM pour valider vos politiques IAM afin de garantir des autorisations sécurisées et fonctionnelles** : l’Analyseur d’accès IAM valide les politiques nouvelles et existantes de manière à ce que les politiques IAM respectent le langage de politique IAM (JSON) et les bonnes pratiques IAM. IAM Access Analyzer fournit plus de 100 vérifications de politiques et des recommandations exploitables pour vous aider à créer des politiques sécurisées et fonctionnelles. Pour plus d’informations, consultez [Validation de politiques avec IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html) dans le *Guide de l’utilisateur IAM*.
+ **Exiger l'authentification multifactorielle (MFA**) : si vous avez un scénario qui nécessite des utilisateurs IAM ou un utilisateur root, activez l'authentification MFA pour une sécurité accrue. Compte AWS Pour exiger la MFA lorsque des opérations d’API sont appelées, ajoutez des conditions MFA à vos politiques. Pour plus d’informations, consultez [Sécurisation de l’accès aux API avec MFA](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html) dans le *Guide de l’utilisateur IAM*.
Pour plus d’informations sur les bonnes pratiques dans IAM, consultez [Bonnes pratiques de sécurité dans IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) dans le *Guide de l’utilisateur IAM*.
## Autorisations supplémentaires requises pour un accès complet
Pour utiliser les autres AWS services auxquels VPC Lattice est intégré et l'ensemble des fonctionnalités de VPC Lattice, vous devez disposer d'autorisations supplémentaires spécifiques. Ces autorisations ne sont pas incluses dans la politique `VPCLatticeFullAccess` gérée en raison du risque d'augmentation [confuse des privilèges des adjoints](https://docs.aws.amazon.com//IAM/latest/UserGuide/confused-deputy.html).
Vous devez associer la politique suivante à votre rôle et l'utiliser avec la stratégie `VPCLatticeFullAccess` gérée.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"firehose:TagDeliveryStream",
"lambda:AddPermission",
"s3:PutBucketPolicy"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"logs:PutResourcePolicy"
],
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:CalledVia": [
"vpc-lattice.amazonaws.com"
]
}
}
},
{
"Effect": "Allow",
"Action": [
"iam:AttachRolePolicy",
"iam:PutRolePolicy"
],
"Resource": "arn:aws:iam::*:role/aws-service-role/vpc-lattice.amazonaws.com/AWSServiceRoleForVpcLattice"
},
{
"Effect": "Allow",
"Action": [
"iam:AttachRolePolicy",
"iam:PutRolePolicy"
],
"Resource": "arn:aws:iam::*:role/aws-service-role/delivery.logs.amazonaws.com/AWSServiceRoleForLogDelivery*"
}
]
}
```
------
Cette politique fournit les autorisations supplémentaires suivantes :
+ `iam:AttachRolePolicy`: vous permet d'associer la politique gérée spécifiée au rôle IAM spécifié.
+ `iam:PutRolePolicy`: vous permet d'ajouter ou de mettre à jour un document de politique intégré au rôle IAM spécifié.
+ `s3:PutBucketPolicy`: vous permet d'appliquer une politique de compartiment à un compartiment Amazon S3.
+ `firehose:TagDeliveryStream`: vous permet d'ajouter ou de mettre à jour des balises pour les flux de diffusion Firehose.
## Exemples de politiques basées sur l'identité pour VPC Lattice
**Topics**
+ [Exemple de politique : gestion des associations de VPC avec un réseau de services](#security_iam_id-based-policy-examples-vpc-to-service-network-association)
+ [Exemple de politique : créer des associations de services avec un réseau de services](#security_iam_id-based-policy-examples-service-to-service-network-association)
+ [Exemple de politique : ajout de balises aux ressources](#security_iam_id-based-policy-examples-tag-resources)
+ [Exemple de politique : créer un rôle lié à un service](#security_iam_id-based-policy-examples-service-linked-role)
### Exemple de politique : gestion des associations de VPC avec un réseau de services
L'exemple suivant illustre une stratégie qui donne aux utilisateurs dotés de cette stratégie l'autorisation de créer, de mettre à jour et de supprimer les associations de VPC à un réseau de service, mais uniquement pour le VPC et le réseau de service spécifiés dans la condition. Pour plus d'informations sur la spécification des clés de condition, consultez [Clés de condition de politique pour VPC Lattice](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-conditionkeys).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"vpc-lattice:CreateServiceNetworkVpcAssociation",
"vpc-lattice:UpdateServiceNetworkVpcAssociation",
"vpc-lattice:DeleteServiceNetworkVpcAssociation"
],
"Resource": [
"*"
],
"Condition": {
"StringEquals": {
"vpc-lattice:ServiceNetworkArn": "arn:aws:vpc-lattice:us-west-2:123456789012:servicenetwork/sn-903004f88example",
"vpc-lattice:VpcId": "vpc-1a2b3c4d"
}
}
}
]
}
```
------
### Exemple de politique : créer des associations de services avec un réseau de services
Si vous n'utilisez pas de clés de condition pour contrôler l'accès aux ressources VPC Lattice, vous pouvez plutôt spécifier les ressources ARNs de l'`Resource`élément pour contrôler l'accès.
L'exemple suivant illustre une politique qui limite les associations de services à un réseau de services que les utilisateurs utilisant cette stratégie peuvent créer en spécifiant le service et le réseau ARNs de services qui peuvent être utilisés avec l'action d'`CreateServiceNetworkServiceAssociation`API. Pour plus d'informations sur la spécification des valeurs ARN, consultez[Ressources relatives aux politiques pour VPC Lattice](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-resources).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"vpc-lattice:CreateServiceNetworkServiceAssociation"
],
"Resource": [
"arn:aws:vpc-lattice:us-west-2:123456789012:servicenetworkserviceassociation/*",
"arn:aws:vpc-lattice:us-west-2:123456789012:service/svc-04d5cc9b88example",
"arn:aws:vpc-lattice:us-west-2:123456789012:servicenetwork/sn-903004f88example"
]
}
]
}
```
------
### Exemple de politique : ajout de balises aux ressources
L'exemple suivant illustre une politique qui autorise les utilisateurs dotés de cette politique à créer des balises sur les ressources VPC Lattice.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"vpc-lattice:TagResource"
],
"Resource": "arn:aws:vpc-lattice:us-west-2:123456789012:*/*"
}
]
}
```
------
### Exemple de politique : créer un rôle lié à un service
VPC Lattice a besoin d'autorisations pour créer un rôle lié à un service la première fois qu'un de vos utilisateurs crée Compte AWS des ressources VPC Lattice. Si le rôle lié au service n'existe pas déjà, VPC Lattice le crée dans votre compte. Le rôle lié au service donne des autorisations à VPC Lattice afin qu'il puisse appeler d'autres personnes en votre nom. Services AWS Pour de plus amples informations, veuillez consulter [Utilisation de rôles liés à un service pour Amazon VPC Lattice](using-service-linked-roles.md).
Pour que cette création de rôle automatique aboutisse, les utilisateurs doivent disposer des autorisations nécessaires pour l'action `iam:CreateServiceLinkedRole`.
```
"Action": "iam:CreateServiceLinkedRole"
```
L'exemple suivant illustre une politique qui autorise les utilisateurs dotés de cette politique à créer un rôle lié à un service pour VPC Lattice.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/vpc-lattice.amazonaws.com/AWSServiceRoleForVpcLattice",
"Condition": {
"StringLike": {
"iam:AWSServiceName":"vpc-lattice.amazonaws.com"
}
}
}
]
}
```
------
Pour plus d’informations, consultez [Autorisations de rôles liés à un service](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#service-linked-role-permissions) dans le *Guide de l’utilisateur IAM*.
# Utilisation de rôles liés à un service pour Amazon VPC Lattice
Amazon VPC Lattice utilise un rôle lié à un service pour les autorisations dont il a besoin pour appeler d'autres personnes en votre nom. Services AWS Pour plus d’informations, consultez la section [Rôles liés à un service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create-service-linked-role.html) dans le *Guide de l’utilisateur IAM*.
VPC Lattice utilise le rôle lié au service nommé. AWSServiceRoleForVpcLattice
## Autorisations de rôle liées à un service pour VPC Lattice
Le rôle lié à un service **AWSServiceRoleForVpcLattice** approuve le fait que le service suivant endosse le rôle :
+ `vpc-lattice.amazonaws.com`
La politique d'autorisation de rôle nommée AWSVpcLatticeServiceRolePolicy permet à VPC Lattice de publier des CloudWatch métriques dans l'espace de noms. `AWS/VpcLattice` Pour plus d'informations, reportez-vous [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSVpcLatticeServiceRolePolicy.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSVpcLatticeServiceRolePolicy.html)à la section *AWS Managed Policy Reference*.
Vous devez configurer les autorisations de manière à permettre à une entité IAM (comme un utilisateur, un groupe ou un rôle) de créer, modifier ou supprimer un rôle lié à un service. Pour de plus amples informations, veuillez consulter [Exemple de politique : créer un rôle lié à un service](security_iam_id-based-policies.md#security_iam_id-based-policy-examples-service-linked-role).
## Création d'un rôle lié à un service pour VPC Lattice
Vous n’avez pas besoin de créer manuellement un rôle lié à un service. Lorsque vous créez des ressources VPC Lattice dans l'API AWS Management Console, le ou l'API AWS CLI AWS , VPC Lattice crée le rôle lié au service pour vous.
Si vous supprimez ce rôle lié à un service et que vous avez ensuite besoin de le recréer, vous pouvez utiliser la même procédure pour recréer le rôle dans votre compte. Lorsque vous créez des ressources VPC Lattice, VPC Lattice crée à nouveau le rôle lié au service pour vous.
## Modifier un rôle lié à un service pour VPC Lattice
Vous pouvez modifier la description de l'**AWSServiceRoleForVpcLattice**utilisation d'IAM. Pour plus d’informations, consultez la section [Modification d’un rôle lié à un service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_update-service-linked-role.html#edit-service-linked-role-iam-console) dans le *Guide de l’utilisateur IAM*.
## Supprimer un rôle lié à un service pour VPC Lattice
Si vous n'avez plus besoin d'utiliser Amazon VPC Lattice, nous vous recommandons de le supprimer. **AWSServiceRoleForVpcLattice**
Vous ne pouvez supprimer ce rôle lié à un service qu'après avoir supprimé toutes les ressources VPC Lattice de votre. Compte AWS
Utilisez la console IAM AWS CLI, le ou l' AWS API pour supprimer le rôle lié au **AWSServiceRoleForVpcLattice**service. Pour plus d’informations, consultez la section [Suppression d’un rôle lié à un service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_delete.html#id_roles_manage_delete_slr) dans le *Guide de l’utilisateur IAM*.
Après avoir supprimé un rôle lié à un service, VPC Lattice le crée à nouveau lorsque vous créez des ressources VPC Lattice dans votre. Compte AWS
## Régions prises en charge pour les rôles liés au service VPC Lattice
VPC Lattice prend en charge l'utilisation de rôles liés au service dans toutes les régions où le service est disponible.
# AWS politiques gérées pour Amazon VPC Lattice
Une politique AWS gérée est une politique autonome créée et administrée par AWS. AWS les politiques gérées sont conçues pour fournir des autorisations pour de nombreux cas d'utilisation courants afin que vous puissiez commencer à attribuer des autorisations aux utilisateurs, aux groupes et aux rôles.
N'oubliez pas que les politiques AWS gérées peuvent ne pas accorder d'autorisations de moindre privilège pour vos cas d'utilisation spécifiques, car elles sont accessibles à tous les AWS clients. Nous vous recommandons de réduire encore les autorisations en définissant des [politiques gérées par le client](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) qui sont propres à vos cas d’utilisation.
Vous ne pouvez pas modifier les autorisations définies dans les politiques AWS gérées. Si les autorisations définies dans une politique AWS gérée sont AWS mises à jour, la mise à jour affecte toutes les identités principales (utilisateurs, groupes et rôles) auxquelles la politique est attachée. AWS est le plus susceptible de mettre à jour une politique AWS gérée lorsqu'une nouvelle Service AWS est lancée ou lorsque de nouvelles opérations d'API sont disponibles pour les services existants.
Pour plus d’informations, consultez [Politiques gérées par AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) dans le *Guide de l’utilisateur IAM*.
## AWS politique gérée : VPCLattice FullAccess
Cette politique fournit un accès complet à Amazon VPC Lattice et un accès limité aux autres services dépendants. Il inclut les autorisations permettant d'effectuer les opérations suivantes :
+ ACM — Récupérez l'ARN du SSL/TLS certificat pour les noms de domaine personnalisés.
+ CloudWatch — Afficher les journaux d'accès et les données de surveillance.
+ CloudWatch Journaux — Configurez et envoyez des journaux d'accès à CloudWatch Logs.
+ Amazon EC2 — Configurez les interfaces réseau et récupérez des informations sur les instances EC2 et. VPCs Ceci est utilisé pour créer des configurations de ressources, des passerelles de ressources et des groupes cibles, configurer des associations d'entités VPC Lattice et enregistrer des cibles.
+ Elastic Load Balancing : récupérez des informations sur un Application Load Balancer pour l'enregistrer en tant que cible.
+ Firehose — Récupérez des informations sur les flux de diffusion utilisés pour stocker les journaux d'accès.
+ Lambda — Récupérez des informations sur une fonction Lambda pour l'enregistrer en tant que cible.
+ Amazon RDS — Récupérez des informations sur les clusters et les instances RDS.
+ Amazon S3 — Récupérez des informations sur les compartiments S3 utilisés pour stocker les journaux d'accès.
Pour voir les autorisations de cette stratégie, consultez [VPCLatticeFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/VPCLatticeFullAccess.html) dans le *AWS Guide de référence des stratégies gérées par*.
Pour utiliser les autres AWS services auxquels VPC Lattice est intégré et l'ensemble des fonctionnalités de VPC Lattice, vous devez disposer d'autorisations supplémentaires spécifiques. Ces autorisations ne sont pas incluses dans la politique `VPCLatticeFullAccess` gérée en raison du risque d'augmentation [confuse des privilèges des adjoints](https://docs.aws.amazon.com//IAM/latest/UserGuide/confused-deputy.html). Pour de plus amples informations, veuillez consulter [Autorisations supplémentaires requises pour un accès complet](security_iam_id-based-policies.md#security_iam_id-based-policy-additional-permissions).
## AWS politique gérée : VPCLattice ReadOnlyAccess
Cette politique fournit un accès en lecture seule à Amazon VPC Lattice et un accès limité aux autres services dépendants. Il inclut les autorisations permettant d'effectuer les opérations suivantes :
+ ACM — Récupérez l'ARN du SSL/TLS certificat pour les noms de domaine personnalisés.
+ CloudWatch — Afficher les journaux d'accès et les données de surveillance.
+ CloudWatch Journaux : affichez les informations de livraison des journaux pour les abonnements aux journaux d'accès.
+ Amazon EC2 — Récupérez des informations sur les instances EC2, créez des groupes cibles et VPCs enregistrez des cibles.
+ Elastic Load Balancing — Récupérez des informations sur un Application Load Balancer.
+ Firehose — Récupérez des informations sur les flux de diffusion pour la livraison des journaux d'accès.
+ Lambda : affiche les informations relatives à une fonction Lambda.
+ Amazon RDS — Récupérez des informations sur les clusters et les instances RDS.
+ Amazon S3 — Récupérez des informations sur les compartiments S3 pour la livraison des journaux d'accès.
Pour voir les autorisations de cette stratégie, consultez [VPCLatticeReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/VPCLatticeReadOnlyAccess.html) dans le *AWS Guide de référence des stratégies gérées par*.
## AWS politique gérée : VPCLattice ServicesInvokeAccess
Cette politique permet d'invoquer les services Amazon VPC Lattice.
Pour voir les autorisations de cette stratégie, consultez [VPCLatticeServicesInvokeAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/VPCLatticeServicesInvokeAccess.html) dans le *AWS Guide de référence des stratégies gérées par*.
## AWS politique gérée : AWSVpc LatticeServiceRolePolicy
Cette politique est associée à un rôle lié à un service nommé **AWSServiceRoleForVpcLattice**pour permettre à VPC Lattice d'effectuer des actions en votre nom. Vous ne pouvez pas attacher cette politique à vos entités IAM. Pour de plus amples informations, veuillez consulter [Utilisation de rôles liés à un service pour Amazon VPC Lattice](using-service-linked-roles.md).
Pour voir les autorisations de cette stratégie, consultez [AWSVpcLatticeServiceRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSVpcLatticeServiceRolePolicy.html) dans le *AWS Guide de référence des stratégies gérées par*.
## Mises à jour des politiques gérées par VPC Lattice AWS
Consultez les détails des mises à jour des politiques AWS gérées pour VPC Lattice depuis que ce service a commencé à suivre ces modifications. Pour recevoir des alertes automatiques concernant les modifications apportées à cette page, abonnez-vous au flux RSS du guide de l'utilisateur du VPC Lattice.
| Modifier | Description | Date |
| --- | --- | --- |
| [VPCLatticeFullAccess](#vpc-lattice-fullaccess-policy) | VPC Lattice ajoute des autorisations en lecture seule pour décrire les clusters et les instances Amazon RDS. | 1er décembre 2024 |
| [VPCLatticeReadOnlyAccess](#vpc-lattice-read-onlyaccess-policy) | VPC Lattice ajoute des autorisations en lecture seule pour décrire les clusters et les instances Amazon RDS. | 1er décembre 2024 |
| [AWSVpcLatticeServiceRolePolicy](#service-linked-role-policy) | VPC Lattice ajoute des autorisations pour permettre à VPC Lattice de créer une interface réseau gérée par le demandeur. | 1er décembre 2024 |
| [VPCLatticeFullAccess](#vpc-lattice-fullaccess-policy) | VPC Lattice ajoute une nouvelle politique visant à accorder des autorisations pour un accès complet à Amazon VPC Lattice et un accès limité à d'autres services dépendants. | 31 mars 2023 |
| [VPCLatticeReadOnlyAccess](#vpc-lattice-read-onlyaccess-policy) | VPC Lattice ajoute une nouvelle politique pour accorder des autorisations d'accès en lecture seule à Amazon VPC Lattice et un accès limité à d'autres services dépendants. | 31 mars 2023 |
| [VPCLatticeServicesInvokeAccess](#vpc-lattice-services-invoke-access-policy) | VPC Lattice ajoute une nouvelle politique permettant d'autoriser l'accès aux services Amazon VPC Lattice pour invoquer les services Amazon VPC Lattice. | 31 mars 2023 |
| [AWSVpcLatticeServiceRolePolicy](#service-linked-role-policy) | VPC Lattice ajoute des autorisations à son rôle lié au service pour permettre à VPC Lattice de publier des métriques dans l'espace de noms. CloudWatch AWS/VpcLattice La AWSVpcLatticeServiceRolePolicy politique inclut l'autorisation d'appeler l'action d' CloudWatch [PutMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricData.html)API. Pour de plus amples informations, veuillez consulter [Utilisation de rôles liés à un service pour Amazon VPC Lattice](using-service-linked-roles.md). | 5 décembre 2022 |
| VPC Lattice a commencé à suivre les modifications | VPC Lattice a commencé à suivre les modifications apportées à ses AWS politiques gérées. | 5 décembre 2022 |
# Validation de conformité pour Amazon VPC Lattice
Des auditeurs tiers évaluent la sécurité et la conformité d'Amazon VPC Lattice dans le cadre de plusieurs AWS programmes de conformité.
Pour savoir si un [programme Services AWS de conformité Service AWS s'inscrit dans le champ d'application de programmes de conformité](https://aws.amazon.com/compliance/services-in-scope/) spécifiques, consultez Services AWS la section de conformité et sélectionnez le programme de conformité qui vous intéresse. Pour des informations générales, voir Programmes de [AWS conformité Programmes AWS](https://aws.amazon.com/compliance/programs/) de .
Vous pouvez télécharger des rapports d'audit tiers à l'aide de AWS Artifact. Pour plus d'informations, voir [Téléchargement de rapports dans AWS Artifact](https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html) .
Votre responsabilité en matière de conformité lors de l'utilisation Services AWS est déterminée par la sensibilité de vos données, les objectifs de conformité de votre entreprise et les lois et réglementations applicables. Pour plus d'informations sur votre responsabilité en matière de conformité lors de l'utilisation Services AWS, consultez [AWS la documentation de sécurité](https://docs.aws.amazon.com/security/).
# Accédez à Amazon VPC Lattice à l'aide des points de terminaison d'interface ()AWS PrivateLink
*Vous pouvez établir une connexion privée entre votre VPC et Amazon VPC Lattice en créant un point de terminaison VPC d'interface.* Les points de terminaison de l'interface sont alimentés par [AWS PrivateLink](https://aws.amazon.com/privatelink/)une technologie qui vous permet d'accéder en privé à VPC APIs Lattice sans passerelle Internet, périphérique NAT, connexion VPN ou connexion. Direct Connect Les instances de votre VPC n'ont pas besoin d'adresses IP publiques pour communiquer avec VPC Lattice. APIs
Chaque point de terminaison d'interface est représenté par une ou plusieurs [interfaces réseau](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) dans vos sous-réseaux.
## Considérations relatives aux points de terminaison VPC d'interface
*Avant de configurer un point de terminaison VPC d'interface pour VPC Lattice, assurez-vous de consulter [Access Services AWS](https://docs.aws.amazon.com/vpc/latest/privatelink/privatelink-access-aws-services.html) through dans le guide. AWS PrivateLinkAWS PrivateLink *
VPC Lattice permet d'appeler toutes ses actions d'API depuis votre VPC.
## Création d'un point de terminaison VPC d'interface pour VPC Lattice
Vous pouvez créer un point de terminaison VPC pour le service VPC Lattice à l'aide de la console Amazon VPC ou du (). AWS Command Line Interface AWS CLI*Pour plus d'informations, consultez la section [Créer un point de terminaison VPC d'interface](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html) dans le AWS PrivateLink Guide.*
Créez un point de terminaison VPC pour VPC Lattice en utilisant le nom de service suivant :
`com.amazonaws.region.vpc-lattice`
Si vous activez le DNS privé pour le point de terminaison, vous pouvez envoyer des demandes d'API à VPC Lattice en utilisant son nom DNS par défaut pour la région, par exemple,. `vpc-lattice.us-east-1.amazonaws.com`
# Résilience dans Amazon VPC Lattice
L'infrastructure AWS mondiale est construite autour Régions AWS de zones de disponibilité.
Régions AWS fournissent plusieurs zones de disponibilité physiquement séparées et isolées, connectées par un réseau à faible latence, à haut débit et hautement redondant.
Avec les zones de disponibilité, vous pouvez concevoir et exploiter des applications et des bases de données qui basculent automatiquement d’une zone à l’autre sans interruption. Les zones de disponibilité sont davantage disponibles, tolérantes aux pannes et ont une plus grande capacité de mise à l’échelle que les infrastructures traditionnelles à un ou plusieurs centres de données.
Pour plus d'informations sur les zones de disponibilité Régions AWS et les zones de disponibilité, consultez la section [Infrastructure AWS globale](https://aws.amazon.com/about-aws/global-infrastructure/).
# Sécurité de l'infrastructure dans Amazon VPC Lattice
En tant que service géré, Amazon VPC Lattice est protégé par la sécurité du réseau AWS mondial. Pour plus d'informations sur les services AWS de sécurité et sur la manière dont AWS l'infrastructure est protégée, consultez la section [Sécurité du AWS cloud](https://aws.amazon.com/security/). Pour concevoir votre AWS environnement en utilisant les meilleures pratiques en matière de sécurité de l'infrastructure, consultez la section [Protection de l'infrastructure](https://docs.aws.amazon.com/wellarchitected/latest/security-pillar/infrastructure-protection.html) dans le cadre * AWS bien architecturé du pilier de sécurité*.
Vous utilisez des appels d'API AWS publiés pour accéder à VPC Lattice via le réseau. Les clients doivent prendre en charge les éléments suivants :
+ Protocole TLS (Transport Layer Security). Nous exigeons TLS 1.2 et recommandons TLS 1.3.
+ Ses suites de chiffrement PFS (Perfect Forward Secrecy) comme DHE (Ephemeral Diffie-Hellman) ou ECDHE (Elliptic Curve Ephemeral Diffie-Hellman). La plupart des systèmes modernes tels que Java 7 et les versions ultérieures prennent en charge ces modes.