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à.

# Scopri come creare un'attività per Amazon ECS Managed Instances con AWS CLI
<a name="getting-started-managed-instances-cli"></a>

 La procedura seguente illustra come configurare un cluster, creare un provider di capacità, registrare una definizione delle attività, eseguire un'attività di Linux e come eseguire altri scenari comuni in Amazon ECS con l' 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 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). 

**Argomenti**
+ [Prerequisiti](#managed-instances-cli-prereq)
+ [Fase 1: creazione di un cluster](#managed-instances-cli-create-cluster)
+ [Fase 2: creazione di un provider di capacità di Amazon ECS Managed Instances](#managed-instances-cli-create-capacity-provider)
+ [Fase 3: configurazione di una strategia predefinita del provider di capacità per il cluster](#managed-instances-cli-configure-cluster)
+ [Fase 4: registrazione di una definizione delle attività di Linux](#managed-instances-cli-register-task-definition)
+ [Fase 5: elenco delle definizioni delle attività](#managed-instances-cli-list-task-definitions)
+ [Fase 6: creazione di un servizio](#managed-instances-cli-create-service)
+ [Fase 7: elenco dei servizi](#managed-instances-cli-list-services)
+ [Fase 8: descrizione del servizio in esecuzione](#managed-instances-cli-describe-service)
+ [Fase 9: test](#managed-instances-cli-test)
+ [Fase 10: Pulizia](#managed-instances-cli-clean-up)

## Prerequisiti
<a name="managed-instances-cli-prereq"></a>

 Prima di iniziare questo tutorial, completa le seguenti operazioni: 
+ Esegui i passaggi in [Configurazione dell'utilizzo di Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/get-set-up-for-amazon-ecs.html).
+ La versione più recente di è installata e configurata. AWS CLI *Per ulteriori informazioni sull'installazione o l'aggiornamento di AWS CLI, consulta [Installazione o aggiornamento all'ultima versione della AWS CLI nella Guida per l'](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)utente.AWS Command Line Interface *
+ Hai completato le fasi descritte in [Configurazione per l'uso di Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Disponi dei ruoli IAM richiesti per Istanze gestite da Amazon ECS. Questo include:
  + Ruolo dell'infrastruttura: consente ad Amazon ECS di effettuare chiamate ai AWS servizi per tuo conto per gestire l'infrastruttura Amazon ECS Managed Instances.

    Per ulteriori informazioni, consulta [Ruolo IAM dell’infrastruttura Amazon ECS](infrastructure_IAM_role.md).
  + Profilo dell'istanza: fornisce le autorizzazioni per l'agente del container di Amazon ECS e il daemon Docker in esecuzione su istanze gestite.

    Il nome del ruolo dell'istanza deve essere incluso `ecsInstanceRole` come prefisso in modo che corrisponda all'`iam:PassRole`azione nel ruolo dell'infrastruttura.

    Per ulteriori informazioni, consulta [Profilo delle istanze gestite da Amazon ECS](managed-instances-instance-profile.md).
+ Sono disponibili un VPC e un gruppo di sicurezza creati per l'uso. Questo tutorial utilizza un'immagine del container ospitata su Amazon ECR Public, quindi le istanze devono avere accesso a internet. Per assegnare alle tue istanze 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 alle istanze.

  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: creazione di un cluster
<a name="managed-instances-cli-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 managed-instances-cluster
```

Output:

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

## Fase 2: creazione di un provider di capacità di Amazon ECS Managed Instances
<a name="managed-instances-cli-create-capacity-provider"></a>

 Prima di poter eseguire attività utilizzando Amazon ECS Managed Instances, devi creare un provider di capacità che definisca la configurazione dell'infrastruttura. Il provider di capacità specifica i ruoli IAM, la configurazione di rete e altre impostazioni per le istanze gestite. 

 Crea un file JSON con la configurazione del provider di capacità. Sostituisci i valori segnaposto con gli identificatori delle risorse effettivi: 

```
{
    "name": "managed-instances-cp",
    "cluster": "managed-instances-cluster",
    "managedInstancesProvider": {
        "infrastructureRoleArn": "arn:aws:iam::aws_account_id:role/ecsInfrastructureRole",
        "instanceLaunchTemplate": {
            "ec2InstanceProfileArn": "arn:aws:iam::aws_account_id:instance-profile/ecsInstanceRole",
            "networkConfiguration": {
                "subnets": [
                    "subnet-abcdef01234567890",
                    "subnet-1234567890abcdef0"
                ],
                "securityGroups": [
                    "sg-0123456789abcdef0"
                ]
            },
            "storageConfiguration": {
                "storageSizeGiB": 100
            },
            "monitoring": "basic"
        }
    }
}
```

 Salva questa configurazione come `managed-instances-cp.json` e crea il provider di capacità: 

```
aws ecs create-capacity-provider --cli-input-json file://managed-instances-cp.json
```

 Il comando restituisce una descrizione del provider di capacità dopo che ne ha completato la creazione. 

## Fase 3: configurazione di una strategia predefinita del provider di capacità per il cluster
<a name="managed-instances-cli-configure-cluster"></a>

 Aggiorna il cluster per utilizzare il provider di capacità Amazon ECS Managed Instances come strategia predefinita per il provider di capacità. Ciò consente alle attività e ai servizi di utilizzare automaticamente Amazon ECS Managed Instances senza specificare esplicitamente il provider di capacità. 

 Crea un file JSON con la configurazione del provider di capacità del cluster: 

```
{
    "cluster": "managed-instances-cluster",
    "capacityProviders": [
        "managed-instances-cp"
    ],
    "defaultCapacityProviderStrategy": [
        {
            "capacityProvider": "managed-instances-cp",
            "weight": 1
        }
    ]
}
```

 Salva questa configurazione come `cluster-cp-strategy.json` e aggiorna il cluster: 

```
aws ecs put-cluster-capacity-providers --cli-input-json file://cluster-cp-strategy.json
```

## Fase 4: registrazione di una definizione delle attività di Linux
<a name="managed-instances-cli-register-task-definition"></a>

 Prima di eseguire un'attività nel cluster, 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 [Parametri di definizione di attività Amazon ECS per Fargate](task_definition_parameters.md). 

```
{
    "family": "sample-managed-instances",
    "networkMode": "awsvpc",
    "containerDefinitions": [
        {
            "name": "managed-instances-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 using Amazon ECS Managed Instances.</p></div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
            ]
        }
    ],
    "requiresCompatibilities": [
        "MANAGED_INSTANCES"
    ],
    "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/managed-instances-task.json
```

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

## Fase 5: elenco delle definizioni delle attività
<a name="managed-instances-cli-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-managed-instances:1"
    ]
}
```

## Fase 6: creazione di un servizio
<a name="managed-instances-cli-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-managed-instances: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 managed-instances-cluster --service-name managed-instances-service --task-definition sample-managed-instances:1 --desired-count 1 --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234]}"
```

 Esempio di utilizzo di una sottorete pubblica: 

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

 Il comando **create-service** restituisce una descrizione del servizio dopo il completamento della creazione. 

## Fase 7: elenco dei servizi
<a name="managed-instances-cli-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 managed-instances-cluster
```

Output:

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

## Fase 8: descrizione del servizio in esecuzione
<a name="managed-instances-cli-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 managed-instances-cluster --services managed-instances-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. 

 L'output mostrerà che il servizio utilizza il provider di capacità Amazon ECS Managed Instances: 

```
{
    "services": [
        {
            "capacityProviderStrategy": [
                {
                    "capacityProvider": "managed-instances-cp",
                    "weight": 1,
                    "base": 0
                }
            ],
            "networkConfiguration": {
                "awsvpcConfiguration": {
                    "subnets": [
                        "subnet-abcd1234"
                    ], 
                    "securityGroups": [
                        "sg-abcd1234"
                    ], 
                    "assignPublicIp": "ENABLED"
                }
            }, 
            "enableECSManagedTags": false, 
            "loadBalancers": [], 
            "deploymentController": {
                "type": "ECS"
            }, 
            "desiredCount": 1, 
            "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/managed-instances-cluster", 
            "serviceArn": "arn:aws:ecs:region:aws_account_id:service/managed-instances-service", 
            "serviceName": "managed-instances-service",
            "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-managed-instances:1"
        }
    ], 
    "failures": []
}
```

## Fase 9: test
<a name="managed-instances-cli-test"></a>

 Per testare l'implementazione, devi trovare l'indirizzo IP pubblico dell'istanza gestita che esegue l'attività. 

### Test di un'attività implementata utilizzando una sottorete pubblica
<a name="managed-instances-cli-test-public-subnet"></a>

 Per prima cosa, ottieni l'ARN dell'attività dal tuo servizio: 

```
aws ecs list-tasks --cluster managed-instances-cluster --service managed-instances-service
```

 L'output contiene l'ARN dell'attività: 

```
{
    "taskArns": [
        "arn:aws:ecs:region:aws_account_id:task/managed-instances-cluster/EXAMPLE"
    ]
}
```

 Descrivi l'attività per ottenere l'ARN dell'istanza di container. Utilizza l'ARN dell'attività per il parametro `tasks`: 

```
aws ecs describe-tasks --cluster managed-instances-cluster --tasks arn:aws:ecs:region:aws_account_id:task/managed-instances-cluster/EXAMPLE
```

 L'output mostra che l'attività è in esecuzione su Amazon ECS Managed Instances e include l'ARN dell'istanza di container: 

```
{
    "tasks": [
        {
            "launchType": "MANAGED_INSTANCES",
            "capacityProviderName": "managed-instances-cp",
            "containerInstanceArn": "arn:aws:ecs:region:aws_account_id:container-instance/managed-instances-cluster/CONTAINER_INSTANCE_ID",
            "taskArn": "arn:aws:ecs:region:aws_account_id:task/managed-instances-cluster/EXAMPLE",
            "taskDefinitionArn": "arn:aws:ecs:region:aws_account_id:task-definition/sample-managed-instances:1"
        }
    ]
}
```

 Descrivi l'istanza di container per ottenere l'ID dell'istanza EC2: 

```
aws ecs describe-container-instances --cluster managed-instances-cluster --container-instances CONTAINER_INSTANCE_ID
```

 L'output include l'ID dell'istanza EC2: 

```
{
    "containerInstances": [
        {
            "ec2InstanceId": "i-1234567890abcdef0",
            "capacityProviderName": "managed-instances-cp",
            "containerInstanceArn": "arn:aws:ecs:region:aws_account_id:container-instance/managed-instances-cluster/CONTAINER_INSTANCE_ID"
        }
    ]
}
```

 Descrivi l'l'istanza EC2 per ottenere l'indirizzo IP pubblico: 

```
aws ec2 describe-instances --instance-ids i-1234567890abcdef0
```

 L'indirizzo IP pubblico è indicato nell'output: 

```
{
    "Reservations": [
        {
            "Instances": [
                {
                    "PublicIpAddress": "198.51.100.2",
                    "InstanceId": "i-1234567890abcdef0"
                }
            ]
        }
    ]
}
```

 Inserisci l'indirizzo IP pubblico nel browser web; dovresti visualizzare una pagina web che mostra l'applicazione **Amazon ECS** di esempio in esecuzione su Amazon ECS Managed Instances. 

### Test di un'attività implementata utilizzando una sottorete privata
<a name="managed-instances-cli-test-private-subnet"></a>

 Per le attività implementate in sottoreti private, puoi utilizzare Amazon ECS Exec per connetterti al container e testare l'implementazione dall'interno dell'istanza. Segui gli stessi passaggi indicati in precedenza per ottenere l'ARN dell'attività, quindi utilizza ECS Exec: 

```
aws ecs execute-command --cluster managed-instances-cluster \
    --task arn:aws:ecs:region:aws_account_id:task/managed-instances-cluster/EXAMPLE \
    --container managed-instances-app \
    --interactive \
    --command "/bin/sh"
```

 Dopo l'esecuzione della shell, puoi testare il server web: 

```
curl localhost
```

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

## Fase 10: Pulizia
<a name="managed-instances-cli-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 managed-instances-cluster --service managed-instances-service --force
```

 Attendi l'eliminazione del servizio e l'arresto di tutte le attività, quindi elimina il provider di capacità: 

```
aws ecs delete-capacity-provider --capacity-provider managed-instances-cp
```

 Elimina il cluster : 

```
aws ecs delete-cluster --cluster managed-instances-cluster
```

**Nota**  
 Le istanze gestite vengono terminate automaticamente quando il provider di capacità viene eliminato. Non è necessario terminare manualmente le istanze EC2.