Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Tutorial per Amazon ECS
<a name="ecs-tutorials"></a>

I seguenti tutorial mostrano come eseguire le attività comuni quando si utilizza Amazon ECS.

È possibile seguire i seguenti tutorial per saperne di più su come iniziare a utilizzare Amazon ECS.


| Panoramica del tutorial | Ulteriori informazioni | 
| --- | --- | 
|  Iniziare a utilizzare Amazon ECS su Fargate.  |  [Ulteriori informazioni su come creare un'attività di Amazon ECS Linux per Fargate](getting-started-fargate.md)  | 
|  Iniziare a utilizzare i container Windows su Fargate.  |  [Ulteriori informazioni su come creare un'attività di Amazon ECS Windows per Fargate](Windows_fargate-getting_started.md)  | 
|  Iniziare a utilizzare i container Windows per EC2.  |  [Ulteriori informazioni su come creare un'attività di Amazon ECS Windows per EC2](getting-started-ecs-ec2-v2.md)  | 

Puoi utilizzare uno dei seguenti tutorial per distribuire attività su Amazon ECS utilizzando AWS CLI


| Panoramica del tutorial | Ulteriori informazioni | 
| --- | --- | 
|  Creazione di un'attività Linux per Fargate.  |  [Creazione di un'attività Amazon ECS Linux per Fargate con AWS CLI](ECS_AWSCLI_Fargate.md)  | 
|  Creazione di un'attività Windows per Fargate.  |  [Creazione di un'attività Amazon ECS Windows per Fargate con AWS CLI](ECS_AWSCLI_Fargate_windows.md)  | 
|  Creazione di un'attività Linux per EC2.  |  [Creazione di un'attività Amazon ECS per EC2 con AWS CLI](ECS_AWSCLI_EC2.md)  | 

È possibile seguire questi tutorial per saperne di più sul monitoraggio e sulla registrazione di log.


| Panoramica del tutorial | Ulteriori informazioni | 
| --- | --- | 
|  Imposta una semplice funzione Lambda che ascolti gli eventi delle attività e li scriva in un flusso di log di CloudWatch Logs.  |  [Configurazione di Amazon ECS per CloudWatch ascoltare gli eventi Events](ecs_cwet.md)  | 
|  Configura una regola di EventBridge evento Amazon che acquisisca solo gli eventi delle attività in cui l'attività ha smesso di essere eseguita perché uno dei suoi contenitori essenziali è terminato.   |  [Invio di avvisi di Amazon Simple Notification Service per gli eventi di attività Amazon ECS arrestate](ecs_cwet2.md)  | 
|  Concatenare i messaggi di log originariamente appartenenti a un contesto ma suddivisi su più record o righe di log.  |  [Concatenazione di messaggi di log Amazon ECS multilinea o di traccia dello stack](firelens-concatanate-multiline.md)  | 
|  Implementa i contenitori Fluent Bit sulle loro istanze Windows in esecuzione in Amazon ECS per trasmettere i log generati dalle attività di Windows ad Amazon per la registrazione centralizzata. CloudWatch   |  [Implementazione di Fluent Bit su container Windows di Amazon ECS](tutorial-deploy-fluentbit-on-windows.md)  | 

È possibile utilizzare i seguenti tutorial per saperne di più su come utilizzare l'autenticazione Active Directory con un account di servizio gestito del gruppo su Amazon ECS.


| Panoramica del tutorial | Ulteriori informazioni | 
| --- | --- | 
|  Utilizzo dell'account di servizio gestito del gruppo con container Linux su EC2.  |  [Utilizzo del gMSA per container EC2 Linux su Amazon ECS](linux-gmsa.md)  | 
|  Utilizzo dell'account di servizio gestito del gruppo con container Windows su EC2.  |  [Informazioni su come utilizzare i gMSA per i container Windows EC2 per Amazon ECS](windows-gmsa.md)  | 
|  Utilizzo dell'account di servizio gestito del gruppo con container Linux su Fargate.  |  [Utilizzo del gMSA per i container Linux su Fargate](fargate-linux-gmsa.md)  | 
|  Creare un'attività che esegue un container Windows con credenziali di accesso ad Active Directory con un account di servizio gestito del gruppo senza dominio.  |  [Utilizzo di contenitori Amazon ECS Windows senza dominio gMSA utilizzando AWS CLI](tutorial-gmsa-windows.md)  | 

# Creazione di un'attività Amazon ECS Linux per Fargate con AWS CLI
<a name="ECS_AWSCLI_Fargate"></a>

La procedura seguente illustra come configurare un cluster, registrare una definizione dei processi, eseguire un processo Linux e come eseguire altri scenari comuni in Amazon ECS con la AWS CLI. Usa la versione più recente dell' AWS CLI. Per ulteriori informazioni su come eseguire l'aggiornamento alla versione più recente, consulta [Installing or updating to the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.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).

