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.
# 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")
}
```