Esempi di montaggio Bind per Amazon ECS

I seguenti esempi coprono i casi d'uso comuni dell'utilizzo di un bind mount per i contenitori.

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

Fornire un volume di dati vuoto per un contenitore legato al ciclo di vita dell'istanza Amazon host EC2

Per le attività ospitate su EC2 istanze Amazon, puoi utilizzare bind mount e collegare i dati al ciclo di vita dell'istanza Amazon host. 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. Tutti i file scritti nel containerPath valore vengono scritti nel sourcePath valore sull' EC2 istanza Amazon host.

Importante

Amazon ECS non sincronizza lo storage tra le EC2 istanze Amazon. Le attività che utilizzano lo storage persistente possono essere collocate su qualsiasi EC2 istanza Amazon del cluster con capacità disponibile. Se le tue attività richiedono uno storage persistente dopo l'arresto e il riavvio, specifica sempre la stessa EC2 istanza Amazon al momento dell'avvio dell'attività con il AWS CLI comando start-task. Puoi utilizzare anche volumi Amazon EFS per l'archiviazione persistente. Per ulteriori informazioni, consulta Usa 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' EC2 istanza Amazon host contiene i dati /ecs/webdata che desideri montare all'interno del contenitore.
```
  "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 EC2 istanze Amazon, puoi definire uno o più volumi su un contenitore e quindi utilizzare il volumesFrom parametro in una definizione di contenitore diversa all'interno della stessa attività per montare tutti i volumi dai punti di montaggio originariamente definiti. sourceContainer 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'my-repo/httpd_dockerfile_volumeimmagine di esempio utilizzata nei passaggi seguenti è 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

Specificate un bind mount nella definizione di un'attività

Gestione dello spazio di memoria di swap dei container