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à.
# Utilizzo dei volumi Docker con Amazon ECS
Quando utilizzi i volumi Docker, puoi usare il driver `local` integrato o un driver di volumi di terze parti. I volumi Docker sono gestiti da Docker e viene creata una directory in `/var/lib/docker/volumes` sull'istanza di container che contiene i dati del volume.
Per usare i volumi Docker, specifica `dockerVolumeConfiguration` nella definizione di attività. Per ulteriori informazioni, consultare [Volumes](https://docs.docker.com/engine/storage/volumes/) nella documentazione di Docker.
Alcuni casi d’uso comune per i volumi Docker sono i seguenti:
+ Offrire volumi di dati persistenti per l’utilizzo con i container
+ Condividere un volume di dati definito in diverse posizioni su differenti container nella stessa istanza di container
+ Definire un volume di dati vuoto, non persistente e montarlo su più container all’interno della stessa attività
+ Per fornire un volume di dati per l’attività gestita da un driver di terze parti
## Considerazioni sull'utilizzo dei volumi Docker
Quando usi volumi Docker, tieni presenti le considerazioni seguenti:
+ I volumi Docker sono supportati solo se si utilizza il tipo di avvio EC2 o istanze esterne.
+ I container Windows supportano solo l'uso del driver `local`.
+ Se viene utilizzato un driver di terze parti, assicurati che sia installato e attivo sull'istanza di container prima dell'avvio dell'agente del container. Se il driver di terze parti non è attivo prima dell'avvio dell'agente, puoi riavviare l'agente del container utilizzando uno dei seguenti comandi:
+ Per l'AMI Amazon Linux 2 ottimizzata per Amazon ECS:
```
sudo systemctl restart ecs
```
+ Per l'AMI Amazon Linux ottimizzata per Amazon ECS:
```
sudo stop ecs && sudo start ecs
```
Per informazioni su come specificare un volume Docker in una definizione dell'attività, consultare [Specifica un volume Docker in una definizione dell'attività Amazon ECS](specify-volume-config.md).
# Specifica un volume Docker in una definizione dell'attività Amazon ECS
Prima che i container possano utilizzare i volumi di dati, è necessario specificare le configurazioni del punto di montaggio e del volume nella definizione di attività. Questa sezione descrive la configurazione del volume per un container. Per le attività che usano un volume Docker, specifica `dockerVolumeConfiguration`. Per le attività che usano un volume host di montaggio vincolato, specifica `host` e facoltativamente `sourcePath`.
Il seguente JSON della definizione di attività illustra la sintassi degli oggetti `volumes` e `mountPoints` per un container.
```
{
"containerDefinitions": [
{
"mountPoints": [
{
"sourceVolume": "string",
"containerPath": "/path/to/mount_volume",
"readOnly": boolean
}
]
}
],
"volumes": [
{
"name": "string",
"dockerVolumeConfiguration": {
"scope": "string",
"autoprovision": boolean,
"driver": "string",
"driverOpts": {
"key": "value"
},
"labels": {
"key": "value"
}
}
}
]
}
```
`name`
▬Tipo: stringa
Obbligatorio: no
Nome del volume. Il nome può contenere un massimo di 255 lettere (maiuscole e minuscole), numeri, trattini (`-`) e trattini bassi (`_`). Nel parametro `sourceVolume` dell'oggetto `mountPoints` della definizione del container viene fatto riferimento a questo nome.
`dockerVolumeConfiguration`
Tipo: oggetto [DockerVolumeConfiguration](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DockerVolumeConfiguration.html)
Obbligatorio: no
Questo parametro viene specificato quando si utilizzano volumi docker. I volumi Docker sono supportati solo se i processi vengono eseguiti su istanze EC2. I container Windows supportano solo l’uso del driver `local`. Per utilizzare i montaggi vincolati, specifica invece un `host`.
`scope`
Tipo: String
Valori validi: `task` \$1 `shared`
Obbligatorio: no
L'ambito del volume Docker che determina il suo ciclo di vita. I volumi Docker che rientrano nell'ambito `task` vengono automaticamente assegnati all'avvio del processo e distrutti quando il processo viene arrestato. I volumi Docker che vengono definiti come `shared` vengono mantenuti dopo l'arresto del processo.
`autoprovision`
Tipo: Booleano
Valore predefinito: `false`
Obbligatorio: no
Se questo valore è `true`, viene creato il volume Docker, se non è già presente. Questo campo è utilizzato solo se `scope` è `shared`. Se `scope` è `task`, questo parametro deve essere omesso.
`driver`
▬Tipo: stringa
Obbligatorio: no
Il driver del volume Docker da utilizzare. Il valore del driver deve corrispondere al nome del driver fornito da Docker perché questo nome è utilizzato per il posizionamento dell'attività. Se il driver è stato installato utilizzando la CLI del plugin Docker, utilizzare `docker plugin ls` per richiamare il nome del driver dall'istanza di container. Se il driver è stato installato utilizzando un altro metodo, utilizzare il rilevamento del plugin Docker per richiamare il nome del driver.
`driverOpts`
▬Tipo: stringa
Obbligatorio: no
Una mappa delle opzioni specifiche del driver Docker da inviare. Questo parametro fa riferimento a `DriverOpts` nella sezione Crea un volume di Docker.
`labels`
▬Tipo: stringa
Obbligatorio: no
Metadati personalizzati da aggiungere al volume Docker.
`mountPoints`
Tipo: array di oggetti
Obbligatorio: no
I punti di montaggio per i volumi di dati nel container. Questo parametro è mappato ai `Volumes` nella creazione container dell'API Docker e l'opzione `--volume` per docker run.
I container Windows possono montare intere directory sulla stessa unità di `$env:ProgramData`. I container Windows non possono montare le directory su un'unità diversa e i punti di montaggio non possono essere utilizzati tra le unità. È necessario specificare i punti di montaggio per collegare un volume Amazon EBS direttamente a un'attività Amazon ECS.
`sourceVolume`
Tipo: String
Obbligatorio: sì, quando si utilizzano `mountPoints`
Il nome del volume da montare.
`containerPath`
Tipo: String
Obbligatorio: sì, quando si utilizzano `mountPoints`
Il percorso nel container in cui verrà montato il volume.
`readOnly`
Tipo: Booleano
Obbligatorio: no
Se il valore è `true`, il container avrà accesso in sola lettura al volume. Se il valore è `false`, il container avrà accesso in scrittura al volume. Il valore predefinito è `false`.
Per le attività su istanze EC2 che eseguono il sistema operativo Windows, lasciare il valore predefinito di `false`.
# Esempi di volumi Docker per Amazon ECS
Gli esempi seguenti mostrano come fornire uno storage temporaneo per un contenitore e come fornire un volume condiviso per più contenitori e come fornire uno storage persistente NFS per un contenitore.
**Fornire un archivio temporaneo per un container utilizzando un volume Docker**
In questo esempio, un container utilizza un volume di dati vuoto che viene smaltito al termine dell'attività. Ad esempio, potresti avere un container che deve accedere alla posizione di storage di alcuni file temporanei durante un'attività. Questa attività può essere eseguita utilizzando un volume Docker.
1. Nella sezione `volumes` della definizione di attività, definisci un volume di dati con i valori `name` e `DockerVolumeConfiguration`. In questo esempio, specifichiamo l'ambito come `task` in modo che il volume venga eliminato dopo l'arresto dell'attività e venga utilizzato il driver `local` incorporato.
```
"volumes": [
{
"name": "scratch",
"dockerVolumeConfiguration" : {
"scope": "task",
"driver": "local",
"labels": {
"scratch": "space"
}
}
}
]
```
1. Nella sezione `containerDefinitions`, definisci un container con valori `mountPoints` che faccia riferimento al nome del volume definito e al valore `containerPath` per montare il volume sul container.
```
"containerDefinitions": [
{
"name": "container-1",
"mountPoints": [
{
"sourceVolume": "scratch",
"containerPath": "/var/scratch"
}
]
}
]
```
**Fornire un archivio persistente per più container utilizzando un volume Docker**
In questo esempio, desideri un volume condiviso per più container da utilizzare e che persista dopo l'interruzione di qualsiasi singola attività che lo utilizza. Il driver `local` integrato è in uso. Per questo motivo, il volume è ancora legato al ciclo di vita dell'istanza di container.
1. Nella sezione `volumes` della definizione di attività, definisci un volume di dati con i valori `name` e `DockerVolumeConfiguration`. In questo esempio, specificare un ambito `shared` in modo che il volume persista, imposta il provisioning automatico su `true`. In questo modo il volume viene creato per l'uso. Quindi, utilizza anche il driver `local` integrato.
```
"volumes": [
{
"name": "database",
"dockerVolumeConfiguration" : {
"scope": "shared",
"autoprovision": true,
"driver": "local",
"labels": {
"database": "database_name"
}
}
}
]
```
1. Nella sezione `containerDefinitions`, definisci un container con valori `mountPoints` che faccia riferimento al nome del volume definito e al valore `containerPath` per montare il volume sul container.
```
"containerDefinitions": [
{
"name": "container-1",
"mountPoints": [
{
"sourceVolume": "database",
"containerPath": "/var/database"
}
]
},
{
"name": "container-2",
"mountPoints": [
{
"sourceVolume": "database",
"containerPath": "/var/database"
}
]
}
]
```
**Fornire lo spazio di archiviazione persistente per un container utilizzando un volume Docker**
In questo esempio, un container utilizza un volume di dati NFS che viene montato automaticamente all'avvio dell'attività e viene smontato al termine. Questo utilizza il driver `local` integrato in Docker. Un esempio di caso d'uso potrebbe essere quello in cui hai un'archiviazione NFS locale e hai la necessità di accedervi attraverso un'attività ECS Anywhere. Ciò può essere ottenuto utilizzando un volume Docker con opzione driver NFS.
1. Nella sezione `volumes` della definizione di attività, definisci un volume di dati con i valori `name` e `DockerVolumeConfiguration`. In questo esempio, specifica un ambito `task` in modo che il volume venga smontato al termine dell'attività. Usa il driver `local` e configura le `driverOpts` con le opzioni `type`, `device` e `o` di conseguenza. Sostituisci `NFS_SERVER` con l'endpoint del server NFS.
```
"volumes": [
{
"name": "NFS",
"dockerVolumeConfiguration" : {
"scope": "task",
"driver": "local",
"driverOpts": {
"type": "nfs",
"device": "$NFS_SERVER:/mnt/nfs",
"o": "addr=$NFS_SERVER"
}
}
}
]
```
1. Nella sezione `containerDefinitions`, definisci un container con valori di `mountPoints` che facciano riferimento al nome del volume definito e al valore di `containerPath` per montare il volume sul container.
```
"containerDefinitions": [
{
"name": "container-1",
"mountPoints": [
{
"sourceVolume": "NFS",
"containerPath": "/var/nfsmount"
}
]
}
]
```