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 di montaggio vincolato con Amazon ECS Con i montaggi vincolati, un file o una directory su un host, ad esempio un'istanza Amazon EC2, sono montati in un container. I montaggi vincolati sono supportati per le attività ospitate su istanze Fargate o Amazon EC2. I montaggi vincolati sono legati al ciclo di vita del container che li utilizza. Una volta arrestati tutti i container che utilizzano un montaggio vincolato, ad esempio quando viene arrestata un'attività, i dati vengono rimossi. Per le attività ospitate su istanze Amazon EC2, i dati possono essere legati al ciclo di vita dell'istanza Amazon EC2 host specificando un `host` e un valore `sourcePath` facoltativo nella definizione di attività. Per ulteriori informazioni, consultare [Bind mounts](https://docs.docker.com/engine/storage/bind-mounts/) nella documentazione Docker. I seguenti sono casi d'uso comune dei montaggi vincolati. + Per fornire un volume di dati vuoto da montare in uno o più container. + Per fornire un volume di dati host in uno o più container. + Per condividere un volume di dati da un container di origine con altri container nello stesso processo. + Per esporre un percorso e il relativo contenuto da un Dockerfile a uno o più container. ## Considerazioni su quando utilizzare i montaggi vincolati Quando usi i montaggi vincolati, tieni presente le seguenti considerazioni. + Per impostazione predefinita, le attività ospitate AWS Fargate utilizzando una versione della piattaforma `1.4.0` o successiva (Linux) `1.0.0` o successiva (Windows) ricevono un minimo di 20 GiB di storage temporaneo per i bind mount. Puoi aumentare la quantità totale di archiviazione temporanea fino a un massimo di 200 GiB, specificando il parametro `ephemeralStorage` nella definizione di attività. + Per esporre i file da un Dockerfile a un volume di dati quando viene eseguito un processo, il piano dati di Amazon ECS cerca una direttiva `VOLUME`. Se il percorso assoluto specificato nella direttiva `VOLUME` è lo stesso presente nel `containerPath` specificato nella definizione di attività, i dati nel percorso della direttiva `VOLUME` vengono copiati sul volume di dati. Nell'esempio Dockerfile seguente, un file denominato `examplefile` nella directory `/var/log/exported` viene scritto sull'host e quindi montato all'interno del container. ``` FROM public.ecr.aws/amazonlinux/amazonlinux:latest RUN mkdir -p /var/log/exported RUN touch /var/log/exported/examplefile VOLUME ["/var/log/exported"] ``` Di default, le autorizzazioni dei volumi sono impostate su `0755` e il proprietario è `root`. Queste autorizzazioni possono essere personalizzate nel Dockerfile. L'esempio seguente definisce il proprietario della directory come `node`. ``` FROM public.ecr.aws/amazonlinux/amazonlinux:latest RUN yum install -y shadow-utils && yum clean all RUN useradd node RUN mkdir -p /var/log/exported && chown node:node /var/log/exported RUN touch /var/log/exported/examplefile USER node VOLUME ["/var/log/exported"] ``` + Per le attività ospitate su istanze Amazon EC2, quando non sono specificati i valori `host` e `sourcePath`, il daemon Docker gestisce il montaggio vincolato per tuo conto. Quando nessun container fa riferimento a questo montaggio vincolato, viene alla fine eliminato dal servizio di pulizia dell'attività dell'agente del container Amazon ECS. Per impostazione predefinita, ciò avviene tre ore dopo la chiusura del container. Tuttavia, puoi configurare questa durata con la variabile dell'agente `ECS_ENGINE_TASK_CLEANUP_WAIT_DURATION`. Per ulteriori informazioni, consulta [Configurazione dell'agente del container Amazon ECS](ecs-agent-config.md). Se è necessario che questi dati vengano conservati oltre il ciclo di vita del container, specifica un valore `sourcePath` per il montaggio vincolato. + Per le attività ospitate su Amazon ECS Managed Instances, parti del filesystem root sono di sola lettura. Read/write i bind mount devono utilizzare directory scrivibili, ad esempio per dati persistenti o temporanei. `/var` `/tmp` Il tentativo di creare read/write bind mount su altre directory comporta l'impossibilità di avviare l'attività con un errore simile al seguente: ``` error creating empty volume: error while creating volume path '/path': mkdir /path: read-only file system ``` I bind mount di sola lettura (configurati nel `mountPoints` parametro) possono puntare `"readOnly": true` a qualsiasi directory accessibile sull'host. Per visualizzare un elenco completo di percorsi scrivibili, puoi eseguire un'attività su un'istanza gestita di Amazon ECS e utilizzarla per ispezionare la tabella di montaggio dell'istanza. Crea una definizione di attività con le seguenti impostazioni per accedere al filesystem host: ``` { "pidMode": "host", "containerDefinitions": [{ "privileged": true, ... }] } ``` Quindi esegui i seguenti comandi dall'interno del contenitore: ``` # List writable mounts cat /proc/1/root/proc/1/mounts | awk '$4 ~ /^rw,/ || $4 == "rw" {print $2}' | sort # List read-only mounts cat /proc/1/root/proc/1/mounts | awk '$4 ~ /^ro,/ || $4 == "ro" {print $2}' | sort ``` **Importante** L'`privileged`impostazione concede al contenitore funzionalità estese sull'host, equivalenti all'accesso root. In questo esempio, viene utilizzata per ispezionare la tabella di montaggio dell'host a fini diagnostici. Per ulteriori informazioni, consulta [Evitare l'esecuzione di container con privilegi (Amazon EC2)](security-tasks-containers.md#security-tasks-containers-recommendations-avoid-privileged-containers). Per ulteriori informazioni sull'esecuzione interattiva dei comandi nei contenitori, vedere. [Monitora i container Amazon ECS con ECS Exec](ecs-exec.md) # Specificare un montaggio vincolato in una definizione dell'attività Amazon ECS Per le attività Amazon ECS ospitate sull'istanza Fargate oppure sulle istanze Amazon EC2, il seguente frammento JSON della definizione di attività illustra la sintassi degli oggetti `volumes`, `mountPoints` e `ephemeralStorage` per una definizione di attività. ``` { "family": "", ... "containerDefinitions" : [ { "mountPoints" : [ { "containerPath" : "/path/to/mount_volume", "sourceVolume" : "string" } ], "name" : "string" } ], ... "volumes" : [ { "name" : "string" } ], "ephemeralStorage": { "sizeInGiB": integer } } ``` Per le attività Amazon ECS ospitate su istanze Amazon EC2, puoi utilizzare il parametro `host` opzionale e un `sourcePath` quando specifichi i dettagli del volume dell'attività. Quando viene specificato, lega il montaggio vincolato al ciclo di vita dell'attività anziché al container. ``` "volumes" : [ { "host" : { "sourcePath" : "string" }, "name" : "string" } ] ``` Di seguito sono riportate descrizioni più dettagliate per ogni parametro di definizione di attività. `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. `host` Obbligatorio: no Il parametro `host` viene utilizzato per legare il ciclo di vita del montaggio vincolato all'istanza host di Amazon EC2 anziché al processo, dove invece è archiviato. Se il parametro `host` è vuoto, il daemon Docker assegna un percorso host per il tuo volume di dati, ma non è garantito che i dati vengano mantenuti dopo che viene interrotta l'esecuzione del container a essi associato. I container Windows possono montare intere directory sulla stessa unità di `$env:ProgramData`. Il `sourcePath` parametro è supportato solo quando si utilizzano attività ospitate su istanze Amazon EC2 o Amazon ECS Managed Instances. `sourcePath` ▬Tipo: stringa Obbligatorio: no Quando viene utilizzato il parametro `host`, specifica un `sourcePath` per dichiarare il percorso sull'istanza Amazon EC2 dell'host presentata al container. Se questo parametro è vuoto, il daemon Docker assegna automaticamente un percorso host. Se il parametro `host` contiene una posizione del file `sourcePath`, il volume di dati rimane nella posizione specificata sull'istanza Amazon EC2 dell'host finché non viene eliminato manualmente. Se il valore `sourcePath` non esiste nell'istanza Amazon EC2 dell'host, viene creato automaticamente dal daemon Docker. Se la posizione è presente, i contenuti della cartella del percorso di origine vengono esportati. `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`. `ephemeralStorage` Tipo: oggetto Obbligatorio: no La quantità di archiviazione temporanea da allocare per il processo. Questo parametro viene utilizzato per espandere la quantità totale di storage temporaneo disponibile, oltre la quantità predefinita, per le attività ospitate AWS Fargate utilizzando una versione della piattaforma `1.4.0` o successiva (Linux) o successiva (Windows). `1.0.0` È possibile utilizzare la CLI di Copilot CloudFormation, l' AWS SDK o la CLI per specificare lo storage temporaneo per un bind mount. # Esempi di montaggio vincolato per Amazon ECS Gli esempi seguenti riguardano i casi d'uso comuni per l'utilizzo di un montaggio vincolato per i container. **Come allocare una maggiore quantità di spazio di archiviazione temporanea per un processo Fargate** Per le attività Amazon ECS ospitate su Fargate che utilizzano la versione della piattaforma `1.4.0` o successiva (Linux) o `1.0.0` o successiva (Windows), è possibile allocare più della quantità predefinita di storage temporaneo per i container nell'attività da utilizzare. Questo esempio può essere incorporato negli altri esempi per allocare più spazio di archiviazione temporanea per i processi Fargate. + Nella definizione di attività, definisci un oggetto `ephemeralStorage`. La `sizeInGiB` deve essere un numero intero compreso tra i valori di `21` e `200` ed è espresso in GiB. ``` "ephemeralStorage": { "sizeInGiB": integer } ``` **Come fornire un volume di dati vuoto per uno o più container** In alcuni casi, si può fornire ai container in un processo un po' di spazio scratch. Ad esempio, potresti avere due container di database che devono accedere alla stessa posizione di storage dei file temporanei durante un'attività. Questo può essere ottenuto utilizzando un montaggio vincolato. 1. Nella sezione `volumes` della definizione di attività, definisci un montaggio vincolato con il nome `database_scratch`. ``` "volumes": [ { "name": "database_scratch" } ] ``` 1. Nella sezione `containerDefinitions`, crea le definizioni di container del database. in modo che montino il volume. ``` "containerDefinitions": [ { "name": "database1", "image": "my-repo/database", "cpu": 100, "memory": 100, "essential": true, "mountPoints": [ { "sourceVolume": "database_scratch", "containerPath": "/var/scratch" } ] }, { "name": "database2", "image": "my-repo/database", "cpu": 100, "memory": 100, "essential": true, "mountPoints": [ { "sourceVolume": "database_scratch", "containerPath": "/var/scratch" } ] } ] ``` **Come utilizzare un percorso e il relativo contenuto in un Dockerfile in un container** In questo esempio, hai un Dockerfile che scrive i dati che si desidera montare all'interno di un container. Questo esempio funziona per le attività ospitate su istanze di Fargate o Amazon EC2. 1. Crea un Dockerfile. L'esempio seguente utilizza l'immagine del container Amazon Linux 2 e crea un file denominato `examplefile` nella directory `/var/log/exported` che vogliamo montare all'interno del container. La direttiva `VOLUME` dovrebbe specificare un percorso assoluto. ``` FROM public.ecr.aws/amazonlinux/amazonlinux:latest RUN mkdir -p /var/log/exported RUN touch /var/log/exported/examplefile VOLUME ["/var/log/exported"] ``` Di default, le autorizzazioni dei volumi sono impostate su `0755` e il proprietario è `root`. Queste autorizzazioni possono essere modificate nel Dockerfile. Nell'esempio seguente il proprietario della directory `/var/log/exported`è impostato su `node`. ``` FROM public.ecr.aws/amazonlinux/amazonlinux:latest RUN yum install -y shadow-utils && yum clean all RUN useradd node RUN mkdir -p /var/log/exported && chown node:node /var/log/exported USER node RUN touch /var/log/exported/examplefile VOLUME ["/var/log/exported"] ``` 1. Nella sezione `volumes` della definizione di attività, definire un volume con il nome `application_logs`. ``` "volumes": [ { "name": "application_logs" } ] ``` 1. Nella sezione `containerDefinitions`, crea le definizioni di container dell'applicazione. in modo che montino lo storage. Il valore `containerPath` deve corrispondere al percorso assoluto specificato nella direttiva `VOLUME` dal Dockerfile. ``` "containerDefinitions": [ { "name": "application1", "image": "my-repo/application", "cpu": 100, "memory": 100, "essential": true, "mountPoints": [ { "sourceVolume": "application_logs", "containerPath": "/var/log/exported" } ] }, { "name": "application2", "image": "my-repo/application", "cpu": 100, "memory": 100, "essential": true, "mountPoints": [ { "sourceVolume": "application_logs", "containerPath": "/var/log/exported" } ] } ] ``` **Come fornire un volume di dati vuoto per un container legato al ciclo di vita dell'istanza host di Amazon EC2** Per le attività ospitate su istanze Amazon EC2, puoi utilizzare i montaggi vincolati e avere i dati legati al ciclo di vita dell'istanza host di Amazon EC2. Puoi farlo utilizzando il parametro `host` e specificando un valore `sourcePath`. Tutti i file esistenti nel `sourcePath` vengono presentati ai container con il valore `containerPath`. Qualsiasi file scritto con il valore `containerPath` viene scritto con il valore `sourcePath`sull'istanza host di Amazon EC2. **Importante** Amazon ECS non sincronizza il tuo spazio di archiviazione tra le istanze Amazon EC2. I processi che utilizzano archiviazione persistente possono essere posizionati su qualsiasi istanza Amazon EC2 nel cluster che abbia capacità disponibile. [Se le tue attività richiedono uno storage persistente dopo l'arresto e il riavvio, specifica sempre la stessa istanza Amazon EC2 al momento dell'avvio dell'attività con il comando start-task. AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/ecs/start-task.html) Puoi utilizzare anche volumi Amazon EFS per l'archiviazione persistente. Per ulteriori informazioni, consulta [Usare i volumi Amazon EFS con Amazon ECS](efs-volumes.md). 1. Nella sezione `volumes` della definizione di attività, definisci un montaggio vincolato con i valori `name` e `sourcePath`. Nell'esempio seguente, l'istanza host di Amazon EC2 contiene dati in `/ecs/webdata` che desideri montare all'interno del container. ``` "volumes": [ { "name": "webdata", "host": { "sourcePath": "/ecs/webdata" } } ] ``` 1. Nella sezione `containerDefinitions`, definisci un container con i valori `mountPoints` che faccia riferimento al nome del montaggio vincolato definito e al valore `containerPath` per montare il montaggio vincolato sul container. ``` "containerDefinitions": [ { "name": "web", "image": "public.ecr.aws/docker/library/nginx:latest", "cpu": 99, "memory": 100, "portMappings": [ { "containerPort": 80, "hostPort": 80 } ], "essential": true, "mountPoints": [ { "sourceVolume": "webdata", "containerPath": "/usr/share/nginx/html" } ] } ] ``` **Per montare un volume definito su più container in diverse posizioni** Puoi definire un volume di dati in una definizione di attività e montarlo in posizioni diverse su container diversi. Ad esempio, il container host ha una cartella di dati del sito Web in `/data/webroot`. Si potrebbe voler montare il volume di dati in sola lettura su due server Web diversi che hanno radici di documenti diverse. 1. Nella sezione `volumes` della definizione di attività, definisci un volume di dati con il nome `webroot` e il percorso di origine `/data/webroot`. ``` "volumes": [ { "name": "webroot", "host": { "sourcePath": "/data/webroot" } } ] ``` 1. Nella sezione `containerDefinitions`, definisci un container per ciascun server Web con i valori `mountPoints` che associano il volume `webroot` al valore `containerPath` puntando alla radice documento per tale container. ``` "containerDefinitions": [ { "name": "web-server-1", "image": "my-repo/ubuntu-apache", "cpu": 100, "memory": 100, "portMappings": [ { "containerPort": 80, "hostPort": 80 } ], "essential": true, "mountPoints": [ { "sourceVolume": "webroot", "containerPath": "/var/www/html", "readOnly": true } ] }, { "name": "web-server-2", "image": "my-repo/sles11-apache", "cpu": 100, "memory": 100, "portMappings": [ { "containerPort": 8080, "hostPort": 8080 } ], "essential": true, "mountPoints": [ { "sourceVolume": "webroot", "containerPath": "/srv/www/htdocs", "readOnly": true } ] } ] ``` **Per montare i volumi da un altro container mediante `volumesFrom`** Per le attività ospitate su istanze Amazon EC2, puoi definire uno o più volumi su un container e quindi utilizzare il parametro `volumesFrom` in un'altra definizione del container (all'interno della stessa attività) per montare tutti i volumi da `sourceContainer` sui relativi punti di montaggio definiti originariamente. Il parametro `volumesFrom` si applica ai volumi configurati nella definizione di attività e a quelli integrati nell'immagine con un Dockerfile. 1. (Opzionale) Per condividere un volume incorporato in un'immagine, usa l'istruzione `VOLUME` nel Dockerfile. Il seguente Dockerfile di esempio utilizza un'immagine `httpd` e quindi aggiunge un volume e lo monta su `dockerfile_volume` nella radice del documento Apache. È la cartella utilizzata dal server Web `httpd`. ``` FROM httpd VOLUME ["/usr/local/apache2/htdocs/dockerfile_volume"] ``` Puoi creare un'immagine con questo Dockerfile ed eseguirne il push a un repository, ad esempio Docker Hub, e utilizzarla nella definizione di attività. L'immagine `my-repo/httpd_dockerfile_volume` di esempio utilizzata nelle seguenti fasi è stata creata con il Dockerfile precedente. 1. Crea una definizione di attività che definisca gli altri volumi e punti di montaggio per i container. In questa sezione `volumes` di esempio, devi creare un volume vuoto denominato `empty`, gestito dal daemon Docker. Esiste anche un volume host definito che viene chiamato `host_etc`. Esporta la cartella `/etc` sull'istanza di container dell'host. ``` { "family": "test-volumes-from", "volumes": [ { "name": "empty", "host": {} }, { "name": "host_etc", "host": { "sourcePath": "/etc" } } ], ``` Nella sezione delle definizioni del container, crea un container che monti i volumi definiti in precedenza. In questo esempio, il container `web` monta i volumi `empty` e `host_etc`. Questo è il container che utilizza l'immagine creata con un volume nel Dockerfile. ``` "containerDefinitions": [ { "name": "web", "image": "my-repo/httpd_dockerfile_volume", "cpu": 100, "memory": 500, "portMappings": [ { "containerPort": 80, "hostPort": 80 } ], "mountPoints": [ { "sourceVolume": "empty", "containerPath": "/usr/local/apache2/htdocs/empty_volume" }, { "sourceVolume": "host_etc", "containerPath": "/usr/local/apache2/htdocs/host_etc" } ], "essential": true }, ``` Crea un altro container che utilizzi `volumesFrom` per montare tutti i volumi associati al container `web`. Tutti i volumi sul container `web` sono montati anche sul container `busybox`. È incluso il volume specificato nel Dockerfile utilizzato per creare l'immagine `my-repo/httpd_dockerfile_volume`. ``` { "name": "busybox", "image": "busybox", "volumesFrom": [ { "sourceContainer": "web" } ], "cpu": 100, "memory": 500, "entryPoint": [ "sh", "-c" ], "command": [ "echo $(date) > /usr/local/apache2/htdocs/empty_volume/date && echo $(date) > /usr/local/apache2/htdocs/host_etc/date && echo $(date) > /usr/local/apache2/htdocs/dockerfile_volume/date" ], "essential": false } ] } ``` Quando questa attività viene eseguita, i volumi vengono montati dai due container e il `command` nel container `busybox` scrive la data e l'ora su un file. Questo file è chiamato `date` in ciascuna cartella dei volumi. che diventano quindi visibili sul sito Web visualizzato dal container `web`. **Nota** Il container `busybox` esegue un comando rapido e poi si chiude, quindi deve essere impostato come `"essential": false` nella definizione del container. In caso contrario, l'intera attività viene interrotta quando si chiude.