**Topics**
+ [

## Prerequisiti
](#ECS_AWSCLI_Fargate_prereq)
+ [

## Fase 1: creare un cluster
](#ECS_AWSCLI_Fargate_create_cluster)
+ [

## Fase 2: Registra una definizione dei processi Linux
](#ECS_AWSCLI_Fargate_register_task_definition)
+ [

## Fase 3: Elenca le definizioni di attività
](#ECS_AWSCLI_Fargate_list_task_definitions)
+ [

## Fase 4: Crea un servizio
](#ECS_AWSCLI_Fargate_create_service)
+ [

## Fase 5: Elenca i servizi
](#ECS_AWSCLI_Fargate_list_services)
+ [

## Fase 6: Descrivi il servizio in esecuzione
](#ECS_AWSCLI_Fargate_describe_service)
+ [

## Fase 7: Test
](#ECS_AWSCLI_Fargate_test)
+ [

## Fase 8: elimina
](#ECS_AWSCLI_Fargate_clean_up)

## Prerequisiti
<a name="ECS_AWSCLI_Fargate_prereq"></a>

Questo tutorial presuppone che siano stati soddisfatti i prerequisiti seguenti:
+ La versione più recente di è installata e configurata. AWS CLI Per ulteriori informazioni sull'installazione o l'aggiornamento di AWS CLI, [Installazione o aggiornamento alla versione più recente di](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). AWS CLI
+ Hai completato le fasi descritte in [Configurazione per l'uso di Amazon ECS](get-set-up-for-amazon-ecs.md).
+ 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 e un gruppo di sicurezza creati per l'uso. Questo tutorial utilizza un'immagine di container ospitata su Amazon ECR Public, quindi il processo deve avere accesso a Internet. Per assegnare alla tua attività un percorso verso Internet, scegli una delle seguenti opzioni.
  + Utilizza una sottorete privata con un gateway NAT con un indirizzo IP elastico.
  + Utilizza una sottorete pubblica e assegna un indirizzo IP pubblico all'attività.

  Per ulteriori informazioni, consulta [Crea un cloud privato virtuale](get-set-up-for-amazon-ecs.md#create-a-vpc).

  Per informazioni su gruppi e regole di sicurezza, consulta [Gruppi di sicurezza predefiniti per te VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#DefaultSecurityGroup) e [Regole di esempio](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#security-group-rule-examples) nella *Guida per l'utente di Amazon Virtual Private Cloud*.
+  Se segui questo tutorial utilizzando una sottorete privata, puoi usare Amazon ECS Exec per interagire direttamente con il container e testare l'implementazione. Dovrai creare un ruolo IAM dell'attività per usare ECS Exec. Per ulteriori informazioni sul ruolo IAM dell'attività e su altri prerequisiti, consultare [Monitor Amazon ECS containers with Amazon ECS Exec](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-exec.html).
+ (Facoltativo) AWS CloudShell è uno strumento che offre ai clienti una riga di comando senza la necessità di creare la propria istanza EC2. Per ulteriori informazioni, consulta [Cos'è? AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) nella *Guida AWS CloudShell per l'utente*.

## Fase 1: creare un cluster
<a name="ECS_AWSCLI_Fargate_create_cluster"></a>

Di default, l'account riceve il cluster `default`.

**Nota**  
Utilizzare il cluster `default` offre il vantaggio di non dover specificare l'opzione `--cluster cluster_name` nei comandi successivi. Se crei un cluster diverso da quello predefinito, devi specificare ì`--cluster cluster_name` per ogni comando che prevedi di usare con tale cluster.

Crea il tuo cluster con un nome univoco con il comando seguente:

```
aws ecs create-cluster --cluster-name fargate-cluster
```

Output:

```
{
    "cluster": {
        "status": "ACTIVE", 
        "defaultCapacityProviderStrategy": [], 
        "statistics": [], 
        "capacityProviders": [], 
        "tags": [], 
        "clusterName": "fargate-cluster", 
        "settings": [
            {
                "name": "containerInsights", 
                "value": "disabled"
            }
        ], 
        "registeredContainerInstancesCount": 0, 
        "pendingTasksCount": 0, 
        "runningTasksCount": 0, 
        "activeServicesCount": 0, 
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster"
    }
}
```

## Fase 2: Registra una definizione dei processi Linux
<a name="ECS_AWSCLI_Fargate_register_task_definition"></a>

Prima di eseguire un'attività nel cluster ECS, devi registrare una definizione di attività. Le definizioni di attività sono elenchi di container raggruppati. L'esempio seguente è una semplice definizione di attività che crea un'app Web PHP utilizzando l'immagine di container httpd ospitata su Docker Hub. Per ulteriori informazioni sui parametri disponibili per la definizione di attività, consulta [Definizioni dei processi di Amazon ECS](task_definitions.md). Per questo tutorial, è necessario utilizzare `taskRoleArn` solo se stai distribuendo l'attività in una sottorete privata e desideri testare l'implementazione. Sostituisci `taskRoleArn` con il ruolo dell'attività IAM creato per utilizzare ECS Exec, come indicato in [Prerequisiti](#ECS_AWSCLI_Fargate_prereq).

```
 {
        "family": "sample-fargate",
        "networkMode": "awsvpc",
        "taskRoleArn": "arn:aws:iam::aws_account_id:role/execCommandRole", 
        "containerDefinitions": [
            {
                "name": "fargate-app",
                "image": "public.ecr.aws/docker/library/httpd:latest",
                "portMappings": [
                    {
                        "containerPort": 80,
                        "hostPort": 80,
                        "protocol": "tcp"
                    }
                ],
                "essential": true,
                "entryPoint": [
                    "sh",
                    "-c"
                ],
                "command": [
                    "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
                ]
            }
        ],
        "requiresCompatibilities": [
            "FARGATE"
        ],
        "cpu": "256",
        "memory": "512"
}
```

Salva il JSON della definizione dell'attività come file e trasmettilo con l'opzione `--cli-input-json file://path_to_file.json`. 

Per utilizzare un file JSON per le definizioni dei container:

```
aws ecs register-task-definition --cli-input-json file://$HOME/tasks/fargate-task.json
```

Il comando **register-task-definition** restituisce una descrizione della definizione di attività una volta completata la registrazione.

## Fase 3: Elenca le definizioni di attività
<a name="ECS_AWSCLI_Fargate_list_task_definitions"></a>

Puoi sempre ottenere un elenco delle definizioni di attività per il tuo account tramite il comando **list-task-definitions**. Il risultato restituito dal comando mostra i valori `family` e `revision` che puoi utilizzare insieme nelle chiamate **run-task** o **start-task**.

```
aws ecs list-task-definitions
```

Output:

```
{
    "taskDefinitionArns": [
        "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1"
    ]
}
```

## Fase 4: Crea un servizio
<a name="ECS_AWSCLI_Fargate_create_service"></a>

Dopo aver registrato un'attività per il tuo account, puoi creare un servizio per le attività registrate nel tuo cluster. Per questo esempio, crei un servizio con un'istanza della definizione delle attività `sample-fargate:1` in esecuzione nel cluster. L'attività richiede un percorso verso Internet, quindi ci sono due modi per ottenere questo risultato. Un modo consiste nell'utilizzare una sottorete privata configurata con un gateway NAT con un indirizzo IP elastico in una sottorete pubblica. Un altro modo consiste nell'utilizzare una sottorete pubblica e assegnare un indirizzo IP pubblico all'attività. Forniamo di seguito entrambi gli esempi. 

Esempio di utilizzo di una sottorete privata. L'opzione ` enable-execute-command ` è necessaria per utilizzare Amazon ECS Exec.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234]}" --enable-execute-command
```

Esempio di utilizzo di una sottorete pubblica.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234],assignPublicIp=ENABLED}"
```

Il comando **create-service** restituisce una descrizione della definizione di attività una volta completata la registrazione.

## Fase 5: Elenca i servizi
<a name="ECS_AWSCLI_Fargate_list_services"></a>

Ottieni un elenco dei servizi per il tuo cluster. Verrà visualizzato il servizio creato nella sezione precedente. Potrai utilizzare più avanti il nome del servizio o l'ARN completo restituito da questo comando per la descrizione del servizio.

```
aws ecs list-services --cluster fargate-cluster
```

Output:

```
{
    "serviceArns": [
        "arn:aws:ecs:region:aws_account_id:service/fargate-cluster/fargate-service"
    ]
}
```

## Fase 6: Descrivi il servizio in esecuzione
<a name="ECS_AWSCLI_Fargate_describe_service"></a>

Per ottenere ulteriori informazioni sulle attività, descrivi il servizio utilizzando il nome del servizio recuperato in precedenza.

```
aws ecs describe-services --cluster fargate-cluster --services fargate-service
```

In caso di esito positivo, verrà restituita una descrizione degli errori del servizio e dei servizi. Ad esempio, nella sezione ` services `, sono disponibili informazioni sulle implementazioni, ad esempio lo stato delle attività in esecuzione o in sospeso. È inoltre possibile trovare informazioni sulla definizione delle attività, la configurazione della rete e gli eventi con indicazione del timestamp. Nella sezione Errori, sono disponibili informazioni sugli eventuali errori associati alla chiamata. Per la risoluzione dei problemi, vedere [Messaggi degli eventi di servizio](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-event-messages.html). Per ulteriori informazioni sulla descrizione del servizio, vedere [Descrivere i servizi](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeServices).

```
{
    "services": [
        {
            "networkConfiguration": {
                "awsvpcConfiguration": {
                    "subnets": [
                        "subnet-abcd1234"
                    ], 
                    "securityGroups": [
                        "sg-abcd1234"
                    ], 
                    "assignPublicIp": "ENABLED"
                }
            }, 
            "launchType": "FARGATE", 
            "enableECSManagedTags": false, 
            "loadBalancers": [], 
            "deploymentController": {
                "type": "ECS"
            }, 
            "desiredCount": 1, 
            "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster", 
            "serviceArn": "arn:aws:ecs:region:aws_account_id:service/fargate-service", 
            "deploymentConfiguration": {
                "maximumPercent": 200, 
                "minimumHealthyPercent": 100
            }, 
            "createdAt": 1692283199.771, 
            "schedulingStrategy": "REPLICA", 
            "placementConstraints": [], 
            "deployments": [
                {
                    "status": "PRIMARY", 
                    "networkConfiguration": {
                        "awsvpcConfiguration": {
                            "subnets": [
                                "subnet-abcd1234"
                            ], 
                            "securityGroups": [
                                "sg-abcd1234"
                            ], 
                            "assignPublicIp": "ENABLED"
                        }
                    }, 
                    "pendingCount": 0, 
                    "launchType": "FARGATE", 
                    "createdAt": 1692283199.771, 
                    "desiredCount": 1, 
                    "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1", 
                    "updatedAt": 1692283199.771, 
                    "platformVersion": "1.4.0", 
                    "id": "ecs-svc/9223370526043414679", 
                    "runningCount": 0
                }
            ], 
            "serviceName": "fargate-service", 
            "events": [
                {
                    "message": "(service fargate-service) has started 2 tasks: (task 53c0de40-ea3b-489f-a352-623bf1235f08) (task d0aec985-901b-488f-9fb4-61b991b332a3).", 
                    "id": "92b8443e-67fb-4886-880c-07e73383ea83", 
                    "createdAt": 1510811841.408
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task b4911bee-7203-4113-99d4-e89ba457c626) (task cc5853e3-6e2d-4678-8312-74f8a7d76474).", 
                    "id": "d85c6ec6-a693-43b3-904a-a997e1fc844d", 
                    "createdAt": 1510811601.938
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task cba86182-52bf-42d7-9df8-b744699e6cfc) (task f4c1ad74-a5c6-4620-90cf-2aff118df5fc).", 
                    "id": "095703e1-0ca3-4379-a7c8-c0f1b8b95ace", 
                    "createdAt": 1510811364.691
                }
            ], 
            "runningCount": 0, 
            "status": "ACTIVE", 
            "serviceRegistries": [], 
            "pendingCount": 0, 
            "createdBy": "arn:aws:iam::aws_account_id:user/user_name", 
            "platformVersion": "LATEST", 
            "placementStrategy": [], 
            "propagateTags": "NONE", 
            "roleArn": "arn:aws:iam::aws_account_id:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS", 
            "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1"
        }
    ], 
    "failures": []
}
```

## Fase 7: Test
<a name="ECS_AWSCLI_Fargate_test"></a>

### Test di un'attività implementata utilizzando una sottorete pubblica
<a name="ECS_AWSCLI_Fargate_test_public"></a>

Descrivi il processo nel servizio in modo da poter ottenere l'interfaccia di rete elastica (ENI) per il processo. 

Per prima cosa, ottieni l'attività ARN.

```
aws ecs list-tasks --cluster fargate-cluster --service fargate-service
```

L'output contiene l'attività ARN.

```
{
    "taskArns": [
        "arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE
    ]
}
```

Descrivi il processo e individua l'ID ENI. Usa l'attività ARN per il parametro `tasks`.

```
aws ecs describe-tasks --cluster fargate-cluster --tasks arn:aws:ecs:us-east-1:123456789012:task/service/EXAMPLE
```

Le informazioni relative all'allegato sono elencate nell'output. 

```
{
    "tasks": [
        {
            "attachments": [
                {
                    "id": "d9e7735a-16aa-4128-bc7a-b2d5115029e9",
                    "type": "ElasticNetworkInterface",
                    "status": "ATTACHED",
                    "details": [
                        {
                            "name": "subnetId",
                            "value": "subnetabcd1234"
                        },
                        {
                            "name": "networkInterfaceId",
                            "value": "eni-0fa40520aeEXAMPLE"
                        },
                    ]
                }
…
}
```

Descrivi l'ENI per ottenere l'indirizzo IP pubblico.

```
aws ec2 describe-network-interfaces --network-interface-id  eni-0fa40520aeEXAMPLE
```

L'indirizzo IP pubblico è indicato nell'output. 

```
{
    "NetworkInterfaces": [
        {
            "Association": {
                "IpOwnerId": "amazon",
                "PublicDnsName": "ec2-34-229-42-222.compute-1.amazonaws.com",
                "PublicIp": "198.51.100.2"
            },
…
}
```

Inserisci l'indirizzo IP pubblico nel browser Web; dovresti visualizzare una pagina Web che mostra l'applicazione **Amazon ECS** di esempio.

### Test di un'attività implementata utilizzando una sottorete privata
<a name="ECS_AWSCLI_Fargate_test_private.title"></a>

 Descrivi l'attività e individua `managedAgents` per verificare che `ExecuteCommandAgent` sia in esecuzione. Annota `privateIPv4Address` per utilizzarlo in un secondo momento.

```
aws ecs describe-tasks --cluster fargate-cluster --tasks arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE
```

 Le informazioni relative all'agente gestito sono elencate nell'output. 

```
{
     "tasks": [
        {
            "attachments": [
                {
                    "id": "d9e7735a-16aa-4128-bc7a-b2d5115029e9",
                    "type": "ElasticNetworkInterface",
                    "status": "ATTACHED",
                    "details": [
                        {
                            "name": "subnetId",
                            "value": "subnetabcd1234"
                        },
                        {
                            "name": "networkInterfaceId",
                            "value": "eni-0fa40520aeEXAMPLE"
                        },
                        {
                            "name": "privateIPv4Address",
                            "value": "10.0.143.156"
                        }
                    ]
                }
            ],
     ...  
     "containers": [
         {
         ...
        "managedAgents": [
                        {
                            "lastStartedAt": "2023-08-01T16:10:13.002000+00:00",
                            "name": "ExecuteCommandAgent",
                            "lastStatus": "RUNNING"
                        } 
                ],
        ...
    }
```

 Dopo aver verificato che ` ExecuteCommandAgent` sia in esecuzione, puoi eseguire il comando seguente per utilizzare una shell (interprete di comandi) interattiva nel container dell'attività. 

```
  aws ecs execute-command --cluster fargate-cluster \
      --task  arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE  \
      --container  fargate-app \
      --interactive \
      --command "/bin/sh"
```

 Dopo l'esecuzione della shell (interprete di comandi) interattiva, esegui i comandi seguenti per installare cURL. 

```
apt update 
```

```
apt install curl 
```

 Dopo aver installato cURL, esegui il comando seguente utilizzando l'indirizzo IP privato ottenuto in precedenza.

```
 curl 10.0.143.156 
```

 Dovresti visualizzare l'equivalente HTML della pagina Web che mostra l'applicazione di esempio di **Amazon ECS**.

```
<html>
    <head> 
     <title>Amazon ECS Sample App</title> 
     <style>body {margin-top: 40px; background-color: #333;} </style>
    </head>
      <body> 
      <div style=color:white;text-align:center> 
      <h1>Amazon ECS Sample App</h1> 
      <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> 
      </div>
      </body>
</html>
```

## Fase 8: elimina
<a name="ECS_AWSCLI_Fargate_clean_up"></a>

Una volta terminato questo tutorial, è necessario eliminare le risorse associate per evitare costi aggiuntivi per le risorse non utilizzate.

Elimina il servizio.

```
aws ecs delete-service --cluster fargate-cluster --service fargate-service --force
```

Elimina il cluster.

```
aws ecs delete-cluster --cluster fargate-cluster
```

# Creazione di un'attività Amazon ECS Windows per Fargate con AWS CLI
<a name="ECS_AWSCLI_Fargate_windows"></a>

La procedura seguente illustra come configurare un cluster, registrare una definizione dei processi, eseguire un processo Windows e come eseguire altri scenari comuni in Amazon ECS con la AWS CLI. Assicurati di usare la versione più recente di AWS CLI. Per ulteriori informazioni su come eseguire l'aggiornamento alla versione più recente, consulta [Installing or updating to the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.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).

**Topics**
+ [

## Prerequisiti
](#ECS_AWSCLI_Fargate_windows_prereq)
+ [

## Fase 1: creare un cluster
](#ECS_AWSCLI_Fargate_windows_create_cluster)
+ [

## Fase 2: Registrazione di una definizione di attività di Windows
](#ECS_AWSCLI_Fargate_windows_register_task_definition)
+ [

## Fase 3: Elenca le definizioni di attività
](#ECS_AWSCLI_Fargate_windows__list_task_definitions)
+ [

## Fase 4: Crea un servizio
](#ECS_AWSCLI_Fargate_windows_create_service)
+ [

## Fase 5: Elenca i servizi
](#ECS_AWSCLI_Fargate_windows_list_services)
+ [

## Fase 6: Descrivi il servizio in esecuzione
](#ECS_AWSCLI_Fargate_windows_describe_service)
+ [

## Fase 7: eliminare
](#ECS_AWSCLI_Fargate_windows_clean_up)

## Prerequisiti
<a name="ECS_AWSCLI_Fargate_windows_prereq"></a>

Questo tutorial presuppone che siano stati soddisfatti i prerequisiti seguenti:
+ La versione più recente di è installata e configurata. AWS CLI Per ulteriori informazioni sull'installazione o l'aggiornamento di AWS CLI, vedere [Installazione o aggiornamento alla versione più recente di](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). AWS CLI
+ Hai completato le fasi descritte in [Configurazione per l'uso di Amazon ECS](get-set-up-for-amazon-ecs.md).
+ 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 e un gruppo di sicurezza creati per l'uso. Questo tutorial utilizza un'immagine di container ospitata su Docker Hub, quindi l'attività deve avere accesso a Internet. Per assegnare alla tua attività un percorso verso Internet, scegli una delle seguenti opzioni.
  + Utilizza una sottorete privata con un gateway NAT con un indirizzo IP elastico.
  + Utilizza una sottorete pubblica e assegna un indirizzo IP pubblico all'attività.

  Per ulteriori informazioni, consulta [Crea un cloud privato virtuale](get-set-up-for-amazon-ecs.md#create-a-vpc).

  Per informazioni su gruppi e regole di sicurezza, consulta [Gruppi di sicurezza predefiniti per te VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#DefaultSecurityGroup) e [Regole di esempio](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#security-group-rule-examples) nella *Guida per l'utente di Amazon Virtual Private Cloud*.
+ (Facoltativo) AWS CloudShell è uno strumento che offre ai clienti una riga di comando senza la necessità di creare la propria istanza EC2. Per ulteriori informazioni, consulta [Cos'è? AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) nella *Guida AWS CloudShell per l'utente*.

## Fase 1: creare un cluster
<a name="ECS_AWSCLI_Fargate_windows_create_cluster"></a>

Di default, l'account riceve il cluster `default`.

**Nota**  
Utilizzare il cluster `default` offre il vantaggio di non dover specificare l'opzione `--cluster cluster_name` nei comandi successivi. Se crei un cluster diverso da quello predefinito, devi specificare ì`--cluster cluster_name` per ogni comando che prevedi di usare con tale cluster.

Crea il tuo cluster con un nome univoco con il comando seguente:

```
aws ecs create-cluster --cluster-name fargate-cluster
```

Output:

```
{
    "cluster": {
        "status": "ACTIVE", 
        "statistics": [], 
        "clusterName": "fargate-cluster", 
        "registeredContainerInstancesCount": 0, 
        "pendingTasksCount": 0, 
        "runningTasksCount": 0, 
        "activeServicesCount": 0, 
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster"
    }
}
```

## Fase 2: Registrazione di una definizione di attività di Windows
<a name="ECS_AWSCLI_Fargate_windows_register_task_definition"></a>

Prima di eseguire un processo Windows nel cluster Amazon ECS, devi registrare una definizione di attività. Le definizioni di attività sono elenchi di container raggruppati. L'esempio seguente contiene una semplice definizione di attività che crea un'app Web. Per ulteriori informazioni sui parametri disponibili per la definizione di attività, consulta [Definizioni dei processi di Amazon ECS](task_definitions.md).

```
{
    "containerDefinitions": [
        {
            "command": ["New-Item -Path C:\\inetpub\\wwwroot\\index.html -Type file -Value '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p>'; C:\\ServiceMonitor.exe w3svc"],
            "entryPoint": [
                "powershell",
                "-Command"
            ],
            "essential": true,
            "cpu": 2048,
            "memory": 4096,
            "image": "mcr.microsoft.com/windows/servercore/iis:windowsservercore-ltsc2019",
            "name": "sample_windows_app",
            "portMappings": [
                {
                    "hostPort": 80,
                    "containerPort": 80,
                    "protocol": "tcp"
                }
            ]
        }
    ],
    "memory": "4096",
    "cpu": "2048",
    "networkMode": "awsvpc",
    "family": "windows-simple-iis-2019-core",
    "executionRoleArn": "arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
    "runtimePlatform": {"operatingSystemFamily": "WINDOWS_SERVER_2019_CORE"},
    "requiresCompatibilities": ["FARGATE"]
}
```

L'esempio precedente JSON può essere passato a AWS CLI in due modi: è possibile salvare la definizione dell'attività JSON come file e passarla con l'`--cli-input-json file://path_to_file.json`opzione.

Per utilizzare un file JSON per le definizioni dei container:

```
aws ecs register-task-definition --cli-input-json file://$HOME/tasks/fargate-task.json
```

Il comando **register-task-definition** restituisce una descrizione della definizione di attività una volta completata la registrazione.

## Fase 3: Elenca le definizioni di attività
<a name="ECS_AWSCLI_Fargate_windows__list_task_definitions"></a>

Puoi sempre ottenere un elenco delle definizioni di attività per il tuo account tramite il comando **list-task-definitions**. Il risultato restituito dal comando mostra i valori `family` e `revision` che puoi utilizzare insieme nelle chiamate **run-task** o **start-task**.

```
aws ecs list-task-definitions
```

Output:

```
{
    "taskDefinitionArns": [
        "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate-windows:1"
    ]
}
```

## Fase 4: Crea un servizio
<a name="ECS_AWSCLI_Fargate_windows_create_service"></a>

Dopo aver registrato un'attività per il tuo account, puoi creare un servizio per le attività registrate nel tuo cluster. Per questo esempio, crei un servizio con un'istanza della definizione delle attività `sample-fargate:1` in esecuzione nel cluster. L'attività richiede un percorso verso Internet, quindi ci sono due modi per ottenere questo risultato. Un modo consiste nell'utilizzare una sottorete privata configurata con un gateway NAT con un indirizzo IP elastico in una sottorete pubblica. Un altro modo consiste nell'utilizzare una sottorete pubblica e assegnare un indirizzo IP pubblico all'attività. Forniamo di seguito entrambi gli esempi. 

Esempio di utilizzo di una sottorete privata.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate-windows:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234]}"
```

Esempio di utilizzo di una sottorete pubblica.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate-windows:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234],assignPublicIp=ENABLED}"
```

Il comando **create-service** restituisce una descrizione della definizione di attività una volta completata la registrazione.

## Fase 5: Elenca i servizi
<a name="ECS_AWSCLI_Fargate_windows_list_services"></a>

Ottieni un elenco dei servizi per il tuo cluster. Verrà visualizzato il servizio creato nella sezione precedente. Potrai utilizzare più avanti il nome del servizio o l'ARN completo restituito da questo comando per la descrizione del servizio.

```
aws ecs list-services --cluster fargate-cluster
```

Output:

```
{
    "serviceArns": [
        "arn:aws:ecs:region:aws_account_id:service/fargate-service"
    ]
}
```

## Fase 6: Descrivi il servizio in esecuzione
<a name="ECS_AWSCLI_Fargate_windows_describe_service"></a>

Per ottenere ulteriori informazioni sulle attività, descrivi il servizio utilizzando il nome del servizio recuperato in precedenza.

```
aws ecs describe-services --cluster fargate-cluster --services fargate-service
```

In caso di esito positivo, verrà restituita una descrizione degli errori del servizio e dei servizi. Ad esempio, nella sezione Servizi, sono disponibili informazioni sulle distribuzioni, ad esempio lo stato delle attività in esecuzione o in sospeso. È inoltre possibile trovare informazioni sulla definizione delle attività, la configurazione della rete e gli eventi con indicazione del timestamp. Nella sezione Errori, sono disponibili informazioni sugli eventuali errori associati alla chiamata. Per la risoluzione dei problemi, vedere [Messaggi degli eventi di servizio](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-event-messages.html). Per ulteriori informazioni sulla descrizione del servizio, vedere [Descrivere i servizi](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeServices). 

```
{
    "services": [
        {
            "status": "ACTIVE", 
            "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate-windows:1", 
            "pendingCount": 2, 
            "launchType": "FARGATE", 
            "loadBalancers": [], 
            "roleArn": "arn:aws:iam::aws_account_id:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS", 
            "placementConstraints": [], 
            "createdAt": 1510811361.128, 
            "desiredCount": 2, 
            "networkConfiguration": {
                "awsvpcConfiguration": {
                    "subnets": [
                        "subnet-abcd1234"
                    ], 
                    "securityGroups": [
                        "sg-abcd1234"
                    ], 
                    "assignPublicIp": "DISABLED"
                }
            }, 
            "platformVersion": "LATEST", 
            "serviceName": "fargate-service", 
            "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster", 
            "serviceArn": "arn:aws:ecs:region:aws_account_id:service/fargate-service", 
            "deploymentConfiguration": {
                "maximumPercent": 200, 
                "minimumHealthyPercent": 100
            }, 
            "deployments": [
                {
                    "status": "PRIMARY", 
                    "networkConfiguration": {
                        "awsvpcConfiguration": {
                            "subnets": [
                                "subnet-abcd1234"
                            ], 
                            "securityGroups": [
                                "sg-abcd1234"
                            ], 
                            "assignPublicIp": "DISABLED"
                        }
                    }, 
                    "pendingCount": 2, 
                    "launchType": "FARGATE", 
                    "createdAt": 1510811361.128, 
                    "desiredCount": 2, 
                    "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate-windows:1", 
                    "updatedAt": 1510811361.128, 
                    "platformVersion": "0.0.1", 
                    "id": "ecs-svc/9223370526043414679", 
                    "runningCount": 0
                }
            ], 
            "events": [
                {
                    "message": "(service fargate-service) has started 2 tasks: (task 53c0de40-ea3b-489f-a352-623bf1235f08) (task d0aec985-901b-488f-9fb4-61b991b332a3).", 
                    "id": "92b8443e-67fb-4886-880c-07e73383ea83", 
                    "createdAt": 1510811841.408
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task b4911bee-7203-4113-99d4-e89ba457c626) (task cc5853e3-6e2d-4678-8312-74f8a7d76474).", 
                    "id": "d85c6ec6-a693-43b3-904a-a997e1fc844d", 
                    "createdAt": 1510811601.938
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task cba86182-52bf-42d7-9df8-b744699e6cfc) (task f4c1ad74-a5c6-4620-90cf-2aff118df5fc).", 
                    "id": "095703e1-0ca3-4379-a7c8-c0f1b8b95ace", 
                    "createdAt": 1510811364.691
                }
            ], 
            "runningCount": 0, 
            "placementStrategy": []
        }
    ], 
    "failures": []
}
```

## Fase 7: eliminare
<a name="ECS_AWSCLI_Fargate_windows_clean_up"></a>

Una volta terminato questo tutorial, è necessario eliminare le risorse associate per evitare costi aggiuntivi per le risorse non utilizzate.

Elimina il servizio.

```
aws ecs delete-service --cluster fargate-cluster --service fargate-service --force
```

Elimina il cluster.

```
aws ecs delete-cluster --cluster fargate-cluster
```

# Creazione di un'attività Amazon ECS per EC2 con AWS CLI
<a name="ECS_AWSCLI_EC2"></a>

La procedura seguente illustra come configurare un cluster, registrare una definizione dei processi, eseguire un processo e come eseguire altri scenari comuni in Amazon ECS con la AWS CLI. Usa la versione più recente dell' AWS CLI. Per ulteriori informazioni su come eseguire l'aggiornamento alla versione più recente, consulta [Installing or updating to the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.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).

**Topics**
+ [

## Prerequisiti
](#AWSCLI_EC2_prereq)
+ [

## Creazione di un cluster
](#AWSCLI_EC2_create_cluster)
+ [

## Avvio di un'istanza di container con l'AMI Amazon ECS
](#AWSCLI_EC2_launch_container_instance)
+ [

## Elencare le istanze di container
](#AWSCLI_EC2_list_container_instances)
+ [

## Descrivere l'istanza di container
](#AWSCLI_EC2_describe_container_instance)
+ [

## Registrare una definizione di attività
](#AWSCLI_EC2_register_task_definition)
+ [

## Elencare le definizioni di attività
](#AWSCLI_EC2_list_task_definitions)
+ [

## Creazione di un servizio
](#AWSCLI_EC2_run_task)
+ [

## Elencare i servizi
](#AWSCLI_EC2_list_tasks)
+ [

## Descrivere il servizio
](#AWSCLI_EC2_describe_service)
+ [

## Descrivere l'attività in esecuzione
](#AWSCLI_EC2_describe_task)
+ [

## Testare il server web
](#AWSCLI_EC2_test_web_server)
+ [

## Eseguire la pulizia delle risorse
](#AWSCLI_EC2_clean_up_resources)

## Prerequisiti
<a name="AWSCLI_EC2_prereq"></a>

Questo tutorial presuppone che siano stati soddisfatti i prerequisiti seguenti:
+ La versione più recente di è installata e configurata. AWS CLI Per ulteriori informazioni sull'installazione o l'aggiornamento di AWS CLI, vedere [Installazione o aggiornamento alla versione più recente di](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). AWS CLI
+ Hai completato le fasi descritte in [Configurazione per l'uso di Amazon ECS](get-set-up-for-amazon-ecs.md).
+ 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).
+ È stato creato un ruolo IAM dell'istanza di container per l'uso. Per ulteriori informazioni, consulta [Ruolo IAM delle istanze di container Amazon ECS](instance_IAM_role.md).
+ È stata creata una VPC per l'uso. Per ulteriori informazioni, consulta [Crea un cloud privato virtuale](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ (Facoltativo) AWS CloudShell è uno strumento che offre ai clienti una riga di comando senza la necessità di creare la propria istanza EC2. Per ulteriori informazioni, consulta [Cos'è? AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) nella *Guida AWS CloudShell per l'utente*.

## Creazione di un cluster
<a name="AWSCLI_EC2_create_cluster"></a>

All'avvio della prima istanza di container, di default l'account riceve il cluster `default`.

**Nota**  
Utilizzare il cluster `default` offre il vantaggio di non dover specificare l'opzione `--cluster cluster_name` nei comandi successivi. Se crei un cluster diverso da quello predefinito, devi specificare ì`--cluster cluster_name` per ogni comando che prevedi di usare con tale cluster.

Crea il tuo cluster con un nome univoco con il comando seguente:

```
aws ecs create-cluster --cluster-name MyCluster
```

Output:

```
{
    "cluster": {
        "clusterName": "MyCluster",
        "status": "ACTIVE",
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/MyCluster"
    }
}
```

## Avvio di un'istanza di container con l'AMI Amazon ECS
<a name="AWSCLI_EC2_launch_container_instance"></a>

Un'istanza di container è un'istanza EC2 che esegue l'agente del container Amazon ECS ed è stata registrata in un cluster. In questa sezione, verrà lanciata un'istanza EC2 utilizzando l'AMI ottimizzata per ECS.

**Per avviare un'istanza di contenitore con AWS CLI**

1. Recupera l'ID AMI Amazon Linux 2 più recente ottimizzato per ECS utilizzando Regione AWS il seguente comando. Questo comando utilizza AWS Systems Manager Parameter Store per ottenere l'ID AMI ottimizzato per ECS più recente. L'AMI include l'agente del container Amazon ECS e il runtime di Docker preinstallati.

   ```
   aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/recommended --query 'Parameters[0].Value' --output text | jq -r '.image_id'
   ```

   Output:

   ```
   ami-abcd1234
   ```

1. Creare un gruppo di sicurezza che consenta l'accesso SSH per la gestione dell'istanza di container e l'accesso HTTP per il server web.

   ```
   aws ec2 create-security-group --group-name ecs-tutorial-sg --description "ECS tutorial security group"
   ```

   Output:

   ```
   {
       "GroupId": "sg-abcd1234"
   }
   ```

1. Aggiungere una regola in entrata al gruppo di sicurezza eseguendo il seguente comando.

   ```
   aws ec2 authorize-security-group-ingress --group-id sg-abcd1234 --protocol tcp --port 80 --cidr 0.0.0.0/0
   ```

   Output:

   ```
   {
       "Return": true,
       "SecurityGroupRules": [
           {
               "SecurityGroupRuleId": "sgr-efgh5678",
               "GroupId": "sg-abcd1234",
               "GroupOwnerId": "123456789012",
               "IsEgress": false,
               "IpProtocol": "tcp",
               "FromPort": 80,
               "ToPort": 80,
               "CidrIpv4": "0.0.0.0/0"
           }
       ]
   }
   ```

   Ora il gruppo di sicurezza consente l'accesso SSH dall'intervallo IP specificato e l'accesso HTTP da qualsiasi posizione. In un ambiente di produzione, è necessario limitare l'accesso SSH al proprio indirizzo IP specifico e valutare la possibilità di limitare l'accesso HTTP in base alle esigenze.

1. Creare una coppia di chiavi EC2 per l'accesso SSH all'istanza di container.

   ```
   aws ec2 create-key-pair --key-name ecs-tutorial-key --query 'KeyMaterial' --output text > ecs-tutorial-key.pem
   chmod 400 ecs-tutorial-key.pem
   ```

   La chiave privata viene salvata nel computer locale con autorizzazioni adeguate per l'accesso SSH.

1. Lanciare un'istanza EC2 utilizzando l'AMI ottimizzata per ECS e configurarla per unirsi al cluster.

   ```
   aws ec2 run-instances --image-id ami-abcd1234 --instance-type t3.micro --key-name ecs-tutorial-key --security-group-ids sg-abcd1234 --iam-instance-profile Name=ecsInstanceRole --user-data '#!/bin/bash
   echo ECS_CLUSTER=MyCluster >> /etc/ecs/ecs.config'
   {
       "Instances": [
           {
               "InstanceId": "i-abcd1234",
               "ImageId": "ami-abcd1234",
               "State": {
                   "Code": 0,
                   "Name": "pending"
               },
               "PrivateDnsName": "",
               "PublicDnsName": "",
               "StateReason": {
                   "Code": "pending",
                   "Message": "pending"
               },
               "InstanceType": "t3.micro",
               "KeyName": "ecs-tutorial-key",
               "LaunchTime": "2025-01-13T10:30:00.000Z"
           }
       ]
   }
   ```

   Lo script di dati utente configura l'agente Amazon ECS per registrare l'istanza in `MyCluster`. L'istanza utilizza il ruolo IAM `ecsInstanceRole`, che fornisce le autorizzazioni necessarie per l'agente.

## Elencare le istanze di container
<a name="AWSCLI_EC2_list_container_instances"></a>

Entro pochi minuti dal lancio dell'istanza del contenitore, l'agente Amazon ECS registra l'istanza nel cluster. MyCluster Per visualizzare l'elenco delle istanze di container in un cluster, esegui questo comando:

```
aws ecs list-container-instances --cluster MyCluster
```

Output:

```
{
    "containerInstanceArns": [
        "arn:aws:ecs:us-east-1:aws_account_id:container-instance/container_instance_ID"
    ]
}
```

## Descrivere l'istanza di container
<a name="AWSCLI_EC2_describe_container_instance"></a>

Dopo aver ottenuto l'ARN o l'ID di un'istanza di container, puoi utilizzare il comando **describe-container-instances** per ottenere informazioni importanti sull'istanza, ad esempio le risorse di CPU e memoria registrate e quelle ancora disponibili.

```
aws ecs describe-container-instances --cluster MyCluster --container-instances container_instance_ID
```

Output:

```
{
    "failures": [],
    "containerInstances": [
        {
            "status": "ACTIVE",
            "registeredResources": [
                {
                    "integerValue": 1024,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "CPU",
                    "doubleValue": 0.0
                },
                {
                    "integerValue": 995,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "MEMORY",
                    "doubleValue": 0.0
                },
                {
                    "name": "PORTS",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [
                        "22",
                        "2376",
                        "2375",
                        "51678"
                    ],
                    "type": "STRINGSET",
                    "integerValue": 0
                },
                {
                    "name": "PORTS_UDP",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [],
                    "type": "STRINGSET",
                    "integerValue": 0
                }
            ],
            "ec2InstanceId": "instance_id",
            "agentConnected": true,
            "containerInstanceArn": "arn:aws:ecs:us-west-2:aws_account_id:container-instance/container_instance_ID",
            "pendingTasksCount": 0,
            "remainingResources": [
                {
                    "integerValue": 1024,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "CPU",
                    "doubleValue": 0.0
                },
                {
                    "integerValue": 995,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "MEMORY",
                    "doubleValue": 0.0
                },
                {
                    "name": "PORTS",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [
                        "22",
                        "2376",
                        "2375",
                        "51678"
                    ],
                    "type": "STRINGSET",
                    "integerValue": 0
                },
                {
                    "name": "PORTS_UDP",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [],
                    "type": "STRINGSET",
                    "integerValue": 0
                }
            ],
            "runningTasksCount": 0,
            "attributes": [
                {
                    "name": "com.amazonaws.ecs.capability.privileged-container"
                },
                {
                    "name": "com.amazonaws.ecs.capability.docker-remote-api.1.17"
                },
                {
                    "name": "com.amazonaws.ecs.capability.docker-remote-api.1.18"
                },
                {
                    "name": "com.amazonaws.ecs.capability.docker-remote-api.1.19"
                },
                {
                    "name": "com.amazonaws.ecs.capability.logging-driver.json-file"
                },
                {
                    "name": "com.amazonaws.ecs.capability.logging-driver.syslog"
                }
            ],
            "versionInfo": {
                "agentVersion": "1.5.0",
                "agentHash": "b197edd",
                "dockerVersion": "DockerVersion: 1.7.1"
            }
        }
    ]
}
```

È inoltre possibile trovare l'ID istanza Amazon EC2 che è possibile utilizzare per monitorare l'istanza nella console Amazon EC2 o con il comando **aws ec2 describe-instances --instance-id *instance\$1id***.

## Registrare una definizione di attività
<a name="AWSCLI_EC2_register_task_definition"></a>

Prima di eseguire un'attività Windows nel cluster Amazon ECS, è necessario registrare una definizione di attività. Le definizioni di attività sono elenchi di container raggruppati. L'esempio seguente illustra una semplice definizione di attività che utilizza un'immagine `nginx`. Per ulteriori informazioni sui parametri disponibili per la definizione di attività, consulta [Definizioni dei processi di Amazon ECS](task_definitions.md).

```
{
    "family": "nginx-task",
    "containerDefinitions": [
        {
            "name": "nginx",
            "image": "public.ecr.aws/ecs-sample-image/amazon-ecs-sample:latest",
            "cpu": 256,
            "memory": 512,
            "essential": true,
            "portMappings": [
                {
                    "containerPort": 80,
                    "hostPort": 80,
                    "protocol": "tcp"
                }
            ]
        }
    ],
    "requiresCompatibilities": ["EC2"],
    "networkMode": "bridge"
}
```

L'esempio precedente JSON può essere passato a a AWS CLI in due modi: puoi salvare la definizione dell'attività JSON come file e passarla con l'opzione. `--cli-input-json file://path_to_file.json` Oppure è possibile inserire il carattere di escape prima delle virgolette nel JSON e trasmettere le definizioni del container JSON nella riga di comando. Se scegli di trasmettere le definizioni del container nella riga di comando, è necessario aggiungere al comando il parametro `--family` utilizzato per mantenere la reciproca associazione tra più versioni della definizione di attività.

Per utilizzare un file JSON per le definizioni dei container:

```
aws ecs register-task-definition --cli-input-json file://$HOME/tasks/nginx.json
```

Il comando **register-task-definition** restituisce una descrizione della definizione di attività una volta completata la registrazione.

```
{
    "taskDefinition": {
        "taskDefinitionArn": "arn:aws:ecs:us-east-1:123456789012:task-definition/nginx-task:1",
        "family": "nginx-task",
        "revision": 1,
        "status": "ACTIVE",
        "containerDefinitions": [
            {
                "name": "nginx",
                "image": "public.ecr.aws/docker/library/nginx:latest",
                "cpu": 256,
                "memory": 512,
                "essential": true,
                "portMappings": [
                    {
                        "containerPort": 80,
                        "hostPort": 80,
                        "protocol": "tcp"
                    }
                ],
                "environment": [],
                "mountPoints": [],
                "volumesFrom": []
            }
        ],
        "volumes": [],
        "networkMode": "bridge",
        "compatibilities": [
            "EC2"
        ],
        "requiresCompatibilities": [
            "EC2"
        ]
    }
}
```

## Elencare le definizioni di attività
<a name="AWSCLI_EC2_list_task_definitions"></a>

Puoi sempre ottenere un elenco delle definizioni di attività per il tuo account tramite il comando **list-task-definitions**. Il risultato restituito dal comando mostra i valori `family` e `revision` che possono essere utilizzati insieme nelle chiamate **create-service**.

```
aws ecs list-task-definitions
```

Output:

```
{
    "taskDefinitionArns": [
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/sleep360:1",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/sleep360:2",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/nginx-task:1",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:3",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:4",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:5",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:6"
    ]
}
```

## Creazione di un servizio
<a name="AWSCLI_EC2_run_task"></a>

Dopo aver registrato un'attività per l'account e aver lanciato un'istanza di container registrata nel cluster, è possibile creare un servizio Amazon ECS che esegua e gestisca il numero desiderato di attività in contemporanea utilizzando la definizione di attività registrata. Per questo esempio, si inserisce una singola istanza della definizione dell'`nginx:1`attività nel cluster MyCluster .

```
aws ecs create-service --cluster MyCluster --service-name nginx-service --task-definition nginx-task:1 --desired-count 1
```

Output:

```
{
    "service": {
        "serviceArn": "arn:aws:ecs:us-east-1:aws_account_id:service/MyCluster/nginx-service",
        "serviceName": "nginx-service",
        "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
        "taskDefinition": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
        "desiredCount": 1,
        "runningCount": 0,
        "pendingCount": 0,
        "launchType": "EC2",
        "status": "ACTIVE",
        "createdAt": "2025-01-13T10:45:00.000Z"
    }
}
```

## Elencare i servizi
<a name="AWSCLI_EC2_list_tasks"></a>

Ottieni un elenco dei servizi per il tuo cluster. Verrà visualizzato il servizio creato nella sezione precedente. In seguito sarà possibile utilizzare l'ID del servizio o l'ARN completo restituito da questo comando per la descrizione del servizio.

```
aws ecs list-services --cluster MyCluster
```

Output:

```
{
    "taskArns": [
        "arn:aws:ecs:us-east-1:aws_account_id:task/task_ID"
    ]
}
```

## Descrivere il servizio
<a name="AWSCLI_EC2_describe_service"></a>

Descrivere il servizio utilizzando il seguente comando per ottenere maggiori informazioni sul servizio.

```
aws ecs describe-services --cluster MyCluster --services nginx-service
```

Output:

```
{
    "services": [
        {
            "serviceArn": "arn:aws:ecs:us-east-1:aws_account_id:service/MyCluster/nginx-service",
            "serviceName": "nginx-service",
            "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
            "taskDefinition": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
            "desiredCount": 1,
            "runningCount": 1,
            "pendingCount": 0,
            "launchType": "EC2",
            "status": "ACTIVE",
            "createdAt": "2025-01-13T10:45:00.000Z",
            "events": [
                {
                    "id": "abcd1234-5678-90ab-cdef-1234567890ab",
                    "createdAt": "2025-01-13T10:45:30.000Z",
                    "message": "(service nginx-service) has started 1 tasks: (task abcd1234-5678-90ab-cdef-1234567890ab)."
                }
            ]
        }
    ]
}
```

## Descrivere l'attività in esecuzione
<a name="AWSCLI_EC2_describe_task"></a>

Dopo aver descritto il servizio, eseguire il seguente comando per ottenere maggiori informazioni sull'attività in esecuzione nell'ambito del servizio.

```
aws ecs list-tasks --cluster MyCluster --service-name nginx-service
```

 Output: 

```
{
    "tasks": [
        {
            "taskArn": "arn:aws:ecs:us-east-1:aws_account_id:task/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
            "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
            "taskDefinitionArn": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
            "containerInstanceArn": "arn:aws:ecs:us-east-1:aws_account_id:container-instance/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
            "lastStatus": "RUNNING",
            "desiredStatus": "RUNNING",
            "containers": [
                {
                    "containerArn": "arn:aws:ecs:us-east-1:aws_account_id:container/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab/abcd1234-5678-90ab-cdef-1234567890ab",
                    "taskArn": "arn:aws:ecs:us-east-1:aws_account_id:task/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
                    "name": "nginx",
                    "lastStatus": "RUNNING",
                    "networkBindings": [
                        {
                            "bindIP": "0.0.0.0",
                            "containerPort": 80,
                            "hostPort": 80,
                            "protocol": "tcp"
                        }
                    ]
                }
            ],
            "createdAt": "2025-01-13T10:45:00.000Z",
            "startedAt": "2025-01-13T10:45:30.000Z"
        }
    ]
}
```

## Testare il server web
<a name="AWSCLI_EC2_test_web_server"></a>

**Per testare il server web**

1. Recuperare l'indirizzo IP pubblico dell'istanza di container eseguendo il seguente comando.

   ```
   aws ec2 describe-instances --instance-ids i-abcd1234 --query 'Reservations[0].Instances[0].PublicIpAddress' --output text
   ```

   Output:

   ```
   203.0.113.25
   ```

1. Dopo aver recuperato l'indirizzo IP, eseguire il seguente comando `curl` con tale indirizzo.

   ```
   curl http://203.0.113.25
   ```

   Output:

   ```
   <!DOCTYPE html>
   <html>
   <head>
   <title>Welcome to nginx!</title>
   ...
   </head>
   <body>
   <h1>Welcome to nginx!</h1>
   <p>If you can see this page, the nginx web server is successfully installed and working.</p>
   ...
   </body>
   </html>
   ```

   La pagina di benvenuto di nginx conferma che il servizio è in esecuzione correttamente ed è accessibile da Internet.

## Eseguire la pulizia delle risorse
<a name="AWSCLI_EC2_clean_up_resources"></a>

Per evitare gli addebiti, eliminare le risorse create in questo tutorial.

**Per eliminare le risorse**

1. Aggiornare il servizio in modo che le attività desiderate siano pari a zero, quindi eliminare il servizio.

   ```
   aws ecs update-service --cluster MyCluster --service nginx-service --desired-count 0
   {
       "service": {
           "serviceArn": "arn:aws:ecs:us-east-1:123456789012:service/MyCluster/nginx-service",
           "serviceName": "nginx-service",
           "desiredCount": 0,
           "runningCount": 1,
           "pendingCount": 0,
           "status": "ACTIVE"
       }
   }
   ```

1. Attendere l'arresto delle attività in esecuzione, poi eliminare il servizio.

   ```
   aws ecs delete-service --cluster MyCluster --service nginx-service
   {
       "service": {
           "serviceArn": "arn:aws:ecs:us-east-1:123456789012:service/MyCluster/nginx-service",
           "serviceName": "nginx-service",
           "status": "DRAINING"
       }
   }
   ```

1. Terminare l'istanza di container creata.

   ```
   aws ec2 terminate-instances --instance-ids i-abcd1234
   {
       "TerminatingInstances": [
           {
               "InstanceId": "i-abcd1234",
               "CurrentState": {
                   "Code": 32,
                   "Name": "shutting-down"
               },
               "PreviousState": {
                   "Code": 16,
                   "Name": "running"
               }
           }
       ]
   }
   ```

1. Eliminare il gruppo di sicurezza e la coppia di chiave creati.

   ```
   aws ec2 delete-security-group --group-id sg-abcd1234
   aws ec2 delete-key-pair --key-name ecs-tutorial-key
   rm ecs-tutorial-key.pem
   ```

1. Elimina il cluster Amazon ECS.

   ```
   aws ecs delete-cluster --cluster MyCluster
   {
       "cluster": {
           "clusterArn": "arn:aws:ecs:us-east-1:123456789012:cluster/MyCluster",
           "clusterName": "MyCluster",
           "status": "INACTIVE"
       }
   }
   ```

# Configurazione di Amazon ECS per CloudWatch ascoltare gli eventi Events
<a name="ecs_cwet"></a>

Scopri come configurare una semplice funzione Lambda che ascolta gli eventi delle attività e li scrive in un flusso di log di CloudWatch Logs.

## Prerequisito: configurazione di un cluster di verifica
<a name="cwet_step_1"></a>

Se non disponi di un cluster in esecuzione da cui acquisire eventi, segui la procedura descritta in [Creazione di un cluster Amazon ECS per i carichi di lavoro Fargate](create-cluster-console-v2.md) per crearne uno. Al termine del tutorial, potrai eseguire un processo su questo cluster per verificare la corretta configurazione della funzione Lambda. 

## Fase 1: Creazione della funzione Lambda
<a name="cwet_step_2"></a>

In questa procedura, viene creata una funzione Lambda semplice che funge da destinazione per i messaggi del flusso di eventi di Amazon ECS. 

1. Apri la console all' AWS Lambda indirizzo. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)

1. Scegli **Crea funzione**. 

1. In **Author from scratch** (Crea da zero) effettua le seguenti operazioni:

   1. In **Name (Nome)**, immetti un valore. 

   1. In **Runtime**, scegli la versione di Python, ad esempio, **Python 3.9**.

   1. In **Role (Ruolo)**, scegliere **Create a new role with basic Lambda permissions (Crea un nuovo ruolo con le autorizzazioni Lambda di base)**.

1. Scegli **Crea funzione**.

1. Nella sezione **Function code** (Codice della funzione), modifica il codice di esempio affinché corrisponda all'esempio seguente:

   ```
   import json
   
   def lambda_handler(event, context):
       if event["source"] != "aws.ecs":
          raise ValueError("Function only supports input from events with a source type of: aws.ecs")
          
       print('Here is the event:')
       print(json.dumps(event))
   ```

   Si tratta di una funzione Python 3.9 semplice che stampa l'evento inviato da Amazon ECS. Se tutto è configurato correttamente, alla fine di questo tutorial, vedrai che i dettagli dell'evento vengono visualizzati nel flusso di log CloudWatch Logs associato a questa funzione Lambda.

1. Scegli **Save** (Salva).

## Fase 2: Registrazione di una regola di evento
<a name="cwet_step_3"></a>

 Successivamente, crei una regola CloudWatch degli eventi che acquisisce gli eventi delle attività provenienti dai tuoi cluster Amazon ECS. Questa regola acquisisce tutti gli eventi provenienti da tutti i cluster all'interno dell'account in cui è definita. Gli stessi messaggi di attività contengono informazioni sull'origine dell'evento, tra cui il cluster in cui esso risiede, utilizzabile per filtrare e ordinare gli eventi in modo programmatico. 

**Nota**  
Quando usi Console di gestione AWS per creare una regola di evento, la console aggiunge automaticamente le autorizzazioni IAM necessarie per concedere a CloudWatch Events l'autorizzazione a chiamare la tua funzione Lambda. Se stai creando una regola di evento utilizzando il AWS CLI, devi concedere questa autorizzazione in modo esplicito. Per ulteriori informazioni, consulta [Events in Amazon EventBridge e Amazon EventBridge ](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events.html) [Event Patterns](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-patterns.html) nella *Amazon EventBridge User Guide*.

**Come instradare gli eventi alla funzione Lambda**

1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Nel pannello di navigazione, selezionare prima **Events (Eventi)**, quindi **Rules (Regole)** e infine **Create rule (Crea regola)**.

1. In **Event Source** (Origine eventi), scegli **ECS** come origine evento. Di default, questa regola si applica a tutti gli eventi di Amazon ECS per tutti i gruppi Amazon ECS. In alternativa, puoi selezionare eventi specifici o un gruppo specifico di Amazon ECS.

1. In **Targets** (Destinazioni), scegli **Add target** (Aggiungi destinazione), in **Target type** (Tipo di destinazione) scegli **Lambda function** (Funzione Lambda) quindi seleziona la tua funzione Lambda.

1. Scegli **Configura dettagli**.

1. In **Rule definition** (Definizione regola), digita un nome e una descrizione per la regola, quindi seleziona **Create rule** (Crea regola).

## Fase 3: creazione di una definizione di attività
<a name="cwet_step_task-def"></a>

Crea una definizione di attività.

1. Apri la console nella [https://console.aws.amazon.com/ecs/versione 2](https://console.aws.amazon.com/ecs/v2).

1. Nel riquadro di navigazione, scegli **Definizioni di attività**.

1. Scegli **Create new Task Definition** (Crea nuova definizione di attività), **Create new revision with JSON** (Crea nuova revisione con JSON).

1. Copia e incolla la seguente definizione di attività di esempio nella casella, quindi scegli **Save (Salva)**.

   ```
   {
      "containerDefinitions": [ 
         { 
            "command": [
               "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
            ],
            "entryPoint": [
               "sh",
               "-c"
            ],
            "essential": true,
            "image": "public.ecr.aws/docker/library/httpd:2.4",
            "logConfiguration": { 
               "logDriver": "awslogs",
               "options": { 
                  "awslogs-group" : "/ecs/fargate-task-definition",
                  "awslogs-region": "us-east-1",
                  "awslogs-stream-prefix": "ecs"
               }
            },
            "name": "sample-fargate-app",
            "portMappings": [ 
               { 
                  "containerPort": 80,
                  "hostPort": 80,
                  "protocol": "tcp"
               }
            ]
         }
      ],
      "cpu": "256",
      "executionRoleArn": "arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
      "family": "fargate-task-definition",
      "memory": "512",
      "networkMode": "awsvpc",
      "runtimePlatform": {
           "operatingSystemFamily": "LINUX"
       },
      "requiresCompatibilities": [ 
          "FARGATE" 
       ]
   }
   ```

1. Scegli **Create** (Crea).

## Fase 4: Test della regola
<a name="cwet_step_4"></a>

 Infine, crei una regola CloudWatch degli eventi che acquisisce gli eventi delle attività provenienti dai tuoi cluster Amazon ECS. Questa regola acquisisce tutti gli eventi provenienti da tutti i cluster all'interno dell'account in cui è definita. Gli stessi messaggi di attività contengono informazioni sull'origine dell'evento, tra cui il cluster in cui esso risiede, utilizzabile per filtrare e ordinare gli eventi in modo programmatico. 

**Per testare la regola**

1. [Apri la console nella versione 2. https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/v2)

1. Scegli **Task definitions** (Definizioni di attività).

1. Scegli **console-sample-app-static**, quindi scegli **Distribuisci**, **Esegui nuova attività**.

1. Per **Cluster**, scegli l'impostazione predefinita, quindi scegli **Deploy** (Implementa).

1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Nel pannello di navigazione, scegli **Logs** e seleziona il gruppo di log per la tua funzione Lambda (ad esempio**,** *my-function* /aws/lambda/).

1. Seleziona un flusso di log per visualizzare i dati di evento. 

# Invio di avvisi di Amazon Simple Notification Service per gli eventi di attività Amazon ECS arrestate
<a name="ecs_cwet2"></a>

Configura una regola di EventBridge evento Amazon che acquisisca solo gli eventi delle attività in cui l'attività ha smesso di essere eseguita perché uno dei suoi contenitori essenziali è terminato. L'evento invia solo eventi di processo con una specifica proprietà `stoppedReason` all'argomento Amazon SNS designato.

## Prerequisito: configurazione di un cluster di verifica
<a name="cwet2_step_1"></a>

 Se non disponi di un cluster in esecuzione da cui acquisire eventi, segui la procedura descritta in [Nozioni di base sull'utilizzo della console con i container Linux su AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/getting-started-fargate.html#get-started-fargate-cluster) per crearne uno. Alla fine di questo tutorial, esegui un'attività su questo cluster per verificare di aver configurato correttamente l'argomento e la EventBridge regola di Amazon SNS. 

## Prerequisito: configurazione delle autorizzazioni per Amazon SNS
<a name="cwet2_step_1a"></a>

 EventBridge Per consentire la pubblicazione su un argomento Amazon SNS, usa i comandi aws sns get-topic-attributes e aws sns. set-topic-attributes 

Per ulteriori informazioni su come aggiungere l'autorizzazione, consulta la sezione [Amazon SNS permissions](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html#eb-sns-permissions) (Autorizzazioni di Amazon SNS) nella *Guida per gli sviluppatori di Amazon Simple Notification Service*.

Aggiungi le autorizzazioni seguenti:

```
{
  "Sid": "PublishEventsToMyTopic",
  "Effect": "Allow",
  "Principal": {
     "Service": "events.amazonaws.com"
  },
  "Action": "sns: Publish",
  "Resource": "arn:aws:sns:region:account-id:TaskStoppedAlert",
}
```

## Fase 1: Creazione e sottoscrizione a un argomento Amazon SNS
<a name="cwet2_step_2"></a>

 In questo tutorial, configuri un argomento Amazon SNS che funga da destinazione evento per la nuova regola di evento. 

Per informazioni sulla creazione e l'abbonamento a un argomento Amazon SNS, consulta [Nozioni di base su Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-getting-started.html#step-create-queue) nella *Guida per gli sviluppatori di Amazon Simple Notification Service* e utilizza la tabella seguente per determinare quali opzioni selezionare.


| Opzione | Valore | 
| --- | --- | 
|  Tipo  | Standard | 
| Name |  TaskStoppedAlert  | 
| Protocollo | Email | 
| Endpoint |  Un indirizzo e-mail a cui hai attualmente accesso  | 

## Fase 2: Registrazione di una regola di evento
<a name="cwet2_step_3"></a>

 Successivamente, registra una regola dell'evento che acquisisca solo eventi di arresto dell'attività per attività con container interrotti. 

Per informazioni su come creare e sottoscrivere un argomento di Amazon SNS, consulta [Create a rule EventBridge in Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-get-started.html) nella *Amazon EventBridge User Guide* e utilizza la tabella seguente per determinare quali opzioni selezionare.


| Opzione | Valore | 
| --- | --- | 
|  Tipo di regola  |  Regola con un modello di evento  | 
| Origine eventi | AWS eventi o eventi per i EventBridge partner | 
| Modello di evento |  Modello personalizzato (editor JSON)  | 
| Modello di evento |  <pre>{<br />   "source":[<br />      "aws.ecs"<br />   ],<br />   "detail-type":[<br />      "ECS Task State Change"<br />   ],<br />   "detail":{<br />      "lastStatus":[<br />         "STOPPED"<br />      ],<br />      "stoppedReason":[<br />         "Essential container in task exited"<br />      ]<br />   }<br />}</pre> | 
| Target type (Tipo di destinazione) |  AWS servizio  | 
| Target | Argomento SNS | 
| Topic |  TaskStoppedAlert (L'argomento che hai creato nel passaggio 1)  | 

## Fase 3: Test del tuo articolo
<a name="cwet2_step_4"></a>

Verificare che la regola funzioni eseguendo un'attività che termine poco dopo l'avvio. Se la regola dell'evento è configurata correttamente, riceverai una e-mail contenente il testo dell'evento entro pochi minuti. Se si dispone di una definizione di attività esistente in grado di soddisfare i requisiti della regola, eseguire un'attività utilizzando tale definizione. In caso contrario, le fasi seguenti descrivono la procedura di registrazione di una definizione di attività Fargate e la relativa esecuzione.

1. Apri la console nella [https://console.aws.amazon.com/ecs/versione 2](https://console.aws.amazon.com/ecs/v2).

1. Nel pannello di navigazione, scegli **Task Definitions** (Definizioni di processo).

1. Scegli **Create new task definition** (Crea nuova definizione di attività), **Create new task definition with JSON** (Crea nuova definizione di attività con JSON).

1. Nella casella dell'editor JSON, modifica il file JSON e copia quanto segue nell'editor.

   ```
   {
      "containerDefinitions":[
         {
            "command":[
               "sh",
               "-c",
               "sleep 5"
            ],
            "essential":true,
            "image":"public.ecr.aws/amazonlinux/amazonlinux:latest",
            "name":"test-sleep"
         }
      ],
      "cpu":"256",
      "executionRoleArn":"arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
      "family":"fargate-task-definition",
      "memory":"512",
      "networkMode":"awsvpc",
      "requiresCompatibilities":[
         "FARGATE"
      ]
   }
   ```

1. Scegli **Create** (Crea).

**Per eseguire un'attività dalla console**

1. Apri la console nella [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. Nella pagina **Cluster**, scegli il cluster che hai creato nei prerequisiti.

1. Dalla scheda **Processi**, scegli **Esegui nuovo processo**.

1. Per **Tipo di applicazione**, scegli **Processo**.

1. Per **Definizione dell'attività**, scegli **fargate-task-definition**.

1. Per **Desired tasks** (Attività desiderate), specifica il numero di attività da avviare.

1. Scegli **Create** (Crea).

# Concatenazione di messaggi di log Amazon ECS multilinea o di traccia dello stack
<a name="firelens-concatanate-multiline"></a>

A partire AWS dalla versione 2.22.0 di Fluent Bit, è incluso un filtro multilinea. Il filtro multilinea aiuta a concatenare i messaggi di log originariamente appartenenti a un contesto ma suddivisi su più record o righe di registro. Per ulteriori informazioni sul filtro multilinea, consulta la [documentazione di Fluent Bit](https://docs.fluentbit.io/manual/pipeline/filters/multiline-stacktrace). 

Esempi comuni di messaggi di log divisi sono:
+ Tracce dello stack. 
+ Applicazioni che stampano i log su più righe. 
+ Registra i messaggi che sono stati divisi perché erano più lunghi della dimensione massima del buffer di runtime specificata. [È possibile concatenare i messaggi di registro suddivisi in base al runtime del contenitore seguendo l'esempio su GitHub: Esempio: Concatenate Container Logs. FireLens Partial/Split ](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/fluent-bit/filter-multiline-partial-message-mode)

## Autorizzazioni IAM richieste
<a name="iam-permissions"></a>

Disponi delle autorizzazioni IAM necessarie affinché l'agente container estragga le immagini del contenitore da Amazon ECR e che il container instrada i log verso Logs. CloudWatch 

Per tali autorizzazioni devi disporre anche dei seguenti ruoli: 
+ Un ruolo IAM del processo. 
+ Un ruolo IAM di esecuzione di attività. 

Sono necessarie le seguenti autorizzazioni:
+ `logs:CreateLogStream`
+ `logs:CreateLogGroup`
+ `logs:PutLogEvents`

## Determinazione dei casi in cui utilizzare l'impostazione del log multilinea
<a name="determine-filter"></a>

Di seguito sono riportati alcuni esempi di frammenti di log visualizzati nella console CloudWatch Logs con l'impostazione di registro predefinita. Puoi guardare la riga che inizia con `log` per determinare se è necessario il filtro multilinea. Quando il contesto è lo stesso, puoi utilizzare l'impostazione di registro multilinea. In questo esempio, il contesto è «com.myproject.model». MyProject».

```
2022-09-20T15:47:56:595-05-00                           {"container_id": "82ba37cada1d44d389b03e78caf74faa-EXAMPLE", "container_name": "example-app", "source=": "stdout", "log": ": "     at com.myproject.modele.(MyProject.badMethod.java:22)",
    {
      "container_id":  "82ba37cada1d44d389b03e78caf74faa-EXAMPLE",
      "container_name: ": "example-app",
      "source": "stdout",
      "log": ": "     at com.myproject.model.MyProject.badMethod(MyProject.java:22)",
      "ecs_cluster": "default",
      "ecs_task_arn": "arn:aws:region:123456789012:task/default/b23c940d29ed4714971cba72cEXAMPLE",
      "ecs_task_definition": "firelense-example-multiline:3"
     }
```

```
2022-09-20T15:47:56:595-05-00                           {"container_id": "82ba37cada1d44d389b03e78caf74faa-EXAMPLE", "container_name": "example-app", "stdout", "log": ": "     at com.myproject.modele.(MyProject.oneMoreMethod.java:18)",
    {
      "container_id":  "82ba37cada1d44d389b03e78caf74faa-EXAMPLE",
      "container_name: ": "example-app",
      "source": "stdout",
      "log": ": "     at com.myproject.model.MyProject.oneMoreMethod(MyProject.java:18)",
      "ecs_cluster": "default",
      "ecs_task_arn": "arn:aws:region:123456789012:task/default/b23c940d29ed4714971cba72cEXAMPLE,
      "ecs_task_definition": "firelense-example-multiline:3"
     }
```

Dopo aver utilizzato l'impostazione del log multilinea, l'output sarà simile all'esempio seguente. 

```
2022-09-20T15:47:56:595-05-00                           {"container_id": "82ba37cada1d44d389b03e78caf74faa-EXAMPLE", "container_name": "example-app", "stdout",...
    {
      "container_id":  "82ba37cada1d44d389b03e78caf74faa-EXAMPLE",
      "container_name: ": "example-app",
      "source": "stdout",
      "log:    "September 20, 2022 06:41:48 Exception in thread \"main\" java.lang.RuntimeException: Something has gone wrong, aborting!\n    
    at com.myproject.module.MyProject.badMethod(MyProject.java:22)\n    at   
    at com.myproject.model.MyProject.oneMoreMethod(MyProject.java:18) com.myproject.module.MyProject.main(MyProject.java:6)",
      "ecs_cluster": "default",
      "ecs_task_arn": "arn:aws:region:123456789012:task/default/b23c940d29ed4714971cba72cEXAMPLE",
      "ecs_task_definition": "firelense-example-multiline:2"
     }
```

## Opzioni di analisi e concatenazione
<a name="parse-multiline-log"></a>

Per analizzare i log e concatenare righe divise a causa di nuove righe, puoi utilizzare una di queste due opzioni.
+ Utilizza il tuo file parser contenente le regole per analizzare e concatenare le righe che appartengono allo stesso messaggio.
+ Utilizzare un parser integrato Fluent Bit. Per l'elenco dei linguaggi supportati dai parser integrati Fluent Bit, consulta la [documentazione di Fluent Bit.](https://docs.fluentbit.io/manual/pipeline/filters/multiline-stacktrace)

Il seguente tutorial illustra i passaggi per ogni caso d'uso. I passaggi mostrano come concatenare più righe e inviare i log ad Amazon. CloudWatch Puoi specificare una destinazione diversa per i log.

### Esempio: utilizzare un parser creato
<a name="customer-parser"></a>

In questo esempio eseguirai i passaggi seguenti: 

1. Crea e carica l'immagine per un container Fluent Bit. 

1. Crea e carica l'immagine per un'applicazione demo multilinea che esegue, fallisce e genera una traccia dello stack multilinea.

1. Crea la definizione di un processo e avviare il processo. 

1. Visualizza i log per verificare che i messaggi che si estendono su più righe appaiano concatenati. 

**Creare e caricare l'immagine per un container Fluent Bit**

Questa immagine includerà il file parser in cui si specifica l'espressione regolare e un file di configurazione che fa riferimento al file parser. 

1. Crea una cartella con il nome `FluentBitDockerImage`. 

1. Nella cartella, crea il file parser contenente le regole per analizzare il log e concatenare le righe che appartengono allo stesso messaggio.

   1. Incolla i contenuti seguenti nel file parser:

      ```
      [MULTILINE_PARSER]
          name          multiline-regex-test
          type          regex
          flush_timeout 1000
          #
          # Regex rules for multiline parsing
          # ---------------------------------
          #
          # configuration hints:
          #
          #  - first state always has the name: start_state
          #  - every field in the rule must be inside double quotes
          #
          # rules |   state name  | regex pattern                  | next state
          # ------|---------------|--------------------------------------------
          rule      "start_state"   "/(Dec \d+ \d+\:\d+\:\d+)(.*)/"  "cont"
          rule      "cont"          "/^\s+at.*/"                     "cont"
      ```

      Mentre personalizzi il modello di regex, ti consigliamo di utilizzare un editor di espressioni regolari per provare l'espressione.

   1. Salva il file con nome `parsers_multiline.conf`. 

1. All'interno della cartella `FluentBitDockerImage`, crea un file di configurazione personalizzato che fa riferimento al file parser creato nel passaggio precedente.

   Per ulteriori informazioni sul file di configurazione personalizzato, consulta [Specifica di un file di configurazione personalizzato](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-taskdef.html#firelens-taskdef-customconfig) nella *Guida per gli sviluppatori di Amazon Elastic Container Service* 

   1. Incolla i contenuti seguenti nel file:

      ```
      [SERVICE]
          flush                 1
          log_level             info
          parsers_file          /parsers_multiline.conf
          
      [FILTER]
          name                  multiline
          match                 *
          multiline.key_content log
          multiline.parser      multiline-regex-test
      ```
**Nota**  
È necessario utilizzare il percorso assoluto del parser. 

   1. Salva il file con nome `extra.conf`. 

1. All'interno della cartella `FluentBitDockerImage`, crea il Dockerfile con l'immagine Fluent Bit e il parser e i file di configurazione creati.

   1. Incolla i contenuti seguenti nel file:

      ```
      FROM public.ecr.aws/aws-observability/aws-for-fluent-bit:latest
      
      ADD parsers_multiline.conf /parsers_multiline.conf
      ADD extra.conf /extra.conf
      ```

   1. Salva il file con nome `Dockerfile`.

1. Utilizzando il Dockerfile, crea un'immagine Fluent Bit personalizzata con il parser e i file di configurazione personalizzati inclusi.
**Nota**  
Puoi posizionare il file di analisi e il file di configurazione in qualsiasi punto dell'immagine Docker, tranne `/fluent-bit/etc/fluent-bit.conf` quando questo percorso del file viene utilizzato da. FireLens

   1. Crea l'immagine: `docker build -t fluent-bit-multiline-image.`

      Dove: `fluent-bit-multiline-image` è il nome dell'immagine in questo esempio.

   1. Verifica che l'immagine sia stata creata correttamente: `docker images —filter reference=fluent-bit-multiline-image` 

      In caso di esito positivo, l'output mostra l'immagine e il tag `latest`.

1. Carica l'immagine Fluent Bit personalizzata in Amazon Elastic Container Registry.

   1. Crea un repository Amazon ECR per archiviare l'immagine: `aws ecr create-repository --repository-name fluent-bit-multiline-repo --region us-east-1`

      Dove: `fluent-bit-multiline-repo` è il nome del repository e `us-east-1` è la regione in questo esempio. 

      L'output fornisce i dettagli del nuovo repository. 

   1. Applica un tag all'immagine con il valore `repositoryUri` ricavato dall'output precedente: `docker tag fluent-bit-multiline-image repositoryUri` 

      Ad esempio: `docker tag fluent-bit-multiline-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo` 

   1. Esegui l'immagine Docker per verificare che sia stata eseguita correttamente: `docker images —filter reference=repositoryUri`

      Nell'output, il nome del repository cambia da a fluent-bit-multiline-repo. `repositoryUri`

   1. Effettua l'autenticazione su Amazon ECR eseguendo il comando `aws ecr get-login-password` e specificando l'ID del log in cui desideri eseguire l'autenticazione: `aws ecr get-login-password | docker login --username AWS --password-stdin registry ID.dkr.ecr.region.amazonaws.com` 

      Ad esempio: `ecr get-login-password | docker login --username AWS --password-stdin xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com`

      Viene visualizzato un messaggio di accesso riuscito.

   1. Invia l'immagine ad Amazon ECR: `docker push registry ID.dkr.ecr.region.amazonaws.com/repository name` 

      Ad esempio: `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo`

**Crea e carica l'immagine per un'applicazione demo multilinea**

Questa immagine includerà un file di script Python che esegue l'applicazione e un file di log di esempio. 

Quando esegui il processo, l'applicazione simula le esecuzioni, quindi fallisce e crea una traccia dello stack. 

1. Crea una cartella denominata `multiline-app`: `mkdir multiline-app` 

1. Crea un file di script Python.

   1. Nella cartella `multiline-app`, crea un file con il nome `main.py`.

   1. Incolla i contenuti seguenti nel file:

      ```
      import os
      import time
      file1 = open('/test.log', 'r')
      Lines = file1.readlines()
       
      count = 0
      
      for i in range(10):
          print("app running normally...")
          time.sleep(1)
      
      # Strips the newline character
      for line in Lines:
          count += 1
          print(line.rstrip())
      print(count)
      print("app terminated.")
      ```

   1. Salvare il file `main.py`.

1. Crea un file di log di esempio. 

   1. Nella cartella `multiline-app`, crea un file con il nome `test.log`.

   1. Incolla i contenuti seguenti nel file:

      ```
      single line...
      Dec 14 06:41:08 Exception in thread "main" java.lang.RuntimeException: Something has gone wrong, aborting!
          at com.myproject.module.MyProject.badMethod(MyProject.java:22)
          at com.myproject.module.MyProject.oneMoreMethod(MyProject.java:18)
          at com.myproject.module.MyProject.anotherMethod(MyProject.java:14)
          at com.myproject.module.MyProject.someMethod(MyProject.java:10)
          at com.myproject.module.MyProject.main(MyProject.java:6)
      another line...
      ```

   1. Salvare il file `test.log`.

1. All'interno della cartella `multiline-app`, crea il Dockerfile.

   1. Incolla i contenuti seguenti nel file:

      ```
      FROM public.ecr.aws/amazonlinux/amazonlinux:latest
      ADD test.log /test.log
      
      RUN yum upgrade -y && yum install -y python3
      
      WORKDIR /usr/local/bin
      
      COPY main.py .
      
      CMD ["python3", "main.py"]
      ```

   1. Salvare il file `Dockerfile`.

1. Usando il Dockerfile, crea un'immagine.

   1. Crea l'immagine: `docker build -t multiline-app-image `

      Dove: `multiline-app-image` è il nome dell'immagine in questo esempio.

   1. Verifica che l'immagine sia stata creata correttamente: `docker images —filter reference=multiline-app-image` 

      In caso di esito positivo, l'output mostra l'immagine e il tag `latest`.

1. Carica l'immagine nel registro del container Amazon Elastic.

   1. Crea un repository Amazon ECR per archiviare l'immagine: `aws ecr create-repository --repository-name multiline-app-repo --region us-east-1`

      Dove: `multiline-app-repo` è il nome del repository e `us-east-1` è la regione in questo esempio. 

      L'output fornisce i dettagli del nuovo repository. Annota il valore `repositoryUri` poiché sarà necessario nei passaggi successivi. 

   1. Applica un tag all'immagine con il valore `repositoryUri` ricavato dall'output precedente: `docker tag multiline-app-image repositoryUri` 

      Ad esempio: `docker tag multiline-app-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo` 

   1. Esegui l'immagine Docker per verificare che sia stata eseguita correttamente: `docker images —filter reference=repositoryUri`

      Nell'output, il nome del repository cambia da `multiline-app-repo` al valore `repositoryUri`.

   1. Invia l'immagine ad Amazon ECR: `docker push aws_account_id.dkr.ecr.region.amazonaws.com/repository name` 

      Ad esempio: `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo`

**Crea la definizione di un processo e avviare il processo**

1. Crea un file di definizione del processo con il nome del file `multiline-task-definition.json`. 

1. Incolla i contenuti seguenti nel file `multiline-task-definition.json`: 

   ```
   {
       "family": "firelens-example-multiline",
       "taskRoleArn": "task role ARN,
       "executionRoleArn": "execution role ARN",
       "containerDefinitions": [
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-image:latest",
               "name": "log_router",
               "firelensConfiguration": {
                   "type": "fluentbit",
                   "options": {
                       "config-file-type": "file",
                       "config-file-value": "/extra.conf"
                   }
               },
               "memoryReservation": 50
           },
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/multiline-app-image:latest",
               "name": "app",
               "logConfiguration": {
                   "logDriver": "awsfirelens",
                   "options": {
                       "Name": "cloudwatch_logs",
                       "region": "us-east-1",
                       "log_group_name": "multiline-test/application",
                       "auto_create_group": "true",
                       "log_stream_prefix": "multiline-"
                   }
               },
               "memoryReservation": 100
           }
       ],
       "requiresCompatibilities": ["FARGATE"],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512"
   }
   ```

   Sostituisci quanto segue nella definizione del processo `multiline-task-definition.json`:

   1. `task role ARN`

      Per trovare l'ARN del ruolo del processo, vai alla Console IAM. Scegliere **Ruoli** e trovare il ruolo del processo `ecs-task-role-for-firelens` che è stato creato. Scegli il ruolo e copia l'**ARN** che appare nella sezione **Summary** (Riepilogo).

   1. `execution role ARN`

      Per trovare l'ARN del ruolo di esecuzione, vai alla Console IAM. Scegli **Roles** (Ruoli) e trova il ruolo `ecsTaskExecutionRole`. Scegli il ruolo e copia l'**ARN** che appare nella sezione **Summary** (Riepilogo).

   1. `aws_account_id`

      Per trovare l'`aws_account_id`, accedi alla Console di gestione AWS. Scegli il tuo nome utente in alto a destra e copia il tuo ID account.

   1. `us-east-1`

      Sostituisci la regione se necessario.

1. Registra il file di definizione del processo: `aws ecs register-task-definition --cli-input-json file://multiline-task-definition.json --region region` 

1. Apri la console alla [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. Nel pannello di navigazione, scegli **Task Definitions** (Definizioni dei processi) quindi scegli la famiglia `firelens-example-multiline`, perché sopra abbiamo registrato la definizione dell'attività processo in questa famiglia nella prima riga della definizione del processo.

1. Scegli la versione più recente. 

1. Scegli **Distribuisci**, **Esegui attività**. 

1. Nella pagina **Esegui attività**, in **Cluster** scegli il cluster, quindi in **Reti** scegli le sottoreti disponibili per tale attività in **Sottoreti**. 

1. Scegli **Create** (Crea). 

**Verifica che i messaggi di log multilinea in Amazon CloudWatch appaiano concatenati**

1. Apri la console all'indirizzo. CloudWatch [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)

1. Nel pannello di navigazione, espandi **Logs** (Log) e scegli **Log groups** (Gruppi di log). 

1. Scegli il gruppo di log `multiline-test/applicatio`. 

1. Scegli il log. Visualizza i messaggi. Le righe che corrispondono alle regole nel file parser vengono concatenate e appaiono come un singolo messaggio. 

   Il seguente frammento di log mostra le righe concatenate in un singolo evento di traccia dello stack Java: 

   ```
   {
       "container_id": "xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "log": "Dec 14 06:41:08 Exception in thread \"main\" java.lang.RuntimeException: Something has gone wrong, aborting!\n    at com.myproject.module.MyProject.badMethod(MyProject.java:22)\n    at com.myproject.module.MyProject.oneMoreMethod(MyProject.java:18)\n    at com.myproject.module.MyProject.anotherMethod(MyProject.java:14)\n    at com.myproject.module.MyProject.someMethod(MyProject.java:10)\n    at com.myproject.module.MyProject.main(MyProject.java:6)",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:2"
   }
   ```

   Il seguente frammento di log mostra come viene visualizzato lo stesso messaggio con una singola riga se esegui un container Amazon ECS non configurato per concatenare messaggi di log multilinea. 

   ```
   {
       "log": "Dec 14 06:41:08 Exception in thread \"main\" java.lang.RuntimeException: Something has gone wrong, aborting!",
       "container_id": "xxxxxx-xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:3"
   }
   ```

### Esempio: utilizzo di un parser integrato Fluent Bit
<a name="fluent-bit-parser"></a>

In questo esempio eseguirai i passaggi seguenti: 

1. Crea e carica l'immagine per un container Fluent Bit. 

1. Crea e carica l'immagine per un'applicazione demo multilinea che esegue, fallisce e genera una traccia dello stack multilinea.

1. Crea la definizione di un processo e avviare il processo. 

1. Visualizza i log per verificare che i messaggi che si estendono su più righe appaiano concatenati. 

**Crea e carica l'immagine per un container Fluent Bit**

Questa immagine includerà un file di configurazione che fa riferimento al parser Fluent Bit. 

1. Crea una cartella con il nome `FluentBitDockerImage`. 

1. All'interno della cartella `FluentBitDockerImage`, crea un file di configurazione personalizzato che fa riferimento al file parser integrato Fluent Bit.

   Per ulteriori informazioni sul file di configurazione personalizzato, consulta [Specifica di un file di configurazione personalizzato](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-taskdef.html#firelens-taskdef-customconfig) nella *Guida per gli sviluppatori di Amazon Elastic Container Service* 

   1. Incolla i contenuti seguenti nel file:

      ```
      [FILTER]
          name                  multiline
          match                 *
          multiline.key_content log
          multiline.parser      go
      ```

   1. Salva il file con nome `extra.conf`. 

1. All'interno della cartella `FluentBitDockerImage`, crea il Dockerfile con l'immagine Fluent Bit e il parser e i file di configurazione creati.

   1. Incolla i contenuti seguenti nel file:

      ```
      FROM public.ecr.aws/aws-observability/aws-for-fluent-bit:latest
      ADD extra.conf /extra.conf
      ```

   1. Salva il file con nome `Dockerfile`.

1. Utilizzando il Dockerfile, crea un'immagine Fluent Bit personalizzata con il file di configurazione personalizzato inclusi.
**Nota**  
È possibile posizionare il file di configurazione in qualsiasi punto dell'immagine Docker, a meno che `/fluent-bit/etc/fluent-bit.conf` questo percorso del file non venga utilizzato da FireLens.

   1. Crea l'immagine: `docker build -t fluent-bit-multiline-image.`

      Dove: `fluent-bit-multiline-image` è il nome dell'immagine in questo esempio.

   1. Verifica che l'immagine sia stata creata correttamente: `docker images —filter reference=fluent-bit-multiline-image` 

      In caso di esito positivo, l'output mostra l'immagine e il tag `latest`.

1. Carica l'immagine Fluent Bit personalizzata in Amazon Elastic Container Registry.

   1. Crea un repository Amazon ECR per archiviare l'immagine: `aws ecr create-repository --repository-name fluent-bit-multiline-repo --region us-east-1`

      Dove: `fluent-bit-multiline-repo` è il nome del repository e `us-east-1` è la regione in questo esempio. 

      L'output fornisce i dettagli del nuovo repository. 

   1. Applica un tag all'immagine con il valore `repositoryUri` ricavato dall'output precedente: `docker tag fluent-bit-multiline-image repositoryUri` 

      Ad esempio: `docker tag fluent-bit-multiline-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo` 

   1. Esegui l'immagine Docker per verificare che sia stata eseguita correttamente: `docker images —filter reference=repositoryUri`

      Nell'output, il nome del repository cambia da fluent-bit-multiline-repo a. `repositoryUri`

   1. Effettua l'autenticazione su Amazon ECR eseguendo il comando `aws ecr get-login-password` e specificando l'ID del log in cui desideri eseguire l'autenticazione: `aws ecr get-login-password | docker login --username AWS --password-stdin registry ID.dkr.ecr.region.amazonaws.com` 

      Ad esempio: `ecr get-login-password | docker login --username AWS --password-stdin xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com`

      Viene visualizzato un messaggio di accesso riuscito.

   1. Invia l'immagine ad Amazon ECR: `docker push registry ID.dkr.ecr.region.amazonaws.com/repository name` 

      Ad esempio: `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo`

**Crea e carica l'immagine per un'applicazione demo multilinea**

Questa immagine includerà un file di script Python che esegue l'applicazione e un file di log di esempio. 

1. Crea una cartella denominata `multiline-app`: `mkdir multiline-app` 

1. Crea un file di script Python.

   1. Nella cartella `multiline-app`, crea un file con il nome `main.py`.

   1. Incolla i contenuti seguenti nel file:

      ```
      import os
      import time
      file1 = open('/test.log', 'r')
      Lines = file1.readlines()
       
      count = 0
      
      for i in range(10):
          print("app running normally...")
          time.sleep(1)
      
      # Strips the newline character
      for line in Lines:
          count += 1
          print(line.rstrip())
      print(count)
      print("app terminated.")
      ```

   1. Salvare il file `main.py`.

1. Crea un file di log di esempio. 

   1. Nella cartella `multiline-app`, crea un file con il nome `test.log`.

   1. Incolla i contenuti seguenti nel file:

      ```
      panic: my panic
      
      goroutine 4 [running]:
      panic(0x45cb40, 0x47ad70)
        /usr/local/go/src/runtime/panic.go:542 +0x46c fp=0xc42003f7b8 sp=0xc42003f710 pc=0x422f7c
      main.main.func1(0xc420024120)
        foo.go:6 +0x39 fp=0xc42003f7d8 sp=0xc42003f7b8 pc=0x451339
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003f7e0 sp=0xc42003f7d8 pc=0x44b4d1
      created by main.main
        foo.go:5 +0x58
      
      goroutine 1 [chan receive]:
      runtime.gopark(0x4739b8, 0xc420024178, 0x46fcd7, 0xc, 0xc420028e17, 0x3)
        /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc420053e30 sp=0xc420053e00 pc=0x42503c
      runtime.goparkunlock(0xc420024178, 0x46fcd7, 0xc, 0x1000f010040c217, 0x3)
        /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc420053e70 sp=0xc420053e30 pc=0x42512e
      runtime.chanrecv(0xc420024120, 0x0, 0xc420053f01, 0x4512d8)
        /usr/local/go/src/runtime/chan.go:506 +0x304 fp=0xc420053f20 sp=0xc420053e70 pc=0x4046b4
      runtime.chanrecv1(0xc420024120, 0x0)
        /usr/local/go/src/runtime/chan.go:388 +0x2b fp=0xc420053f50 sp=0xc420053f20 pc=0x40439b
      main.main()
        foo.go:9 +0x6f fp=0xc420053f80 sp=0xc420053f50 pc=0x4512ef
      runtime.main()
        /usr/local/go/src/runtime/proc.go:185 +0x20d fp=0xc420053fe0 sp=0xc420053f80 pc=0x424bad
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc420053fe8 sp=0xc420053fe0 pc=0x44b4d1
      
      goroutine 2 [force gc (idle)]:
      runtime.gopark(0x4739b8, 0x4ad720, 0x47001e, 0xf, 0x14, 0x1)
        /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003e768 sp=0xc42003e738 pc=0x42503c
      runtime.goparkunlock(0x4ad720, 0x47001e, 0xf, 0xc420000114, 0x1)
        /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003e7a8 sp=0xc42003e768 pc=0x42512e
      runtime.forcegchelper()
        /usr/local/go/src/runtime/proc.go:238 +0xcc fp=0xc42003e7e0 sp=0xc42003e7a8 pc=0x424e5c
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003e7e8 sp=0xc42003e7e0 pc=0x44b4d1
      created by runtime.init.4
        /usr/local/go/src/runtime/proc.go:227 +0x35
      
      goroutine 3 [GC sweep wait]:
      runtime.gopark(0x4739b8, 0x4ad7e0, 0x46fdd2, 0xd, 0x419914, 0x1)
        /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003ef60 sp=0xc42003ef30 pc=0x42503c
      runtime.goparkunlock(0x4ad7e0, 0x46fdd2, 0xd, 0x14, 0x1)
        /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003efa0 sp=0xc42003ef60 pc=0x42512e
      runtime.bgsweep(0xc42001e150)
        /usr/local/go/src/runtime/mgcsweep.go:52 +0xa3 fp=0xc42003efd8 sp=0xc42003efa0 pc=0x419973
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003efe0 sp=0xc42003efd8 pc=0x44b4d1
      created by runtime.gcenable
        /usr/local/go/src/runtime/mgc.go:216 +0x58
      one more line, no multiline
      ```

   1. Salvare il file `test.log`.

1. All'interno della cartella `multiline-app`, crea il Dockerfile.

   1. Incolla i contenuti seguenti nel file:

      ```
      FROM public.ecr.aws/amazonlinux/amazonlinux:latest
      ADD test.log /test.log
      
      RUN yum upgrade -y && yum install -y python3
      
      WORKDIR /usr/local/bin
      
      COPY main.py .
      
      CMD ["python3", "main.py"]
      ```

   1. Salvare il file `Dockerfile`.

1. Usando il Dockerfile, crea un'immagine.

   1. Crea l'immagine: `docker build -t multiline-app-image `

      Dove: `multiline-app-image` è il nome dell'immagine in questo esempio.

   1. Verifica che l'immagine sia stata creata correttamente: `docker images —filter reference=multiline-app-image` 

      In caso di esito positivo, l'output mostra l'immagine e il tag `latest`.

1. Carica l'immagine nel registro del container Amazon Elastic.

   1. Crea un repository Amazon ECR per archiviare l'immagine: `aws ecr create-repository --repository-name multiline-app-repo --region us-east-1`

      Dove: `multiline-app-repo` è il nome del repository e `us-east-1` è la regione in questo esempio. 

      L'output fornisce i dettagli del nuovo repository. Annota il valore `repositoryUri` poiché sarà necessario nei passaggi successivi. 

   1. Applica un tag all'immagine con il valore `repositoryUri` ricavato dall'output precedente: `docker tag multiline-app-image repositoryUri` 

      Ad esempio: `docker tag multiline-app-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo` 

   1. Esegui l'immagine Docker per verificare che sia stata eseguita correttamente: `docker images —filter reference=repositoryUri`

      Nell'output, il nome del repository cambia da `multiline-app-repo` al valore `repositoryUri`.

   1. Invia l'immagine ad Amazon ECR: `docker push aws_account_id.dkr.ecr.region.amazonaws.com/repository name` 

      Ad esempio: `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo`

**Crea la definizione di un processo e avviare il processo**

1. Crea un file di definizione del processo con il nome del file `multiline-task-definition.json`. 

1. Incolla i contenuti seguenti nel file `multiline-task-definition.json`: 

   ```
   {
       "family": "firelens-example-multiline",
       "taskRoleArn": "task role ARN,
       "executionRoleArn": "execution role ARN",
       "containerDefinitions": [
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-image:latest",
               "name": "log_router",
               "firelensConfiguration": {
                   "type": "fluentbit",
                   "options": {
                       "config-file-type": "file",
                       "config-file-value": "/extra.conf"
                   }
               },
               "memoryReservation": 50
           },
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/multiline-app-image:latest",
               "name": "app",
               "logConfiguration": {
                   "logDriver": "awsfirelens",
                   "options": {
                       "Name": "cloudwatch_logs",
                       "region": "us-east-1",
                       "log_group_name": "multiline-test/application",
                       "auto_create_group": "true",
                       "log_stream_prefix": "multiline-"
                   }
               },
               "memoryReservation": 100
           }
       ],
       "requiresCompatibilities": ["FARGATE"],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512"
   }
   ```

   Sostituisci quanto segue nella definizione del processo `multiline-task-definition.json`:

   1. `task role ARN`

      Per trovare l'ARN del ruolo del processo, vai alla Console IAM. Scegliere **Ruoli** e trovare il ruolo del processo `ecs-task-role-for-firelens` che è stato creato. Scegli il ruolo e copia l'**ARN** che appare nella sezione **Summary** (Riepilogo).

   1. `execution role ARN`

      Per trovare l'ARN del ruolo di esecuzione, vai alla Console IAM. Scegli **Roles** (Ruoli) e trova il ruolo `ecsTaskExecutionRole`. Scegli il ruolo e copia l'**ARN** che appare nella sezione **Summary** (Riepilogo).

   1. `aws_account_id`

      Per trovare l'`aws_account_id`, accedi alla Console di gestione AWS. Scegli il tuo nome utente in alto a destra e copia il tuo ID account.

   1. `us-east-1`

      Sostituisci la regione se necessario.

1. Registra il file di definizione del processo: `aws ecs register-task-definition --cli-input-json file://multiline-task-definition.json --region us-east-1` 

1. Apri la console alla [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. Nel pannello di navigazione, scegli **Task Definitions** (Definizioni dei processi) quindi scegli la famiglia `firelens-example-multiline`, perché sopra abbiamo registrato la definizione dell'attività processo in questa famiglia nella prima riga della definizione del processo.

1. Scegli la versione più recente. 

1. Scegli **Distribuisci**, **Esegui attività**. 

1. Nella pagina **Esegui attività**, in **Cluster** scegli il cluster, quindi in **Reti** scegli le sottoreti disponibili per tale attività in **Sottoreti**. 

1. Scegli **Create** (Crea). 

**Verifica che i messaggi di log multilinea in Amazon CloudWatch appaiano concatenati**

1. Apri la console all'indirizzo. CloudWatch [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)

1. Nel pannello di navigazione, espandi **Logs** (Log) e scegli **Log groups** (Gruppi di log). 

1. Scegli il gruppo di log `multiline-test/applicatio`. 

1. Scegli il log e visualizza i messaggi. Le righe che corrispondono alle regole nel file parser vengono concatenate e appaiono come un singolo messaggio. 

   Il seguente snippet di log mostra una traccia dello stack Go concatenata in un singolo evento: 

   ```
   {
       "log": "panic: my panic\n\ngoroutine 4 [running]:\npanic(0x45cb40, 0x47ad70)\n  /usr/local/go/src/runtime/panic.go:542 +0x46c fp=0xc42003f7b8 sp=0xc42003f710 pc=0x422f7c\nmain.main.func1(0xc420024120)\n  foo.go:6 +0x39 fp=0xc42003f7d8 sp=0xc42003f7b8 pc=0x451339\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003f7e0 sp=0xc42003f7d8 pc=0x44b4d1\ncreated by main.main\n  foo.go:5 +0x58\n\ngoroutine 1 [chan receive]:\nruntime.gopark(0x4739b8, 0xc420024178, 0x46fcd7, 0xc, 0xc420028e17, 0x3)\n  /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc420053e30 sp=0xc420053e00 pc=0x42503c\nruntime.goparkunlock(0xc420024178, 0x46fcd7, 0xc, 0x1000f010040c217, 0x3)\n  /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc420053e70 sp=0xc420053e30 pc=0x42512e\nruntime.chanrecv(0xc420024120, 0x0, 0xc420053f01, 0x4512d8)\n  /usr/local/go/src/runtime/chan.go:506 +0x304 fp=0xc420053f20 sp=0xc420053e70 pc=0x4046b4\nruntime.chanrecv1(0xc420024120, 0x0)\n  /usr/local/go/src/runtime/chan.go:388 +0x2b fp=0xc420053f50 sp=0xc420053f20 pc=0x40439b\nmain.main()\n  foo.go:9 +0x6f fp=0xc420053f80 sp=0xc420053f50 pc=0x4512ef\nruntime.main()\n  /usr/local/go/src/runtime/proc.go:185 +0x20d fp=0xc420053fe0 sp=0xc420053f80 pc=0x424bad\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc420053fe8 sp=0xc420053fe0 pc=0x44b4d1\n\ngoroutine 2 [force gc (idle)]:\nruntime.gopark(0x4739b8, 0x4ad720, 0x47001e, 0xf, 0x14, 0x1)\n  /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003e768 sp=0xc42003e738 pc=0x42503c\nruntime.goparkunlock(0x4ad720, 0x47001e, 0xf, 0xc420000114, 0x1)\n  /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003e7a8 sp=0xc42003e768 pc=0x42512e\nruntime.forcegchelper()\n  /usr/local/go/src/runtime/proc.go:238 +0xcc fp=0xc42003e7e0 sp=0xc42003e7a8 pc=0x424e5c\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003e7e8 sp=0xc42003e7e0 pc=0x44b4d1\ncreated by runtime.init.4\n  /usr/local/go/src/runtime/proc.go:227 +0x35\n\ngoroutine 3 [GC sweep wait]:\nruntime.gopark(0x4739b8, 0x4ad7e0, 0x46fdd2, 0xd, 0x419914, 0x1)\n  /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003ef60 sp=0xc42003ef30 pc=0x42503c\nruntime.goparkunlock(0x4ad7e0, 0x46fdd2, 0xd, 0x14, 0x1)\n  /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003efa0 sp=0xc42003ef60 pc=0x42512e\nruntime.bgsweep(0xc42001e150)\n  /usr/local/go/src/runtime/mgcsweep.go:52 +0xa3 fp=0xc42003efd8 sp=0xc42003efa0 pc=0x419973\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003efe0 sp=0xc42003efd8 pc=0x44b4d1\ncreated by runtime.gcenable\n  /usr/local/go/src/runtime/mgc.go:216 +0x58",
       "container_id": "xxxxxx-xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:2"
   }
   ```

   Il seguente snippet di log mostra come viene visualizzato lo stesso evento se si esegue un container ECS non configurato per concatenare messaggi di log multilinea. Il campo di log contiene una singola riga.

   ```
   {
       "log": "panic: my panic",
       "container_id": "xxxxxx-xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:3"
   ```

**Nota**  
Se i tuoi log passano ai file di log anziché all'output standard, ti consigliamo di specificare i parametri di configurazione `multiline.parser` e `multiline.key_content` nel [plug-in Tail input](https://docs.fluentbit.io/manual/pipeline/inputs/tail#multiline-support) anziché nel filtro.

# Implementazione di Fluent Bit su container Windows di Amazon ECS
<a name="tutorial-deploy-fluentbit-on-windows"></a>

Fluent Bit è un processore e router di log veloce e flessibile supportato da vari sistemi operativi. Può essere utilizzato per indirizzare i log verso varie AWS destinazioni come Amazon CloudWatch Logs, Firehose, Amazon S3 e Amazon Service. OpenSearch Fluent Bit supporta soluzioni partner comuni come [Datadog](https://www.datadoghq.com/), [Splunk](https://www.splunk.com/) e server HTTP personalizzati. Per ulteriori informazioni su Fluent Bit, consulta il sito Web di [https://fluentbit.io/](https://fluentbit.io/).

L'immagine **AWS for Fluent Bit** è disponibile su Amazon ECR sia nella galleria pubblica Amazon ECR che in un repository Amazon ECR nella maggior parte delle regioni per la disponibilità elevata. Per ulteriori informazioni, consulta [https://github.com/aws/aws-for-fluent-bit](https://github.com/aws/aws-for-fluent-bit)il sito Web. GitHub 

Questo tutorial illustra come distribuire i contenitori Fluent Bit sulle relative istanze Windows in esecuzione in Amazon ECS per trasmettere i log generati dalle attività di Windows ad Amazon per la registrazione centralizzata. CloudWatch 

Questo tutorial utilizza il seguente approccio:
+ Fluent Bit funziona come servizio con la strategia di pianificazione Daemon. Questa strategia garantisce che una singola istanza di Fluent Bit venga sempre eseguita sulle istanze di container del cluster.
  + Ascolta sulla porta 24224 utilizzando il plug-in di input di inoltro.
  + Aprire la porta 24224 all'host in modo che il runtime docker possa inviare i log a Fluent Bit utilizzando tale porta.
  + Ha una configurazione che consente a Fluent Bit di inviare i record dei log alle destinazioni specificate.
+ Avvia tutti gli altri container di attività Amazon ECS utilizzando il driver di registrazione fluentd. Per ulteriori informazioni, consulta [Driver di registrazione Fluentd](https://docs.docker.com/engine/logging/drivers/fluentd/) sul sito Web della documentazione Docker.
  + Docker si connette al socket TCP 24224 su localhost all'interno del namespace dell'host.
  + L'agente Amazon ECS aggiunge le etichette ai container che includono il nome del cluster, l'ARN dell'attività, il nome della famiglia della definizione di attività, il numero di revisione della definizione di attività, l'ARN dell'attività e il nome del container delle attività. Le stesse informazioni vengono aggiunte al record di log utilizzando l'opzione labels del driver di registrazione fluentd docker. Per ulteriori informazioni, consulta [labels, labels-regex, env ed env-regex](https://docs.docker.com/config/containers/logging/fluentd/#labels-labels-regex-env-and-env-regex) sul sito Web contenente la documentazione di Docker.
  + Poiché l'opzione `async` del driver di registrazione fluentd è impostata su `true`, quando il container Fluent Bit viene riavviato, docker memorizza i log nel buffer fino al riavvio del container Fluent Bit. Puoi aumentare il limite del buffer impostando l'opzione. fluentd-buffer-limit Per ulteriori informazioni, consulta il sito [fluentd-buffer-limit](https://docs.docker.com/config/containers/logging/fluentd/#fluentd-buffer-limit)Web della documentazione di Docker.

 Di seguito è riportato il flusso di lavoro:
+ Il container di Fluent Bit si avvia e ascolta sulla porta 24224 che è esposta all'host.
+ Fluent Bit utilizza le credenziali del ruolo IAM dell'attività specificate nella definizione di attività.
+ Altre attività avviate sulla stessa istanza utilizzano il driver di registrazione fluentd docker per connettersi al container di Fluent Bit sulla porta 24224. 
+ Quando i container dell'applicazione generano log, il runtime docker aggiunge un tag a tali record, aggiunge altri metadati specificati nelle etichette e quindi li inoltra sulla porta 24224 del namespace dell'host. 
+ Fluent Bit riceve il record di log sulla porta 24224 perché è esposto al namespace dell'host.
+ Fluent Bit esegue l'elaborazione interna e indirizza i log come specificato.

Questo tutorial utilizza la configurazione CloudWatch Fluent Bit predefinita che esegue le seguenti operazioni:
+ Crea un nuovo gruppo di log per ogni cluster e famiglia di definizione di attività.
+ Crea un nuovo flusso di log per ogni container di attività nel gruppo di log sopra generato ogni volta che viene avviata una nuova attività. Ogni flusso verrà contrassegnato con l'ID dell'attività a cui appartiene il container.
+ Aggiunge altri metadati tra cui il nome del cluster, l'ARN dell'attività, il nome del container di attività, la famiglia di definizioni di attività e il numero di revisione della definizione di attività in ogni voce del log.

  Ad esempio, se hai `task_1` with `container_1` `container_2` e t `ask_2` with`container_3`, i seguenti sono i flussi di CloudWatch log:
  + `/aws/ecs/windows.ecs_task_1`

    `task-out.TASK_ID.container_1`

    `task-out.TASK_ID.container_2`
  + `/aws/ecs/windows.ecs_task_2`

    `task-out.TASK_ID.container_3`

**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).

**Topics**
+ [

## Prerequisiti
](#tutorial-deploy-fluentbit-on-windows-prereqs)
+ [

## Fase 1: Creazione dei ruoli di accesso IAM
](#tutorial-deploy-fluentbit-on-windows-iam-access-role)
+ [

## Fase 2: Creazione di un'istanza di container Windows di Amazon ECS
](#tutorial-deploy-fluentbit-on-windows-instance)
+ [

## Fase 3: Configurazione di Fluent Bit
](#tutorial-deploy-fluentbit-on-windows-configure-fluentbit)
+ [

## Passaggio 4: Registrare una definizione di attività Windows Fluent Bit che indirizza i log a CloudWatch
](#tutorial-deploy-fluentbit-on-windows-register-task-definition)
+ [

## Fase 5: Esecuzione della definizione di attività `ecs-windows-fluent-bit` come servizio Amazon ECS utilizzando la strategia di pianificazione del daemon
](#tutorial-deploy-fluentbit-on-windows-run-task)
+ [

## Fase 6: Registrazione di una definizione di attività di Windows che genera i log
](#tutorial-deploy-fluentbit-on-windows-register-task-def-logs)
+ [

## Fase 7: Esecuzione della definizione di attività `windows-app-task`
](#tutorial-deploy-fluentbit-on-windows-run-task-fluentbit)
+ [

## Passaggio 8: verifica degli accessi CloudWatch
](#tutorial-deploy-fluentbit-on-windows-verify)
+ [

## Fase 9: Pulizia
](#tutorial-deploy-fluentbit-on-windows-cleanup)

## Prerequisiti
<a name="tutorial-deploy-fluentbit-on-windows-prereqs"></a>

Questo tutorial presuppone che siano stati soddisfatti i prerequisiti seguenti:
+ 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).
+ L'immagine del container `aws-for-fluent-bit` è disponibile per i seguenti sistemi operativi Windows:
  + Windows Server, versione 2019 (Core)
  + Windows Server, versione 2019 (Full)
  + Windows Server 2022 Core
  + Windows Server 2022 Full
+ Hai completato le fasi descritte in [Configurazione per l'uso di Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Hai un cluster. In questo tutorial, il nome del cluster è **FluentBit-cluster**.
+ Hai un VPC con una sottorete pubblica in cui verrà avviata l'istanza EC2. È possibile utilizzare il VPC di default. Puoi anche utilizzare una sottorete privata che consente agli CloudWatch endpoint Amazon di raggiungere la sottorete. Per ulteriori informazioni sugli CloudWatch endpoint Amazon, consulta la sezione [ CloudWatch Endpoints e quote Amazon](https://docs.aws.amazon.com/general/latest/gr/cw_region.html) nel. *Riferimenti generali di AWS* Per ulteriori informazioni sull'utilizzo della procedura guidata di Amazon VPC per creare un VPC, consulta [Crea un cloud privato virtuale](get-set-up-for-amazon-ecs.md#create-a-vpc).

## Fase 1: Creazione dei ruoli di accesso IAM
<a name="tutorial-deploy-fluentbit-on-windows-iam-access-role"></a>

Crea i ruoli IAM di Amazon ECS.

1.  Crea il ruolo dell'istanza del contenitore Amazon ECS denominato "ecsInstanceRole». Per ulteriori informazioni, consulta [Ruolo IAM delle istanze di container di Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/instance_IAM_role.html).

1. Crea un ruolo IAM per l'attività Fluent Bit denominata `fluentTaskRole`. Per ulteriori informazioni, consulta [Ruolo IAM dell'attività Amazon ECS](task-iam-roles.md).

    Le autorizzazioni IAM concesse nel ruolo IAM sono assunte dai container delle attività. Per consentire a Fluent Bit di inviare i log a CloudWatch, devi assegnare le seguenti autorizzazioni al ruolo IAM dell'attività.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
       {
           "Effect": "Allow",
           "Action": [
               "logs:CreateLogStream",
               "logs:CreateLogGroup",
               "logs:DescribeLogStreams",
               "logs:PutLogEvents"
           ],
           "Resource": "*"
       }
       ]
   }
   ```

------

1. Collegare la policy al ruolo.

   1. Salva il contenuto di cui sopra in un file denominato `fluent-bit-policy.json`.

   1. Per collegare la policy in linea al ruolo IAM `fluentTaskRole`, esegui il comando riportato.

      ```
      aws iam put-role-policy --role-name fluentTaskRole --policy-name fluentTaskPolicy --policy-document file://fluent-bit-policy.json
      ```

## Fase 2: Creazione di un'istanza di container Windows di Amazon ECS
<a name="tutorial-deploy-fluentbit-on-windows-instance"></a>

Creazione di un'istanza di container Windows di Amazon ECS

**Creazione di un'istanza Amazon ECS**

1. Usa il comando `aws ssm get-parameters` per recuperare l'ID AMI per la regione che ospita il tuo VPC. Per ulteriori informazioni, consulta [Retrieving Amazon ECS-Optimized AMI metadata](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/retrieve-ecs-optimized_windows_AMI.html).

1. Utilizza la console di Amazon EC2 per avviare l'istanza.

   1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

   1. Seleziona la Regione da utilizzare nella barra di navigazione.

   1. Da **Pannello di controllo EC2**, scegli **Avvia istanza**.

   1. Per **Name (Nome)**, inserisci un nome univoco.

   1. Per **Application and OS Images (Amazon Machine Image)** (Immagini di applicazioni e sistema operativo [Amazon Machine Image]), scegli l'AMI che è stata recuperata nel primo passaggio.

   1. In **Instance type (Tipo di istanza)** selezionare `t3.xlarge`.

   1. Per **Key pair (login)** (Coppia di chiavi [accesso]), scegli una coppia di chiavi. 

   1. In **Network settings** (Impostazioni di rete), per **Security group** (Gruppo di sicurezza), scegli un gruppo di sicurezza esistente o creane uno nuovo.

   1. In **Network settings** (Impostazioni di rete), per **Auto-assign Public IP** (Assegna automaticamente un IP pubblico), seleziona **Enable** (Abilita). 

   1. In **Dettagli avanzati**, per il **profilo dell'istanza IAM**, scegli. **ecsInstanceRole**

   1. Configura la tua istanza di container Amazon ECS con i seguenti dati utente. In **Dettagli avanzati**, incolla lo script seguente nel campo **Dati utente**, sostituendolo *cluster\$1name* con il nome del cluster.

      ```
      <powershell>
      Import-Module ECSTools
      Initialize-ECSAgent -Cluster cluster-name -EnableTaskENI -EnableTaskIAMRole -LoggingDrivers '["awslogs","fluentd"]'
      </powershell>
      ```

   1. Quando sei pronto, seleziona il campo di conferma e scegli **Launch Instances** (Avvia istanze). 

   1. Una pagina di conferma indicherà che l'istanza si sta avviando. Scegliere **View Instances (Visualizza istanze)** per chiudere la pagina di conferma e tornare alla console.

## Fase 3: Configurazione di Fluent Bit
<a name="tutorial-deploy-fluentbit-on-windows-configure-fluentbit"></a>

È possibile utilizzare la seguente configurazione predefinita fornita da AWS per iniziare rapidamente:
+ [Amazon CloudWatch](https://github.com/aws/aws-for-fluent-bit/blob/mainline/ecs_windows_forward_daemon/cloudwatch.conf) che si basa sul plug-in Fluent Bit per [Amazon CloudWatch](https://docs.fluentbit.io/manual/v/1.9-pre/pipeline/outputs/cloudwatch) nel Manuale *ufficiale Fluent Bit*.

In alternativa, puoi utilizzare altre configurazioni predefinite fornite da. AWS Per ulteriori informazioni, consulta [Sostituzione del punto di ingresso per l'immagine Windows](https://github.com/aws/aws-for-fluent-bit/tree/mainline/ecs_windows_forward_daemon#overriding-the-entrypoint-for-the-windows-image) su `aws-for-fluent-bit` sul sito Web di Github.

La configurazione predefinita di Amazon CloudWatch Fluent Bit è mostrata di seguito.

Sostituisci le seguenti variabili:
+ *region*con la regione in cui desideri inviare i CloudWatch log di Amazon.

```
[SERVICE]
    Flush               5
    Log_Level           info
    Daemon              off

[INPUT]
    Name                forward
    Listen              0.0.0.0
    Port                24224
    Buffer_Chunk_Size   1M
    Buffer_Max_Size     6M
    Tag_Prefix          ecs.

# Amazon ECS agent adds the following log keys as labels to the docker container.
# We would use fluentd logging driver to add these to log record while sending it to Fluent Bit.
[FILTER]
    Name                modify
    Match               ecs.*
    Rename              com.amazonaws.ecs.cluster ecs_cluster
    Rename              com.amazonaws.ecs.container-name ecs_container_name
    Rename              com.amazonaws.ecs.task-arn ecs_task_arn
    Rename              com.amazonaws.ecs.task-definition-family ecs_task_definition_family
    Rename              com.amazonaws.ecs.task-definition-version ecs_task_definition_version

[FILTER]
    Name                rewrite_tag
    Match               ecs.*
    Rule                $ecs_task_arn ^([a-z-:0-9]+)/([a-zA-Z0-9-_]+)/([a-z0-9]+)$  out.$3.$ecs_container_name false
    Emitter_Name        re_emitted

[OUTPUT]
    Name                cloudwatch_logs
    Match               out.*
    region              region
    log_group_name      fallback-group
    log_group_template  /aws/ecs/$ecs_cluster.$ecs_task_definition_family
    log_stream_prefix   task-
    auto_create_group   On
```

Ogni log che entra in Fluent Bit ha un tag specificato dall'utente o viene generato automaticamente quando non ne viene fornito uno. I tag possono essere utilizzati per indirizzare log diversi verso destinazioni diverse. Per ulteriori informazioni, consulta [Tag](https://docs.fluentbit.io/manual/concepts/key-concepts#tag) nel *manuale ufficiale di Fluent Bit*. 

La configurazione di Fluent Bit sopra descritta ha le seguenti proprietà:
+ Il plug-in di input di inoltro ascolta il traffico in entrata sulla porta TCP 24224. 
+ Ogni voce di log ricevuta su quella porta ha un tag che il plug-in di input di inoltro modifica per aggiungere una stringa `ecs.` al record come prefisso. 
+ La pipeline interna di Fluent Bit indirizza la voce del log per modificare il filtro utilizzando l'espressione regolare Match. Questo filtro sostituisce le chiavi del record di log JSON nel formato che Fluent Bit può utilizzare. 
+ La voce di log modificata viene quindi utilizzata dal filtro rewrite\$1tag. Questo filtro modifica il tag del record di registro nel formato out. *TASK\$1ID*. *CONTAINER\$1NAME*. 
+ Il nuovo tag verrà indirizzato al plug-in cloudwatch\$1logs di output che crea i gruppi e i flussi di log come descritto in precedenza utilizzando le opzioni e del `log_group_template` plug-in di output. `log_stream_prefix` CloudWatch Per ulteriori informazioni, consulta [Configuration parameters](https://docs.fluentbit.io/manual/v/1.9-pre/pipeline/outputs/cloudwatch#configuration-parameters) (Parametri di configurazione) nel *manuale ufficiale di Fluent Bit*. 

## Passaggio 4: Registrare una definizione di attività Windows Fluent Bit che indirizza i log a CloudWatch
<a name="tutorial-deploy-fluentbit-on-windows-register-task-definition"></a>

Registrare una definizione di attività Windows Fluent Bit verso cui indirizzare i log. CloudWatch

**Nota**  
Questa definizione di attività espone la porta del container 24224 di Fluent Bit alla porta host 24224. Verifica che questa porta non sia aperta nel gruppo di sicurezza dell'istanza EC2 per impedire l'accesso dall'esterno.

**Come registrare una definizione di attività**

1. Crea un file denominato `fluent-bit.json` con i seguenti contenuti.

   Sostituisci le seguenti variabili:
   + *task-iam-role*con l'Amazon Resource Name (ARN) del ruolo IAM della tua attività
   + *region*con la regione in cui viene eseguita la tua attività

   ```
   {
     "family": "ecs-windows-fluent-bit",
     "taskRoleArn": "task-iam-role",
     "containerDefinitions": [
       {
         "name": "fluent-bit",
         "image": "public.ecr.aws/aws-observability/aws-for-fluent-bit:windowsservercore-latest",
         "cpu": 512,
         "portMappings": [
           {
             "hostPort": 24224,
             "containerPort": 24224,
             "protocol": "tcp"
           }
         ],
         "entryPoint": [
           "Powershell",
           "-Command"
         ],
         "command": [
           "C:\\entrypoint.ps1 -ConfigFile C:\\ecs_windows_forward_daemon\\cloudwatch.conf"
         ],
         "environment": [
           {
             "name": "AWS_REGION",
             "value": "region"
           }
         ],
         "memory": 512,
         "essential": true,
         "logConfiguration": {
           "logDriver": "awslogs",
           "options": {
             "awslogs-group": "/ecs/fluent-bit-logs",
             "awslogs-region": "region",
             "awslogs-stream-prefix": "flb",
             "awslogs-create-group": "true"
           }
         }
       }
     ],
     "memory": "512",
     "cpu": "512"
   }
   ```

1. Utilizza il comando seguente per registrare la definizione dell'attività.

   ```
   aws ecs register-task-definition --cli-input-json file://fluent-bit.json --region region
   ```

   Puoi sempre ottenere un elenco delle definizioni di attività per l'account tramite il comando `list-task-definitions`. L'output che mostra i valori della famiglia e delle revisioni che è possibile utilizzare insieme a `run-task` o `start-task`.

## Fase 5: Esecuzione della definizione di attività `ecs-windows-fluent-bit` come servizio Amazon ECS utilizzando la strategia di pianificazione del daemon
<a name="tutorial-deploy-fluentbit-on-windows-run-task"></a>

Dopo aver registrato una definizione di attività per l'account, puoi eseguire un'attività nel cluster. Per questo tutorial, esegui una istanza della definizione di attività `ecs-windows-fluent-bit:1` nel cluster `FluentBit-cluster`. Esegui l'attività in un servizio che utilizza la strategia di pianificazione dei daemon, che garantisce che una singola istanza di Fluent Bit venga sempre eseguita su ciascuna delle istanze di container.

**Per eseguire un'attività**

1. Esegui il comando seguente per avviare la definizione di attività `ecs-windows-fluent-bit:1` (registrata nel passaggio precedente) come servizio.
**Nota**  
Questa definizione di attività utilizza il driver di registrazione `awslogs`; l'istanza di container deve disporre delle autorizzazioni necessarie.

   Sostituisci le seguenti variabili:
   + *region*con la regione in cui viene eseguito il servizio

   ```
   aws ecs create-service \
       --cluster FluentBit-cluster \
       --service-name FluentBitForwardDaemonService \
       --task-definition ecs-windows-fluent-bit:1 \
       --launch-type EC2 \
       --scheduling-strategy DAEMON \
       --region region
   ```

1. Per elencare le attività, esegui il comando riportato.

   Sostituisci le seguenti variabili:
   + *region*con la regione in cui vengono eseguite le attività di assistenza

   ```
   aws ecs list-tasks --cluster FluentBit-cluster --region region
   ```

## Fase 6: Registrazione di una definizione di attività di Windows che genera i log
<a name="tutorial-deploy-fluentbit-on-windows-register-task-def-logs"></a>

Registrazione di una definizione di attività di Windows che genera i log Questa definizione di attività implementa l'immagine del container di Windows che scriverà un numero incrementale su `stdout` ogni secondo.

La definizione di attività utilizza il driver di registrazione fluentd che si collega alla porta 24224 su cui ascolta il plug-in Fluent Bit. L'agente Amazon ECS etichetta ogni container Amazon ECS con tag che includono il nome del cluster, l'ARN dell'attività, il nome della famiglia della definizione di attività, il numero di revisione della definizione di attività e il nome del container delle attività. Queste etichette chiave-valore vengono passate a Fluent Bit.

**Nota**  
Questa attività utilizza la modalità di rete `default`. Tuttavia, è anche possibile utilizzare la modalità di rete `awsvpc` con l'attività.

**Come registrare una definizione di attività**

1. Crea un file denominato `windows-app-task.json` con i seguenti contenuti.

   ```
   {
     "family": "windows-app-task",
     "containerDefinitions": [
       {
         "name": "sample-container",
         "image": "mcr.microsoft.com/windows/servercore:ltsc2019",
         "cpu": 512,
         "memory": 512,
         "essential": true,
         "entryPoint": [
           "Powershell",
           "-Command"
         ],
         "command": [
           "$count=1;while(1) { Write-Host $count; sleep 1; $count=$count+1;}"
         ],
         "logConfiguration": {
           "logDriver": "fluentd",
           "options": {
             "fluentd-address": "localhost:24224",
             "tag": "{{ index .ContainerLabels \"com.amazonaws.ecs.task-definition-family\" }}",
             "fluentd-async": "true",
             "labels": "com.amazonaws.ecs.cluster,com.amazonaws.ecs.container-name,com.amazonaws.ecs.task-arn,com.amazonaws.ecs.task-definition-family,com.amazonaws.ecs.task-definition-version"
           }
         }
       }
     ],
     "memory": "512",
     "cpu": "512"
   }
   ```

1. Utilizza il comando seguente per registrare la definizione dell'attività.

   Sostituisci le seguenti variabili:
   + *region*con la regione in cui viene eseguita l'attività

   ```
   aws ecs register-task-definition --cli-input-json file://windows-app-task.json --region region
   ```

   Puoi sempre ottenere un elenco delle definizioni di attività per l'account tramite il comando `list-task-definitions`. L'output che mostra i valori della famiglia e delle revisioni che è possibile utilizzare insieme a `run-task` o `start-task`.

## Fase 7: Esecuzione della definizione di attività `windows-app-task`
<a name="tutorial-deploy-fluentbit-on-windows-run-task-fluentbit"></a>

Dopo aver registrato la definizione di attività `windows-app-task`, eseguila nel cluster `FluentBit-cluster`.

**Per eseguire un'attività**

1. Esegui la definizione di attività `windows-app-task:1` registrata nella fase precedente.

   Sostituisci le seguenti variabili:
   + *region*con la regione in cui viene eseguita l'attività

   ```
   aws ecs run-task --cluster FluentBit-cluster --task-definition windows-app-task:1 --count 2 --region region
   ```

1. Per elencare le attività, esegui il comando riportato.

   ```
   aws ecs list-tasks --cluster FluentBit-cluster
   ```

## Passaggio 8: verifica degli accessi CloudWatch
<a name="tutorial-deploy-fluentbit-on-windows-verify"></a>

Per verificare la configurazione di Fluent Bit, controlla i seguenti gruppi di log nella CloudWatch console:
+ `/ecs/fluent-bit-logs`: questo è il gruppo di log che corrisponde al container del daemon Fluent Bit in esecuzione sull'istanza di container.
+ `/aws/ecs/FluentBit-cluster.windows-app-task`: questo è il gruppo di log che corrisponde a tutte le attività avviate per la famiglia di definizione di attività `windows-app-task` all'interno del cluster `FluentBit-cluster`.

   `task-out.FIRST_TASK_ID.sample-container`: questo flusso di log contiene tutti i log generati dalla prima istanza dell'attività nel container delle attività sample-container. 

  `task-out.SECOND_TASK_ID.sample-container`: questo flusso di log contiene tutti i log generati dalla seconda istanza dell'attività nel container delle attività sample-container. 

 Il flusso di log `task-out.TASK_ID.sample-container` ha campi simili ai seguenti:

```
{
    "source": "stdout",
    "ecs_task_arn": "arn:aws:ecs:region:0123456789012:task/FluentBit-cluster/13EXAMPLE",
    "container_name": "/ecs-windows-app-task-1-sample-container-cEXAMPLE",
    "ecs_cluster": "FluentBit-cluster",
    "ecs_container_name": "sample-container",
    "ecs_task_definition_version": "1",
    "container_id": "61f5e6EXAMPLE",
    "log": "10",
    "ecs_task_definition_family": "windows-app-task"
}
```

**Verifica della configurazione di Fluent Bit**

1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Nel pannello di navigazione, selezionare **Log groups (Gruppi di log)**. Assicurati di trovarti nella regione in cui è stato implementato Fluent Bit sui container.

   Nell'elenco dei gruppi di log di Regione AWS, dovresti vedere quanto segue:
   + `/ecs/fluent-bit-logs`
   + `/aws/ecs/FluentBit-cluster.windows-app-task`

   Se questi gruppi di log sono visualizzati, la configurazione Fluent Bit è verificata.

## Fase 9: Pulizia
<a name="tutorial-deploy-fluentbit-on-windows-cleanup"></a>

Una volta terminato questo tutorial, rimuovi le risorse associate per evitare costi aggiuntivi per risorse che non utilizzi. 

**Per eliminare le risorse del tutorial**

1. Interrompi l'attività `windows-simple-task` e l'attività `ecs-fluent-bit`. Per ulteriori informazioni, consulta [Interruzione di un'attività di Amazon ECS](standalone-task-stop.md).

1. Esegui il comando riportato per eliminare il gruppo di log `/ecs/fluent-bit-logs`. Per ulteriori informazioni, sull'eliminazione dei gruppi di log, consulta [delete-log-group](https://docs.aws.amazon.com/cli/latest/reference/logs/delete-log-group.html)la sezione *AWS Command Line Interface Reference.*

   ```
   aws logs delete-log-group --log-group-name /ecs/fluent-bit-logs
   aws logs delete-log-group --log-group-name /aws/ecs/FluentBit-cluster.windows-app-task
   ```

1. Esegui il comando riportato per terminare l'istanza.

   ```
   aws ec2 terminate-instances --instance-ids instance-id
   ```

1. Esegui i comandi riportati per eliminare i ruoli IAM. 

   ```
   aws iam delete-role --role-name ecsInstanceRole
   aws iam delete-role --role-name fluentTaskRole
   ```

1. Esegui il seguente comando per eliminare il cluster Amazon ECS.

   ```
   aws ecs delete-cluster --cluster FluentBit-cluster
   ```

# Utilizzo del gMSA per container EC2 Linux su Amazon ECS
<a name="linux-gmsa"></a>

Amazon ECS supporta l'autenticazione di Active Directory per i container Linux su EC2 tramite un tipo speciale di account di servizio chiamato *account di servizio gestito del gruppo* (gMSA).

Le applicazioni di rete basate su Linux, ad esempio le applicazioni .NET Core, possono utilizzare Active Directory per facilitare l'autenticazione e la gestione delle autorizzazioni tra utenti e servizi. Puoi utilizzare questa funzionalità progettando applicazioni che si integrano con Active Directory e vengono eseguite su server aggiunti al dominio. Tuttavia, poiché i container Linux non possono essere aggiunti a un dominio, è necessario configurare un container Linux da eseguire con gMSA.

Un container Linux che viene eseguito con gMSA si basa sul daemon `credentials-fetcher` che viene eseguito sull'istanza Amazon EC2 host del container. Quindi, il daemon recupera le credenziali gMSA dal controller di dominio Active Directory e successivamente le trasferisce all'istanza di container. Per ulteriori informazioni sugli account di servizio, consulta [Crea gMSAs per i container Windows](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts) nel sito Web Microsoft Learn.

## Considerazioni
<a name="linux-gmsa-considerations"></a>

Prima di utilizzare gMSA per i container Linux, valuta quanto segue:
+ Se i container vengono eseguiti su EC2, puoi utilizzare gMSA per i container Windows e Linux. Per informazioni su come utilizzare il gMSA per container Linux su Fargate, consultare [Utilizzo del gMSA per i container Linux su Fargate](fargate-linux-gmsa.md).
+ Potrebbe essere necessario un computer Windows aggiunto al dominio per completare i prerequisiti. Ad esempio, potresti aver bisogno di un computer Windows aggiunto al dominio per creare gMSA in Active Directory con PowerShell. Gli PowerShell strumenti RSAT Active Director sono disponibili solo perWindows. Per ulteriori informazioni, consulta [Installazione degli strumenti di amministrazione Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_install_ad_tools.html).
+ Hai scelto tra la modalità **gMSA senza dominio** e **l'aggiunta di ogni istanza in un unico dominio**. Utilizzando gMSA senza dominio, l'istanza di container non viene aggiunta al dominio, le altre applicazioni sull'istanza non possono utilizzare le credenziali per accedere al dominio e le attività che si uniscono a domini diversi possono essere eseguite sulla stessa istanza.

  Quindi, scegli l'archiviazione di dati per CredSpec e, facoltativamente, per le credenziali utente di Active Directory per gMSA senza dominio.

  Amazon ECS utilizza un file di specifica delle credenziali di Active Directory (CredSpec). Questo file contiene i metadati gMSA utilizzati per propagare il contesto dell'account gMSA al container. Il file CredSpec viene generato e quindi archiviato in una delle opzioni di archiviazione di CredSpec nella tabella seguente, specifica del sistema operativo delle istanze di container. Per utilizzare il metodo senza dominio, una sezione facoltativa del file CredSpec può specificare le credenziali in una delle opzioni di archiviazione *domainless user credentials* riportate nella tabella seguente, in base al sistema operativo delle istanze di container.    
<a name="gmsa-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonECS/latest/developerguide/linux-gmsa.html)

## Prerequisiti
<a name="linux-gmsa-prerequisites"></a>

Prima di utilizzare la funzionalità gMSA per container Linux con Amazon ECS, assicurati di completare le seguenti operazioni:
+ Configura un dominio Active Directory con le risorse a cui desideri che i tuoi container accedano. Amazon ECS supporta le configurazioni seguenti:
  + Un Directory Service Active Directory. Directory Service è un Active Directory AWS gestito ospitato su Amazon EC2. Per ulteriori informazioni, vedere Guida [introduttiva a AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) nella *Guida all'AWS Directory Service amministrazione*.
  + Una Active Directory on-premises. Devi assicurarti che l'istanza di container Linux di Amazon ECS possa essere aggiunta al dominio. Per ulteriori informazioni, consulta [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect.html).
+ Disponi di un account gMSA nell'Active Directory. Per ulteriori informazioni, consulta [Utilizzo del gMSA per container EC2 Linux su Amazon ECS](#linux-gmsa).
+ Hai installato e stai eseguendo il daemon `credentials-fetcher` su un'istanza di container Amazon ECS Linux. Inoltre, hai aggiunto un set iniziale di credenziali al daemon `credentials-fetcher` per l'autenticazione con Active Directory.
**Nota**  
Il daemon `credentials-fetcher` è disponibile solo per Amazon Linux 2023 e Fedora 37 e versioni successive. Il daemon non è disponibile per Amazon Linux 2. Per ulteriori informazioni, consulta [aws/credentials-fetcher](https://github.com/aws/credentials-fetcher) su. GitHub
+ Configuri le credenziali per l'autenticazione del daemon `credentials-fetcher` con Active Directory. Le credenziali devono essere membri del gruppo di sicurezza di Active Directory che ha accesso all'account gMSA. Sono disponibili diverse opzioni in [Decidi se aggiungere le istanze al dominio o utilizzare gMSA senza dominio.](#linux-gmsa-initial-creds).
+ Hai aggiunto le autorizzazioni IAM richieste. Le autorizzazioni richieste dipendono dai metodi scelti per le credenziali iniziali e per l'archiviazione della specifica delle credenziali:
  + Se utilizzi *domainless gMSA* per le credenziali iniziali, sono necessarie le autorizzazioni IAM per il ruolo di esecuzione dell'attività. Gestione dei segreti AWS 
  + Se archivi la specifica delle credenziali nell'archivio dei parametri SSM, le autorizzazioni IAM per l'archivio dei parametri Systems Manager per Amazon EC2 sono necessarie per il ruolo di esecuzione dell'attività.
  + Se archivi la specifica delle credenziali in Amazon S3, le autorizzazioni IAM per Amazon Simple Storage Service sono necessarie per il ruolo di esecuzione delle attività.

## Configurazione di container Linux compatibili con gMSA in Amazon ECS
<a name="linux-gmsa-setup"></a>
<a name="linux-gmsa-setup-infra"></a>
**Preparazione dell'infrastruttura**  
I passaggi seguenti sono considerazioni e configurazioni che vengono eseguite una sola volta. Dopo aver completato questi passaggi, puoi automatizzare la creazione delle istanze di container per riutilizzare questa configurazione.

Decidi come fornire le credenziali iniziali e configura i dati utente EC2 in un modello di avvio EC2 riutilizzabile per installare il daemon `credentials-fetcher`.

1. <a name="linux-gmsa-initial-creds"></a>

**Decidi se aggiungere le istanze al dominio o utilizzare gMSA senza dominio.**
   + <a name="linux-gmsa-initial-join"></a>

**Aggiunta di istanze EC2 al dominio di Active Directory**

     
     + <a name="linux-gmsa-initial-join-userdata"></a>

**Aggiunta delle istanze in base ai dati dell'utente**

       Completa i passaggi per aggiungere il dominio Active Directory ai dati utente EC2 in un modello di avvio EC2. Più gruppi con Amazon EC2 Auto Scaling possono utilizzare lo stesso modello di avvio.

       Puoi utilizzare questi passaggi [Aggiunta di un Active Directory o a un dominio FreeIPA](https://docs.fedoraproject.org/en-US/quick-docs/join-active-directory-freeipa/) in Fedora Docs.
   + <a name="linux-gmsa-initial-domainless"></a>

**Creazione di un utente Active Directory per gMSA senza dominio**

     Il daemon `credentials-fetcher` ha una funzionalità chiamata *gMSA senza dominio*. Questa funzionalità richiede un dominio, ma l'istanza EC2 non deve essere aggiunta al dominio. Utilizzando gMSA senza dominio, l'istanza di container non viene aggiunta al dominio, le altre applicazioni sull'istanza non possono utilizzare le credenziali per accedere al dominio e le attività che si uniscono a domini diversi possono essere eseguite sulla stessa istanza. Al contrario, fornisci il nome di un segreto in Gestione dei segreti AWS nel file CredSpec. Il segreto deve contenere un nome utente, una password e un dominio a cui accedere.

     Questa funzionalità è supportata e può essere utilizzata con container Linux e Windows.

     Questa funzionalità è simile alla funzionalità *gMSA support for non-domain-joined container hosts*. Per ulteriori informazioni sulla funzionalità di Windows, consulta [Architettura e miglioramenti di gMSA](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#gmsa-architecture-and-improvements) sul sito Web Microsoft Learn.

     1. Crea un utente nel dominio di Active Directory. L'utente di Active Directory deve disporre dell'autorizzazione per accedere agli account del servizio di gMSA utilizzati nelle attività.

     1. Crea un account segreto Gestione dei segreti AWS, dopo aver creato l'utente in Active Directory. Per ulteriori informazioni, consulta [Creare un Gestione dei segreti AWS segreto](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).

     1. Inserisci il nome utente, la password e il dominio dell'utente nelle coppie chiave-valore JSON denominate rispettivamente `username`, `password` e `domainName`.

        ```
        {"username":"username","password":"passw0rd", "domainName":"example.com"}
        ```

     1. Aggiungi la configurazione al file CredSpec per l'account del servizio. Il `HostAccountConfig` aggiuntivo contiene il nome della risorsa Amazon (ARN) del segreto in Secrets Manager.

        In Windows, `PluginGUID` deve corrispondere al GUID nel seguente frammento di codice esemplificativo. In Linux, `PluginGUID` viene ignorato. Sostituisci `MySecret` con l'esempio del nome della risorsa Amazon (ARN) del segreto.

        ```
            "ActiveDirectoryConfig": {
                "HostAccountConfig": {
                    "PortableCcgVersion": "1",
                    "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
                    "PluginInput": {
                        "CredentialArn": "arn:aws:secretsmanager:aws-region:111122223333:secret:MySecret"
                    }
                }
        ```

     1. La funzionalità *gMSA senza dominio* richiede autorizzazioni aggiuntive nel ruolo di esecuzione dell'attività. Segui il passaggio [(Facoltativo) segreto gMSA senza dominio](#linux-gmsa-domainless-secret).

1. <a name="linux-gmsa-install"></a>

**Configurazione delle istanze e installazione del daemon `credentials-fetcher`**

   Puoi installare il daemon `credentials-fetcher` con uno script di dati utente nel tuo modello di avvio Amazon EC2. Gli esempi seguenti mostrano due tipi di dati utente, `cloud-config` YAML o lo script bash. Questi esempi sono per Amazon Linux 2023 (AL2023). Sostituisci `MyCluster` con il nome del cluster Amazon ECS a cui desideri che si aggiungano queste istanze.
   + <a name="linux-gmsa-install-yaml"></a>

**`cloud-config` YAML**

     ```
     Content-Type: text/cloud-config
     package_reboot_if_required: true
     packages:
       # prerequisites
       - dotnet
       - realmd
       - oddjob
       - oddjob-mkhomedir
       - sssd
       - adcli
       - krb5-workstation
       - samba-common-tools
       # https://github.com/aws/credentials-fetcher gMSA credentials management for containers
       - credentials-fetcher
     write_files:
     # configure the ECS Agent to join your cluster.
     # replace MyCluster with the name of your cluster.
     - path: /etc/ecs/ecs.config
       owner: root:root
       permissions: '0644'
       content: |
         ECS_CLUSTER=MyCluster
         ECS_GMSA_SUPPORTED=true
     runcmd:
     # start the credentials-fetcher daemon and if it succeeded, make it start after every reboot
     - "systemctl start credentials-fetcher"
     - "systemctl is-active credentials-fetcher && systemctl enable credentials-fetcher"
     ```
   + <a name="linux-gmsa-install-userdata"></a>

**Script bash**

     Se hai più dimestichezza con gli script bash e disponi di più variabili da scrivere per `/etc/ecs/ecs.config`, utilizza il seguente formato `heredoc`. Questo formato scrive tutti gli elementi nel file di configurazione, inserendoli tra le righe **cat** ed `EOF`.

     ```
     #!/usr/bin/env bash
     set -euxo pipefail
     
     # prerequisites
     timeout 30 dnf install -y dotnet realmd oddjob oddjob-mkhomedir sssd adcli krb5-workstation samba-common-tools
     # install https://github.com/aws/credentials-fetcher gMSA credentials management for containers
     timeout 30 dnf install -y credentials-fetcher
     
     # start credentials-fetcher
     systemctl start credentials-fetcher
     systemctl is-active credentials-fetcher && systemctl enable credentials-fetcher
     
     cat <<'EOF' >> /etc/ecs/ecs.config
     ECS_CLUSTER=MyCluster
     ECS_GMSA_SUPPORTED=true
     EOF
     ```

   Esistono variabili di configurazione opzionali per il daemon `credentials-fetcher` che puoi impostare in `/etc/ecs/ecs.config`. Consigliamo di impostare le variabili nei dati utente nel blocco YAML o `heredoc` in modo simile agli esempi precedenti. In questo modo si evitano problemi di configurazione parziale che possono verificarsi quando si modifica un file più volte. Per ulteriori informazioni sulla configurazione dell'agente ECS, consulta [Amazon ECS Container Agent on.](https://github.com/aws/amazon-ecs-agent/blob/master/README.md#environment-variables) GitHub
   + Facoltativamente, puoi utilizzare la variabile `CREDENTIALS_FETCHER_HOST` se modifichi la configurazione del daemon `credentials-fetcher` per spostare il socket in un'altra posizione.

**Configurazione di autorizzazioni e segreti**  
Esegui i passaggi seguenti una volta per ogni applicazione e ogni definizione dell'attività. Consigliamo di utilizzare la best practice di concedere il privilegio minimo e limitare le autorizzazioni utilizzate nella policy. In questo modo, ogni attività può leggere solo i segreti di cui ha bisogno.

1. <a name="linux-gmsa-domainless-secret"></a>

**(Facoltativo) segreto gMSA senza dominio**

   Se utilizzi il metodo senza dominio in cui l'istanza non è aggiunta al dominio, segui questo passaggio.

   Inoltre, devi aggiungere le autorizzazioni seguenti come policy inline al ruolo di esecuzione dell'attività del ruolo IAM. In questo modo il daemon `credentials-fetcher` accede al segreto di Secrets Manager. Sostituisci l'esempio `MySecret` con il nome della risorsa Amazon (ARN) del segreto nell'elenco `Resource`.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:my-secret-AbCdEf"
           }
       ]
   }
   ```

------
**Nota**  
Se utilizzi la tua chiave KMS per crittografare il tuo segreto, devi aggiungere le autorizzazioni necessarie a questo ruolo e aggiungere questo ruolo alla policy chiave. AWS KMS 

1. 

**Decidere se utilizzare SSM Parameter Store o S3 per archiviare il CredSpec**

   Amazon ECS supporta i seguenti modi per fare riferimento al percorso del file nel campo `credentialSpecs` di una definizione di attività.

   Se unisci le istanze a un singolo dominio, utilizza il prefisso `credentialspec:` all'inizio dell'ARN nella stringa. Se utilizzi gMSA senza dominio, usa `credentialspecdomainless:`.

   Per ulteriori informazioni su CredSpec, consulta [File di specifica delle credenziali](#linux-gmsa-credentialspec).
   + <a name="linux-gmsa-credspec-s3"></a>

**Bucket Amazon S3**

     Aggiungi le specifiche delle credenziali a un bucket Amazon S3. Quindi, fai riferimento al nome della risorsa Amazon (ARN) del bucket Amazon S3 nel campo `credentialSpecs` della definizione di attività.

     ```
     {
         "family": "",
         "executionRoleArn": "",
         "containerDefinitions": [
             {
                 "name": "",
                 ...
                 "credentialSpecs": [
                     "credentialspecdomainless:arn:aws:s3:::${BucketName}/${ObjectName}"
                 ],
                 ...
             }
         ],
         ...
     }
     ```

     Devi aggiungere le seguenti autorizzazioni come policy inline al ruolo IAM di esecuzione delle attività Amazon ECS per consentire alle attività l'accesso al bucket Amazon S3.

------
#### [ JSON ]

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
         "Statement": [
             {
                 "Sid": "VisualEditor",
                 "Effect": "Allow",
                 "Action": [
                     "s3:Get*",
                     "s3:List*"
                 ],
                 "Resource": [
                     "arn:aws:s3:::amzn-s3-demo-bucket",
                     "arn:aws:s3:::amzn-s3-demo-bucket/{object}"
                 ]
             }
         ]
     }
     ```

------
   + <a name="linux-gmsa-credspec-ssm"></a>

**Parametro dell'archivio parametri di SSM**

     Aggiungi la specifica delle credenziali a un parametro SSM Parameter Store. Quindi, fai riferimento al nome della risorsa Amazon (ARN) del parametro SSM Parameter Store nel campo `credentialSpecs` della definizione delle attività.

     ```
     {
         "family": "",
         "executionRoleArn": "",
         "containerDefinitions": [
             {
                 "name": "",
                 ...
                 "credentialSpecs": [
                     "credentialspecdomainless:arn:aws:ssm:aws-region:111122223333:parameter/parameter_name"
                 ],
                 ...
             }
         ],
         ...
     }
     ```

     Aggiungi le seguenti autorizzazioni come policy inline al ruolo IAM di esecuzione delle attività Amazon ECS per consentire alle attività l'accesso al parametro SSM Parameter Store.

------
#### [ JSON ]

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
         "Statement": [
             {
                 "Effect": "Allow",
                 "Action": [
                     "ssm:GetParameters"
                 ],
                 "Resource": "arn:aws:ssm:us-east-1:123456789012:parameter/my-parameter"
             }
         ]
     }
     ```

------

## File di specifica delle credenziali
<a name="linux-gmsa-credentialspec"></a>

Amazon ECS utilizza un file di specifica delle credenziali di Active Directory (*CredSpec*). Questo file contiene i metadati gMSA utilizzati per propagare il contesto dell'account gMSA al container Linux. Genera il file CredSpec e fai riferimento a esso nel campo `credentialSpecs` della definizione delle attività. Il file CredSpec non contiene segreti.

Di seguito è riportato un esempio del file CredSpec.

```
{
    "CmsPlugins": [
        "ActiveDirectory"
    ],
    "DomainJoinConfig": {
        "Sid": "S-1-5-21-2554468230-2647958158-2204241789",
        "MachineAccountName": "WebApp01",
        "Guid": "8665abd4-e947-4dd0-9a51-f8254943c90b",
        "DnsTreeName": "example.com",
        "DnsName": "example.com",
        "NetBiosName": "example"
    },
    "ActiveDirectoryConfig": {
        "GroupManagedServiceAccounts": [
            {
                "Name": "WebApp01",
                "Scope": "example.com"
            }
        ],
        "HostAccountConfig": {
            "PortableCcgVersion": "1",
            "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
            "PluginInput": {
                "CredentialArn": "arn:aws:secretsmanager:aws-region:111122223333:secret:MySecret"
            }
        }
    }
}
```
<a name="linux-gmsa-credentialspec-create"></a>
**Creazione di una CredSpec**  
Crea un file CredSpec utilizzando il modulo PowerShell CredSpec su un computer Windows che fa parte del dominio. Segui i passaggi descritti in [Creazione di una specifica delle credenziali](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#create-a-credential-spec) sul sito Web Microsoft Learn.

# Utilizzo del gMSA per i container Linux su Fargate
<a name="fargate-linux-gmsa"></a>

Amazon ECS supporta l'autenticazione di Active Directory per i container Linux su Fargate tramite un tipo speciale di account di servizio chiamato *account di servizio gestito del gruppo* (gMSA).

Le applicazioni di rete basate su Linux, ad esempio le applicazioni .NET Core, possono utilizzare Active Directory per facilitare l'autenticazione e la gestione delle autorizzazioni tra utenti e servizi. Puoi utilizzare questa funzionalità progettando applicazioni che si integrano con Active Directory e vengono eseguite su server aggiunti al dominio. Tuttavia, poiché i container Linux non possono essere aggiunti a un dominio, è necessario configurare un container Linux da eseguire con gMSA.

## Considerazioni
<a name="fargate-linux-gmsa-considerations"></a>

Prima di utilizzare il gMSA per i container Linux su Fargate, valutare quanto segue:
+ È necessario eseguire la versione della piattaforma 1.4 o successiva.
+ Potrebbe essere necessario un computer Windows aggiunto al dominio per completare i prerequisiti. Ad esempio, potresti aver bisogno di un computer Windows aggiunto al dominio per creare gMSA in Active Directory con PowerShell. Gli PowerShell strumenti RSAT Active Director sono disponibili solo per. Windows Per ulteriori informazioni, consulta [Installazione degli strumenti di amministrazione Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_install_ad_tools.html).
+ È necessario utilizzare un **gMSA senza dominio**. 

  Amazon ECS utilizza un file di specifica delle credenziali di Active Directory (CredSpec). Questo file contiene i metadati gMSA utilizzati per propagare il contesto dell'account gMSA al container. È possibile generare il file CredSpec e poi archiviarlo in un bucket Amazon S3.
+ Un'attività può supportare solo un Active Directory.

## Prerequisiti
<a name="fargate-linux-gmsa-prerequisites"></a>

Prima di utilizzare la funzionalità gMSA per container Linux con Amazon ECS, assicurati di completare le seguenti operazioni:
+ Configura un dominio Active Directory con le risorse a cui desideri che i tuoi container accedano. Amazon ECS supporta le configurazioni seguenti:
  + Un Directory Service Active Directory. Directory Service è un Active Directory AWS gestito ospitato su Amazon EC2. Per ulteriori informazioni, vedere Guida [introduttiva a AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) nella *Guida all'AWS Directory Service amministrazione*.
  + Una Active Directory on-premises. Devi assicurarti che l'istanza di container Linux di Amazon ECS possa essere aggiunta al dominio. Per ulteriori informazioni, consulta [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect-network-to-amazon.html).
+ Disponi di un account gMSA esistente in Active Directory e di un utente con l'autorizzazione di accesso all'account di servizio gMSA. Per ulteriori informazioni, consulta [Creazione di un utente Active Directory per gMSA senza dominio](#fargate-linux-gmsa-initial-domainless).
+ Disponi di un bucket Amazon S3. Per ulteriori informazioni, consultare [Creating a bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) nella *Guida per l'utente di Amazon S3*.

## Configurazione di container Linux compatibili con gMSA in Amazon ECS
<a name="fargate-linux-gmsa-setup"></a>
<a name="linux-gmsa-setup-infra"></a>
**Preparazione dell'infrastruttura**  
I passaggi seguenti sono considerazioni e configurazioni che vengono eseguite una sola volta. 
+ <a name="fargate-linux-gmsa-initial-domainless"></a>

**Creazione di un utente Active Directory per gMSA senza dominio**

  Quando si utilizza un gMSA senza dominio, il container non viene aggiunto al dominio. Le altre applicazioni eseguite sul container non possono utilizzare le credenziali per accedere al dominio. Le attività che utilizzano un dominio diverso possono essere eseguite sullo stesso container. Fornisci il nome di un segreto Gestione dei segreti AWS nel CredSpec file. Il segreto deve contenere un nome utente, una password e un dominio a cui accedere.

  Questa funzionalità è simile alla funzionalità *gMSA support for non-domain-joined container hosts*. Per ulteriori informazioni sulla funzionalità di Windows, consulta [Architettura e miglioramenti di gMSA](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#gmsa-architecture-and-improvements) sul sito Web Microsoft Learn.

  1. Configurare un utente nel dominio di Active Directory. L'utente di Active Directory deve disporre dell'autorizzazione di accesso all'account di servizio gMSA utilizzato nelle attività.

  1. Disponi di un VPC e delle sottoreti in grado di risolvere il nome di dominio Active Directory. Configurare il VPC con opzioni DHCP con il nome di dominio che indirizza al nome del servizio Active Directory. Per informazioni su come configurare le opzioni DHCP per un VPC, consultare [Work with DHCP option sets](https://docs.aws.amazon.com/vpc/latest/userguide/DHCPOptionSet.html) nella *Guida per l'utente di Amazon Virtual Private Cloud*.

  1. Crea un segreto in Gestione dei segreti AWS. 

  1. Creare il file di specifica delle credenziali.

**Configurazione di autorizzazioni e segreti**  
Eseguire i passaggi descritti di seguito una volta per ogni applicazione e ogni definizione dell'attività. Consigliamo di utilizzare la best practice di concedere il privilegio minimo e limitare le autorizzazioni utilizzate nella policy. In questo modo, ogni attività può leggere solo i segreti di cui ha bisogno.

1. Crea un utente nel dominio di Active Directory. L'utente di Active Directory deve disporre dell'autorizzazione per accedere agli account del servizio di gMSA utilizzati nelle attività.

1. Dopo aver creato l'utente di Active Directory, crea un account segreto in Gestione dei segreti AWS. Per ulteriori informazioni, consulta [Creazione di un segreto Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).

1. Inserisci il nome utente, la password e il dominio dell'utente nelle coppie chiave-valore JSON denominate rispettivamente `username`, `password` e `domainName`.

   ```
   {"username":"username","password":"passw0rd", "domainName":"example.com"}
   ```

1. <a name="fargate-linux-gmsa-domainless-secret"></a>Inoltre, devi aggiungere le autorizzazioni seguenti come policy inline al ruolo di esecuzione dell'attività del ruolo IAM. In questo modo il daemon `credentials-fetcher` accede al segreto di Secrets Manager. Sostituisci l'esempio `MySecret` con il nome della risorsa Amazon (ARN) del segreto nell'elenco `Resource`.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": [
               "arn:aws:secretsmanager:us-east-1:111122223333:secret:MySecret"
               ]
           }
       ]
   }
   ```

------
**Nota**  
Se utilizzi la tua chiave KMS per crittografare il tuo segreto, devi aggiungere le autorizzazioni necessarie a questo ruolo e aggiungere questo ruolo alla politica delle AWS KMS chiavi.

1. <a name="linux-gmsa-credspec-ssm"></a>Aggiungi le specifiche delle credenziali a un bucket Amazon S3. Quindi, fai riferimento al nome della risorsa Amazon (ARN) del bucket Amazon S3 nel campo `credentialSpecs` della definizione di attività.

   ```
   {
       "family": "",
       "executionRoleArn": "",
       "containerDefinitions": [
           {
               "name": "",
               ...
               "credentialSpecs": [
                   "credentialspecdomainless:arn:aws:s3:::${BucketName}/${ObjectName}"
               ],
               ...
           }
       ],
       ...
   }
   ```

   Devi aggiungere le seguenti autorizzazioni come policy inline al ruolo IAM di esecuzione delle attività Amazon ECS per consentire alle attività l'accesso al bucket Amazon S3.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "VisualEditor",
               "Effect": "Allow",
               "Action": [
               "s3:GetObjectVersion",
               "s3:ListBucket"
               ],
               "Resource": [
                   "arn:aws:s3:::{bucket_name}",
                   "arn:aws:s3:::{bucket_name}/{object}"
               ]
           }
       ]
   }
   ```

------

## File di specifica delle credenziali
<a name="fargate-linux-gmsa-credentialspec"></a>

Amazon ECS utilizza un file di specifica delle credenziali di Active Directory (*CredSpec*). Questo file contiene i metadati gMSA utilizzati per propagare il contesto dell'account gMSA al container Linux. Genera il file CredSpec e fai riferimento a esso nel campo `credentialSpecs` della definizione delle attività. Il file CredSpec non contiene segreti.

Di seguito è riportato un esempio del file CredSpec.

```
{
    "CmsPlugins": [
        "ActiveDirectory"
    ],
    "DomainJoinConfig": {
        "Sid": "S-1-5-21-2554468230-2647958158-2204241789",
        "MachineAccountName": "WebApp01",
        "Guid": "8665abd4-e947-4dd0-9a51-f8254943c90b",
        "DnsTreeName": "example.com",
        "DnsName": "example.com",
        "NetBiosName": "example"
    },
    "ActiveDirectoryConfig": {
        "GroupManagedServiceAccounts": [
            {
                "Name": "WebApp01",
                "Scope": "example.com"
            }
        ],
        "HostAccountConfig": {
            "PortableCcgVersion": "1",
            "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
            "PluginInput": {
                "CredentialArn": "arn:aws:secretsmanager:aws-region:111122223333:secret:MySecret"
            }
        }
    }
}
```
<a name="fargate-linux-gmsa-credentialspec-create"></a>
**Creazione di CredSpec e caricamento su Amazon S3**  
Crea un file CredSpec utilizzando il modulo PowerShell CredSpec su un computer Windows che fa parte del dominio. Segui i passaggi descritti in [Creazione di una specifica delle credenziali](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#create-a-credential-spec) sul sito Web Microsoft Learn.

Dopo aver creato il file di specifica delle credenziali, caricarlo su un bucket Amazon S3. Copia il file CredSpec nel computer o nell'ambiente in cui esegui i comandi AWS CLI .

Esegui il AWS CLI comando seguente per CredSpec caricarlo su Amazon S3. Sostituisci `amzn-s3-demo-bucket` con il nome del bucket Amazon S3. Puoi archiviare il file come oggetto in qualsiasi bucket e posizione, ma devi consentire l'accesso a tale bucket e tale posizione nella policy associata al ruolo di esecuzione dell'attività.

Per PowerShell, usa il seguente comando:

```
$ Write-S3Object -BucketName "amzn-s3-demo-bucket" -Key "ecs-domainless-gmsa-credspec" -File "gmsa-cred-spec.json"
```

Il AWS CLI comando seguente utilizza i caratteri di continuazione con barra rovesciata utilizzati dalle shell compatibili`sh`. 

```
$ aws s3 cp gmsa-cred-spec.json \
s3://amzn-s3-demo-bucket/ecs-domainless-gmsa-credspec
```

# Utilizzo di contenitori Amazon ECS Windows senza dominio gMSA utilizzando AWS CLI
<a name="tutorial-gmsa-windows"></a>

Il tutorial seguente mostra come creare un'attività Amazon ECS che esegue un container Windows con credenziali per accedere ad Active Directory con la AWS CLI. Utilizzando gMSA senza dominio, l'istanza di container non viene aggiunta al dominio, le altre applicazioni sull'istanza non possono utilizzare le credenziali per accedere al dominio e le attività che si uniscono a domini diversi possono essere eseguite sulla stessa istanza.

**Topics**
+ [

## Prerequisiti
](#tutorial-gmsa-windows-prerequisites)
+ [

## Fase 1: creazione e configurazione dell'account gMSA su Active Directory Domain Services (AD DS)
](#tutorial-gmsa-windows-step1)
+ [

## Fase 2: caricamento delle credenziali in Secrets Manager
](#tutorial-gmsa-windows-step2)
+ [

## Fase3: modifica del codice JSON CredSpec per includere informazioni relative a gMSA senza dominio
](#tutorial-gmsa-windows-step3)
+ [

## Fase 4: caricamento di CredSpec su Amazon S3
](#tutorial-gmsa-windows-step4)
+ [

## Fase 5: creazione di un cluster Amazon ECS (facoltativo)
](#tutorial-gmsa-windows-step5)
+ [

## Fase 6: creazione di un ruolo IAM per le istanze di container
](#tutorial-gmsa-windows-step6)
+ [

## Fase 7: creazione di un ruolo di esecuzione dell'attività personalizzata
](#tutorial-gmsa-windows-step7)
+ [

## Fase 8: creazione di un ruolo dell'attività per Amazon ECS Exec
](#tutorial-gmsa-windows-step8)
+ [

## Fase 9: registrazione di una definizione di attività che utilizza gMSA senza dominio
](#tutorial-gmsa-windows-step9)
+ [

## Fase 10: registrazione di un'istanza di container Windows nel cluster
](#tutorial-gmsa-windows-step10)
+ [

## Fase 11: verifica dell'istanza di container
](#tutorial-gmsa-windows-step11)
+ [

## Fase 12: esecuzione di un'attività di Windows
](#tutorial-gmsa-windows-step12)
+ [

## Fase 13: verifica che il container disponga delle credenziali gMSA
](#tutorial-gmsa-windows-step13)
+ [

## Fase 14: pulizia
](#tutorial-gmsa-windows-step14)
+ [

## Debug di gMSA senza dominio in Amazon ECS per i container Windows
](#tutorial-gmsa-windows-debugging)

## Prerequisiti
<a name="tutorial-gmsa-windows-prerequisites"></a>

Questo tutorial presuppone che siano stati soddisfatti i prerequisiti seguenti:
+ Hai completato le fasi descritte in [Configurazione per l'uso di Amazon ECS](get-set-up-for-amazon-ecs.md).
+ L'utente IAM ha le autorizzazioni necessarie specificate nell'esempio di policy IAM [AmazonECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess).
+  La versione più recente di AWS CLI è installata e configurata. Per ulteriori informazioni sull'installazione o l'aggiornamento di AWS CLI, vedere [Installazione](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) di. AWS Command Line Interface
**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).
+ Configura un dominio Active Directory con le risorse a cui desideri che i tuoi container accedano. Amazon ECS supporta le configurazioni seguenti:
  + Un Active Directory. Directory Service Directory Service è un Active Directory AWS gestito ospitato su Amazon EC2. Per ulteriori informazioni, vedere Guida [introduttiva a AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) nella *Guida all'AWS Directory Service amministrazione*.
  + Una Active Directory on-premises. Devi assicurarti che l'istanza di container Linux di Amazon ECS possa essere aggiunta al dominio. Per ulteriori informazioni, consulta [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect-network-to-amazon.html).
+ Disponi di un VPC e delle sottoreti in grado di risolvere il nome di dominio Active Directory.
+ Hai scelto tra la modalità **gMSA senza dominio** e **l'aggiunta di ogni istanza in un unico dominio**. Utilizzando gMSA senza dominio, l'istanza di container non viene aggiunta al dominio, le altre applicazioni sull'istanza non possono utilizzare le credenziali per accedere al dominio e le attività che si uniscono a domini diversi possono essere eseguite sulla stessa istanza.

  Quindi, scegli l'archiviazione di dati per CredSpec e, facoltativamente, per le credenziali utente di Active Directory per gMSA senza dominio.

  Amazon ECS utilizza un file di specifica delle credenziali di Active Directory (CredSpec). Questo file contiene i metadati gMSA utilizzati per propagare il contesto dell'account gMSA al container. Il file CredSpec viene generato e quindi archiviato in una delle opzioni di archiviazione di CredSpec nella tabella seguente, specifica del sistema operativo delle istanze di container. Per utilizzare il metodo senza dominio, una sezione facoltativa del file CredSpec può specificare le credenziali in una delle opzioni di archiviazione *domainless user credentials* riportate nella tabella seguente, in base al sistema operativo delle istanze di container.    
<a name="gmsa-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonECS/latest/developerguide/tutorial-gmsa-windows.html)
+ (Facoltativo) AWS CloudShell è uno strumento che offre ai clienti una riga di comando senza la necessità di creare la propria istanza EC2. Per ulteriori informazioni, consulta [Cos'è? AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) nella *Guida AWS CloudShell per l'utente*.

## Fase 1: creazione e configurazione dell'account gMSA su Active Directory Domain Services (AD DS)
<a name="tutorial-gmsa-windows-step1"></a>

Crea e configura un account gMSA nel dominio Active Directory.

**Nota**  
Questa fase crea due account separati: un account di servizio gestito del gruppo (gMSA) che fornisce l'identità per i container e un account utente normale utilizzato per l'autenticazione del dominio. Questi account hanno scopi diversi e devono avere nomi diversi.

1. 

**Genera una chiave principale del servizio di distribuzione delle chiavi**
**Nota**  
Se lo stai utilizzando Directory Service, puoi saltare questo passaggio.

   La chiave principale KDS e le autorizzazioni gMSA sono configurate con Microsoft AD gestito da AWS .

   Se non hai ancora creato un account del sevizio gMSA nel tuo dominio, dovrai prima generare una chiave principale del servizio di distribuzione delle chiavi (KDS). Il KDS è responsabile della creazione, della rotazione e del rilascio della password gMSA agli host autorizzati. Quando `ccg.exe` ha bisogno di recuperare le credenziali gMSA, contatta KDS per recuperare la password attuale.

   Per verificare se la chiave radice KDS è già stata creata, esegui il seguente PowerShell cmdlet con privilegi di amministratore di dominio su un controller di dominio utilizzando il modulo. `ActiveDirectory` PowerShell Per ulteriori informazioni sul modulo, vedere [ActiveDirectory Module](https://learn.microsoft.com/en-us/powershell/module/activedirectory/?view=windowsserver2022-ps) nel sito Web Microsoft Learn.

   ```
   PS C:\> Get-KdsRootKey
   ```

   Se il comando restituisce un ID chiave, puoi ignorare il resto della procedura. In caso contrario, crea la chiave principale KDS eseguendo il comando seguente:

   ```
   PS C:\> Add-KdsRootKey -EffectiveImmediately
   ```

   Sebbene l'argomento `EffectiveImmediately` del comando implichi l'efficacia immediata della chiave, devi attendere 10 ore prima che la chiave principale KDS venga replicata e sia disponibile per l'uso su tutti i controller di dominio.

1. 

**Crea l'account gMSA**

   Per creare l'gMSAaccount e consentire il `ccg.exe` recupero della gMSA password, esegui i seguenti PowerShell comandi da un server o client Windows con accesso al dominio. Sostituire `ExampleAccount` con il nome desiderato per l'account gMSA e sostituire `example-domain` con il nome del dominio Active Directory (ad esempio, se il dominio è `contoso.com`, utilizzare `contoso`).

   1. 

      ```
      PS C:\> Install-WindowsFeature RSAT-AD-PowerShell
      ```

   1. 

      ```
      PS C:\> New-ADGroup -Name "ExampleAccount Authorized Hosts" -SamAccountName "ExampleAccountHosts" -GroupScope DomainLocal
      ```

   1. 

      ```
      PS C:\> New-ADServiceAccount -Name "ExampleAccount" -DnsHostName "example-domain" -ServicePrincipalNames "host/ExampleAccount", "host/example-domain" -PrincipalsAllowedToRetrieveManagedPassword "ExampleAccountHosts"
      ```

   1. Crea un utente con una password permanente senza scadenza. Queste credenziali vengono archiviate Gestione dei segreti AWS e utilizzate da ogni attività per accedere al dominio. Si tratta di un account utente separato dall'account gMSA creato in precedenza. Sostituire `ExampleServiceUser` con il nome desiderato per questo account utente di servizio.

      ```
      PS C:\> New-ADUser -Name "ExampleServiceUser" -AccountPassword (ConvertTo-SecureString -AsPlainText "Test123" -Force) -Enabled 1 -PasswordNeverExpires 1
      ```

   1. 

      ```
      PS C:\> Add-ADGroupMember -Identity "ExampleAccountHosts" -Members "ExampleServiceUser"
      ```

   1. Installa il PowerShell modulo per la creazione di CredSpec oggetti in Active Directory e genera il codice CredSpec JSON.

      ```
      PS C:\> Install-PackageProvider -Name NuGet -Force
      ```

      ```
      PS C:\> Install-Module CredentialSpec
      ```

   1. 

      ```
      PS C:\> New-CredentialSpec -AccountName ExampleAccount
      ```

1. Copia l'output JSON del comando precedente in un file denominato `gmsa-cred-spec.json`. Si tratta del file CredSpec che viene utilizzato nella fase 3, [Fase3: modifica del codice JSON CredSpec per includere informazioni relative a gMSA senza dominio](#tutorial-gmsa-windows-step3).

## Fase 2: caricamento delle credenziali in Secrets Manager
<a name="tutorial-gmsa-windows-step2"></a>

Copia le credenziali di Active Directory in un sistema di archiviazione sicuro delle credenziali, in modo che ogni attività possa recuperarle. Questo è il metodo gMSA senza dominio. Utilizzando gMSA senza dominio, l'istanza di container non viene aggiunta al dominio, le altre applicazioni sull'istanza non possono utilizzare le credenziali per accedere al dominio e le attività che si uniscono a domini diversi possono essere eseguite sulla stessa istanza.

Questo passaggio utilizza il. AWS CLI Puoi eseguire questi comandi in AWS CloudShell nella shell (interprete di comandi) predefinita, ovvero `bash`.
+ Esegui il AWS CLI comando seguente e sostituisci il nome utente, la password e il nome di dominio in modo che corrispondano al tuo ambiente. Utilizzare il nome dell'account utente di servizio (non il nome dell'account gMSA) come nome utente. Mantieni l'ARN del segreto da utilizzare nella fase successiva, [Fase3: modifica del codice JSON CredSpec per includere informazioni relative a gMSA senza dominio](#tutorial-gmsa-windows-step3)

  Il comando seguente utilizza i caratteri di continuazione (barra rovesciata) utilizzati da `sh` e dalle shell compatibili. Questo comando non è compatibile con PowerShell. È necessario modificare il comando con cui utilizzarlo PowerShell.

  ```
  $ aws secretsmanager create-secret \
  --name gmsa-plugin-input \
  --description "Amazon ECS - gMSA Portable Identity." \
  --secret-string "{\"username\":\"ExampleServiceUser\",\"password\":\"Test123\",\"domainName\":\"contoso.com\"}"
  ```

## Fase3: modifica del codice JSON CredSpec per includere informazioni relative a gMSA senza dominio
<a name="tutorial-gmsa-windows-step3"></a>

Prima di caricare CredSpec su una delle opzioni di archiviazione, aggiungi le informazioni a CredSpec con l'ARN del segreto in Secrets Manager del passaggio precedente. Per [ulteriori informazioni, vedi lo use case Additional Credential Spec Configuration for non-domain-joined Container Host nel](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#additional-credential-spec-configuration-for-non-domain-joined-container-host-use-case) sito Web Microsoft Learn.

1. Aggiungi le seguenti informazioni al file CredSpec all'interno di `ActiveDirectoryConfig`. Sostituisci l'ARN con il segreto in Secrets Manager del passaggio precedente.

   Tieni presente che il valore `PluginGUID` deve corrispondere al GUID nel seguente frammento di codice esemplificativo ed è obbligatorio.

   ```
   "HostAccountConfig": {
         "PortableCcgVersion": "1",
         "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
         "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
   ```

   Puoi anche usare un segreto nell'archivio parametri SSM con l'ARN in questo formato: `\"arn:aws:ssm:aws-region:111122223333:parameter/gmsa-plugin-input\"`.

1. Il file CredSpec modificato sarà simile all'esempio seguente:

   ```
   {
     "CmsPlugins": [
       "ActiveDirectory"
     ],
     "DomainJoinConfig": {
       "Sid": "S-1-5-21-4066351383-705263209-1606769140",
       "MachineAccountName": "ExampleAccount",
       "Guid": "ac822f13-583e-49f7-aa7b-284f9a8c97b6",
       "DnsTreeName": "example-domain",
       "DnsName": "example-domain",
       "NetBiosName": "example-domain"
     },
     "ActiveDirectoryConfig": {
       "GroupManagedServiceAccounts": [
         {
           "Name": "ExampleAccount",
           "Scope": "example-domain"
         },
         {
           "Name": "ExampleAccount",
           "Scope": "example-domain"
         }
       ],
       "HostAccountConfig": {
         "PortableCcgVersion": "1",
         "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
         "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
     }
   }
   ```

## Fase 4: caricamento di CredSpec su Amazon S3
<a name="tutorial-gmsa-windows-step4"></a>



Questo passaggio utilizza il. AWS CLI Puoi eseguire questi comandi in AWS CloudShell nella shell (interprete di comandi) predefinita, ovvero `bash`.

1. Copia il file CredSpec nel computer o nell'ambiente in cui esegui i comandi AWS CLI .

1. Esegui il AWS CLI comando seguente per CredSpec caricarlo su Amazon S3. Sostituisci `MyBucket` con il nome del bucket Amazon S3. Puoi archiviare il file come oggetto in qualsiasi bucket e posizione, ma devi consentire l'accesso a tale bucket e tale posizione nella policy associata al ruolo di esecuzione dell'attività.

   Il comando seguente utilizza i caratteri di continuazione (barra rovesciata) utilizzati da `sh` e dalle shell compatibili. Questo comando non è compatibile con PowerShell. È necessario modificare il comando con cui utilizzarlo PowerShell.

   ```
   $ aws s3 cp gmsa-cred-spec.json \
   s3://MyBucket/ecs-domainless-gmsa-credspec
   ```

## Fase 5: creazione di un cluster Amazon ECS (facoltativo)
<a name="tutorial-gmsa-windows-step5"></a>

Per impostazione predefinita, l'account dispone di un cluster Amazon ECS denominato `default`. Questo cluster viene utilizzato per impostazione predefinita in AWS CLI SDKs, e CloudFormation. Puoi utilizzare cluster aggiuntivi per raggruppare e organizzare le attività e l'infrastruttura e assegnare impostazioni predefinite per alcune configurazioni.

È possibile creare un cluster da Console di gestione AWS AWS CLI, SDKs, o CloudFormation. Le impostazioni e la configurazione nel cluster non influiscono su gMSA.

Questo passaggio utilizza il AWS CLI. Puoi eseguire questi comandi in AWS CloudShell nella shell (interprete di comandi) predefinita, ovvero `bash`.

```
$ aws ecs create-cluster --cluster-name windows-domainless-gmsa-cluster
```

**Importante**  
Se vuoi creare un cluster personalizzato, devi specificare `--cluster clusterName` per ogni comando che prevedi di usare con tale cluster.

## Fase 6: creazione di un ruolo IAM per le istanze di container
<a name="tutorial-gmsa-windows-step6"></a>

Un'*istanza di container* è un computer host per l'esecuzione di container in attività ECS, ad esempio istanze Amazon EC2. Ogni istanza di container viene registrata in un cluster Amazon ECS. Prima di avviare le istanze Amazon EC2 e registrarle in un cluster, devi creare un ruolo IAM per le istanze di container da utilizzare.

Per creare il ruolo dell'istanza di container, consulta [Ruolo IAM delle istanze di container Amazon ECS](instance_IAM_role.md). Il ruolo `ecsInstanceRole` predefinito dispone di autorizzazioni sufficienti per completare questo tutorial.

## Fase 7: creazione di un ruolo di esecuzione dell'attività personalizzata
<a name="tutorial-gmsa-windows-step7"></a>

Amazon ECS può utilizzare un ruolo IAM diverso per le autorizzazioni necessarie all'avvio di ogni attività, anziché il ruolo dell'istanza di container. Questo ruolo è il *ruolo di esecuzione dell'attività*. Ti consigliamo di creare un ruolo di esecuzione dell'attività con le sole autorizzazioni necessarie per l'esecuzione dell'attività da parte di ECS, note anche come *autorizzazioni con privilegi minimi*. *Per ulteriori informazioni sul principio del privilegio minimo, vedere [SEC03- BP02 Garantire l'accesso con il minimo privilegio](https://docs.aws.amazon.com/wellarchitected/latest/framework/sec_permissions_least_privileges.html) nel Well-Architected AWS Framework.*

1. Per creare un ruolo di esecuzione dell'attività, consulta [Creazione del ruolo di esecuzione attività](task_execution_IAM_role.md#create-task-execution-role). Le autorizzazioni predefinite consentono all'istanza del contenitore di estrarre le immagini dei contenitori da Amazon Elastic Container Registry `stdout` e `stderr` dalle tue applicazioni per registrarle su Amazon CloudWatch Logs.

   Poiché il ruolo richiede autorizzazioni personalizzate per questo tutorial, puoi assegnare al ruolo un nome diverso da `ecsTaskExecutionRole`. Questo tutorial utilizza `ecsTaskExecutionRole` nelle fasi successive.

1. Aggiungi le seguenti autorizzazioni creando una policy personalizzata, una policy in linea che esiste solo per questo ruolo o una policy che puoi riutilizzare. Sostituisci l'ARN della `Resource` nella prima istruzione con il bucket e la posizione di Amazon S3 e la seconda `Resource` con l'ARN del segreto in Secrets Manager.

   Se esegui la crittografa del segreto in Secrets Manager con una chiave personalizzata, devi consentire anche `kms:Decrypt` per la chiave.

   Se al posto di Secrets Manager utilizzi l'archivio parametri SSM, devi consentire `ssm:GetParameter` per il parametro, anziché `secretsmanager:GetSecretValue`.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject"
               ],
               "Resource": "arn:aws:s3:::MyBucket/ecs-domainless-gmsa-credspec/gmsa-cred-spec.json"
           },
           {
               "Effect": "Allow",
               "Action": [
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": "arn:aws:secretsmanager:us-east-1:111122223333:secret:gmsa-plugin-AbCdEf"
           }
       ]
   }
   ```

------

## Fase 8: creazione di un ruolo dell'attività per Amazon ECS Exec
<a name="tutorial-gmsa-windows-step8"></a>

Questo tutorial utilizza Amazon ECS Exec per verificare la funzionalità eseguendo un comando all'interno di un'attività in esecuzione. Per utilizzare ECS Exec, è necessario attivare ECS Exec nel servizio o nell'attività. Inoltre, il ruolo dell'attività (non il ruolo di esecuzione dell'attività) deve disporre delle autorizzazioni `ssmmessages`. Per informazioni sulla policy IAM richiesta, consulta [Autorizzazioni ACS Exec](task-iam-roles.md#ecs-exec-required-iam-permissions).

Questo passaggio utilizza il. AWS CLI Puoi eseguire questi comandi in AWS CloudShell nella shell (interprete di comandi) predefinita, ovvero `bash`.

Per creare un ruolo di attività utilizzando il AWS CLI, segui questi passaggi.

1. Crea un file denominato `ecs-tasks-trust-policy.json` con i seguenti contenuti:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Principal": {
                   "Service": "ecs-tasks.amazonaws.com"
               },
               "Action": "sts:AssumeRole"
           }
       ]
   }
   ```

------

1. Crea un ruolo IAM. Puoi sostituire il nome `ecs-exec-demo-task-role` ma mantenerlo per i passaggi successivi.

   Il comando seguente utilizza i caratteri di continuazione (barra rovesciata) utilizzati da `sh` e dalle shell compatibili. Questo comando non è compatibile con PowerShell. È necessario modificare il comando con cui utilizzarlo PowerShell.

   ```
   $ aws iam create-role --role-name ecs-exec-demo-task-role \
   --assume-role-policy-document file://ecs-tasks-trust-policy.json
   ```

   Puoi eliminare il file `ecs-tasks-trust-policy.json`.

1. Crea un file denominato `ecs-exec-demo-task-role-policy.json` con i seguenti contenuti:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "ssmmessages:CreateControlChannel",
                   "ssmmessages:CreateDataChannel",
                   "ssmmessages:OpenControlChannel",
                   "ssmmessages:OpenDataChannel"
               ],
               "Resource": "*"
           }
       ]
   }
   ```

------

1. Crea una policy IAM e collegala al ruolo della fase precedente.

   Il comando seguente utilizza i caratteri di continuazione (barra rovesciata) utilizzati da `sh` e dalle shell compatibili. Questo comando non è compatibile con PowerShell. È necessario modificare il comando con cui utilizzarlo PowerShell.

   ```
   $ aws iam put-role-policy \
       --role-name ecs-exec-demo-task-role \
       --policy-name ecs-exec-demo-task-role-policy \
       --policy-document file://ecs-exec-demo-task-role-policy.json
   ```

   Puoi eliminare il file `ecs-exec-demo-task-role-policy.json`.

## Fase 9: registrazione di una definizione di attività che utilizza gMSA senza dominio
<a name="tutorial-gmsa-windows-step9"></a>



Questo passaggio utilizza il AWS CLI. Puoi eseguire questi comandi in AWS CloudShell nella shell (interprete di comandi) predefinita, ovvero `bash`.

1. Crea un file denominato `windows-gmsa-domainless-task-def.json` con i seguenti contenuti:

   ```
   {
     "family": "windows-gmsa-domainless-task",
     "containerDefinitions": [
       {
         "name": "windows_sample_app",
         "image": "mcr.microsoft.com/windows/servercore/iis",
         "cpu": 1024,
         "memory": 1024,
         "essential": true,
         "credentialSpecs": [
                   "credentialspecdomainless:arn:aws:s3:::ecs-domainless-gmsa-credspec/gmsa-cred-spec.json"
         ],
         "entryPoint": [
           "powershell",
           "-Command"
         ],
         "command": [
           "New-Item -Path C:\\inetpub\\wwwroot\\index.html -ItemType file -Value '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p>' -Force ; C:\\ServiceMonitor.exe w3svc"
         ],
         "portMappings": [
           {
             "protocol": "tcp",
             "containerPort": 80,
             "hostPort": 8080
           }
         ]
       }
     ],
     "taskRoleArn": "arn:aws:iam::111122223333:role/ecs-exec-demo-task-role",
     "executionRoleArn": "arn:aws:iam::111122223333:role/ecsTaskExecutionRole"
   }
   ```

1. Registra la definizione di attività con il comando seguente:

   Il comando seguente utilizza i caratteri di continuazione (barra rovesciata) utilizzati da `sh` e dalle shell compatibili. Questo comando non è compatibile con PowerShell. È necessario modificare il comando con cui utilizzarlo PowerShell.

   ```
   $ aws ecs register-task-definition \
   --cli-input-json file://windows-gmsa-domainless-task-def.json
   ```

## Fase 10: registrazione di un'istanza di container Windows nel cluster
<a name="tutorial-gmsa-windows-step10"></a>

Avvia un'istanza Windows di Amazon EC2 ed esegui l'agente di container ECS per registrarla come istanza di container nel cluster. ECS esegue le attività sulle istanze di container registrate nel cluster in cui vengono avviate le attività.

1. Per avviare un'istanza Windows di Amazon EC2 configurata per Amazon ECS in, consulta Console di gestione AWS. [Avvio di un'istanza di container Windows di Amazon ECS](launch_window-container_instance.md) Fermati alla fase relativa ai *dati utente*.

1. Per quanto riguarda gMSA, i dati utente devono impostare la variabile di ambiente `ECS_GMSA_SUPPORTED` prima di avviare l'agente del container ECS.

   Per ECS Exec, l'agente deve iniziare con l'argomento `-EnableTaskIAMRole`.

   Per proteggere il ruolo IAM dell'istanza impedendo alle attività di raggiungere il servizio Web IMDS EC2 al fine di recuperare le credenziali del ruolo, aggiungi l'argomento `-AwsvpcBlockIMDS`. Ciò si applica solo alle attività che utilizzano la modalità di rete `awsvpc`.

   ```
   <powershell>
   [Environment]::SetEnvironmentVariable("ECS_GMSA_SUPPORTED", $TRUE, "Machine")
   Import-Module ECSTools
   Initialize-ECSAgent -Cluster windows-domainless-gmsa-cluster -EnableTaskIAMRole -AwsvpcBlockIMDS
   </powershell>
   ```

1. Analizza un riepilogo della configurazione dell'istanza nel pannello **Summary** (Riepilogo) e, quando è tutto pronto, scegli **Launch instance** (Avvia istanza).

## Fase 11: verifica dell'istanza di container
<a name="tutorial-gmsa-windows-step11"></a>

Puoi verificare la presenza di un'istanza di container nel cluster utilizzando la Console di gestione AWS. Tuttavia, gMSA necessita di funzionalità aggiuntive indicate come *attributi*. Questi attributi non sono visibili in Console di gestione AWS, quindi questo tutorial utilizza il. AWS CLI

Questo passaggio utilizza il AWS CLI. Puoi eseguire questi comandi in AWS CloudShell nella shell (interprete di comandi) predefinita, ovvero `bash`.

1. Elenca le istanze di container nel cluster. Le istanze di container hanno un ID diverso dall'ID dell'istanza EC2.

   ```
   $ aws ecs list-container-instances
   ```

   Output:

   ```
   {
       "containerInstanceArns": [
           "arn:aws:ecs:aws-region:111122223333:container-instance/default/MyContainerInstanceID"
       ]
   }
   ```

   Ad esempio, `526bd5d0ced448a788768334e79010fd` è un ID di istanza di container valido.

1. Utilizza l'ID istanza di container della fase precedente per informazioni dettagliate sull'istanza di container. Sostituisci `MyContainerInstanceID` con l'ID.

   Il comando seguente utilizza i caratteri di continuazione (barra rovesciata) utilizzati da `sh` e dalle shell compatibili. Questo comando non è compatibile con PowerShell. È necessario modificare il comando con cui utilizzarlo PowerShell.

   ```
   $ aws ecs describe-container-instances \
        ----container-instances MyContainerInstanceID
   ```

   Nota che l'output è molto lungo.

1. Verifica che l'elenco `attributes` contenga un oggetto con la chiave denominata `name` e un valore `ecs.capability.gmsa-domainless`. Di seguito è mostrato un esempio dell'oggetto.

   Output:

   ```
   {
       "name": "ecs.capability.gmsa-domainless"
   }
   ```

## Fase 12: esecuzione di un'attività di Windows
<a name="tutorial-gmsa-windows-step12"></a>

Esegui un'attività Amazon ECS. Se nel cluster è presente una sola istanza di container, puoi utilizzare `run-task`. Se sono presenti molte istanze di container diverse, potrebbe essere più semplice utilizzare `start-task` e specificare l'ID dell'istanza di container su cui eseguire l'attività piuttosto che aggiungere vincoli di posizionamento alla definizione di attività per controllare il tipo di istanza su cui eseguire l'attività.

Questo passaggio utilizza il AWS CLI. Puoi eseguire questi comandi in AWS CloudShell nella shell (interprete di comandi) predefinita, ovvero `bash`.

1. 

   Il comando seguente utilizza i caratteri di continuazione (barra rovesciata) utilizzati da `sh` e dalle shell compatibili. Questo comando non è compatibile con PowerShell. È necessario modificare il comando con cui utilizzarlo PowerShell.

   ```
   aws ecs run-task --task-definition windows-gmsa-domainless-task \
       --enable-execute-command --cluster windows-domainless-gmsa-cluster
   ```

   Prendi nota dell'ID attività restituito dal comando.

1. Esegui il comando seguente per verificare che l'attività sia stata avviata. Questo comando resta in attesa e non restituisce il prompt della shell (interprete di comandi) fino all'avvio dell'attività. Sostituisci `MyTaskID` con l'ID attività ottenuto nella fase precedente.

   ```
   $ aws ecs wait tasks-running --task MyTaskID
   ```

## Fase 13: verifica che il container disponga delle credenziali gMSA
<a name="tutorial-gmsa-windows-step13"></a>

Verifica che il container dell'attività abbia un token Kerberos. gMSA 

Questo passaggio utilizza il AWS CLI. Puoi eseguire questi comandi in AWS CloudShell nella shell (interprete di comandi) predefinita, ovvero `bash`.

1. 

   Il comando seguente utilizza i caratteri di continuazione (barra rovesciata) utilizzati da `sh` e dalle shell compatibili. Questo comando non è compatibile con PowerShell. È necessario modificare il comando con cui utilizzarlo PowerShell.

   ```
   $ aws ecs execute-command \
   --task MyTaskID \
   --container windows_sample_app \
   --interactive \
   --command powershell.exe
   ```

   L'output sarà un PowerShell prompt.

1. Esegui il seguente comando nel PowerShell terminale all'interno del contenitore.

   ```
   PS C:\> klist get ExampleAccount$
   ```

   Tieni presente che il `Principal` presente nell'output è uguale a quello creato in precedenza.

## Fase 14: pulizia
<a name="tutorial-gmsa-windows-step14"></a>

Una volta terminato questo tutorial, è necessario eliminare le risorse associate per evitare costi aggiuntivi per le risorse non utilizzate.

Questo passaggio utilizza il AWS CLI. Puoi eseguire questi comandi in AWS CloudShell nella shell (interprete di comandi) predefinita, ovvero `bash`.

1. Interrompi l'attività. Sostituisci `MyTaskID` con l'ID attività della fase 12, [Fase 12: esecuzione di un'attività di Windows](#tutorial-gmsa-windows-step12).

   ```
   $ aws ecs stop-task --task MyTaskID
   ```

1. Termina l'istanza Amazon EC2. Successivamente, l'istanza di container nel cluster verrà eliminata automaticamente dopo un'ora.

   Puoi individuare e terminare l'istanza mediante la console Amazon EC2 o puoi eseguire il comando seguente. Per eseguire il comando, trova l'ID dell'istanza EC2 nell'output del comando `aws ecs describe-container-instances` della fase 1, [Fase 11: verifica dell'istanza di container](#tutorial-gmsa-windows-step11) .i-10a64379è un esempio di ID dell'istanza EC2.

   ```
   $ aws ec2 terminate-instances --instance-ids MyInstanceID
   ```

1. Elimina il file CredSpec in Amazon S3. Sostituisci `MyBucket` con il nome del bucket Amazon S3.

   ```
   $ aws s3api delete-object --bucket MyBucket --key ecs-domainless-gmsa-credspec/gmsa-cred-spec.json
   ```

1. Elimina il segreto da Secrets Manager. Se invece hai utilizzato l'archivio parametri SSM, elimina il parametro.

   Il comando seguente utilizza i caratteri di continuazione (barra rovesciata) utilizzati da `sh` e dalle shell compatibili. Questo comando non è compatibile con PowerShell. È necessario modificare il comando con cui utilizzarlo PowerShell.

   ```
   $ aws secretsmanager delete-secret --secret-id gmsa-plugin-input \
        --force-delete-without-recovery
   ```

1. Annulla la registrazione della definizione di attività ed eliminala. Dopo aver annullato la registrazione, la definizione di attività viene contrassegnata come inattiva, in modo che non possa essere utilizzata per avviare nuove attività. Puoi quindi eliminare la definizione di attività.

   1. Annulla la registrazione della definizione di attività specificando la versione. ECS crea automaticamente delle versioni delle definizioni di attività, numerate a partire da 1. Fai riferimento alle versioni nello stesso formato delle etichette sulle immagini di container, ad esempio `:1`.

      ```
      $ aws ecs deregister-task-definition --task-definition windows-gmsa-domainless-task:1
      ```

   1. Elimina la definizione di attività.

      ```
      $ aws ecs delete-task-definitions --task-definition windows-gmsa-domainless-task:1
      ```

1. (Facoltativo) Elimina il cluster ECS, se ne hai creato uno.

   ```
   $ aws ecs delete-cluster --cluster windows-domainless-gmsa-cluster
   ```

## Debug di gMSA senza dominio in Amazon ECS per i container Windows
<a name="tutorial-gmsa-windows-debugging"></a>



Stato dell'attività di Amazon ECS  
ECS tenta di avviare esattamente un'attività una volta. Se un'attività presenza un problema, viene interrotta e impostata nello stato `STOPPED`. Esistono due tipi comuni di problemi relativi alle attività. Innanzitutto, le attività che non possono essere avviate. In secondo luogo, le attività in cui l'applicazione si è interrotta all'interno di uno dei container. Nel campo **Motivo interrotto** dell'attività Console di gestione AWS, esamina il motivo per cui l'attività è stata interrotta. Nella AWS CLI, descrivi l'attività e osserva il campo `stoppedReason`. Per i passaggi da seguire AWS CLI, consulta[Visualizza gli errori relativi alle attività interrotte in Amazon ECS](stopped-task-errors.md). Console di gestione AWS 

Eventi Windows  
Gli eventi di Windows per gMSA nei container vengono registrati nel file di log `Microsoft-Windows-Containers-CCG` e sono disponibili all'interno del Visualizzatore eventi nella sezione Applicazioni e servizi in `Logs\Microsoft\Windows\Containers-CCG\Admin`. Per ulteriori suggerimenti sul debug, consulta [Risoluzione dei problemi relativi ai contenitori g MSAs for Windows sul](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/gmsa-troubleshooting#non-domain-joined-container-hosts-use-event-logs-to-identify-configuration-issues) sito Web Microsoft Learn.

Plug-in gMSA per l'agente ECS  
La registrazione del plug-in gMSA per l'agente ECS sull'istanza di container Windows si trova nella seguente directory, `C:/ProgramData/Amazon/gmsa-plugin/`. Verifica all'interno del log se le credenziali utente senza dominio sono state scaricate dalla posizione di archiviazione, ad esempio Secrets Manager, e se il formato delle credenziali è stato letto correttamente.

# Informazioni su come utilizzare i gMSA per i container Windows EC2 per Amazon ECS
<a name="windows-gmsa"></a>

Amazon ECS supporta l'autenticazione di Active Directory per i container Windows tramite un tipo speciale di account di servizio denominato *account di servizio gestito di gruppo* (gMSA, group Managed Service Account).

Le applicazioni di rete basate su Windows, ad esempio le applicazioni .NET, utilizzano spesso Active Directory per facilitare l'autenticazione e la gestione delle autorizzazioni tra utenti e servizi. Gli sviluppatori di solito progettano le loro applicazioni per l'integrazione con Active Directory e l'esecuzione su server aggiunti al dominio a tale scopo. Poiché i container Windows non possono essere aggiunti al dominio, è necessario configurare un container Windows per l'esecuzione con account gMSA.

Un container Windows in esecuzione con gMSA si basa sulla relativa istanza host Amazon EC2 per recuperare le credenziali gMSA dal controller di dominio Active Directory e fornirle all'istanza del container. Per ulteriori informazioni, consulta [Creare](https://docs.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts) contenitori g per Windows. MSAs 

**Nota**  
Questa funzione non è supportata per i container Windows su Fargate.

**Topics**
+ [

## Considerazioni
](#windows-gmsa-considerations)
+ [

## Prerequisiti
](#windows-gmsa-prerequisites)
+ [

## Configurazione di gMSA per container Windows su Amazon ECS
](#windows-gmsa-setup)

## Considerazioni
<a name="windows-gmsa-considerations"></a>

Quando si utilizzano contenitori g MSAs per Windows, è necessario considerare quanto segue:
+ Quando utilizzi l'AMI Windows Server 2016 Full ottimizzata per Amazon ECS per le istanze di container, il nome host del container deve essere uguale al nome dell'account gMSA definito nel file delle specifiche delle credenziali. Per specificare un nome host per un container, usa il parametro di definizione del container `hostname`. Per ulteriori informazioni, consulta [Impostazioni di rete](task_definition_parameters.md#container_definition_network).
+ Hai scelto tra la modalità **gMSA senza dominio** e **l'aggiunta di ogni istanza in un unico dominio**. Utilizzando gMSA senza dominio, l'istanza di container non viene aggiunta al dominio, le altre applicazioni sull'istanza non possono utilizzare le credenziali per accedere al dominio e le attività che si uniscono a domini diversi possono essere eseguite sulla stessa istanza.

  Quindi, scegli l'archiviazione di dati per CredSpec e, facoltativamente, per le credenziali utente di Active Directory per gMSA senza dominio.

  Amazon ECS utilizza un file di specifica delle credenziali di Active Directory (CredSpec). Questo file contiene i metadati gMSA utilizzati per propagare il contesto dell'account gMSA al container. Il file CredSpec viene generato e quindi archiviato in una delle opzioni di archiviazione di CredSpec nella tabella seguente, specifica del sistema operativo delle istanze di container. Per utilizzare il metodo senza dominio, una sezione facoltativa del file CredSpec può specificare le credenziali in una delle opzioni di archiviazione *domainless user credentials* riportate nella tabella seguente, in base al sistema operativo delle istanze di container.    
<a name="gmsa-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonECS/latest/developerguide/windows-gmsa.html)

## Prerequisiti
<a name="windows-gmsa-prerequisites"></a>

Prima di utilizzare la funzionalità gMSA per container Windows con Amazon ECS, assicurati di completare le seguenti operazioni:
+ Configura un dominio Active Directory con le risorse a cui desideri che i tuoi container accedano. Amazon ECS supporta le configurazioni seguenti:
  + Un Directory Service Active Directory. Directory Service è un Active Directory AWS gestito ospitato su Amazon EC2. Per ulteriori informazioni, vedere Guida [introduttiva a AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) nella *Guida all'AWS Directory Service amministrazione*.
  + Una Active Directory on-premises. Devi assicurarti che l'istanza di container Linux di Amazon ECS possa essere aggiunta al dominio. Per ulteriori informazioni, consulta [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect-network-to-amazon.html).
+ Disponi di un account gMSA nell'Active Directory. Per ulteriori informazioni, consulta [Create g MSAs for Windows containers](https://docs.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts).
+ **Hai scelto di utilizzare *gMSA senza dominio* o l'istanza di container Amazon ECS Windows che ospita il processo Amazon ECS deve essere un *dominio aggiunto* ad Active Directory ed essere membro del gruppo di sicurezza di Active Directory che ha accesso all'account gMSA.**

  Utilizzando gMSA senza dominio, l'istanza di container non viene aggiunta al dominio, le altre applicazioni sull'istanza non possono utilizzare le credenziali per accedere al dominio e le attività che si uniscono a domini diversi possono essere eseguite sulla stessa istanza.
+ Hai aggiunto le autorizzazioni IAM richieste. Le autorizzazioni richieste dipendono dai metodi scelti per le credenziali iniziali e per l'archiviazione della specifica delle credenziali:
  + Se utilizzi *domainless gMSA* per le credenziali iniziali, Gestione dei segreti AWS sono necessarie le autorizzazioni IAM per il ruolo dell'istanza Amazon EC2.
  + Se archivi la specifica delle credenziali nell'archivio dei parametri SSM, le autorizzazioni IAM per l'archivio dei parametri Systems Manager per Amazon EC2 sono necessarie per il ruolo di esecuzione dell'attività.
  + Se archivi la specifica delle credenziali in Amazon S3, le autorizzazioni IAM per Amazon Simple Storage Service sono necessarie per il ruolo di esecuzione delle attività.

## Configurazione di gMSA per container Windows su Amazon ECS
<a name="windows-gmsa-setup"></a>

Per configurare gMSA per container Windows su Amazon ECS, puoi seguire il tutorial completo che include la configurazione dei prerequisiti [Utilizzo di contenitori Amazon ECS Windows senza dominio gMSA utilizzando AWS CLI](tutorial-gmsa-windows.md).

Le seguenti sezioni illustrano la configurazione di CredSpec in dettaglio.

**Topics**
+ [

### Esempio CredSpec
](#windows-gmsa-example)
+ [

### Configurazione di gMSA senza dominio
](#windows-gmsa-domainless)
+ [

### Riferimento a un file di specifiche delle credenziali in una definizione di attività
](#windows-gmsa-credentialspec)

### Esempio CredSpec
<a name="windows-gmsa-example"></a>

Amazon ECS utilizza un file di specifiche delle credenziali che contiene i metadati gMSA utilizzati per propagare il contesto dell'account gMSA al container Windows. Puoi generare il file di specifiche delle credenziali e farvi riferimento nel campo `credentialSpec` della definizione di attività. Il file delle specifiche delle credenziali non contiene segreti.

Di seguito è riportato un file di specifiche delle credenziali di esempio:

```
{
    "CmsPlugins": [
        "ActiveDirectory"
    ],
    "DomainJoinConfig": {
        "Sid": "S-1-5-21-2554468230-2647958158-2204241789",
        "MachineAccountName": "WebApp01",
        "Guid": "8665abd4-e947-4dd0-9a51-f8254943c90b",
        "DnsTreeName": "contoso.com",
        "DnsName": "contoso.com",
        "NetBiosName": "contoso"
    },
    "ActiveDirectoryConfig": {
        "GroupManagedServiceAccounts": [
            {
                "Name": "WebApp01",
                "Scope": "contoso.com"
            }
        ]
    }
}
```

### Configurazione di gMSA senza dominio
<a name="windows-gmsa-domainless"></a>

Consigliamo gMSA senza dominio anziché aggiungere le istanze di container a un singolo dominio. Utilizzando gMSA senza dominio, l'istanza di container non viene aggiunta al dominio, le altre applicazioni sull'istanza non possono utilizzare le credenziali per accedere al dominio e le attività che si uniscono a domini diversi possono essere eseguite sulla stessa istanza.

1. Prima di caricare CredSpec su una delle opzioni di archiviazione, aggiungi le informazioni a CredSpec con l'ARN del segreto in Secrets Manager o SSM Parameter Store. Per [ulteriori informazioni, vedi lo use case Additional Credential Spec Configuration for non-domain-joined Container Host nel](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#additional-credential-spec-configuration-for-non-domain-joined-container-host-use-case) sito Web Microsoft Learn.

**Formato di credenziali gMSA senza dominio**  
Di seguito è riportato il formato JSON per le credenziali gMSA senza dominio per Active Directory. Archivia le credenziali in Secrets Manager o SSM Parameter Store.

   ```
   {
       "username":"WebApp01",
       "password":"Test123!",
       "domainName":"contoso.com"
   }
   ```

1. Aggiungi le seguenti informazioni al file CredSpec all'interno di `ActiveDirectoryConfig`. Sostituisci l'ARN con il segreto in Secrets Manager o SSM Parameter Store.

   Tieni presente che il valore `PluginGUID` deve corrispondere al GUID nel seguente frammento di codice esemplificativo ed è obbligatorio.

   ```
       "HostAccountConfig": {
           "PortableCcgVersion": "1",
           "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
           "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
   ```

   Puoi anche usare un segreto nell'archivio parametri SSM con l'ARN in questo formato: `\"arn:aws:ssm:aws-region:111122223333:parameter/gmsa-plugin-input\"`.

1. Il file CredSpec modificato sarà simile all'esempio seguente:

   ```
   {
     "CmsPlugins": [
       "ActiveDirectory"
     ],
     "DomainJoinConfig": {
       "Sid": "S-1-5-21-4066351383-705263209-1606769140",
       "MachineAccountName": "WebApp01",
       "Guid": "ac822f13-583e-49f7-aa7b-284f9a8c97b6",
       "DnsTreeName": "contoso",
       "DnsName": "contoso",
       "NetBiosName": "contoso"
     },
     "ActiveDirectoryConfig": {
       "GroupManagedServiceAccounts": [
         {
           "Name": "WebApp01",
           "Scope": "contoso"
         },
         {
           "Name": "WebApp01",
           "Scope": "contoso"
         }
       ],
       "HostAccountConfig": {
         "PortableCcgVersion": "1",
         "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
         "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
     }
   }
   ```

### Riferimento a un file di specifiche delle credenziali in una definizione di attività
<a name="windows-gmsa-credentialspec"></a>

Amazon ECS supporta i seguenti modi per fare riferimento al percorso del file nel campo `credentialSpecs` di una definizione di attività. Per ognuna di queste opzioni, puoi fornire `credentialspec:` o `domainlesscredentialspec:`, a seconda che tu stia unendo rispettivamente le istanze di container a un singolo dominio o utilizzando gMSA senza dominio.

#### Bucket Amazon S3
<a name="gmsa-credspec-s3"></a>

Aggiungi le specifiche delle credenziali a un bucket Amazon S3 e quindi fai riferimento all'Amazon Resource Name (ARN) del bucket Amazon S3 nel campo `credentialSpecs` della definizione di attività.

```
{
    "family": "",
    "executionRoleArn": "",
    "containerDefinitions": [
        {
            "name": "",
            ...
            "credentialSpecs": [
                "credentialspecdomainless:arn:aws:s3:::${BucketName}/${ObjectName}"
            ],
            ...
        }
    ],
    ...
}
```

Devi inoltre aggiungere le seguenti autorizzazioni come policy in linea al ruolo IAM di esecuzione di processi Amazon ECS per consentire ai processi l'accesso al bucket Amazon S3.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "VisualEditor",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::{bucket_name}",
                "arn:aws:s3:::{bucket_name}/{object}"
            ]
        }
    ]
}
```

------

#### Parametro dell'archivio parametri di SSM
<a name="gmsa-credspec-ssm"></a>

Aggiungi le specifiche delle credenziali a un parametro dell'archivio parametri di SSM e quindi fai riferimento all'Amazon Resource Name (ARN) del parametro dell'archivio parametri di SSM nel campo `credentialSpecs` della definizione di attività.

```
{
    "family": "",
    "executionRoleArn": "",
    "containerDefinitions": [
        {
            "name": "",
            ...
            "credentialSpecs": [
                "credentialspecdomainless:arn:aws:ssm:region:111122223333:parameter/parameter_name"
            ],
            ...
        }
    ],
    ...
}
```

È inoltre necessario aggiungere le seguenti autorizzazioni come policy in linea al ruolo IAM di esecuzione del processo di Amazon ECS per consentire ai processi l'accesso al parametro dell'archivio parametri di SSM.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ssm:GetParameters"
            ],
            "Resource": "arn:aws:ssm:*:111122223333:parameter/example*"
        }
    ]
}
```

------

#### File locale
<a name="gmsa-credspec-file"></a>

Con i dettagli delle specifiche delle credenziali in un file locale, fai riferimento al percorso del file nel campo `credentialSpecs` della definizione di attività. Il percorso del file a cui si fa riferimento deve essere relativo alla directory `C:\ProgramData\Docker\CredentialSpecs` e utilizzare la barra rovesciata ("\$1") come separatore del percorso del file.

```
{
    "family": "",
    "executionRoleArn": "",
    "containerDefinitions": [
        {
            "name": "",
            ...
            "credentialSpecs": [
                "credentialspec:file://CredentialSpecDir\CredentialSpecFile.json"
            ],
            ...
        }
    ],
    ...
}
```

# Utilizzo di EC2 Image Builder per creare modelli personalizzati ottimizzati per Amazon ECS AMIs
<a name="image-builder-tutorial"></a>

AWS consiglia di utilizzare le AMI ottimizzate per Amazon ECS perché sono preconfigurate con i requisiti e i consigli per eseguire i carichi di lavoro dei container. In alcuni casi, potrebbe essere necessario personalizzare l'AMI per integrare software aggiuntivi. È possibile utilizzare EC2 Image Builder per la creazione, la gestione e l'implementazione delle immagini server. La proprietà delle immagini personalizzate create nell'account viene mantenuta. È possibile utilizzare le pipeline di EC2 Image Builder per automatizzare gli aggiornamenti e l'applicazione di patch di sistema per le immagini oppure utilizzare un comando autonomo per creare un'immagine con le risorse di configurazione definite.

Viene creata una ricetta per l'immagine. La ricetta include un'immagine principale ed eventuali componenti aggiuntivi. Inoltre, viene creata una pipeline che distribuisce l'AMI personalizzata.

Viene creata una ricetta per l'immagine. Una ricetta di immagine di Image Builder è un documento che definisce l'immagine di base e i componenti applicati all'immagine di base per produrre la configurazione desiderata per l'immagine AMI di output. Inoltre, viene creata una pipeline che distribuisce l'AMI personalizzata. Per ulteriori informazioni, consultare la pagina [How EC2 Image Builder works](https://docs.aws.amazon.com/imagebuilder/latest/userguide/how-image-builder-works.html) nella *Guida per l'utente di EC2 Image Builder*.

Consigliamo di utilizzare una delle seguenti AMI ottimizzate per Amazon ECS come “immagine principale” in EC2 Image Builder:
+ Linux
  + x86 ottimizzato per Amazon ECS AL2023 
  + AMI Amazon Linux 2023 (arm64) ottimizzata per Amazon ECS
  + AMI Amazon Linux 2 kernel 5 ottimizzata per Amazon ECS
  + AMI Amazon Linux 2 x86 ottimizzata per Amazon ECS
+ Windows
  + Windows 2022 Full x86 ottimizzata per Amazon ECS
  + Windows 2022 Core x86 ottimizzata per Amazon ECS
  + Windows 2019 Full x86 ottimizzata per Amazon ECS
  + Windows 2019 Core x86 ottimizzata per Amazon ECS
  + Windows 2016 Full x86 ottimizzata per Amazon ECS

Consigliamo anche di selezionare l'opzione “Usa la versione del sistema operativo più recente”. Per l'immagine parent, la pipeline utilizzerà il controllo delle versioni semantico, che aiuta a rilevare gli aggiornamenti delle dipendenze nei processi con pianificazione automatica. Per ulteriori informazioni, consultare [Semantic versioning](https://docs.aws.amazon.com/imagebuilder/latest/userguide/ibhow-semantic-versioning.html) nella *Guida per l'utente di EC2 Image Builder*.

AWS aggiorna regolarmente le immagini AMI ottimizzate per Amazon ECS con patch di sicurezza e la nuova versione di Container Agent. Quando si utilizza un ID AMI come immagine principale nella ricetta di immagine, è necessario controllare regolarmente gli aggiornamenti dell'immagine principale. Se sono disponibili aggiornamenti, è necessario creare una nuova versione della ricetta con l'AMI aggiornata. Ciò garantisce che le immagini personalizzate incorporino la versione più recente dell'immagine principale. Per informazioni su come creare un flusso di lavoro per aggiornare automaticamente le istanze EC2 nel cluster Amazon ECS con quelle appena create AMIs, vedi [Come creare una pipeline di rafforzamento dell'AMI e automatizzare gli aggiornamenti alla](https://aws.amazon.com/blogs/security/how-to-create-an-ami-hardening-pipeline-and-automate-updates-to-your-ecs-instance-fleet/) tua flotta di istanze ECS.

È anche possibile specificare il nome della risorsa Amazon (ARN) di un'immagine parent pubblicata tramite una pipeline EC2 Image Builder gestita. Amazon pubblica regolarmente immagini AMI ottimizzate per Amazon ECS tramite pipeline gestite. Queste immagini sono accessibili pubblicamente. Sono necessarie le autorizzazioni corrette per accedere all'immagine. Quando si utilizza l'ARN di un'immagine anziché un'AMI nella ricetta Image Builder, la pipeline utilizza automaticamente la versione più recente dell'immagine parent ogni volta che viene eseguita. Questo approccio elimina la necessità di creare manualmente nuove versioni della ricetta per ogni aggiornamento. 

## Pulizia delle AMI ottimizzate per Amazon ECS
<a name="cleanup-ecs-optimized-ami"></a>

Quando si utilizza un'AMI ottimizzata per Amazon ECS come immagine principale, è necessario ripulire l'immagine per evitare problemi transitori. L'AMI ottimizzata per Amazon ECS è preconfigurata per l'avvio automatico dell'agente Amazon ECS e la registrazione come istanza di container con Amazon ECS. Utilizzarla come immagine di base senza una pulizia adeguata può causare problemi nell'AMI personalizzata.

Per ripulire l'immagine per utilizzi futuri, creare un componente che esegua i seguenti comandi per arrestare il pacchetto ecs-init e i processi Docker:

```
sudo systemctl stop ecs
sudo systemctl stop docker
```

Rimuovere tutti i file di log dall'istanza attuale per evitare che vengano preservati con il salvataggio dell'immagine. Utilizzare lo script di esempio presente alla pagina [Security best practices for EC2 Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/security-best-practices.html) per eliminare i vari file dall'istanza.

Per eliminare i dati specifici di Amazon ECS, eseguire i seguenti comandi:

```
sudo rm -rf /var/log/ecs/*
sudo rm /var/lib/ecs/data/agent.db
```

Per ulteriori informazioni sulla creazione di un'AMI personalizzata ottimizzata per Amazon ECS AMIs, consulta [Come posso creare un'AMI personalizzata da un'AMI ottimizzata per Amazon ECS](https://forums.aws.amazon.com/knowledge-center/ecs-create-custom-amis/)? nel Knowledge Center. AWS 

## Utilizzo dell'ARN dell'immagine con infrastructure as code (IaC)
<a name="infrastructure-as-code-arn"></a>

Puoi configurare la ricetta utilizzando la console EC2 Image Builder o l'infrastruttura come codice ( CloudFormation ad esempio, AWS ) o l'SDK. Quando specifichi un'immagine principale nella tua ricetta, puoi specificare un ID AMI EC2, un ARN Marketplace AWS dell'immagine Image Builder, un ID prodotto o un'immagine del contenitore. AWS pubblica pubblicamente sia l'immagine AMI che IDs l'immagine Image Builder ARNs di Amazon AMIs ECS ottimizzata. Il formato ARN dell'immagine è il seguente:

```
arn:${Partition}:imagebuilder:${Region}:${Account}:image/${ImageName}/${ImageVersion}
```

Il formato di `ImageVersion` è il seguente. Sostituisci *minor* e *patch* con *major* i valori più recenti.

```
<major>.<minor>.<patch>
```

È possibile sostituire `major` `minor` e `patch` utilizzare valori specifici oppure utilizzare l'ARN senza versione di un'immagine, in modo che la pipeline rimanga up-to-date con la versione più recente dell'immagine principale. Un ARN senza versione utilizza il formato wildcard “x.x.x” per rappresentare la versione dell'immagine. Questo approccio consente al servizio Image Builder di risolversi automaticamente nella versione più recente dell'immagine. L'utilizzo di un ARN senza versione garantisce che il riferimento punti sempre all'immagine più recente disponibile, semplificando il processo di mantenimento delle immagini aggiornate nell'implementazione. Quando viene creata una ricetta con la console, EC2 Image Builder identifica automaticamente l'ARN dell'immagine parent. Quando si utilizza IaC per creare la ricetta, è necessario identificare l'ARN e selezionare la versione dell'immagine desiderata o utilizzare l'arn senza versione per indicare l'immagine più recente disponibile. Consigliamo di creare uno script automatico per filtrare e visualizzare solo le immagini in linea con i criteri desiderati. Il seguente script Python mostra come recuperare un elenco di applicazioni ottimizzate per Amazon ECS. AMIs 

Lo script accetta due argomenti facoltativi: `owner` e `platform`, i cui valori predefiniti sono rispettivamente “Amazon” e “Windows”. I valori validi per l'argomento owner sono `Self`, `Shared`, `Amazon` e `ThirdParty`. I valori validi per l'argomento platform sono `Windows` e `Linux`. Ad esempio, se lo script viene eseguito con l'argomento `owner` impostato su `Amazon` e `platform` impostata su `Linux`, genera un elenco di immagini pubblicate da Amazon, incluse immagini ottimizzate per Amazon ECS.

```
import boto3
import argparse

def list_images(owner, platform):
    # Create a Boto3 session
    session = boto3.Session()
    
    # Create an EC2 Image Builder client
    client = session.client('imagebuilder')

    # Define the initial request parameters
    request_params = {
        'owner': owner,
        'filters': [
            {
                'name': 'platform',
                'values': [platform]
            }
        ]
    }

    # Initialize the results list
    all_images = []

    # Get the initial response with the first page of results
    response = client.list_images(**request_params)

    # Extract images from the response
    all_images.extend(response['imageVersionList'])

    # While 'nextToken' is present, continue paginating
    while 'nextToken' in response and response['nextToken']:
        # Update the token for the next request
        request_params['nextToken'] = response['nextToken']

        # Get the next page of results
        response = client.list_images(**request_params)

        # Extract images from the response
        all_images.extend(response['imageVersionList'])

    return all_images

def main():
    # Initialize the parser
    parser = argparse.ArgumentParser(description="List AWS images based on owner and platform")
    
    # Add the parameters/arguments
    parser.add_argument("--owner", default="Amazon", help="The owner of the images. Default is 'Amazon'.")
    parser.add_argument("--platform", default="Windows", help="The platform type of the images. Default is 'Windows'.")

    # Parse the arguments
    args = parser.parse_args()

    # Retrieve all images based on the provided owner and platform
    images = list_images(args.owner, args.platform)

    # Print the details of the images
    for image in images:
        print(f"Name: {image['name']}, Version: {image['version']}, ARN: {image['arn']}")

if __name__ == "__main__":
    main()
```

## Utilizzo dell'immagine ARN con CloudFormation
<a name="arn-with-cloudformation"></a>

Una ricetta di immagine Image Builder è un blueprint che specifica l'immagine principale e i componenti necessari per ottenere la configurazione prevista dell'immagine di output. Viene utilizzata la risorsa `AWS::ImageBuilder::ImageRecipe`. Impostare il valore `ParentImage` sull'ARN dell'immagine. Utilizzare l'ARN senza versione dell'immagine desiderata per assicurare che la pipeline usi sempre la versione più recente dell'immagine. Ad esempio, `arn:aws:imagebuilder:us-east-1:aws:image/amazon-linux-2023-ecs-optimized-x86/x.x.x`. La seguente definizione della risorsa `AWS::ImageBuilder::ImageRecipe` utilizza l'ARN di un'immagine gestita da Amazon:

```
ECSRecipe:
    Type: AWS::ImageBuilder::ImageRecipe
    Properties:
      Name: MyRecipe
      Version: '1.0.0'
      Components:
        - ComponentArn: [<The component arns of the image recipe>]
      ParentImage: "arn:aws:imagebuilder:us-east-1:aws:image/amazon-linux-2023-ecs-optimized-x86/x.x.x"
```

Per ulteriori informazioni sulla risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagerecipe.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagerecipe.html), consultare la *Guida per l'utente di AWS CloudFormation *.

È possibile automatizzare la creazione di nuove immagini nella pipeline impostando la proprietà `Schedule` della risorsa `AWS::ImageBuilder::ImagePipeline`. La proprietà di pianificazione schedule include una condizione di avvio e un'espressione Cron. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagepipeline.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagepipeline.html) nella *Guida per l'utente di AWS CloudFormation *.

 L'esempio seguente di `AWS::ImageBuilder::ImagePipeline` fa in modo che la pipeline esegua una build ogni giorno alle 10:00 UTC (Coordinated Universal Time). Impostare i seguenti valori di `Schedule`:
+ Imposta `PipelineExecutionStartCondition` su `EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE`. La build viene avviata solo se vengono aggiornate risorse dipendenti come l'immagine principale o i componenti, che utilizzano il carattere jolly “x” nelle proprie versioni semantiche. In questo modo si garantisce che la build incorpori gli aggiornamenti più recenti di tali risorse.
+ Imposta ScheduleExpression sull'espressione cron. `(0 10 * * ? *)`

```
ECSPipeline:
    Type: AWS::ImageBuilder::ImagePipeline
    Properties:
      Name: my-pipeline
      ImageRecipeArn: <arn of the recipe you created in previous step>
      InfrastructureConfigurationArn: <ARN of the infrastructure configuration associated with this image pipeline>
      Schedule:
        PipelineExecutionStartCondition: EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE
        ScheduleExpression: 'cron(0 10 * * ? *)'
```

## Utilizzo dell'ARN dell'immagine con Terraform
<a name="arn-with-terraform"></a>

L'approccio per specificare l'immagine principale e la pianificazione della pipeline in Terraform è in linea con quello in AWS CloudFormation. Viene utilizzata la risorsa `aws_imagebuilder_image_recipe`. Impostare il valore `parent_image` sull'ARN dell'immagine. Utilizzare l'ARN senza versione dell'immagine desiderata per assicurare che la pipeline usi sempre la versione più recente dell'immagine. Per ulteriori informazioni, consultare [https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_recipe#argument-reference](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_recipe#argument-reference) nella documentazione di Terraform. 

Nel blocco di configurazione della programmazione di `aws_imagebuilder_image_pipeline resource`, impostare il valore dell'argomento `schedule_expression` su un'espressione Cron a scelta per specificare la frequenza di esecuzione della pipeline e impostare `pipeline_execution_start_condition` su `EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE`. Per ulteriori informazioni, consultare [https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_pipeline#argument-reference](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_pipeline#argument-reference) nella documentazione di Terraform. 

# Utilizzo di AWS Deep Learning Containers su Amazon ECS
<a name="deep-learning-containers"></a>

AWS I Deep Learning Containers forniscono un set di immagini Docker per addestrare e servire modelli in TensorFlow Apache MXNet (Incubating) su Amazon ECS. I Deep Learning Containers consentono ambienti ottimizzati con TensorFlow le librerie NVIDIA CUDA (per istanze GPU) e Intel MKL (per istanze CPU). Le immagini dei contenitori per Deep Learning Container sono disponibili in Amazon ECR per fare riferimento alle definizioni di processo di Amazon ECS. Puoi utilizzare i Deep Learning Containers insieme a Amazon Elastic Inference per ridurre i costi di inferenza.

Per iniziare a usare Deep Learning Containers senza Elastic Inference su Amazon ECS, consultare [Amazon ECS setup](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/deep-learning-containers-ecs-setup.html) nella *Guida per gli sviluppatori di AWS Deep Learning AMIs *.

# Tutorial: creazione di un servizio utilizzando una distribuzione Blue/Green
<a name="create-blue-green"></a>

Amazon ECS ha integrato le blue/green distribuzioni nella procedura guidata Create Service sulla console Amazon ECS. Per ulteriori informazioni, consulta [Creazione di un'implementazione di aggiornamenti continui di Amazon ECS](create-service-console-v2.md).

Il seguente tutorial mostra come creare un servizio Amazon ECS contenente un'attività Fargate che utilizza blue/green il tipo di distribuzione con. AWS CLI

**Nota**  
È stato aggiunto il supporto per l'esecuzione di una blue/green distribuzione per CloudFormation. *Per ulteriori informazioni, consulta [Eseguire le distribuzioni blu/green di Amazon ECS tramite l' CodeDeploy utilizzo CloudFormation nella Guida per](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html) l'utente.AWS CloudFormation *

## Prerequisiti
<a name="create-blue-green-prereqs"></a>

Questo tutorial presuppone che siano stati soddisfatti i prerequisiti seguenti:
+ La versione più recente di è installata e configurata. AWS CLI Per ulteriori informazioni sull'installazione o l'aggiornamento di AWS CLI, vedere [Installazione](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) di. AWS Command Line Interface
+ Hai completato le fasi descritte in [Configurazione per l'uso di Amazon ECS](get-set-up-for-amazon-ecs.md).
+ 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 e un gruppo di sicurezza creati per l'uso. Per ulteriori informazioni, consulta [Crea un cloud privato virtuale](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ Viene creato il ruolo CodeDeploy IAM di Amazon ECS. Per ulteriori informazioni, consulta [Ruolo CodeDeploy IAM di Amazon ECS](codedeploy_IAM_role.md).

## Fase 1: Creazione di un Application Load Balancer
<a name="create-blue-green-loadbalancer"></a>

I servizi Amazon ECS che utilizzano il tipo di blue/green implementazione richiedono l'uso di un Application Load Balancer o un Network Load Balancer. In questa esercitazione viene utilizzato un Application Load Balancer.

**Per creare un Application Load Balancer**

1. Utilizzate il [create-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-load-balancer.html)comando per creare un Application Load Balancer. Specificare due sottoreti che non appartengono alla stessa zona di disponibilità, nonché un gruppo di sicurezza.

   ```
   aws elbv2 create-load-balancer \
        --name bluegreen-alb \
        --subnets subnet-abcd1234 subnet-abcd5678 \
        --security-groups sg-abcd1234 \
        --region us-east-1
   ```

   L'output include l'Amazon Resource Name (ARN) del load balancer, con il formato seguente:

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642
   ```

1. Utilizzate il [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-target-group.html)comando per creare un gruppo target. Questo gruppo target instraderà il traffico verso il set di attività originale nel servizio.

   ```
   aws elbv2 create-target-group \
        --name bluegreentarget1 \
        --protocol HTTP \
        --port 80 \
        --target-type ip \
        --vpc-id vpc-abcd1234 \
        --region us-east-1
   ```

   L'output include l'ARN del gruppo target, con il seguente formato:

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4
   ```

1. Utilizzare il comando [create-listener](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-listener.html) per creare un listener del load balancer con una regola predefinita che inoltra le richieste al gruppo target.

   ```
   aws elbv2 create-listener \
        --load-balancer-arn arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642 \
        --protocol HTTP \
        --port 80 \
        --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4 \
        --region us-east-1
   ```

   L'output include l'ARN del listener, con il formato seguente:

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:listener/app/bluegreen-alb/e5ba62739c16e642/665750bec1b03bd4
   ```

## Fase 2: creazione di un cluster Amazon ECS
<a name="create-blue-green-cluster"></a>

Utilizzare il comando [create-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-cluster.html) per creare un cluster denominato `tutorial-bluegreen-cluster` da utilizzare.

```
aws ecs create-cluster \
     --cluster-name tutorial-bluegreen-cluster \
     --region us-east-1
```

L'output include l'ARN del cluster, con il formato seguente:

```
arn:aws:ecs:region:aws_account_id:cluster/tutorial-bluegreen-cluster
```

## Fase 3: Registra una definizione di attività
<a name="create-blue-green-taskdef"></a>

Utilizzate il [register-task-definition](https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html)comando per registrare una definizione di attività compatibile con Fargate. Devi usare la modalità di rete `awsvpc`. Di seguito è riportata la definizione di attività di esempio usata per questo tutorial.

Crea innanzitutto un file denominato `fargate-task.json` con i seguenti contenuti. Assicurati di utilizzare l'ARN del ruolo di esecuzione dell'attività. Per ulteriori informazioni, consulta [Ruolo IAM di esecuzione di attività Amazon ECS](task_execution_IAM_role.md).

```
{
    "family": "sample-fargate", 
    "networkMode": "awsvpc", 
    "containerDefinitions": [
        {
            "name": "sample-app", 
            "image": "public.ecr.aws/docker/library/httpd:latest", 
            "portMappings": [
                {
                    "containerPort": 80, 
                    "hostPort": 80, 
                    "protocol": "tcp"
                }
            ], 
            "essential": true, 
            "entryPoint": [
                "sh",
		"-c"
            ], 
            "command": [
                "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
            ]
        }
    ], 
    "requiresCompatibilities": [
        "FARGATE"
    ], 
    "cpu": "256", 
    "memory": "512"
}
```

Quindi, registra la definizione di attività utilizzando il file `fargate-task.json` creato.

```
aws ecs register-task-definition \
     --cli-input-json file://fargate-task.json \
     --region us-east-1
```

## Fase 4: creazione di un servizio Amazon ECS
<a name="create-blue-green-service"></a>

Utilizza il comando [create-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-service.html) per creare un servizio. 

Crea innanzitutto un file denominato `service-bluegreen.json` con i seguenti contenuti.

```
{
    "cluster": "tutorial-bluegreen-cluster",
    "serviceName": "service-bluegreen",
    "taskDefinition": "tutorial-task-def",
    "loadBalancers": [
        {
            "targetGroupArn": "arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4",
            "containerName": "sample-app",
            "containerPort": 80
        }
    ],
    "launchType": "FARGATE",
    "schedulingStrategy": "REPLICA",
    "deploymentController": {
        "type": "CODE_DEPLOY"
    },
    "platformVersion": "LATEST",
    "networkConfiguration": {
       "awsvpcConfiguration": {
          "assignPublicIp": "ENABLED",
          "securityGroups": [ "sg-abcd1234" ],
          "subnets": [ "subnet-abcd1234", "subnet-abcd5678" ]
       }
    },
    "desiredCount": 1
}
```

Quindi, crea il servizio utilizzando il file `service-bluegreen.json` creato.

```
aws ecs create-service \
     --cli-input-json file://service-bluegreen.json \
     --region us-east-1
```

L'output include l'ARN del servizio, con il formato seguente:

```
arn:aws:ecs:region:aws_account_id:service/service-bluegreen
```

## Fase 5: Creare le risorse AWS CodeDeploy
<a name="create-blue-green-codedeploy"></a>

Utilizza i seguenti passaggi per creare CodeDeploy l'applicazione, il gruppo target Application Load Balancer per il gruppo di CodeDeploy distribuzione e il gruppo di CodeDeploy distribuzione.

**Per creare risorse CodeDeploy**

1. Utilizzate il comando [create-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-application.html) per creare un' CodeDeploy applicazione. Specificare la piattaforma di calcolo `ECS`.

   ```
   aws deploy create-application \
        --application-name tutorial-bluegreen-app \
        --compute-platform ECS \
        --region us-east-1
   ```

   L'output include l'ID applicazione, con il formato seguente:

   ```
   {
       "applicationId": "b8e9c1ef-3048-424e-9174-885d7dc9dc11"
   }
   ```

1. Utilizzate il [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-target-group.html)comando per creare un secondo gruppo target di Application Load Balancer, che verrà utilizzato durante la creazione del gruppo di CodeDeploy distribuzione.

   ```
   aws elbv2 create-target-group \
        --name bluegreentarget2 \
        --protocol HTTP \
        --port 80 \
        --target-type ip \
        --vpc-id "vpc-0b6dd82c67d8012a1" \
        --region us-east-1
   ```

   L'output include l'ARN per il gruppo target, con il seguente formato:

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget2/708d384187a3cfdc
   ```

1. Utilizzate il [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)comando per creare un gruppo CodeDeploy di distribuzione.

   Crea innanzitutto un file denominato `tutorial-deployment-group.json` con i seguenti contenuti. Questo esempio utilizza la risorsa che è stata creata. Per la`serviceRoleArn`, specifica l'ARN del tuo ruolo Amazon ECS IAM. CodeDeploy Per ulteriori informazioni, consulta [Ruolo CodeDeploy IAM di Amazon ECS](codedeploy_IAM_role.md).

   ```
   {
      "applicationName": "tutorial-bluegreen-app",
      "autoRollbackConfiguration": {
         "enabled": true,
         "events": [ "DEPLOYMENT_FAILURE" ]
      },
      "blueGreenDeploymentConfiguration": {
         "deploymentReadyOption": {
            "actionOnTimeout": "CONTINUE_DEPLOYMENT",
            "waitTimeInMinutes": 0
         },
         "terminateBlueInstancesOnDeploymentSuccess": {
            "action": "TERMINATE",
            "terminationWaitTimeInMinutes": 5
         }
      },
      "deploymentGroupName": "tutorial-bluegreen-dg",
      "deploymentStyle": {
         "deploymentOption": "WITH_TRAFFIC_CONTROL",
         "deploymentType": "BLUE_GREEN"
      },
      "loadBalancerInfo": {
         "targetGroupPairInfoList": [
           {
             "targetGroups": [
                {
                    "name": "bluegreentarget1"
                },
                {
                    "name": "bluegreentarget2"
                }
             ],
             "prodTrafficRoute": {
                 "listenerArns": [
                     "arn:aws:elasticloadbalancing:region:aws_account_id:listener/app/bluegreen-alb/e5ba62739c16e642/665750bec1b03bd4"
                 ]
             }
           }
         ]
      },
      "serviceRoleArn": "arn:aws:iam::aws_account_id:role/ecsCodeDeployRole",
      "ecsServices": [
          {
              "serviceName": "service-bluegreen",
              "clusterName": "tutorial-bluegreen-cluster"
          }
      ]
   }
   ```

   Quindi crea il gruppo di CodeDeploy distribuzione.

   ```
   aws deploy create-deployment-group \
        --cli-input-json file://tutorial-deployment-group.json \
        --region us-east-1
   ```

   L'output include l'ID del gruppo di distribuzione, con il formato seguente:

   ```
   {
       "deploymentGroupId": "6fd9bdc6-dc51-4af5-ba5a-0a4a72431c88"
   }
   ```

## Fase 6: creazione e monitoraggio di una CodeDeploy distribuzione
<a name="create-blue-green-verify"></a>

Utilizza i seguenti passaggi per creare e caricare un file di specifiche dell'applicazione (AppSpec file) e una CodeDeploy distribuzione.

**Per creare e monitorare una CodeDeploy distribuzione**

1. Crea e carica un AppSpec file utilizzando i seguenti passaggi.

   1. Creare un file denominato `appspec.yaml` con il contenuto del gruppo di distribuzione CodeDeploy . Questo esempio utilizza le risorse create in precedenza nel tutorial.

      ```
      version: 0.0
      Resources:
        - TargetService:
            Type: AWS::ECS::Service
            Properties:
              TaskDefinition: "arn:aws:ecs:region:aws_account_id:task-definition/first-run-task-definition:7"
              LoadBalancerInfo:
                ContainerName: "sample-app"
                ContainerPort: 80
              PlatformVersion: "LATEST"
      ```

   1. Usa il comando [s3 mb](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html) per creare un bucket Amazon S3 per il file. AppSpec 

      ```
      aws s3 mb s3://tutorial-bluegreen-bucket
      ```

   1. Usa il comando [s3 cp](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html) per caricare il AppSpec file nel bucket Amazon S3.

      ```
      aws s3 cp ./appspec.yaml s3://tutorial-bluegreen-bucket/appspec.yaml
      ```

1. Crea la CodeDeploy distribuzione utilizzando i seguenti passaggi.

   1. Crea un file denominato `create-deployment.json` con il contenuto della CodeDeploy distribuzione. Questo esempio utilizza le risorse create in precedenza nel tutorial.

      ```
      {
          "applicationName": "tutorial-bluegreen-app",
          "deploymentGroupName": "tutorial-bluegreen-dg",
          "revision": {
              "revisionType": "S3",
              "s3Location": {
                  "bucket": "tutorial-bluegreen-bucket",
                  "key": "appspec.yaml",
                  "bundleType": "YAML"
              }
          }
      }
      ```

   1. Utilizzare il comando [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html) per creare l'implementazione.

      ```
      aws deploy create-deployment \
           --cli-input-json file://create-deployment.json \
           --region us-east-1
      ```

      L'output include l'ID di distribuzione, con il formato seguente:

      ```
      {
          "deploymentId": "d-RPCR1U3TW"
      }
      ```

   1. Utilizzate il [get-deployment-target](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-target.html)comando per ottenere i dettagli della distribuzione, specificando l'`deploymentId`output precedente.

      ```
      aws deploy get-deployment-target \
           --deployment-id "d-IMJU3A8TW" \
           --target-id tutorial-bluegreen-cluster:service-bluegreen \
           --region us-east-1
      ```

      Continuare a recuperare i dettagli di distribuzione fino a quando lo stato è `Succeeded`, come mostrato nel seguente output.

      ```
      {
          "deploymentTarget": {
              "deploymentTargetType": "ECSTarget",
              "ecsTarget": {
                  "deploymentId": "d-RPCR1U3TW",
                  "targetId": "tutorial-bluegreen-cluster:service-bluegreen",
                  "targetArn": "arn:aws:ecs:region:aws_account_id:service/service-bluegreen",
                  "lastUpdatedAt": 1543431490.226,
                  "lifecycleEvents": [
                      {
                          "lifecycleEventName": "BeforeInstall",
                          "startTime": 1543431361.022,
                          "endTime": 1543431361.433,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "Install",
                          "startTime": 1543431361.678,
                          "endTime": 1543431485.275,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AfterInstall",
                          "startTime": 1543431485.52,
                          "endTime": 1543431486.033,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "BeforeAllowTraffic",
                          "startTime": 1543431486.838,
                          "endTime": 1543431487.483,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AllowTraffic",
                          "startTime": 1543431487.748,
                          "endTime": 1543431488.488,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AfterAllowTraffic",
                          "startTime": 1543431489.152,
                          "endTime": 1543431489.885,
                          "status": "Succeeded"
                      }
                  ],
                  "status": "Succeeded",
                  "taskSetsInfo": [
                      {
                          "identifer": "ecs-svc/9223370493425779968",
                          "desiredCount": 1,
                          "pendingCount": 0,
                          "runningCount": 1,
                          "status": "ACTIVE",
                          "trafficWeight": 0.0,
                          "targetGroup": {
                              "name": "bluegreentarget1"
                          }
                      },
                      {
                          "identifer": "ecs-svc/9223370493423413672",
                          "desiredCount": 1,
                          "pendingCount": 0,
                          "runningCount": 1,
                          "status": "PRIMARY",
                          "trafficWeight": 100.0,
                          "targetGroup": {
                              "name": "bluegreentarget2"
                          }
                      }
                  ]
              }
          }
      }
      ```

## Fase 7: eliminare
<a name="create-blue-green-cleanup"></a>

Una volta terminato questo tutorial, rimuovi le risorse associate per evitare costi aggiuntivi per risorse che non utilizzi.

**Rimozione delle risorse del tutorial**

1. Usa il [delete-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-deployment-group.html)comando per eliminare il gruppo CodeDeploy di distribuzione.

   ```
   aws deploy delete-deployment-group \
        --application-name tutorial-bluegreen-app \
        --deployment-group-name tutorial-bluegreen-dg \
        --region us-east-1
   ```

1. Utilizzate il comando [delete-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html) per eliminare l' CodeDeploy applicazione.

   ```
   aws deploy delete-application \
        --application-name tutorial-bluegreen-app \
        --region us-east-1
   ```

1. Utilizza il comando [delete-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/delete-service.html) per eliminare il servizio Amazon ECS. L'uso del flag `--force` consente di eliminare un servizio anche se il numero di attività non è stato ridotto a zero.

   ```
   aws ecs delete-service \
        --service arn:aws:ecs:region:aws_account_id:service/service-bluegreen \
        --force \
        --region us-east-1
   ```

1. Utilizza il comando [delete-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/delete-cluster.html) per eliminare il cluster Amazon ECS.

   ```
   aws ecs delete-cluster \
        --cluster tutorial-bluegreen-cluster \
        --region us-east-1
   ```

1. Usa il comando [s3 rm](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html) per eliminare il AppSpec file dal bucket Amazon S3.

   ```
   aws s3 rm s3://tutorial-bluegreen-bucket/appspec.yaml
   ```

1. Utilizza il comando [s3 rb](https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html) per eliminare il bucket Amazon S3.

   ```
   aws s3 rb s3://tutorial-bluegreen-bucket
   ```

1. Utilizzate il [delete-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-load-balancer.html)comando per eliminare l'Application Load Balancer.

   ```
   aws elbv2 delete-load-balancer \
        --load-balancer-arn arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642 \
        --region us-east-1
   ```

1. Utilizzate il [delete-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-target-group.html)comando per eliminare i due gruppi target di Application Load Balancer.

   ```
   aws elbv2 delete-target-group \
        --target-group-arn arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4 \
        --region us-east-1
   ```

   ```
   aws elbv2 delete-target-group \
        --target-group-arn arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget2/708d384187a3cfdc \
        --region us-east-1
   ```