```
# Configurazione di Amazon ECS Service Connect con AWS CLI
È possibile creare un servizio Amazon ECS per un'attività Fargate che usa Service Connect con la AWS CLI.
**Nota**
Puoi utilizzare gli endpoint del servizio dual-stack per interagire con Amazon ECS da AWS CLI, SDKs e l'API Amazon ECS su entrambi e. IPv4 IPv6 Per ulteriori informazioni, consulta [Utilizzo degli endpoint dual-stack Amazon ECS](dual-stack-endpoint.md).
## Prerequisiti
Di seguito sono riportati i prerequisiti di Service Connect:
+ Verifica che sia installata e configurata la versione più recente di. AWS CLI Per ulteriori informazioni, consultare [Installing or updating to the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ L'utente IAM dispone delle autorizzazioni necessarie specificate nell'esempio di policy IAM [AmazonECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess).
+ Sono disponibili un VPC, una sottorete, una tabella di instradamento e un gruppo di sicurezza creati per l'uso. Per ulteriori informazioni, consultare [Crea un cloud privato virtuale](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ Hai un ruolo di esecuzione delle attività con il nome `ecsTaskExecutionRole` e la policy gestita da `AmazonECSTaskExecutionRolePolicy` è associata al ruolo. Questo ruolo consente a Fargate di scrivere i log delle applicazioni NGINX e i log del proxy Service Connect su Amazon Logs. CloudWatch Per ulteriori informazioni, consulta [Creazione del ruolo di esecuzione attività](task_execution_IAM_role.md#create-task-execution-role).
## Fase 1: Creazione del cluster
Utilizzare la procedura seguente per creare un cluster e un namespace Amazon ECS.
**Per creare il cluster e AWS Cloud Map lo spazio dei nomi Amazon ECS**
1. Crea un cluster Amazon ECS denominato `tutorial` da utilizzare. Il parametro `--service-connect-defaults` imposta il namespace predefinito del cluster. Nell'output di esempio, uno AWS Cloud Map spazio dei nomi con il nome `service-connect` non esiste in questo account e Regione AWS quindi lo spazio dei nomi viene creato da Amazon ECS. Il namespace è creato in AWS Cloud Map nell'account ed è visibile insieme a tutti gli altri spazi dei nomi, quindi utilizza un nome che ne indichi lo scopo.
```
aws ecs create-cluster --cluster-name tutorial --service-connect-defaults namespace=service-connect
```
Output:
```
{
"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. Verifica che il cluster sia stato creato:
```
aws ecs describe-clusters --clusters tutorial
```
Output:
```
{
"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. (Facoltativo) Verifica che lo spazio dei nomi sia stato creato in. AWS Cloud MapÈ possibile utilizzare la configurazione Console di gestione AWS o la AWS CLI configurazione normale così come viene creata in. AWS Cloud Map
Ad esempio, utilizza la AWS CLI.
```
aws servicediscovery get-namespace --id ns-EXAMPLE
```
Output:
```
{
"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"
}
}
```
## Fase 2: Creazione del servizio per il server
La funzionalità Service Connect è progettata per l'interconnessione di più applicazioni su Amazon ECS. Almeno una di queste applicazioni deve fornire un servizio Web a cui connettersi. In questa fase viene creata:
+ La definizione dell'attività che utilizza l'immagine del container NGINX ufficiale non modificata e include la configurazione di Service Connect.
+ La definizione del servizio Amazon ECS che configura Service Connect per fornire il rilevamento servizi e il mesh di servizi che indirizza il traffico verso questo servizio. La configurazione riutilizza il namespace predefinito della configurazione del cluster per ridurre la quantità di operazioni di configurazione del servizio effettuata per ciascun servizio.
+ Il servizio Amazon ECS. Esegue un'attività utilizzando la definizione di attività e inserisce un container aggiuntivo per il proxy Service Connect. Il proxy Service Connect è in ascolto sulla porta dalla mappatura della porta del container nella definizione di attività. In un'applicazione client in esecuzione su Amazon ECS, il proxy nell'attività client ascolta le connessioni in uscita al nome della porta di definizione dell'attività, al nome della porta di individuazione del servizio o al nome alias del client del servizio e al numero di porta dall'alias del client.
**Creazione del servizio Web con Service Connect**
1. Registra una definizione di attività che sia compatibile con Fargate e utilizzi la modalità di rete `awsvpc`. Completare la procedura riportata di seguito.
1. Crea un file denominato `service-connect-nginx.json` con il contenuto della seguente definizione di attività.
Questa definizione di attività configura Service Connect aggiungendo i parametri `name` e `appProtocol` alla mappatura delle porte. Il nome della porta rende questa porta più identificabile nella configurazione del servizio quando vengono utilizzate più porte. Il nome della porta viene utilizzato anche per impostazione predefinita come nome individuabile per essere utilizzato da altre applicazioni nel namespace.
La definizione dell'attività contiene il ruolo IAM dell'attività perché il servizio ha abilitato l'esecuzione ECS.
**Importante**
Questa definizione di attività utilizza `logConfiguration` a per inviare l'output nginx da `stdout` e `stderr` verso Amazon Logs. CloudWatch Questo ruolo di esecuzione delle attività non dispone delle autorizzazioni aggiuntive necessarie per creare il CloudWatch gruppo di log Logs. Crea il gruppo di log in CloudWatch Logs utilizzando o. Console di gestione AWS AWS CLI Se non desideri inviare i log di nginx a Logs, puoi rimuovere CloudWatch il. `logConfiguration`
Sostituisci l' Account AWS id nel ruolo di esecuzione dell'attività con il tuo id. Account AWS
```
{
"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. Registra la definizione di attività usando il file `service-connect-nginx.json`:
```
aws ecs register-task-definition --cli-input-json file://service-connect-nginx.json
```
1. Creare un servizio:
1. Crea un file denominato `service-connect-nginx-service.json` con il contenuto del servizio Amazon ECS che stai per creare. Questo esempio usa la definizione di attività creata nella fase precedente. È obbligatorio l'uso di un parametro `awsvpcConfiguration` perché la definizione di attività di esempio usa la modalità di rete `awsvpc`.
Quando si crea il servizio ECS, specificare Fargate e la versione della piattaforma `LATEST` che supporta Service Connect. I `securityGroups` e le `subnets` devono appartenere a un cloud VPC che soddisfi i requisiti per l'utilizzo di Amazon ECS. Puoi ottenere il gruppo di sicurezza e la sottorete IDs dalla console Amazon VPC.
Questo servizio configura Service Connect aggiungendo il parametro `serviceConnectConfiguration`. Il namespace non è richiesto perché il cluster ha un namespace predefinito configurato. Le applicazioni client in esecuzione in ECS nel namespace si connettono a questo servizio utilizzando il `portName` e la porta negli `clientAliases`. Ad esempio, questo servizio è raggiungibile tramite `http://nginx:80/`, poiché nginx fornisce una pagina di benvenuto nella posizione root `/`. Le applicazioni esterne che non sono in esecuzione in Amazon ECS o che non si trovano nello stesso namespace possono raggiungere questa applicazione tramite il proxy Service Connect utilizzando l'indirizzo IP dell'attività e il numero di porta indicato nella definizione dell'attività. Per la configurazione di `tls`, aggiungere il certificato `arn` per il `awsPcaAuthorityArn`, `kmsKey` e `roleArn` del ruolo IAM.
Questo servizio utilizza un `logConfiguration` per inviare l'output del proxy Service Connect da `stdout` e `stderr` verso Amazon CloudWatch Logs. Questo ruolo di esecuzione delle attività non dispone delle autorizzazioni aggiuntive necessarie per creare il gruppo di CloudWatch log Logs. Crea il gruppo di log in CloudWatch Logs utilizzando o. Console di gestione AWS AWS CLI Si consiglia di creare questo gruppo di log e di archiviare i log proxy in CloudWatch Logs. Se non desideri inviare i log del proxy a Logs, puoi CloudWatch rimuovere il. `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. Creare un servizio utilizzando il file `service-connect-nginx-service.json`:
```
aws ecs create-service --cluster tutorial --cli-input-json file://service-connect-nginx-service.json
```
Output:
```
{
"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` fornita viene visualizzata all'interno della prima *implementazione* dell'output. Quando apporti modifiche al servizio ECS in modi che richiedono modifiche alle attività, Amazon ECS crea una nuova implementazione.
## Fase 3: Verifica della riuscita della connessione
Per verificare che Service Connect sia configurato e funzionante, completa questa procedura per connetterti al servizio Web da un'applicazione esterna. Quindi, guarda le metriche aggiuntive nelle creazioni CloudWatch del proxy Service Connect.
**Connessione al servizio Web da un'applicazione esterna**
+ Connessione all'indirizzo IP dell'attività e alla porta del container utilizzando l'indirizzo IP dell'attività
Usa il AWS CLI per ottenere l'ID dell'attività, utilizzando. `aws ecs list-tasks --cluster tutorial`
Se le sottoreti e il gruppo di sicurezza consentono il traffico proveniente dalla rete Internet pubblica sulla porta della definizione dell'attività, sarà possibile connettersi all'IP pubblico dal computer. Tuttavia, l'IP pubblico non è disponibile da `describe-tasks`, quindi la procedura prevede di accedere ad Amazon EC2 Console di gestione AWS o AWS CLI ottenere i dettagli dell'interfaccia di rete elastica.
In questo esempio, un'istanza Amazon EC2 nello stesso VPC utilizza l'IP privato dell'attività. L'applicazione è nginx, ma l'intestazione `server: envoy` mostra che viene utilizzato il proxy Service Connect. Il proxy Service Connect è in ascolto sulla porta del container a partire dalla definizione dell'attività.
```
$ 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.
```
**Visualizzazione dei parametri di Service Connect**
Il proxy Service Connect crea metriche dell'applicazione (connessione HTTP HTTP2, gRPC o TCP) nelle metriche. CloudWatch Quando usi la CloudWatch console, visualizza le dimensioni metriche aggiuntive di **DiscoveryName**, (, **DiscoveryName ServiceName, ClusterName**) e (**TargetDiscoveryName**, **TargetDiscoveryName ServiceName, ClusterName**) nello spazio dei nomi Amazon ECS. Per ulteriori informazioni su questi parametri e sulle dimensioni, consulta [Visualizza i parametri disponibili](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/viewing_metrics_with_cloudwatch.html) nella Amazon CloudWatch Logs User Guide.
# Usare il rilevamento servizi per connettere i servizi Amazon ECS con nomi DNS
Il servizio Amazon ECS può facoltativamente essere configurato per l'uso della funzione di individuazione dei servizi di Amazon ECS. Service Discovery utilizza azioni AWS Cloud Map API per gestire i namespace HTTP e DNS per i tuoi servizi Amazon ECS. Per ulteriori informazioni, consultare [What Is AWS Cloud Map](https://docs.aws.amazon.com/cloud-map/latest/dg/Welcome.html) nella *Guida per gli sviluppatori di AWS Cloud Map *.
L'individuazione dei servizi è disponibile nelle seguenti regioni: AWS
| Nome della regione | Regione |
| --- | --- |
| Stati Uniti orientali (Virginia settentrionale) | us-east-1 |
| Stati Uniti orientali (Ohio) | us-east-2 |
| Stati Uniti occidentali (California settentrionale) | us-west-1 |
| US West (Oregon) | us-west-2 |
| Africa (Città del Capo) | af-south-1 |
| Asia Pacific (Hong Kong) | ap-east-1 |
| Asia Pacifico (Taipei) | ap-east-2 |
| Asia Pacifico (Mumbai) | ap-south-1 |
| Asia Pacifico (Hyderabad) | ap-south-2 |
| Asia Pacifico (Tokyo) | ap-northeast-1 |
| Asia Pacifico (Seoul) | ap-northeast-2 |
| Asia Pacifico (Osaka-Locale) | ap-northeast-3 |
| Asia Pacifico (Singapore) | ap-southeast-1 |
| Asia Pacific (Sydney) | ap-southeast-2 |
| Asia Pacifico (Giacarta) | ap-southeast-3 |
| Asia Pacifico (Melbourne) | ap-southeast-4 |
| Asia Pacifico (Malesia) | ap-southeast-5 |
| Asia Pacifico (Nuova Zelanda) | ap-southeast-6 |
| Asia Pacifico (Thailandia) | ap-southeast-7 |
| Canada (Centrale) | ca-central-1 |
| Canada occidentale (Calgary) | ca-west-1 |
| Cina (Pechino) | cn-north-1 |
| China (Ningxia) | cn-northwest-1 |
| Europe (Frankfurt) | eu-central-1 |
| Europa (Zurigo) | eu-central-2 |
| Europa (Irlanda) | eu-west-1 |
| Europe (London) | eu-west-2 |
| Europe (Paris) | eu-west-3 |
| Europe (Milan) | eu-south-1 |
| Europa (Stoccolma) | eu-north-1 |
| Israele (Tel Aviv) | il-central-1 |
| Europa (Spagna) | eu-south-2 |
| Medio Oriente (Emirati Arabi Uniti) | me-central-1 |
| Messico (Centrale) | mx-central-1 |
| Medio Oriente (Bahrein) | me-south-1 |
| Sud America (San Paolo) | sa-east-1 |
| AWS GovCloud (Stati Uniti orientali) | us-gov-east-1 |
| AWS GovCloud (Stati Uniti occidentali) | us-gov-west-1 |
## Concetti relativi all'individuazione dei servizi
L'individuazione dei servizi è costituita dai componenti seguenti:
+ **Namespace di rilevamento servizi**: un raggruppamento logico di servizi di rilevamento dei servizi che condividono lo stesso nome di dominio, ad esempio `example.com`, che rappresenta la posizione in cui si vuole instradare il traffico. È possibile creare un namespace con una chiamata al comando `aws servicediscovery create-private-dns-namespace` o nella console classica di Amazon ECS. È possibile utilizzare il comando `aws servicediscovery list-namespaces` per visualizzare le informazioni di riepilogo dei namespace creati dall'account corrente. Per ulteriori informazioni sui comandi di individuazione dei servizi, vedere `[create-private-dns-namespace](https://docs.aws.amazon.com/cli/latest/reference/servicediscovery/create-private-dns-namespace.html)` e `[list-namespaces](https://docs.aws.amazon.com/cli/latest/reference/servicediscovery/list-namespaces.html)` nella *Guida di AWS CLI riferimento AWS Cloud Map (service discovery)*.
+ **Servizio di individuazione dei servizi**: è incluso nel namespace di individuazione dei servizi ed è costituito dal nome del servizio e dalla configurazione DNS per il namespace. Fornisce il componente principale seguente:
+ **Registro dei servizi**: consente di cercare un servizio tramite azioni DNS o AWS Cloud Map API e recuperare uno o più endpoint disponibili che possono essere utilizzati per connettersi al servizio.
+ **Istanza di individuazione dei servizi**: esiste all'interno del servizio di individuazione dei servizi e include gli attributi associati a ogni servizio Amazon ECS nella directory del servizio.
+ **Attributi dell'istanza**: i metadati seguenti vengono aggiunti come attributi personalizzati per ciascun servizio Amazon ECS configurato per l'utilizzo dell'individuazione dei servizi:
+ **`AWS_INSTANCE_IPV4`**— Per un `A` record, l' IPv4 indirizzo che Route 53 restituisce in risposta alle query DNS e AWS Cloud Map restituisce quando rileva i dettagli dell'istanza, ad esempio. `192.0.2.44`
+ **`AWS_INSTANCE_IPV6`**— Per un `AAAA` record, l' IPv6 indirizzo che Route 53 restituisce in risposta alle query DNS e AWS Cloud Map restituisce quando rileva i dettagli dell'istanza, ad esempio,. ` 2001:0db8:85a3:0000:0000:abcd:0001:2345` Sia `AWS_INSTANCE_IPv4` che `AWS_INSTANCE_IPv6` vengono aggiunti per i servizi dualstack di Amazon ECS. `AWS_INSTANCE_IPv6`Viene aggiunto solo per i servizi IPv6 solo di Amazon ECS.
+ **`AWS_INSTANCE_PORT`**: il valore della porta associato al servizio di individuazione dei servizi.
+ **`AVAILABILITY_ZONE`**: la zona di disponibilità in cui il processo è stato avviato. Per i processi che utilizzano EC2, questa è la zona di disponibilità in cui è presente l'istanza di container. Per i processi che utilizzano Fargate, questa è la zona di disponibilità in cui è presente l'interfaccia di rete elastica.
+ **`REGION`**: la regione in cui è presente il processo.
+ **`ECS_SERVICE_NAME`**: il nome del servizio Amazon ECS a cui appartiene il processo.
+ **`ECS_CLUSTER_NAME`**: il nome del cluster Amazon ECS a cui appartiene il processo.
+ **`EC2_INSTANCE_ID`**: l'ID dell'istanza di container in cui è stata posizionato il processo Questo attributo personalizzato non viene aggiunto se l'attività sta utilizzando Fargate.
+ **`ECS_TASK_DEFINITION_FAMILY`**: la famiglia della definizione di attività utilizzata dal processo.
+ **`ECS_TASK_SET_EXTERNAL_ID`**: se viene creato un set di processi per un'implementazione esterna ed è associato a un registro di individuazione dei servizi, l'attributo `ECS_TASK_SET_EXTERNAL_ID` includerà l'ID esterno del set di processi.
+ **Controlli dell'integrità di Amazon ECS**: Amazon ECS esegue periodicamente controlli dell'integrità a livello di container. Se un endpoint non supera il controllo dello stato, viene rimosso dal routing DNS e contrassegnato come non integro.
## Considerazioni relative all'individuazione dei servizi
Quando usi l'individuazione dei servizi, tieni presenti le considerazioni seguenti:
+ L'individuazione dei servizi è supportata per i processi su Fargate che utilizzano la piattaforma versione 1.1.0 o successiva. Per ulteriori informazioni, consultare [Versioni della piattaforma Fargate per Amazon ECS](platform-fargate.md).
+ I servizi configurati per l'utilizzo del rilevamento dei servizi Amazon ECS hanno un limite di 1.000 processi per servizio. Ciò è dovuto a una quota di servizio Route 53.
+ Il flusso di lavoro Crea servizio nella console Amazon ECS supporta solo la registrazione dei servizi in spazi dei nomi DNS privati. Quando viene creato uno spazio dei nomi DNS AWS Cloud Map privato, verrà creata automaticamente una zona ospitata privata di Route 53.
+ Per la corretta risoluzione DNS, gli attributi DNS del VPC devono essere configurati. Per ulteriori informazioni su come configurare gli attributi, consulta [Supporto DNS nel VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) nella *Guida per l'utente di Amazon VPC*.
+ Amazon ECS non supporta la registrazione di servizi in namespace condivisi AWS Cloud Map .
+ I record DNS creati per un servizio DNS si registrano sempre con l'indirizzo IP privato per il processo piuttosto che l'indirizzo IP pubblico, anche quando vengono utilizzati gli spazi di nomi pubblici.
+ L'individuazione dei servizi richiede che i processi specifichino la modalità di rete `awsvpc`, `bridge` o `host` (`none` non è supportata).
+ Se la definizione di attività del servizio usa la modalità di rete `awsvpc`, puoi creare qualsiasi combinazione di record `A` o `SRV` per ciascuna attività di servizio. Se si utilizzano i record `SRV`, è necessaria una porta. Inoltre, è possibile creare record `AAAA` se il servizio utilizza sottoreti dualstack. Se il servizio utilizza IPv6 solo sottoreti, non puoi creare record. `A`
+ Se la definizione di attività di servizio usa la modalità di rete `bridge` o `host`, un record SRV è il solo tipo di record DNS supportato. Crea un record SRV per ciascuna operazione di servizio. Il record SRV deve specificare un nome di container e una combinazione di porte di container dalla definizione di attività.
+ È possibile eseguire query sui record DNS per un servizio di individuazione dei servizi all'interno del VPC. Viene usato questo formato: `.`.
+ Quando si esegue una query DNS sul nome del servizio, i record `A` e `AAAA` restituiscono un set di indirizzi IP corrispondenti alle attività. I record `SRV` restituiscono un set di indirizzi IP e porte per ciascuna attività.
+ Se dispone di otto o meno record integri, Route 53 risponde alle query DNS con tutti i record integri.
+ Quando tutti i record non sono integri, Route 53 risponde alle query DNS con un massimo di otto record non integri.
+ Puoi configurare il rilevamento dei servizi per un servizio protetto da un load balancer, ma il traffico del rilevamento dei servizi viene sempre instradato verso l'attività e non verso il load balancer.
+ L'individuazione dei servizi non supporta l'utilizzo di Classic Load Balancer.
+ Per il servizio di individuazione dei servizi consigliamo di utilizzare i controlli dell'integrità a livello dei container gestiti da Amazon ECS.
+ **HealthCheckCustomConfig**—Amazon ECS gestisce i controlli sanitari per tuo conto. Amazon ECS usa le informazioni ottenute dal container e dai controlli dell'integrità, insieme allo stato dell'attività, per aggiornare l'integrità con AWS Cloud Map. Questo comportamento viene specificato tramite il parametro `--health-check-custom-config` durante la creazione del servizio di individuazione dei servizi. Per ulteriori informazioni, consulta [HealthCheckCustomConfig](https://docs.aws.amazon.com/cloud-map/latest/api/API_HealthCheckCustomConfig.html) nella *documentazione di riferimento dell’API AWS Cloud Map *.
+ Le AWS Cloud Map risorse create quando viene utilizzato il service discovery devono essere pulite manualmente.
+ Le attività e le istanze vengono registrate come `UNHEALTHY` fino a quando i controlli dell'integrità del container non restituiscono un valore. Se i controlli dell'integrità risultano positivi, lo stato viene aggiornato a `HEALTHY`. Se i controlli dell'integrità del container hanno esito negativo, la registrazione dell'istanza di rilevamento servizi viene annullata.
## Prezzi del servizio di individuazione dei servizi
I clienti che utilizzano l'individuazione dei servizi di Amazon ECS pagano per le risorse Route 53 e le operazioni API di individuazione AWS Cloud Map . Sono inclusi i costi per la creazione delle zone ospitate di Route 53 e per le query nel registro del servizio. Per ulteriori informazioni, consultare [Prezzi di AWS Cloud Map](https://docs.aws.amazon.com/cloud-map/latest/dg/cloud-map-pricing.html) nella *Guida per gli sviluppatori di AWS Cloud Map *.
Amazon ECS esegue controlli di integrità a livello di container e li espone a operazioni API di controllo dello stato AWS Cloud Map personalizzate. Questa opzione al momento viene fornita gratuitamente ai clienti. Se configuri controlli dell'integrità di rete aggiuntivi per le attività esposte pubblicamente, potrebbero esserti addebitati i relativi costi.
# Creazione di un servizio Amazon ECS che utilizza il rilevamento servizi.
Maggiori informazioni su come creare un servizio contenente un'attività Fargate che usa il rilevamento servizi con la AWS CLI.
Per un elenco delle scoperte di Regioni AWS tali servizi di supporto, consulta. [Usare il rilevamento servizi per connettere i servizi Amazon ECS con nomi DNS](service-discovery.md)
Per informazioni sulle regioni che supportano Fargate, consulta [Regioni supportate per Amazon ECS su Fargate AWS](AWS_Fargate-Regions.md).
**Nota**
Puoi utilizzare gli endpoint del servizio dual-stack per interagire con Amazon ECS da AWS CLI, SDKs e l'API Amazon ECS su entrambi e. IPv4 IPv6 Per ulteriori informazioni, consulta [Utilizzo degli endpoint dual-stack Amazon ECS](dual-stack-endpoint.md).
## Prerequisiti
Prima di iniziare questo tutorial, verifica che siano soddisfatti i seguenti requisiti preliminari:
+ La versione più recente di è installata e configurata. AWS CLI Per ulteriori informazioni, consultare [Installing or updating to the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Le fasi descritte in [Configurazione per l'uso di Amazon ECS](get-set-up-for-amazon-ecs.md) sono complete.
+ L'utente IAM dispone delle autorizzazioni necessarie specificate nell'esempio di policy IAM [AmazonECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess).
+ Hai creato almeno un VPC e un gruppo di sicurezza. Per ulteriori informazioni, consulta [Crea un cloud privato virtuale](get-set-up-for-amazon-ecs.md#create-a-vpc).
## Passaggio 1: creare le risorse di Service Discovery in AWS Cloud Map
Utilizza la procedura seguente per creare il namespace di individuazione dei servizi e il servizio di individuazione dei servizi.
1. Crea un namespace privato di individuazione dei servizi Cloud Map. In questo esempio viene creato un namespace denominato `tutorial`. Sostituisci *vpc-abcd1234* con l'ID di uno dei tuoi esistenti VPCs.
```
aws servicediscovery create-private-dns-namespace \
--name tutorial \
--vpc vpc-abcd1234
```
L'output di questo comando è il seguente:
```
{
"OperationId": "h2qe3s6dxftvvt7riu6lfy2f6c3jlhf4-je6chs2e"
}
```
1. Usando `OperationId` dall'output della fase precedente, verificare che il namespace privato sia stato creato correttamente. Annotare l'ID del namespace perché verrà utilizzato nei comandi successivi.
```
aws servicediscovery get-operation \
--operation-id h2qe3s6dxftvvt7riu6lfy2f6c3jlhf4-je6chs2e
```
L'output è il seguente.
```
{
"Operation": {
"Id": "h2qe3s6dxftvvt7riu6lfy2f6c3jlhf4-je6chs2e",
"Type": "CREATE_NAMESPACE",
"Status": "SUCCESS",
"CreateDate": 1519777852.502,
"UpdateDate": 1519777856.086,
"Targets": {
"NAMESPACE": "ns-uejictsjen2i4eeg"
}
}
}
```
1. Usando l'ID `NAMESPACE` dall'output nella fase precedente, crea un servizio di individuazione dei servizi. Questo esempio crea un servizio denominato `myapplication`. Prendi nota dell'ID del servizio e dell'ARN perché li utilizzerai nei comandi successivi.
```
aws servicediscovery create-service \
--name myapplication \
--dns-config "NamespaceId="ns-uejictsjen2i4eeg",DnsRecords=[{Type="A",TTL="300"}]" \
--health-check-custom-config FailureThreshold=1
```
L'output è il seguente.
```
{
"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"
}
}
```
## Fase 2: Creazione delle risorse Amazon ECS
Utilizza la procedura seguente per creare il cluster Amazon ECS, la definizione di attività e il servizio.
1. Crea un cluster Amazon ECS. In questo esempio viene creato un cluster denominato `tutorial`.
```
aws ecs create-cluster \
--cluster-name tutorial
```
1. Registra una definizione di attività che sia compatibile con Fargate e utilizzi la modalità di rete `awsvpc`. Completare la procedura riportata di seguito.
1. Crea un file denominato `fargate-task.json` con il contenuto della seguente definizione di attività.
```
{
"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. Registrazione della definizione dell'attività tramite `fargate-task.json`.
```
aws ecs register-task-definition \
--cli-input-json file://fargate-task.json
```
1. Crea un servizio ECS completando la seguente procedura:
1. Creazione di un file denominato `ecs-service-discovery.json` con il contenuto del servizio ECS che stai per creare. Questo esempio usa la definizione di attività creata nella fase precedente. È obbligatorio l'uso di un parametro `awsvpcConfiguration` perché la definizione di attività di esempio usa la modalità di rete `awsvpc`.
Quando si crea il servizio ECS, specificare Fargate e la versione della piattaforma `LATEST` che supporta il rilevamento servizi. Quando viene creato il servizio di individuazione dei servizi in AWS Cloud Map , l'ARN restituito è `registryArn`. `securityGroups` e `subnets` devono appartenere al VPC utilizzato per creare il namespace Cloud Map. Puoi ottenere il gruppo di sicurezza e la sottorete IDs dalla 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. Crea il tuo servizio ECS utilizzando `ecs-service-discovery.json`.
```
aws ecs create-service \
--cli-input-json file://ecs-service-discovery.json
```
## Fase 3: Verifica Service Discovery in AWS Cloud Map
Puoi verificare che sia stato creato tutto correttamente eseguendo una query sulle informazioni di individuazione dei servizi. Dopo aver configurato l'individuazione del servizio, puoi utilizzare le operazioni AWS Cloud Map API o effettuare una chiamata `dig` da un'istanza all'interno del tuo VPC. Completare la procedura riportata di seguito.
1. Usando l'ID servizio di individuazione dei servizi, elenca le istanze di individuazione dei servizi. Prendi nota dell'ID istanza (contrassegnato in grassetto) per la pulizia delle risorse.
```
aws servicediscovery list-instances \
--service-id srv-utcrh6wavdkggqtk
```
L'output è il seguente.
```
{
"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. Utilizza il namespace, il servizio di individuazione dei servizi e parametri aggiuntivi quali il nome del cluster ECS per ottenere i dettagli sulle istanze di individuazione dei servizi.
```
aws servicediscovery discover-instances \
--namespace-name tutorial \
--service-name myapplication \
--query-parameters ECS_CLUSTER_NAME=tutorial
```
1. Puoi eseguire query sui record DNS creati nella zona ospitata di Route 53 per il servizio di individuazione dei servizi con i seguenti comandi AWS CLI :
1. Con l'ID del namespace, ottenere le informazioni sul namespace che includono l'ID della zona ospitata di Route 53.
```
aws servicediscovery \
get-namespace --id ns-uejictsjen2i4eeg
```
L'output è il seguente.
```
{
"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. Utilizzando l'ID della zona ospitata di Route 53 dalla fase precedente (visualizza il testo in grassetto), ottieni il set di record delle risorse per la zona ospitata.
```
aws route53 list-resource-record-sets \
--hosted-zone-id Z35JQ4ZFDRYPLV
```
1. Puoi eseguire query sul DNS anche da un'istanza all'interno tramite `dig`.
```
dig +short myapplication.tutorial
```
## Fase 4: pulizia
Una volta terminato questo tutorial, elimina le risorse associate in modo da evitare costi aggiuntivi per le risorse non utilizzate. Completare la procedura riportata di seguito.
1. Annulla la registrazione delle istanze del servizio di individuazione dei servizi utilizzando l'ID servizio e l'ID istanza annotati in precedenza.
```
aws servicediscovery deregister-instance \
--service-id srv-utcrh6wavdkggqtk \
--instance-id 16becc26-8558-4af1-9fbd-f81be062a266
```
L'output è il seguente.
```
{
"OperationId": "xhu73bsertlyffhm3faqi7kumsmx274n-jh0zimzv"
}
```
1. Utilizzando l'`OperationId` dall'output della fase precedente, verifica che la registrazione delle istanze del servizio di individuazione dei servizi sia stata annullata correttamente.
```
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. Eliminazione del servizio di individuazione dei servizi utilizzando l'ID servizio.
```
aws servicediscovery delete-service \
--id srv-utcrh6wavdkggqtk
```
1. Eliminazione del namespace di rilevamento servizi utilizzando l'ID del namespace.
```
aws servicediscovery delete-namespace \
--id ns-uejictsjen2i4eeg
```
L'output è il seguente.
```
{
"OperationId": "c3ncqglftesw4ibgj5baz6ktaoh6cg4t-jh0ztysj"
}
```
1. Usando l'`OperationId` dall'output della fase precedente, verificare che il namespace di rilevamento servizi sia stato eliminato correttamente.
```
aws servicediscovery get-operation \
--operation-id c3ncqglftesw4ibgj5baz6ktaoh6cg4t-jh0ztysj
```
L'output è il seguente.
```
{
"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. Aggiorna il conteggio desiderato per il servizio Amazon ECS a `0`. Questa operazione deve essere eseguita per eliminare il servizio nella fase successiva.
```
aws ecs update-service \
--cluster tutorial \
--service ecs-service-discovery \
--desired-count 0
```
1. Elimina il servizio Amazon ECS.
```
aws ecs delete-service \
--cluster tutorial \
--service ecs-service-discovery
```
1. Elimina il cluster Amazon ECS.
```
aws ecs delete-cluster \
--cluster tutorial
```
# Usa Amazon VPC Lattice per connettere, osservare e proteggere i tuoi servizi Amazon ECS
Amazon VPC Lattice è un servizio di rete di applicazioni completamente gestito che consente ai clienti di Amazon ECS di osservare, proteggere e monitorare le applicazioni create su servizi di AWS elaborazione e account VPCs, senza richiedere alcuna modifica al codice.
VPC Lattice utilizza gruppi di destinazione che sono una raccolta di risorse di calcolo. Questi obiettivi eseguono l'applicazione o il servizio e possono essere istanze Amazon EC2, indirizzi IP, funzioni Lambda e Application Load Balancer. Associando i propri servizi Amazon ECS a un gruppo di destinazione di VPC Lattice, i clienti possono ora abilitare le attività Amazon ECS come destinazioni IP in VPC Lattice. Quando vengono avviate le attività per il servizio registrato, Amazon ECS le registra automaticamente nel gruppo di destinazione di VPC Lattice.
**Nota**
Quando si utilizzano cinque configurazioni di VPC Lattice, il tempo di implementazione potrebbe essere leggermente più lungo rispetto a quando si utilizzano meno configurazioni.
Una regola del listener viene utilizzata per inoltrare il traffico a un gruppo di destinazione specifico quando le condizioni sono soddisfatte. Un listener verifica le richieste di connessione utilizzando il protocollo sulla porta configurata. Un servizio instrada le richieste verso i suoi obiettivi registrati in base alle regole definite al momento della configurazione del listener.
Inoltre, Amazon ECS sostituisce automaticamente un'attività anche se diventa non integra in base ai controlli dell'integrità di VPC Lattice. Una volta associati a VPC Lattice, i clienti Amazon ECS possono anche sfruttare molte altre funzionalità di connettività, sicurezza e osservabilità cross-computing di VPC Lattice, come la connessione a servizi tra cluster e account con integrazione IAM per l'autorizzazione e l' VPCsautenticazione e funzionalità avanzate di AWS Resource Access Manager gestione del traffico.
I clienti di Amazon ECS possono trarre vantaggio da VPC Lattice nei modi seguenti:
+ Maggiore produttività degli sviluppatori: VPC Lattice aumenta la produttività degli sviluppatori consentendo loro di concentrarsi sulla creazione di funzionalità, mentre VPC Lattice gestisce le sfide di rete, sicurezza e osservabilità in modo uniforme su tutte le piattaforme di elaborazione.
+ Migliore livello di sicurezza: VPC Lattice consente agli sviluppatori di autenticare e proteggere facilmente la comunicazione tra applicazioni e piattaforme di calcolo, applicare la crittografia in transito e applicare controlli di accesso granulari con le policy di autenticazione di VPC Lattice. Ciò consente di adottare una postura di sicurezza più solida che soddisfa i principali requisiti normativi e di conformità del settore.
+ Migliore scalabilità e resilienza delle applicazioni: VPC Lattice consente di creare una rete di applicazioni implementate con funzionalità come autorizzazione, autenticazione, monitoraggio e instradamento basati su percorsi, intestazioni e metodi. Questi vantaggi vengono forniti senza sovraccarico di risorse sui carichi di lavoro e possono supportare implementazioni multi-cluster che generano milioni di richieste al secondo senza aggiungere latenza significativa.
+ Flessibilità di implementazione con infrastruttura eterogenea: VPC Lattice offre funzionalità coerenti in tutti i servizi di calcolo come Amazon ECS, Fargate, Amazon EC2, Amazon EKS e Lambda, e consente all'organizzazione la flessibilità di scegliere l'infrastruttura adatta per ogni applicazione.
## Come funziona VPC Lattice con altri servizi Amazon ECS
L'uso di VPC Lattice con Amazon ECS può cambiare la modalità di utilizzo di altri servizi Amazon ECS, mentre altri rimangono invariati.
**Application Load Balancer**
Non è più necessario creare un Application Load Balancer specifico da utilizzare con il tipo di gruppo di destinazione Application Load Balancer in VPC Lattice che poi si collega al servizio Amazon ECS. È solo necessario configurare il servizio Amazon ECS con un gruppo di destinazione VPC Lattice. È anche possibile scegliere di utilizzare Application Load Balancer con Amazon ECS contemporaneamente.
**Implementazioni in sequenza di Amazon ECS**
Solo le implementazioni in sequenza di Amazon ECS funzionano con VPC Lattice, e Amazon ECS inserisce le attività in modo sicuro e le rimuove dai servizi durante l'implementazione. La distribuzione e le distribuzioni del codice non sono supportate. Blue/Green
Per saperne di più su VPC Lattice, consultare [Amazon VPC Lattice User Guide](https://docs.aws.amazon.com/vpc-lattice/latest/ug/what-is-vpc-lattice.html).
# Crea un servizio che utilizza VPC Lattice
È possibile utilizzare Console di gestione AWS o il AWS CLI per creare un servizio con VPC Lattice.
## Prerequisiti
Prima di iniziare questo tutorial, verifica che siano soddisfatti i seguenti requisiti preliminari:
+ La versione più recente di AWS CLI è installata e configurata. Per ulteriori informazioni, consultare [Installing the AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html).
**Nota**
Puoi utilizzare gli endpoint del servizio dual-stack per interagire con Amazon ECS da AWS CLI, SDKs e l'API Amazon ECS su entrambi e. IPv4 IPv6 Per ulteriori informazioni, consulta [Utilizzo degli endpoint dual-stack Amazon ECS](dual-stack-endpoint.md).
+ Le fasi descritte in [Configurazione per l'uso di Amazon ECS](get-set-up-for-amazon-ecs.md) sono complete.
+ L'utente IAM dispone delle autorizzazioni necessarie specificate nell'esempio di policy IAM [AmazonECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess).
## Crea un servizio che utilizza VPC Lattice con Console di gestione AWS
Seguire questi passaggi per creare un servizio con VPC Lattice utilizzando Console di gestione AWS.
1. [Apri la console alla v2. https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/v2)
1. Nella pagina di navigazione, scegli **Cluster**.
1. Nella pagina **Cluster**, scegliere il cluster in cui creare il servizio.
1. Nella scheda **Servizi**, scegliere **Crea**.
Se non è mai stato creato un servizio in precedenza, seguire i passaggi riportati in [Creazione di un servizio Amazon ECS utilizzando la console](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html), poi continuare con questi passaggi quando si raggiunge la sezione relativa a VPC Lattice.
1. Scegliere **Attiva VPC Lattice** selezionando il pulsante.
1. Per utilizzare un ruolo esistente, per **Ruolo di infrastruttura ECS per Amazon ECS**, sceglierne uno già creato da utilizzare durante la creazione del gruppo di destinazione VPC Lattice. Per creare un nuovo ruolo, **Crea ruolo di infrastruttura ECS**.
1. Scegliere il **VPC**.
Il **VPC** dipende dalla modalità di rete selezionata al momento della registrazione della definizione dell'attività. Se si utilizza la modalità `host` o `network` con EC2, scegliere il VPC.
Per la modalità `awsvpc`, il VPC viene selezionato automaticamente in base al VPC scelto in **Rete** e non può essere modificato.
1. In **Gruppi di destinazione**, scegliere il gruppo o i gruppi di destinazione. È necessario scegliere un gruppo di destinazione compreso tra 1 e 5. Scegliere **Aggiungi gruppo di destinazione** per aggiungere altri gruppi di destinazione. Scegliere il **Nome della porta**, il **Protocollo** e la **Porta** per ogni gruppo di destinazione scelto. Per rimuovere un gruppo di destinazione, scegliere **Rimuovi**.
**Nota**
Se si desidera aggiungere gruppi di destinazione esistenti, è necessario usare la AWS CLI. *Per istruzioni su come aggiungere gruppi target utilizzando il AWS CLI, consulta [register-targets](https://docs.aws.amazon.com/cli/latest/reference/vpc-lattice/register-targets.html) nella Guida di riferimento. AWS Command Line Interface *
Sebbene un servizio VPC Lattice possa essere collegato a più gruppi di destinazione, un gruppo di destinazione può essere aggiunto solo a un singolo servizio.
Per creare un servizio in una configurazione IPv6 -only, scegli i gruppi di destinazione con un tipo di indirizzo IP di. `IPv6`
1. A questo punto, accedere alla console VPC Lattice per continuare la configurazione. È qui che si includono i nuovi gruppi di destinazione nell'azione predefinita del listener o nelle regole di un servizio VPC Lattice esistente.
Per ulteriori informazioni, consultare [Listener rules for your VPC Lattice service](https://docs.aws.amazon.com/vpc-lattice/latest/ug/listener-rules.html).
**Importante**
È necessario consentire il prefisso `vpc-lattice` della regola in entrata per il gruppo o le attività di sicurezza e i controlli di integrità possono avere esito negativo.
## Crea un servizio che utilizza VPC Lattice con AWS CLI
Usa AWS CLI per creare un servizio con VPC Lattice. Sostituisci ogni *user input placeholder* con le tue informazioni.
1. Creazione di un file di configurazione del gruppo di destinazione. L'esempio seguente è denominato `tg-config.json`
```
{
"ipAddressType": "IPV4",
"port": 443,
"protocol": "HTTPS",
"protocolVersion": "HTTP1",
"vpcIdentifier": "vpc-f1663d9868EXAMPLE"
}
```
1. Utilizzare il seguente comando per creare un gruppo di destinazione di VPC Lattice.
```
aws vpc-lattice create-target-group \
--name my-lattice-target-group-ip \
--type IP \
--config file://tg-config.json
```
**Nota**
Per creare un servizio in una configurazione IPv6 solo, crea gruppi target con un tipo di indirizzo IP di. `IPv6` Per ulteriori informazioni, consulta [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/vpc-lattice/create-target-group.html) nella *documentazione di riferimento dei comandi della AWS CLI *.
Output di esempio:
```
{
"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. Il seguente file JSON denominato *ecs-service-vpc-lattice.json* è un esempio utilizzato per collegare un servizio Amazon ECS a un gruppo target VPC Lattice. Il `portName` nell'esempio seguente è quello definito nel campo `name` delle proprietà `portMappings` della definizione dell'attività.
```
{
"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"
}
```
Utilizzare il seguente comando per creare un servizio Amazon ECS e collegarlo al gruppo di destinazione VPC Lattice utilizzando l'esempio json sopra riportato.
```
aws ecs create-service \
--cluster clusterName \
--serviceName ecs-service-vpc-lattice \
--cli-input-json file://ecs-service-vpc-lattice.json
```
**Nota**
VPC Lattice non è supportato in Amazon ECS Anywhere.