```
# Configuration d'Amazon ECS Service Connect avec AWS CLI
Vous pouvez créer un service Amazon ECS pour une tâche Fargate qui utilise Service Connect avec l’ AWS CLI.
**Note**
Vous pouvez utiliser des points de terminaison de service à double pile pour interagir avec Amazon ECS à partir de AWS CLI SDKs, et de l'API Amazon ECS via les deux IPv4 et. IPv6 Pour de plus amples informations, veuillez consulter [Utilisation des points de terminaison à double pile Amazon ECS](dual-stack-endpoint.md).
## Conditions préalables
Les prérequis Service Connect sont les suivants :
+ Vérifiez que la dernière version de AWS CLI est installée et configurée. Pour plus d’informations, consultez la section [Installation ou mise à jour de la version la plus récente de l’ AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Votre utilisateur IAM dispose des autorisations requises spécifiées dans l’exemple de politique IAM [Amazon ECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess).
+ Vous avez un VPC, un sous-réseau, une table de routage et un groupe de sécurité prêts à être utilisés. Pour de plus amples informations, veuillez consulter [Créer un Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ Vous avez un rôle d'exécution de tâches portant le nom `ecsTaskExecutionRole` et la politique gérée par `AmazonECSTaskExecutionRolePolicy` est associée au rôle. Ce rôle permet à Fargate d'écrire les journaux de l'application NGINX et les journaux du proxy Service Connect sur Amazon Logs. CloudWatch Pour de plus amples informations, veuillez consulter [Création du rôle d'exécution de tâche](task_execution_IAM_role.md#create-task-execution-role).
## Étape 1 : créer le cluster
Pour créer votre espace de noms et votre cluster Amazon ECS, effectuez les étapes suivantes.
**Pour créer le cluster et l'espace de AWS Cloud Map noms Amazon ECS**
1. Créez un cluster Amazon ECS nommé `tutorial` que vous allez utiliser. Le paramètre `--service-connect-defaults` définit l'espace de noms par défaut du cluster. Dans l'exemple de sortie, aucun AWS Cloud Map espace de noms du même nom `service-connect` n'existe dans ce compte. L'espace de noms est donc créé par Amazon ECS. Région AWS L'espace de noms est créé dans AWS Cloud Map dans le compte, et il est visible avec tous les autres espaces de noms. Utilisez donc un nom descriptif.
```
aws ecs create-cluster --cluster-name tutorial --service-connect-defaults namespace=service-connect
```
Sortie :
```
{
"cluster": {
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/tutorial",
"clusterName": "tutorial",
"serviceConnectDefaults": {
"namespace": "arn:aws:servicediscovery:us-west-2:123456789012:namespace/ns-EXAMPLE"
},
"status": "PROVISIONING",
"registeredContainerInstancesCount": 0,
"runningTasksCount": 0,
"pendingTasksCount": 0,
"activeServicesCount": 0,
"statistics": [],
"tags": [],
"settings": [
{
"name": "containerInsights",
"value": "disabled"
}
],
"capacityProviders": [],
"defaultCapacityProviderStrategy": [],
"attachments": [
{
"id": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"type": "sc",
"status": "ATTACHING",
"details": []
}
],
"attachmentsStatus": "UPDATE_IN_PROGRESS"
}
}
}
```
1. Vérifiez que le cluster est créé :
```
aws ecs describe-clusters --clusters tutorial
```
Sortie :
```
{
"clusters": [
{
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/tutorial",
"clusterName": "tutorial",
"serviceConnectDefaults": {
"namespace": "arn:aws:servicediscovery:us-west-2:123456789012:namespace/ns-EXAMPLE"
},
"status": "ACTIVE",
"registeredContainerInstancesCount": 0,
"runningTasksCount": 0,
"pendingTasksCount": 0,
"activeServicesCount": 0,
"statistics": [],
"tags": [],
"settings": [],
"capacityProviders": [],
"defaultCapacityProviderStrategy": []
}
],
"failures": []
}
```
1. (Facultatif) Vérifiez que l'espace de noms est créé dans AWS Cloud Map. Vous pouvez utiliser la configuration AWS Management Console ou la AWS CLI configuration normale telle qu'elle a été créée dans AWS Cloud Map.
Par exemple, utilisez l' AWS CLI :
```
aws servicediscovery get-namespace --id ns-EXAMPLE
```
Sortie :
```
{
"Namespace": {
"Id": "ns-EXAMPLE",
"Arn": "arn:aws:servicediscovery:us-west-2:123456789012:namespace/ns-EXAMPLE",
"Name": "service-connect",
"Type": "HTTP",
"Properties": {
"DnsProperties": {
"SOA": {}
},
"HttpProperties": {
"HttpName": "service-connect"
}
},
"CreateDate": 1661749852.422,
"CreatorRequestId": "service-connect"
}
}
```
## Étape 2 : créer le service pour le serveur
La fonctionnalité Service Connect est destinée à interconnecter plusieurs applications sur Amazon ECS. Au moins l'une de ces applications doit fournir un service Web auquel se connecter. Au cours de cette étape, vous allez créer :
+ La définition de tâche qui utilise l'image officielle non modifiée du conteneur NGINX et qui inclut la configuration de Service Connect.
+ La définition du service Amazon ECS qui configure Service Connect pour fournir la découverte de service et la mise en proxy de maillage de services pour le trafic vers ce service. La configuration réutilise l'espace de noms par défaut de la configuration du cluster afin de réduire la quantité de configuration de service que vous effectuez pour chaque service.
+ Le service Amazon ECS. Il exécute une tâche à l'aide de la définition de tâche et insère un conteneur supplémentaire pour le proxy Service Connect. Le proxy écoute sur le port depuis le mappage de ports du conteneur dans la définition de la tâche. Dans une application cliente exécutée dans Amazon ECS, le proxy intégré à la tâche client écoute les connexions sortantes vers le nom du port de définition de la tâche, le nom de découverte du service ou le nom d'alias du client de service, ainsi que le numéro de port provenant de l'alias client.
**Pour créer le service Web avec Service Connect**
1. Enregistrez une définition de tâche compatible avec Fargate et qui utilise le mode réseau `awsvpc`. Procédez comme suit :
1. Créez un fichier nommé `service-connect-nginx.json` avec le contenu de la définition de tâche suivante.
Cette définition de tâche configure Service Connect en ajoutant les paramètres de `name` et de `appProtocol` au mappage des ports. Le nom du port permet de mieux identifier ce port dans la configuration du service lorsque plusieurs ports sont utilisés. Le nom du port est également utilisé par défaut comme nom détectable à utiliser par d'autres applications de l'espace de noms.
La définition de tâche contient le rôle IAM de tâche, car ECS Exec est activé sur le service.
**Important**
Cette définition de tâche utilise un `logConfiguration` pour envoyer la sortie nginx depuis `stdout` et `stderr` vers Amazon Logs. CloudWatch Ce rôle d'exécution de tâches ne dispose pas des autorisations supplémentaires requises pour créer le groupe de CloudWatch journaux Logs. Créez le groupe de CloudWatch journaux dans Logs à l'aide du AWS Management Console ou AWS CLI. Si vous ne souhaitez pas envoyer les journaux nginx à Logs, vous pouvez CloudWatch supprimer le. `logConfiguration`
Remplacez l' Compte AWS identifiant dans le rôle d'exécution de la tâche par votre Compte AWS identifiant.
```
{
"family": "service-connect-nginx",
"executionRoleArn": "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"taskRoleArn": "arn:aws:iam::123456789012:role/ecsTaskRole",
"networkMode": "awsvpc",
"containerDefinitions": [
{
"name": "webserver",
"image": "public.ecr.aws/docker/library/nginx:latest",
"cpu": 100,
"portMappings": [
{
"name": "nginx",
"containerPort": 80,
"protocol": "tcp",
"appProtocol": "http"
}
],
"essential": true,
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/service-connect-nginx",
"awslogs-region": "region",
"awslogs-stream-prefix": "nginx"
}
}
}
],
"cpu": "256",
"memory": "512"
}
```
1. Enregistrez la définition de tâche à l'aide du fichier `service-connect-nginx.json` :
```
aws ecs register-task-definition --cli-input-json file://service-connect-nginx.json
```
1. Créez un service :
1. Créez un fichier nommé `service-connect-nginx-service.json` avec le contenu du service Amazon ECS que vous créez. Cet exemple utilise la définition de tâche créée à l'étape précédente. Le paramètre `awsvpcConfiguration` est obligatoire, car l'exemple de définition de tâche utilise le mode réseau `awsvpc`.
Lorsque vous créez le service ECS, spécifiez Fargate et la version de plateforme `LATEST` qui prend en charge Service Connect. Les `securityGroups` et les `subnets` doivent appartenir à un VPC répondant aux exigences requises pour utiliser Amazon ECS. Vous pouvez obtenir le groupe de sécurité et le sous-réseau IDs depuis la console Amazon VPC.
Ce service configure Service Connect en ajoutant le paramètre `serviceConnectConfiguration`. L'espace de noms n'est pas obligatoire car un espace de noms par défaut est configuré pour le cluster. Les applications clientes exécutées dans ECS dans l'espace de noms se connectent à ce service en utilisant le `portName` et le port dans les `clientAliases`. Par exemple, ce service est accessible via `http://nginx:80/`, car nginx fournit une page de bienvenue à l'emplacement racine `/`. Les applications externes qui ne s'exécutent pas dans Amazon ECS ou qui ne se trouvent pas dans le même espace de noms peuvent accéder à cette application via le proxy Service Connect en utilisant l'adresse IP de la tâche et le numéro de port figurant dans la définition de la tâche. Pour votre configuration `tls`, ajoutez l’`arn` du certificat pour votre `awsPcaAuthorityArn`, votre `kmsKey` et `roleArn` de votre rôle IAM.
Ce service utilise un `logConfiguration` pour envoyer la sortie du proxy Service Connect depuis `stdout` et `stderr` vers Amazon CloudWatch Logs. Ce rôle d'exécution de tâches ne dispose pas des autorisations supplémentaires requises pour créer le groupe de CloudWatch journaux Logs. Créez le groupe de CloudWatch journaux dans Logs à l'aide du AWS Management Console ou AWS CLI. Nous vous recommandons de créer ce groupe de journaux et de stocker les journaux du proxy dans CloudWatch Logs. Si vous ne souhaitez pas envoyer les journaux du proxy à CloudWatch Logs, vous pouvez supprimer le`logConfiguration`.
```
{
"cluster": "tutorial",
"deploymentConfiguration": {
"maximumPercent": 200,
"minimumHealthyPercent": 0
},
"deploymentController": {
"type": "ECS"
},
"desiredCount": 1,
"enableECSManagedTags": true,
"enableExecuteCommand": true,
"launchType": "FARGATE",
"networkConfiguration": {
"awsvpcConfiguration": {
"assignPublicIp": "ENABLED",
"securityGroups": [
"sg-EXAMPLE"
],
"subnets": [
"subnet-EXAMPLE",
"subnet-EXAMPLE",
"subnet-EXAMPLE"
]
}
},
"platformVersion": "LATEST",
"propagateTags": "SERVICE",
"serviceName": "service-connect-nginx-service",
"serviceConnectConfiguration": {
"enabled": true,
"services": [
{
"portName": "nginx",
"clientAliases": [
{
"port": 80
}
],
"tls": {
"issuerCertificateAuthority": {
"awsPcaAuthorityArn": "certificateArn"
},
"kmsKey": "kmsKey",
"roleArn": "iamRoleArn"
}
}
],
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/service-connect-proxy",
"awslogs-region": "region",
"awslogs-stream-prefix": "service-connect-proxy"
}
}
},
"taskDefinition": "service-connect-nginx"
}
```
1. Créez un service à l’aide du fichier `service-connect-nginx-service.json` :
```
aws ecs create-service --cluster tutorial --cli-input-json file://service-connect-nginx-service.json
```
Sortie :
```
{
"service": {
"serviceArn": "arn:aws:ecs:us-west-2:123456789012:service/tutorial/service-connect-nginx-service",
"serviceName": "service-connect-nginx-service",
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/tutorial",
"loadBalancers": [],
"serviceRegistries": [],
"status": "ACTIVE",
"desiredCount": 1,
"runningCount": 0,
"pendingCount": 0,
"launchType": "FARGATE",
"platformVersion": "LATEST",
"platformFamily": "Linux",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/service-connect-nginx:1",
"deploymentConfiguration": {
"deploymentCircuitBreaker": {
"enable": false,
"rollback": false
},
"maximumPercent": 200,
"minimumHealthyPercent": 0
},
"deployments": [
{
"id": "ecs-svc/3763308422771520962",
"status": "PRIMARY",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/service-connect-nginx:1",
"desiredCount": 1,
"pendingCount": 0,
"runningCount": 0,
"failedTasks": 0,
"createdAt": 1661210032.602,
"updatedAt": 1661210032.602,
"launchType": "FARGATE",
"platformVersion": "1.4.0",
"platformFamily": "Linux",
"networkConfiguration": {
"awsvpcConfiguration": {
"assignPublicIp": "ENABLED",
"securityGroups": [
"sg-EXAMPLE"
],
"subnets": [
"subnet-EXAMPLEf",
"subnet-EXAMPLE",
"subnet-EXAMPLE"
]
}
},
"rolloutState": "IN_PROGRESS",
"rolloutStateReason": "ECS deployment ecs-svc/3763308422771520962 in progress.",
"failedLaunchTaskCount": 0,
"replacedTaskCount": 0,
"serviceConnectConfiguration": {
"enabled": true,
"namespace": "service-connect",
"services": [
{
"portName": "nginx",
"clientAliases": [
{
"port": 80
}
]
}
],
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/service-connect-proxy",
"awslogs-region": "us-west-2",
"awslogs-stream-prefix": "service-connect-proxy"
},
"secretOptions": []
}
},
"serviceConnectResources": [
{
"discoveryName": "nginx",
"discoveryArn": "arn:aws:servicediscovery:us-west-2:123456789012:service/srv-EXAMPLE"
}
]
}
],
"roleArn": "arn:aws:iam::123456789012:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS",
"version": 0,
"events": [],
"createdAt": 1661210032.602,
"placementConstraints": [],
"placementStrategy": [],
"networkConfiguration": {
"awsvpcConfiguration": {
"assignPublicIp": "ENABLED",
"securityGroups": [
"sg-EXAMPLE"
],
"subnets": [
"subnet-EXAMPLE",
"subnet-EXAMPLE",
"subnet-EXAMPLE"
]
}
},
"schedulingStrategy": "REPLICA",
"enableECSManagedTags": true,
"propagateTags": "SERVICE",
"enableExecuteCommand": true
}
}
```
La `serviceConnectConfiguration` que vous avez fournie apparaît dans le premier *déploiement* de la sortie. Lorsque vous apportez des modifications au service ECS de manière à modifier des tâches, un nouveau déploiement est créé par Amazon ECS.
## Étape 3 : Vérifier que vous pouvez vous connecter
Pour vérifier que Service Connect est configuré et fonctionne, procédez comme suit pour vous connecter au service Web à partir d'une application externe. Consultez ensuite les mesures supplémentaires dans CloudWatch le proxy Service Connect créé.
**Pour vous connecter au service Web à partir d'une application externe**
+ Connectez-vous à l'adresse IP de la tâche et au port du conteneur à l'aide de l'adresse IP de la tâche
Utilisez le AWS CLI pour obtenir l'ID de la tâche, en utilisant le`aws ecs list-tasks --cluster tutorial`.
Si vos sous-réseaux et votre groupe de sécurité autorisent le trafic depuis l'Internet public sur le port défini par la tâche, vous pouvez vous connecter à l'adresse IP publique depuis votre ordinateur. L'adresse IP publique n'étant pas disponible dans `describe-tasks`, les étapes consistent à se rendre sur Amazon EC2 AWS Management Console ou AWS CLI à obtenir les détails de l'interface Elastic Network.
Dans cet exemple, une instance Amazon EC2 dans le même VPC utilise l'adresse IP privée de la tâche. L'application est nginx, mais l'en-tête `server: envoy` indique que le proxy Service Connect est utilisé. Le proxy Service Connect écoute sur le port du conteneur depuis la définition de la tâche.
```
$ curl -v 10.0.19.50:80/
* Trying 10.0.19.50:80...
* Connected to 10.0.19.50 (10.0.19.50) port 80 (#0)
> GET / HTTP/1.1
> Host: 10.0.19.50
> User-Agent: curl/7.79.1
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
< server: envoy
< date: Tue, 23 Aug 2022 03:53:06 GMT
< content-type: text/html
< content-length: 612
< last-modified: Tue, 16 Apr 2019 13:08:19 GMT
< etag: "5cb5d3c3-264"
< accept-ranges: bytes
< x-envoy-upstream-service-time: 0
<
Welcome to nginx!
Welcome to nginx!
If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.
For online documentation and support please refer to
nginx.org.
Commercial support is available at
nginx.com.
Thank you for using nginx.
```
**Pour consulter les métriques de Service Connect**
Le proxy Service Connect crée des métriques d'application (connexion HTTP HTTP2, gRPC ou TCP) dans des métriques. CloudWatch Lorsque vous utilisez la CloudWatch console, consultez les dimensions métriques supplémentaires de **DiscoveryName**, (**DiscoveryName, ServiceName, ClusterName**) et (**TargetDiscoveryName**, **TargetDiscoveryName ServiceName, ClusterName**) dans l'espace de noms Amazon ECS. Pour plus d'informations sur ces statistiques et les dimensions, consultez la section [Afficher les mesures disponibles](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/viewing_metrics_with_cloudwatch.html) dans le guide de l'utilisateur Amazon CloudWatch Logs.
# Utilisation de la découverte de service pour connecter les services Amazon ECS avec des noms DNS
Vous pouvez éventuellement configurer votre Amazon ECS service afin d'utiliser la découverte de service Amazon ECS. La découverte de services utilise des actions d' AWS Cloud Map API pour gérer les espaces de noms HTTP et DNS pour vos services Amazon ECS. Pour plus d'informations, consultez [Présentation de AWS Cloud Map](https://docs.aws.amazon.com/cloud-map/latest/dg/Welcome.html) dans le *Manuel du développeur AWS Cloud Map *.
La découverte de services est disponible dans les AWS régions suivantes :
| Nom de la région | Région |
| --- | --- |
| USA Est (Virginie du Nord) | us-east-1 |
| USA Est (Ohio) | us-east-2 |
| USA Ouest (Californie du Nord) | us-west-1 |
| US West (Oregon) | us-west-2 |
| Afrique (Le Cap) | af-south-1 |
| Asie-Pacifique (Hong Kong) | ap-east-1 |
| Asie-Pacifique (Taipei) | ap-east-2 |
| Asie-Pacifique (Mumbai) | ap-south-1 |
| Asie-Pacifique (Hyderabad) | ap-south-2 |
| Asie-Pacifique (Tokyo) | ap-northeast-1 |
| Asie-Pacifique (Séoul) | ap-northeast-2 |
| Asie-Pacifique (Osaka) | ap-northeast-3 |
| Asie-Pacifique (Singapour) | ap-southeast-1 |
| Asie-Pacifique (Sydney) | ap-southeast-2 |
| Asie-Pacifique (Jakarta) | ap-southeast-3 |
| Asie-Pacifique (Melbourne) | ap-southeast-4 |
| Asie-Pacifique (Malaisie) | ap-southeast-5 |
| Asie-Pacifique (Nouvelle-Zélande) | ap-southeast-6 |
| Asie-Pacifique (Thaïlande) | ap-southeast-7 |
| Canada (Centre) | ca-central-1 |
| Canada-Ouest (Calgary) | ca-west-1 |
| Chine (Beijing) | cn-north-1 |
| China (Ningxia) | cn-northwest-1 |
| Europe (Francfort) | eu-central-1 |
| Europe (Zurich) | eu-central-2 |
| Europe (Irlande) | eu-west-1 |
| Europe (Londres) | eu-west-2 |
| Europe (Paris) | eu-west-3 |
| Europe (Milan) | eu-south-1 |
| Europe (Stockholm) | eu-north-1 |
| Israël (Tel Aviv) | il-central-1 |
| Europe (Espagne) | eu-south-2 |
| Moyen-Orient (EAU) | me-central-1 |
| Mexique (Centre) | mx-central-1 |
| Moyen-Orient (Bahreïn) | me-south-1 |
| Amérique du Sud (São Paulo) | sa-east-1 |
| AWS GovCloud (USA Est) | us-gov-east-1 |
| AWS GovCloud (US-Ouest) | us-gov-west-1 |
## Concepts associés à la découverte de service
La découverte de service se compose des éléments suivants :
+ **Espace de noms de découverte de services** : groupe logique de services de découverte de services qui partagent le même nom de domaine, tel que `example.com`, vers lequel vous souhaitez acheminer le trafic. Vous pouvez créer un espace de noms avec un appel à la commande `aws servicediscovery create-private-dns-namespace` ou dans la console Amazon ECS. Vous pouvez utiliser la commande `aws servicediscovery list-namespaces` pour afficher les informations récapitulatives concernant les espaces de noms créés par le compte actuel. Pour plus d'informations sur les commandes de découverte de services, consultez `[create-private-dns-namespace](https://docs.aws.amazon.com/cli/latest/reference/servicediscovery/create-private-dns-namespace.html)` et consultez `[list-namespaces](https://docs.aws.amazon.com/cli/latest/reference/servicediscovery/list-namespaces.html)` le *Guide de AWS CLI référence AWS Cloud Map (de découverte de services)*.
+ **Service de découverte de service** : présent dans l'espace de noms de la découverte de service, il se compose du nom du service et de la configuration DNS correspondant à l'espace de noms. Il fournit les principaux composants suivants :
+ **Registre des services** : vous permet de rechercher un service via des actions DNS ou AWS Cloud Map API et de récupérer un ou plusieurs points de terminaison disponibles pouvant être utilisés pour vous connecter au service.
+ **Instance de découverte de service** : existe dans le service de découverte de service et comprend les attributs associés à chaque service Amazon ECS service dans le répertoire de services.
+ **Attributs de l'instance** : les métadonnées suivantes sont ajoutées en tant qu'attributs personnalisés pour chaque service Amazon ECS service qui est configuré pour utiliser la découverte de service :
+ **`AWS_INSTANCE_IPV4`**— Pour `A` mémoire, l' IPv4 adresse renvoyée par Route 53 en réponse aux requêtes DNS et AWS Cloud Map lorsqu'elle découvre les détails de l'instance, par exemple,`192.0.2.44`.
+ **`AWS_INSTANCE_IPV6`**— Pour `AAAA` mémoire, l' IPv6 adresse renvoyée par Route 53 en réponse aux requêtes DNS et AWS Cloud Map lorsqu'elle découvre les détails de l'instance, par exemple,` 2001:0db8:85a3:0000:0000:abcd:0001:2345`. `AWS_INSTANCE_IPv4` et `AWS_INSTANCE_IPv6` sont ajoutés pour les services Amazon ECS à double pile. Seul `AWS_INSTANCE_IPv6` est ajouté pour les services Amazon ECS IPv6 uniquement.
+ **`AWS_INSTANCE_PORT`** – La valeur de port associées au service de découverte de service.
+ **`AVAILABILITY_ZONE`** – La zone de disponibilité dans laquelle la tâche a été lancée. Pour les tâches qui utilisent EC2, il s’agit de la zone de disponibilité dans laquelle l’instance de conteneur existe. Pour les tâches qui utilisent Fargate, il s’agit de la zone de disponibilité dans laquelle l’interface réseau Elastic existe.
+ **`REGION`** – La région dans laquelle la tâche existe.
+ **`ECS_SERVICE_NAME`** – Le nom du service Amazon ECS service auquel la tâche appartient.
+ **`ECS_CLUSTER_NAME`** – Le nom du cluster Amazon ECS auquel la tâche appartient.
+ **`EC2_INSTANCE_ID`** – L'ID de l'instance de conteneur sur laquelle la tâche a été placée. Cet attribut personnalisé n’est pas ajouté si la tâche utilise Fargate.
+ **`ECS_TASK_DEFINITION_FAMILY`** – La famille de définition de tâche que la tâche utilise.
+ **`ECS_TASK_SET_EXTERNAL_ID`** – Si un ensemble de tâches est créé pour un déploiement externe et est associé à un registre de découverte de service, alors l'attribut `ECS_TASK_SET_EXTERNAL_ID` contiendra l'ID externe de l'ensemble de tâches.
+ **Surveillances de l'état Amazon ECS** : Amazon ECS permet d'effectuer des surveillances d'état régulières au niveau du conteneur. Si un point de terminaison échoue à la surveillance de l'état, il est supprimé du routage DNS et marqué comme défectueux.
## Remarques relatives à la découverte de service
Les informations suivantes doivent être prises en compte lors de l'utilisation de la découverte de service :
+ La découverte de service est prise en charge pour les tâches sur Fargate qui utilisent la version de plateforme 1.1.0 ou supérieure. Pour de plus amples informations, veuillez consulter [Versions de plateforme Fargate pour Amazon ECS](platform-fargate.md).
+ Les services configurés pour utiliser la découverte de service sont limités à 1 000 tâches par service. Cela est dû à un quota de service Route 53.
+ Le flux de travail créer un service dans la console Amazon ECS prend uniquement en charge l'enregistrement des services dans des espaces de noms DNS privés. Lorsqu'un espace de noms DNS AWS Cloud Map privé est créé, une zone hébergée privée Route 53 est créée automatiquement.
+ Les attributs DNS du VPC doivent être configurés pour une résolution DNS réussie. Pour plus d'informations sur la configuration des attributs, consultez [Attributs DNS dans votre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) dans le *Guide de l'utilisateur Amazon VPC*.
+ Amazon ECS ne prend pas en charge l'enregistrement de services dans des AWS Cloud Map espaces de noms partagés.
+ Les registres DNS créés pour un service de découverte de service sont toujours enregistrés avec l'adresse IP privée de la tâche et non pas l'adresse IP publique, même lorsque des espaces de noms publics sont utilisés.
+ La découverte de service exige que les tâches spécifient le mode réseau `awsvpc`, `bridge` ou `host` (`none` n'est pas pris en charge).
+ Si la définition de tâche du service utilise le mode réseau `awsvpc`, vous pouvez créer n’importe quelle combinaison d’enregistrements `A` ou `SRV` pour chaque tâche de service. Si vous utilisez des enregistrements `SRV`, un port est requis. Vous pouvez également créer des enregistrements `AAAA` si le service utilise des sous-réseaux à double pile. Si le service utilise IPv6 uniquement des sous-réseaux, vous ne pouvez pas créer `A` d'enregistrements.
+ Si la définition de tâche du service utilise le mode réseau `bridge` ou `host`, un registre SRV est le seul type de registre DNS pris en charge. Créez un registre SRV pour chaque tâche de service. Le registre SRV doit spécifier une combinaison de nom de conteneur et de port de conteneur à partir de la définition de tâche.
+ Vous pouvez interroger les registres DNS pour un service de découverte de service au sein de votre VPC. Ces enregistrements utilisent le format suivant : `.`.
+ Lors de l’exécution d’une requête DNS sur le nom du service, les enregistrements `A` et `AAAA` renvoient un ensemble d’adresses IP correspondant à vos tâches. Les enregistrements `SRV` renvoient un ensemble d’adresses IP et de ports pour chaque tâche.
+ Si vous disposez de huit registres sains ou moins, Route 53 répond à toutes les requêtes DNS par tous les registres sains.
+ Lorsque tous les registres sont non sains, Route 53 répond à toutes les requêtes DNS par jusqu'à huit registres non sains.
+ Vous pouvez configurer la découverte de service pour un service situé derrière un équilibreur de charge, mais le trafic de découverte de service est toujours acheminé vers la tâche et non pas vers l'équilibreur de charge.
+ La découverte de service ne prend pas en charge l'utilisation des équilibreurs de charge Classic Load Balancer.
+ Nous vous recommandons d'utiliser les surveillances de l'état au niveau des conteneurs gérés par Amazon ECS pour votre service de découverte de service.
+ **HealthCheckCustomConfig**—Amazon ECS gère les bilans de santé en votre nom. Amazon ECS utilise les informations obtenues par le conteneur et les surveillances de l'état, et l'état de votre tâche, afin de mettre à jour l'état avec AWS Cloud Map. Cette configuration est spécifiée à l'aide du paramètre `--health-check-custom-config` au moment de la création de votre service de découverte de service. Pour plus d’informations, consultez [HealthCheckCustomConfig](https://docs.aws.amazon.com/cloud-map/latest/api/API_HealthCheckCustomConfig.html) dans la *Référence d’API AWS Cloud Map *.
+ Les AWS Cloud Map ressources créées lors de l'utilisation de la découverte de services doivent être nettoyées manuellement.
+ Les tâches et les instances sont enregistrées comme `UNHEALTHY` jusqu’à ce que la surveillance de l’état du conteneur renvoie une valeur. Si les surveillances de l’état réussissent, le statut est mis à jour à `HEALTHY`. Si la surveillance de l’état du conteneur échoue, l’enregistrement de l’instance de découverte de service est annulé.
## Tarification de la découverte de service
Les clients utilisant la découverte de service Amazon ECS service sont facturés pour les ressources Route 53 et les opérations d'API de découverte AWS Cloud Map . Le montant facturé englobe les coûts associés à la création des zones hébergées Route 53 et des requêtes sur le registre de services. Pour plus d'informations, consultez [Tarification AWS Cloud Map](https://docs.aws.amazon.com/cloud-map/latest/dg/cloud-map-pricing.html) dans le *Guide du développeur AWS Cloud Map *.
Amazon ECS effectue des contrôles de santé au niveau des conteneurs et les expose à des opérations d'API de vérification d'état AWS Cloud Map personnalisées. Ceci est actuellement mis à la disposition des clients sans frais supplémentaires. Si vous configurez des surveillances de l'état du réseau supplémentaires pour les tâches exposées publiquement, vous êtes facturé pour ces surveillances de l'état.
# Création d’un service Amazon ECS qui utilise la découverte de service
Découvrez comment créer un service contenant une tâche Fargate qui utilise la découverte de service avec l’ AWS CLI.
Pour obtenir la liste de Régions AWS ces services d'assistance découverts, consultez[Utilisation de la découverte de service pour connecter les services Amazon ECS avec des noms DNS](service-discovery.md).
Pour de plus amples informations sur les Régions qui prennent en charge Fargate, veuillez consulter [Régions prises en charge pour Amazon ECS sur AWS Fargate](AWS_Fargate-Regions.md).
**Note**
Vous pouvez utiliser des points de terminaison de service à double pile pour interagir avec Amazon ECS à partir de AWS CLI SDKs, et de l'API Amazon ECS via les deux IPv4 et. IPv6 Pour de plus amples informations, veuillez consulter [Utilisation des points de terminaison à double pile Amazon ECS](dual-stack-endpoint.md).
## Conditions préalables
Avant de commencer ce didacticiel, vérifiez que vous respectez les conditions requises suivantes :
+ La dernière version du AWS CLI est installée et configurée. Pour plus d’informations, consultez la section [Installation ou mise à jour de la version la plus récente de l’ AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Les étapes décrites dans [Configurer l'utilisation d'Amazon ECS](get-set-up-for-amazon-ecs.md) sont terminées.
+ Votre utilisateur IAM dispose des autorisations requises spécifiées dans l’exemple de politique IAM [Amazon ECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess).
+ Vous avez créé au moins un VPC et un groupe de sécurité. Pour de plus amples informations, veuillez consulter [Créer un Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).
## Étape 1 : créer les ressources Service Discovery dans AWS Cloud Map
Suivez ces étapes suivantes pour créer votre espace de noms de découverte de service et votre service de découverte de service :
1. Créez un espace de noms de découverte de service Cloud Map privé. Cet exemple crée un espace de noms appelé `tutorial`. *vpc-abcd1234*Remplacez-le par l'identifiant de l'un de vos identifiants existants VPCs.
```
aws servicediscovery create-private-dns-namespace \
--name tutorial \
--vpc vpc-abcd1234
```
La sortie de cette commande est la suivante.
```
{
"OperationId": "h2qe3s6dxftvvt7riu6lfy2f6c3jlhf4-je6chs2e"
}
```
1. À l'aide du paramètre `OperationId` obtenu à partir de la sortie de l'étape précédente, vérifiez que l'espace de noms privés a bien été créé. Notez l'ID de l'espace de noms car vous l'utiliserez dans les commandes suivantes.
```
aws servicediscovery get-operation \
--operation-id h2qe3s6dxftvvt7riu6lfy2f6c3jlhf4-je6chs2e
```
La sortie est la suivante.
```
{
"Operation": {
"Id": "h2qe3s6dxftvvt7riu6lfy2f6c3jlhf4-je6chs2e",
"Type": "CREATE_NAMESPACE",
"Status": "SUCCESS",
"CreateDate": 1519777852.502,
"UpdateDate": 1519777856.086,
"Targets": {
"NAMESPACE": "ns-uejictsjen2i4eeg"
}
}
}
```
1. En utilisant l'ID `NAMESPACE` indiqué dans la sortie de l'étape précédente, créez un service de découverte de service. Cet exemple crée un service nommé `myapplication`. Notez l'ID du service et l'ARN car vous les utiliserez dans les commandes suivantes.
```
aws servicediscovery create-service \
--name myapplication \
--dns-config "NamespaceId="ns-uejictsjen2i4eeg",DnsRecords=[{Type="A",TTL="300"}]" \
--health-check-custom-config FailureThreshold=1
```
La sortie est la suivante.
```
{
"Service": {
"Id": "srv-utcrh6wavdkggqtk",
"Arn": "arn:aws:servicediscovery:region:aws_account_id:service/srv-utcrh6wavdkggqtk",
"Name": "myapplication",
"DnsConfig": {
"NamespaceId": "ns-uejictsjen2i4eeg",
"DnsRecords": [
{
"Type": "A",
"TTL": 300
}
]
},
"HealthCheckCustomConfig": {
"FailureThreshold": 1
},
"CreatorRequestId": "e49a8797-b735-481b-a657-b74d1d6734eb"
}
}
```
## Étape 2 : Créer les ressources Amazon ECS
Suivez ces étapes pour créer votre cluster, votre définition de tâche et votre service Amazon ECS service :
1. Créez un nouveau cluster Amazon ECS. Cet exemple crée un cluster appelé `tutorial`.
```
aws ecs create-cluster \
--cluster-name tutorial
```
1. Enregistrez une définition de tâche compatible avec Fargate et qui utilise le mode réseau `awsvpc`. Procédez comme suit :
1. Créez un fichier nommé `fargate-task.json` avec le contenu de la définition de tâche suivante.
```
{
"family": "tutorial-task-def",
"networkMode": "awsvpc",
"containerDefinitions": [
{
"name": "sample-app",
"image": "public.ecr.aws/docker/library/httpd:2.4",
"portMappings": [
{
"containerPort": 80,
"hostPort": 80,
"protocol": "tcp"
}
],
"essential": true,
"entryPoint": [
"sh",
"-c"
],
"command": [
"/bin/sh -c \"echo ' Amazon ECS Sample App Amazon ECS Sample App
Congratulations!
Your application is now running on a container in Amazon ECS.
' > /usr/local/apache2/htdocs/index.html && httpd-foreground\""
]
}
],
"requiresCompatibilities": [
"FARGATE"
],
"cpu": "256",
"memory": "512"
}
```
1. Enregistrez la définition de tâche en utilisant `fargate-task.json`.
```
aws ecs register-task-definition \
--cli-input-json file://fargate-task.json
```
1. Créez un service ECS en procédant comme suit :
1. Créez un fichier nommé `ecs-service-discovery.json` avec le contenu du service ECS que vous créez. Cet exemple utilise la définition de tâche créée à l'étape précédente. Le paramètre `awsvpcConfiguration` est obligatoire, car l'exemple de définition de tâche utilise le mode réseau `awsvpc`.
Lorsque vous créez le service ECS, spécifiez le type de lancement Fargate et la version de plateforme `LATEST`, qui prend en charge la fonction de découverte de service. Lorsque le service de découverte de service est créé dans AWS Cloud Map , `registryArn` est l'ARN renvoyé. Les `securityGroups` et les `subnets` doivent appartenir au VPC utilisé pour créer l'espace de noms Cloud Map. Vous pouvez obtenir le groupe de sécurité et le sous-réseau IDs depuis la console Amazon VPC.
```
{
"cluster": "tutorial",
"serviceName": "ecs-service-discovery",
"taskDefinition": "tutorial-task-def",
"serviceRegistries": [
{
"registryArn": "arn:aws:servicediscovery:region:aws_account_id:service/srv-utcrh6wavdkggqtk"
}
],
"launchType": "FARGATE",
"platformVersion": "LATEST",
"networkConfiguration": {
"awsvpcConfiguration": {
"assignPublicIp": "ENABLED",
"securityGroups": [ "sg-abcd1234" ],
"subnets": [ "subnet-abcd1234" ]
}
},
"desiredCount": 1
}
```
1. Créez votre service ECS à l'aide du `ecs-service-discovery.json`.
```
aws ecs create-service \
--cli-input-json file://ecs-service-discovery.json
```
## Étape 3 : vérifier la découverte du service dans AWS Cloud Map
Vous pouvez vérifier que tout est bien créé en interrogeant les informations associées à la fonction de découverte de service. Une fois la découverte des services configurée, vous pouvez soit utiliser des opérations d' AWS Cloud Map API, soit effectuer un appel `dig` depuis une instance au sein de votre VPC. Procédez comme suit :
1. À l'aide de l'ID de service de découverte de service, répertoriez les instances de découverte de service. Notez l'ID de l'instance (en gras) pour le nettoyage des ressources.
```
aws servicediscovery list-instances \
--service-id srv-utcrh6wavdkggqtk
```
La sortie est la suivante.
```
{
"Instances": [
{
"Id": "16becc26-8558-4af1-9fbd-f81be062a266",
"Attributes": {
"AWS_INSTANCE_IPV4": "172.31.87.2"
"AWS_INSTANCE_PORT": "80",
"AVAILABILITY_ZONE": "us-east-1a",
"REGION": "us-east-1",
"ECS_SERVICE_NAME": "ecs-service-discovery",
"ECS_CLUSTER_NAME": "tutorial",
"ECS_TASK_DEFINITION_FAMILY": "tutorial-task-def"
}
}
]
}
```
1. Utilisez l'espace de noms, le service et les paramètres supplémentaires tels que le nom du cluster ECS pour demander des informations détaillées sur les instances de la fonction de découverte de service.
```
aws servicediscovery discover-instances \
--namespace-name tutorial \
--service-name myapplication \
--query-parameters ECS_CLUSTER_NAME=tutorial
```
1. Vous pouvez interroger les registres DNS créés dans la zone hébergée Route 53 de votre service de découverte de service à l'aide des commandes AWS CLI suivantes :
1. À l'aide de l'ID de l'espace de noms, obtenez les informations relatives à l'espace de noms, lesquelles incluent l'ID de la zone hébergée Route 53.
```
aws servicediscovery \
get-namespace --id ns-uejictsjen2i4eeg
```
La sortie est la suivante.
```
{
"Namespace": {
"Id": "ns-uejictsjen2i4eeg",
"Arn": "arn:aws:servicediscovery:region:aws_account_id:namespace/ns-uejictsjen2i4eeg",
"Name": "tutorial",
"Type": "DNS_PRIVATE",
"Properties": {
"DnsProperties": {
"HostedZoneId": "Z35JQ4ZFDRYPLV"
}
},
"CreateDate": 1519777852.502,
"CreatorRequestId": "9049a1d5-25e4-4115-8625-96dbda9a6093"
}
}
```
1. À l'aide de l'ID de zone hébergée Route 53 de l'étape précédente (voir le texte en gras), obtenez l'enregistrement de ressource défini pour la zone hébergée.
```
aws route53 list-resource-record-sets \
--hosted-zone-id Z35JQ4ZFDRYPLV
```
1. Vous pouvez également interroger le DNS à partir d'une instance de votre VPC à l'aide de `dig`.
```
dig +short myapplication.tutorial
```
## Étape 4 : nettoyer
Une fois que vous avez terminé ce didacticiel, nettoyez les ressources qui lui sont associées afin d'éviter la facturation de frais pour des ressources inutilisées. Procédez comme suit :
1. Annulez l'enregistrement des instances de service de découverte de service à l'aide de l'ID de service et de l'ID de l'instance que vous avez notés précédemment.
```
aws servicediscovery deregister-instance \
--service-id srv-utcrh6wavdkggqtk \
--instance-id 16becc26-8558-4af1-9fbd-f81be062a266
```
La sortie est la suivante.
```
{
"OperationId": "xhu73bsertlyffhm3faqi7kumsmx274n-jh0zimzv"
}
```
1. À l'aide du `OperationId` indiqué dans la sortie de l'étape précédente, vérifiez que l'inscription des instances du service de découverte de service ont été correctement annulées.
```
aws servicediscovery get-operation \
--operation-id xhu73bsertlyffhm3faqi7kumsmx274n-jh0zimzv
```
```
{
"Operation": {
"Id": "xhu73bsertlyffhm3faqi7kumsmx274n-jh0zimzv",
"Type": "DEREGISTER_INSTANCE",
"Status": "SUCCESS",
"CreateDate": 1525984073.707,
"UpdateDate": 1525984076.426,
"Targets": {
"INSTANCE": "16becc26-8558-4af1-9fbd-f81be062a266",
"ROUTE_53_CHANGE_ID": "C5NSRG1J4I1FH",
"SERVICE": "srv-utcrh6wavdkggqtk"
}
}
}
```
1. Supprimez le service de découverte de service en utilisant l'ID du service.
```
aws servicediscovery delete-service \
--id srv-utcrh6wavdkggqtk
```
1. Supprimer l'espace de noms de découverte de service en utilisant l'ID de l'espace de noms.
```
aws servicediscovery delete-namespace \
--id ns-uejictsjen2i4eeg
```
La sortie est la suivante.
```
{
"OperationId": "c3ncqglftesw4ibgj5baz6ktaoh6cg4t-jh0ztysj"
}
```
1. À l'aide du `OperationId` indiqué dans la sortie de l'étape précédente, vérifiez que l'espace de noms de la découverte de service a été correctement supprimé.
```
aws servicediscovery get-operation \
--operation-id c3ncqglftesw4ibgj5baz6ktaoh6cg4t-jh0ztysj
```
La sortie est la suivante.
```
{
"Operation": {
"Id": "c3ncqglftesw4ibgj5baz6ktaoh6cg4t-jh0ztysj",
"Type": "DELETE_NAMESPACE",
"Status": "SUCCESS",
"CreateDate": 1525984602.211,
"UpdateDate": 1525984602.558,
"Targets": {
"NAMESPACE": "ns-rymlehshst7hhukh",
"ROUTE_53_CHANGE_ID": "CJP2A2M86XW3O"
}
}
}
```
1. Définissez le nombre souhaité pour le service Amazon ECS sur `0`. Vous devez effectuer cette étape pour supprimer le service à l'étape suivante.
```
aws ecs update-service \
--cluster tutorial \
--service ecs-service-discovery \
--desired-count 0
```
1. Supprimez l'Amazon ECS service.
```
aws ecs delete-service \
--cluster tutorial \
--service ecs-service-discovery
```
1. Supprimez le cluster Amazon ECS.
```
aws ecs delete-cluster \
--cluster tutorial
```
# Utilisez Amazon VPC Lattice pour connecter, observer et sécuriser vos services Amazon ECS
Amazon VPC Lattice est un service de mise en réseau d'applications entièrement géré qui permet aux clients d'Amazon ECS d'observer, de sécuriser et de surveiller les applications basées sur des services AWS informatiques et des comptes VPCs, sans avoir à modifier le code.
VPC Lattice utilise des groupes cibles, qui sont un ensemble de ressources de calcul. Ces cibles exécutent votre application ou votre service et peuvent être des instances Amazon EC2, des adresses IP, des fonctions Lambda et des équilibreurs de charge d'application. En associant leurs services Amazon ECS à un groupe cible VPC Lattice, les clients peuvent désormais activer les tâches Amazon ECS en tant que cibles IP dans VPC Lattice. Amazon ECS enregistre automatiquement les tâches auprès du groupe cible VPC Lattice lorsque les tâches du service enregistré sont lancées.
**Note**
Lorsque vous utilisez cinq configurations VPC Lattice, votre temps de déploiement peut être légèrement plus long que lorsque vous utilisez moins de configurations.
Une règle d’écoute est utilisée pour transférer le trafic vers un groupe cible spécifié lorsque les conditions sont remplies. Un écouteur vérifie les requêtes de connexion à l’aide du protocole sur le port que vous avez configuré. Un service achemine les requêtes vers ses cibles enregistrées en fonction des règles que vous définissez lors de la configuration de votre écouteur.
Amazon ECS remplace également automatiquement une tâche si elle devient défectueuse selon les surveillances de l’état de VPC Lattice. Une fois associés à VPC Lattice, les clients d'Amazon ECS peuvent également tirer parti des nombreuses autres fonctionnalités de connectivité, de sécurité et d'observabilité entre ordinateurs de VPC Lattice, telles que la connexion aux services entre clusters et comptes AWS Resource Access Manager avec VPCs, l'intégration IAM pour l'autorisation et l'authentification, et les fonctionnalités avancées de gestion du trafic.
Les avantages de VPC Lattice pour les clients Amazon ECS sont les suivants.
+ Productivité accrue des développeurs : VPC Lattice améliore la productivité des développeurs en vous permettant de vous concentrer sur la création de fonctionnalités, tandis que VPC Lattice gère les défis liés au réseau, à la sécurité et à l’observabilité de manière uniforme sur toutes les plateformes de calcul.
+ Meilleure posture de sécurité : VPC Lattice permet à vos développeurs d’authentifier et de sécuriser facilement les communications entre les applications et les plateformes informatiques, d’appliquer le chiffrement en transit et de mettre en place des contrôles d’accès granulaires grâce aux politiques d’authentification VPC Lattice. Cela vous permet d’adopter une posture de sécurité renforcée qui répond aux principales exigences réglementaires et de conformité du secteur.
+ Capacité de mise à l’échelle et résilience améliorées des applications : VPC Lattice vous permet de créer un réseau d’applications déployées avec des fonctionnalités telles que le routage, l’authentification, l’autorisation et la surveillance basés sur les chemins, les en-têtes et les méthodes. Ces avantages sont fournis sans frais supplémentaires en termes de ressources sur les charges de travail et peuvent prendre en charge des déploiements multiclusters générant des millions de requêtes par seconde sans ajouter de latence significative.
+ Flexibilité de déploiement grâce à une infrastructure hétérogène : VPC Lattice fournit des fonctionnalités cohérentes sur tous les services de calcul tels qu’Amazon ECS, Fargate, Amazon EC2, Amazon EKS et Lambda. permettant à votre organisation de choisir l’infrastructure adaptée à chaque application.
## Comment VPC Lattice fonctionne avec les autres services Amazon ECS
L’utilisation de VPC Lattice avec Amazon ECS peut modifier la façon dont vous utilisez d’autres services Amazon ECS, tandis que d’autres restent inchangés.
**Application Load Balancers**
Vous n’avez plus besoin de créer un Application Load Balancer spécifique devant être utilisé avec le type de groupe cible Application Load Balancer dans VPC Lattice, qui est ensuite lié au service Amazon ECS. Au lieu de cela, il vous suffit de configurer votre service Amazon ECS avec un groupe cible VPC Lattice. Vous pouvez également choisir d’utiliser Application Load Balancer avec Amazon ECS en même temps.
**Déploiements propagés Amazon ECS**
Seuls les déploiements propagés Amazon ECS fonctionnent avec VPC Lattice, et Amazon ECS introduit des tâches dans les services et les supprime en toute sécurité pendant le déploiement. Le déploiement du code et les Blue/Green déploiements ne sont pas pris en charge.
Pour en savoir plus sur VPC Lattice, consultez le [Guide de l’utilisateur Amazon VPC Lattice](https://docs.aws.amazon.com/vpc-lattice/latest/ug/what-is-vpc-lattice.html).
# Création d'un service utilisant VPC Lattice
Vous pouvez utiliser le AWS Management Console ou le AWS CLI pour créer un service avec VPC Lattice.
## Conditions préalables
Avant de commencer ce didacticiel, vérifiez que vous respectez les conditions requises suivantes :
+ La dernière version du AWS CLI est installée et configurée. Pour plus d’informations, consultez [Installing the AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html) (Installation de).
**Note**
Vous pouvez utiliser des points de terminaison de service à double pile pour interagir avec Amazon ECS à partir de AWS CLI SDKs, et de l'API Amazon ECS via les deux IPv4 et. IPv6 Pour de plus amples informations, veuillez consulter [Utilisation des points de terminaison à double pile Amazon ECS](dual-stack-endpoint.md).
+ Les étapes décrites dans [Configurer l'utilisation d'Amazon ECS](get-set-up-for-amazon-ecs.md) sont terminées.
+ Votre utilisateur IAM dispose des autorisations requises spécifiées dans l’exemple de politique IAM [Amazon ECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess).
## Créez un service qui utilise VPC Lattice avec AWS Management Console
Procédez comme suit pour créer un service avec VPC Lattice à l’aide de l’ AWS Management Console.
1. Ouvrez la console à la [https://console.aws.amazon.com/ecs/version 2](https://console.aws.amazon.com/ecs/v2).
1. Dans la page de navigation, choisissez **Clusters**.
1. Sur la page **Clusters**, choisissez le cluster dans lequel créer le service.
1. Sous l'onglet **Services** choisissez **Create** (Créer).
Si vous n’avez jamais créé de service auparavant, suivez les étapes décrites dans [Création d’un service Amazon ECS à l’aide de la console](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html), puis poursuivez ces étapes lorsque vous atteignez la section VPC Lattice.
1. Choisissez **Activer le réseau VPC** en cochant le bouton.
1. Pour utiliser un rôle existant, pour **Rôle d’infrastructure ECS pour Amazon ECS**, choisissez-en un que vous avez déjà créé pour l’utiliser lors de la création du groupe cible VPC Lattice. Pour créer un rôle, **Créer un rôle d’infrastructure ECS**.
1. Choisissez le **VPC**.
Le **VPC** dépend du mode réseau que vous avez sélectionné lors de l’enregistrement de votre définition de tâche. Si vous utilisez le mode `host` ou `network` avec EC2, choisissez votre VPC.
Pour le mode `awsvpc`, le VPC est automatiquement sélectionné en fonction du VPC que vous avez choisi sous **Mise en réseau** et ne peut pas être modifié.
1. Sous **Groupes cibles**, sélectionnez le ou les groupes cibles. Vous devez choisir au moins un groupe cible et pouvez en avoir jusqu’à cinq. Sélectionnez **Ajouter un groupe cible** pour ajouter d’autres groupes cibles. Choisissez le **Nom du port**, le **Protocole** et le **Port** pour chaque groupe cible que vous avez choisi. Pour supprimer un groupe cible, sélectionnez **Supprimer**.
**Note**
Si vous souhaitez ajouter un groupe cible existant, vous devez utiliser l’ AWS CLI. *Pour obtenir des instructions sur la façon d'ajouter des groupes cibles à l'aide de AWS CLI, voir [register-targets](https://docs.aws.amazon.com/cli/latest/reference/vpc-lattice/register-targets.html) dans la AWS Command Line Interface référence.*
Bien qu’un service VPC Lattice puisse avoir plusieurs groupes cibles, chaque groupe cible ne peut être ajouté qu’à un seul service.
Pour créer un service dans une configuration IPv6 uniquement, choisissez des groupes cibles avec un type d'adresse IP de`IPv6`.
1. À ce stade, vous accédez à la console VPC Lattice pour poursuivre la configuration. C’est ici que vous incluez vos nouveaux groupes cibles dans l’action par défaut de l’écouteur ou dans les règles d’un service VPC Lattice existant.
Pour plus d’informations, consultez la section [Règles d’écoute pour votre service VPC Lattice](https://docs.aws.amazon.com/vpc-lattice/latest/ug/listener-rules.html).
**Important**
Vous devez autoriser le préfixe de règle de trafic entrant `vpc-lattice` à accéder à votre groupe de sécurité, sinon les tâches et la surveillance de l’état échoueront.
## Créez un service qui utilise VPC Lattice avec AWS CLI
Utilisez le AWS CLI pour créer un service avec VPC Lattice. Remplacez chaque *user input placeholder* par vos propres informations.
1. Créez un fichier de configuration de groupe cible. L’exemple suivant est nommé `tg-config.json`
```
{
"ipAddressType": "IPV4",
"port": 443,
"protocol": "HTTPS",
"protocolVersion": "HTTP1",
"vpcIdentifier": "vpc-f1663d9868EXAMPLE"
}
```
1. Utilisez la commande suivante pour créer un groupe cible VPC Lattice.
```
aws vpc-lattice create-target-group \
--name my-lattice-target-group-ip \
--type IP \
--config file://tg-config.json
```
**Note**
Pour créer un service dans une configuration IPv6 uniquement, créez des groupes cibles avec un type d'adresse IP de`IPv6`. Pour plus d’informations, consultez [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/vpc-lattice/create-target-group.html) dans la *Référence des commandes de l’AWS CLI *.
Exemple de sortie :
```
{
"arn": "arn:aws:vpc-lattice:us-east-2:123456789012:targetgroup/tg-0eaa4b9ab4EXAMPLE",
"config": {
"healthCheck": {
"enabled": true,
"healthCheckIntervalSeconds": 30,
"healthCheckTimeoutSeconds": 5,
"healthyThresholdCount": 5,
"matcher": {
"httpCode": "200"
},
"path": "/",
"protocol": "HTTPS",
"protocolVersion": "HTTP1",
"unhealthyThresholdCount": 2
},
"ipAddressType": "IPV4",
"port": 443,
"protocol": "HTTPS",
"protocolVersion": "HTTP1",
"vpcIdentifier": "vpc-f1663d9868EXAMPLE"
},
"id": "tg-0eaa4b9ab4EXAMPLE",
"name": "my-lattice-target-group-ip",
"status": "CREATE_IN_PROGRESS",
"type": "IP"
}
```
1. Le fichier JSON suivant *ecs-service-vpc-lattice.json* est un exemple utilisé pour associer un service Amazon ECS à un groupe cible VPC Lattice. Le `portName` dans l’exemple ci-dessous est le même que celui que vous avez défini dans le champ `name` de la propriété `portMappings` de votre définition de tâche.
```
{
"serviceName": "ecs-service-vpc-lattice",
"taskDefinition": "ecs-task-def",
"vpcLatticeConfigurations": [
{
"targetGroupArn": "arn:aws:vpc-lattice:us-west-2:123456789012:targetgroup/tg-0eaa4b9ab4EXAMPLE",
"portName": "testvpclattice",
"roleArn": "arn:aws:iam::123456789012:role/ecsInfrastructureRoleVpcLattice"
}
],
"desiredCount": 5,
"role": "ecsServiceRole"
}
```
Utilisez la commande suivante pour créer un service Amazon ECS et l’associer au groupe cible VPC Lattice à l’aide de l’exemple json ci-dessus.
```
aws ecs create-service \
--cluster clusterName \
--serviceName ecs-service-vpc-lattice \
--cli-input-json file://ecs-service-vpc-lattice.json
```
**Note**
VPC Lattice n’est pas pris en charge sur Amazon ECS Anywhere.