

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Contoh Bind mount untuk Amazon ECS
<a name="bind-mount-examples"></a>

Contoh berikut mencakup kasus penggunaan umum untuk menggunakan dudukan pengikat untuk wadah Anda.

**Untuk mengalokasikan peningkatan jumlah ruang penyimpanan sementara untuk tugas Fargate**

Untuk tugas Amazon ECS yang di-host di Fargate menggunakan `1.4.0` versi platform atau yang lebih baru (Linux) `1.0.0` atau (Windows), Anda dapat mengalokasikan lebih dari jumlah penyimpanan sementara default untuk wadah dalam tugas yang akan digunakan. Contoh ini dapat dimasukkan ke dalam contoh lain untuk mengalokasikan lebih banyak penyimpanan sementara untuk tugas Fargate Anda.
+ Dalam ketentuan tugas, tentukan objek `ephemeralStorage`. `sizeInGiB` harus integer antara nilai-nilai `21` dan `200` dinyatakan dalam GiB.

  ```
  "ephemeralStorage": {
      "sizeInGiB": integer
  }
  ```

**Untuk menyediakan volume data kosong untuk satu atau lebih kontainer.**

Dalam beberapa kasus, Anda ingin menyediakan kontainer dalam tugas beberapa ruang scratch. Misalnya, Anda mungkin memiliki dua wadah database yang perlu mengakses lokasi penyimpanan file awal yang sama selama tugas. Hal ini dapat dicapai dengan menggunakan pemasangan terikat.

1. Dalam ketentuan tugas bagian `volumes`, tentukan pemasangan terikat dengan nama `database_scratch`.

   ```
     "volumes": [
       {
         "name": "database_scratch"
       }
     ]
   ```

1. Di `containerDefinitions` bagian ini, buat definisi wadah database. Ini agar mereka memasang 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"
           }
         ]
       }
     ]
   ```

**Untuk mengekspos jalur dan isinya dari Dockerfile ke kontainer.**

Dalam contoh ini, Anda memiliki Dockerfile yang menulis data yang ingin Anda pasang di dalam kontainer. Contoh ini berfungsi untuk tugas yang di-host di instance Fargate atau Amazon EC2.

1. Buat Dockerfile. Contoh berikut menggunakan image kontainer Amazon Linux 2 publik dan membuat file yang diberi nama `examplefile` di `/var/log/exported` direktori yang ingin kita pasang di dalam wadah. Direktif `VOLUME` harus menentukan jalur absolut.

   ```
   FROM public.ecr.aws/amazonlinux/amazonlinux:latest
   RUN mkdir -p /var/log/exported
   RUN touch /var/log/exported/examplefile
   VOLUME ["/var/log/exported"]
   ```

   Secara default, izin volume diatur ke `0755` dan pemilik sebagai `root`. Izin ini dapat diubah di Dockerfile. Contoh berikut mendefinisikan pemilik direktori `/var/log/exported` diatur ke `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. Dalam ketentuan tugas bagian `volumes`, tentukan volume dengan nama `application_logs`.

   ```
     "volumes": [
       {
         "name": "application_logs"
       }
     ]
   ```

