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