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.

Nella sezione volumes della definizione di attività, definisci un montaggio vincolato con il nome database_scratch.
```
  "volumes": [
    {
      "name": "database_scratch"
    }
  ]
```

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.

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"]
```
Nella sezione volumes della definizione di attività, definire un volume con il nome application_logs.
```
  "volumes": [
    {
      "name": "application_logs"
    }
  ]
```

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 sourcePathsull'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 lo storage persistente dopo l'arresto e il riavvio, devi specificare sempre la stessa istanza Amazon EC2 al momento dell'avvio con il comando start-task della AWS CLI. Puoi utilizzare anche volumi Amazon EFS per l'archiviazione persistente. Per ulteriori informazioni, consulta Usare i volumi Amazon EFS con Amazon ECS.

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"
      }
    }
  ]
```

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.

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"
      }
    }
  ]

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.

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

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.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Specificare un montaggio vincolato in una definizione dell'attività

Gestione dello spazio di memoria di swap del container