1. Di `containerDefinitions` bagian ini, buat definisi wadah aplikasi. Ini agar mereka memasang penyimpanan. `containerPath`Nilai harus cocok dengan jalur absolut yang ditentukan dalam `VOLUME` arahan dari 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"
           }
         ]
       }
     ]
   ```

**Untuk menyediakan volume data kosong untuk wadah yang terkait dengan siklus hidup instans Amazon EC2 host**

Untuk tugas yang di-host di instans Amazon EC2, Anda dapat menggunakan mount bind dan memiliki data yang terkait dengan siklus hidup instans Amazon EC2 host. Anda dapat melakukan ini dengan menggunakan `host` parameter dan menentukan `sourcePath` nilai. File apa pun yang ada di `sourcePath` disajikan ke wadah pada `containerPath` nilainya. File apa pun yang ditulis dengan `containerPath` nilai ditulis ke `sourcePath` nilai pada instans Amazon EC2 host.
**penting**  
Amazon ECS tidak menyinkronkan penyimpanan Anda di seluruh instans Amazon EC2. Tugas yang menggunakan penyimpanan persisten dapat ditempatkan pada instans Amazon EC2 apa pun di klaster Anda yang memiliki kapasitas yang tersedia. [Jika tugas Anda memerlukan penyimpanan persisten setelah berhenti dan memulai ulang, selalu tentukan instans Amazon EC2 yang sama pada waktu peluncuran tugas dengan AWS CLI perintah start-task.](https://docs.aws.amazon.com/cli/latest/reference/ecs/start-task.html) Anda juga dapat menggunakan volume Amazon EFS untuk penyimpanan persisten. Untuk informasi selengkapnya, lihat [Gunakan volume Amazon EFS dengan Amazon ECS](efs-volumes.md).

1. Dalam ketentuan tugas bagian `volumes`, tentukan pemasangan terikat dengan `name` dan nilai `sourcePath`. Dalam contoh berikut, instans Amazon EC2 host berisi data `/ecs/webdata` yang ingin Anda pasang di dalam wadah.

   ```
     "volumes": [
       {
         "name": "webdata",
         "host": {
           "sourcePath": "/ecs/webdata"
         }
       }
     ]
   ```

1. Di bagian `containerDefinitions`, mendefiniskan sebuah kontainer dengan nilai-nilai `mountPoints` yang mereferensikan nama pemasangan terikat dan nilai `containerPath` untuk memasang pemasangan terikat pada kontainer.

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

**Untuk memasang volume yang ditetapkan pada beberapa kontainer di lokasi yang berbeda**

Anda dapat menentukan volume data dalam ketentuan tugas dan memasang volume tersebut di lokasi yang berbeda pada kontainer yang berbeda. Misalnya, wadah host Anda memiliki folder data situs web di`/data/webroot`. Anda mungkin ingin me-mount volume data tersebut sebagai read-only pada dua server web berbeda yang memiliki akar dokumen yang berbeda.

1. Dalam ketentuan tugas bagian `volumes`, tentukan volume data dengan nama `webroot` dan jalur sumber `/data/webroot`.

   ```
     "volumes": [
       {
         "name": "webroot",
         "host": {
           "sourcePath": "/data/webroot"
         }
       }
     ]
   ```

1. Di bagian `containerDefinitions`, tentukan kontainer untuk setiap server web dengan nilai-nilai `mountPoints` yang mengasosiasikan volume `webroot` dengan nilai `containerPath` menunjuk ke akar dokumen untuk kontainer itu.

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

**Untuk memasang volume dari kontainer lain menggunakan `volumesFrom`.**

Untuk tugas yang dihosting di instans Amazon EC2, Anda dapat menentukan satu atau beberapa volume pada penampung, lalu menggunakan `volumesFrom` parameter dalam definisi container yang berbeda dalam tugas yang sama untuk memasang semua volume dari titik pemasangan yang `sourceContainer` ditentukan semula. Parameter`volumesFrom` berlaku untuk volume yang didefinisikan dalam ketentuan tugas, dan volume yang dibangun ke dalam citra dengan Dockerfile.

1. (Opsional) Untuk berbagi volume yang dibangun ke dalam gambar, gunakan `VOLUME` instruksi di Dockerfile. Contoh berikut Dockerfile menggunakan `httpd` gambar, dan kemudian menambahkan volume dan memasangnya `dockerfile_volume` di root dokumen Apache. Ini adalah folder yang digunakan oleh server `httpd` web.

   ```
   FROM httpd
   VOLUME ["/usr/local/apache2/htdocs/dockerfile_volume"]
   ```

   Anda dapat membangun citra dengan Dockerfile ini dan mendorongnya ke repositori, seperti Docker Hub, dan menggunakannya dalam ketentuan tugas Anda. Contoh `my-repo/httpd_dockerfile_volume` gambar yang digunakan dalam langkah-langkah berikut dibuat dengan Dockerfile sebelumnya.

1. Buat ketentuan tugas yang mendefinisikan volume lain dan memasang titik untuk kontainer. Dalam contoh bagian `volumes` ini, Anda akan membuat volume kosong yang disebut `empty`, yang dikelola oleh daemon Docker. Ada juga volume host yang ditentukan yang disebut`host_etc`. Ini mengekspor `/etc` folder pada instance wadah host.

   ```
   {
     "family": "test-volumes-from",
     "volumes": [
       {
         "name": "empty",
         "host": {}
       },
       {
         "name": "host_etc",
         "host": {
           "sourcePath": "/etc"
         }
       }
     ],
   ```

   Di bagian ketentuan kontainer, buat kontainer yang memasang volume yang didefinisikan sebelumnya. Dalam contoh ini, `web` wadah memasang `host_etc` volume `empty` dan. Ini adalah wadah yang menggunakan gambar yang dibangun dengan volume di 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
       },
   ```

   Buat kontainer lain yang menggunakan `volumesFrom` untuk memasang semua volume yang terkait dengan kontainer `web`. Semua volume pada `web` wadah juga dipasang pada `busybox` wadah. Ini termasuk volume yang ditentukan dalam Dockerfile yang digunakan untuk membangun gambar. `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
       }
     ]
   }
   ```

   Saat tugas ini dijalankan, kedua kontainer memasang volume, dan `command` dalam `busybox` wadah menulis tanggal dan waktu ke file. File ini dipanggil `date` di setiap folder volume. Folder kemudian terlihat di situs web yang ditampilkan oleh kontainer `web`.
**catatan**  
Karena kontainer `busybox` menjalankan perintah cepat dan kemudian keluar, itu harus ditetapkan sebagai `"essential": false` dalam ketentuan kontainer. Jika tidak, kontainer berhenti seluruh tugas ketika keluar.