Tutorial: Menyimpan data dalam aplikasi kontainer menggunakan volume di Visual Studio Code

2025-01-26

Dalam tutorial ini, Anda akan belajar mempertahankan data dalam aplikasi kontainer. Saat Anda menjalankannya atau memperbaruinya, data masih tersedia. Ada dua jenis volume utama yang digunakan untuk mempertahankan data. Tutorial ini berfokus pada volume yang dinamai.

Anda juga akan mempelajari tentang pemasangan ikat , yang mengontrol titik pemasangan yang tepat pada host. Anda dapat menggunakan bind mounts untuk mempertahankan data, namun juga dapat menambahkan lebih banyak data ke dalam kontainer. Saat mengerjakan aplikasi, Anda dapat menggunakan bind mount untuk memasukkan kode sumber ke dalam kontainer agar dapat melihat perubahan kode, merespons, dan memungkinkan Anda melihat perubahan secara langsung.

Tutorial ini juga memperkenalkan pembuatan lapisan gambar, cache lapisan, dan build multi-tahap.

Dalam tutorial ini, Anda mempelajari cara:

Memahami data di seluruh kontainer.
Simpan data menggunakan volume yang diberi nama.
Gunakan pemasangan ikatan.
Lihat lapisan gambar.
Dependensi cache.
Memahami bangun multi-tahap.

Prasyarat

Tutorial ini melanjutkan tutorial sebelumnya, Membuat dan berbagi aplikasi kontainer dengan Visual Studio Code. Mulailah dengan yang satu itu, yang mencakup prasyarat.

Memahami data di seluruh kontainer

Di bagian ini, Anda akan memulai dua kontainer dan membuat file di masing-masing kontainer. File yang dibuat dalam satu kontainer tidak tersedia di kontainer lain.

Mulai kontainer ubuntu dengan menggunakan perintah ini:
```
docker run -d ubuntu bash -c "shuf -i 1-10000 -n 1 -o /data.txt && tail -f /dev/null"
```
Perintah ini mulai memanggil dua perintah dengan menggunakan &&. Bagian pertama memilih satu angka acak dan menulisnya ke /data.txt. Perintah kedua adalah mengawasi file agar kontainer tetap berjalan.
Di Visual Studio Code, di Penjelajah Kontainer, klik kanan kontainer ubuntu dan pilih Lampirkan Shell.

Terminal terbuka yang menjalankan shell di kontainer Ubuntu.
Jalankan perintah berikut untuk melihat konten file /data.txt.
```
cat /data.txt
```
Terminal menunjukkan angka antara 1 dan 10000.

Untuk menggunakan baris perintah untuk melihat hasil ini, dapatkan ID kontainer dengan menggunakan perintah docker ps, dan jalankan perintah berikut.
```
docker exec <container-id> cat /data.txt
```

Mulai kontainer ubuntu lain.

docker run -d ubuntu bash -c "shuf -i 1-10000 -n 1 -o /data.txt && tail -f /dev/null"

Gunakan perintah ini untuk melihat isi folder.
```
docker run -it ubuntu ls /
```
Seharusnya tidak ada file data.txt di sana karena ditulis ke ruang sementara yang hanya digunakan untuk kontainer pertama.
Pilih dua kontainer Ubuntu ini. Klik kanan dan pilih Hapus. Dari baris perintah, Anda dapat menghapusnya dengan menggunakan perintah docker rm -f.

Menyimpan data todo Anda menggunakan volume dengan nama khusus

Secara default, aplikasi todo menyimpan datanya dalam Database SQLite di /etc/todos/todo.db. SQLite Database adalah database relasional yang menyimpan data satu file. Pendekatan ini berfungsi untuk proyek kecil.

Anda dapat mempertahankan satu file di host. Ketika Anda membuatnya tersedia untuk kontainer berikutnya, aplikasi dapat melanjutkan dari titik terakhir. Dengan membuat volume dan mengaitkan atau meletakkanke folder tempat data disimpan, Anda dapat mempertahankan data. Kontainer menulis ke file todo.db dan data tersebut tersimpan pada host dalam volume.

Untuk bagian ini, gunakan volume bernama . Docker mempertahankan lokasi fisik volume pada disk. Mengacu pada nama volume, Docker akan menyediakan data yang tepat.

Buat volume dengan menggunakan perintah docker volume create.
```
docker volume create todo-db
```
Di bawah KONTAINER, pilih memulai dan klik kanan. Pilih Hentikan untuk menghentikan kontainer aplikasi.

Untuk menghentikan kontainer dari baris perintah, gunakan perintah docker stop.
Mulailah kontainer getting-started dengan menggunakan perintah berikut.
```
docker run -dp 3000:3000 -v todo-db:/etc/todos getting-started
```
Parameter volume menentukan volume yang akan dipasang dan lokasinya, /etc/todos.
Refresh browser Anda untuk memuat ulang aplikasi. Jika Anda telah menutup jendela browser, buka http://localhost:3000/. Tambahkan beberapa item ke daftar todo Anda.
Hapus kontainer memulai untuk aplikasi todo. Klik kanan kontainer di Penjelajah Kontainer dan pilih Hapus atau gunakan perintah docker stop dan docker rm.
Mulai kontainer baru menggunakan perintah yang sama:
```
docker run -dp 3000:3000 -v todo-db:/etc/todos getting-started
```
Perintah ini memasang drive yang sama seperti sebelumnya. Segarkan browser Anda. Item yang Anda tambahkan masih ada dalam daftar Anda.
Hapus kontainer memulai lagi.

Volume bernama dan penautan bind, yang dibahas di bawah ini, adalah jenis volume utama yang didukung oleh instalasi mesin Docker default.

Harta benda	Volume yang Diberi Nama	Pemasangan Ikatan
Lokasi Host	Docker memilih	Anda mengontrol
Contoh Pemasangan (menggunakan `-v`)	my-volume:/usr/local/data	/path/to/data:/usr/local/data
Mengisi volume baru dengan konten kontainer	Ya	Tidak
Mendukung Pengandar Volume	Ya	Tidak

Ada banyak plugin driver volume yang tersedia untuk mendukung NFS, SFTP, NetApp, dan banyak lagi. Plugin ini sangat penting untuk menjalankan kontainer pada beberapa host di lingkungan berkluster seperti Swarm atau Kubernetes.

Jika Anda bertanya-tanya di mana Docker menyimpan sebenarnya data Anda, jalankan perintah berikut.

docker volume inspect todo-db

Lihat outputnya, mirip dengan hasil ini.

[
    {
        "CreatedAt": "2019-09-26T02:18:36Z",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/todo-db/_data",
        "Name": "todo-db",
        "Options": {},
        "Scope": "local"
    }
]

Mountpoint adalah lokasi aktual tempat data disimpan. Di sebagian besar komputer, Anda memerlukan akses root untuk mengakses direktori ini dari host.

Gunakan bind mounts

Dengan bind mount , Anda mengontrol titik pemasangan yang tepat pada host. Pendekatan ini mempertahankan data, tetapi sering digunakan untuk memberikan lebih banyak data ke dalam kontainer. Anda dapat menggunakan pemasangan bind untuk memasukkan kode sumber ke dalam kontainer guna memungkinkannya melihat perubahan kode, menanggapi, dan memungkinkan Anda melihat perubahan segera.

Untuk menjalankan kontainer Anda untuk mendukung alur kerja pengembangan, Anda akan mengambil langkah-langkah berikut:

Hapus kontainer getting-started apa pun.
Di folder app, jalankan perintah berikut.
```
docker run -dp 3000:3000 -w /app -v ${PWD}:/app node:lts-alpine sh -c "yarn install && yarn run dev"
```
Perintah ini berisi parameter berikut.
- -dp 3000:3000 Sama seperti sebelumnya. Jalankan dalam mode terpisah dan buat pemetaan port.
- -w /app Direktori kerja di dalam kontainer.
- -v ${PWD}:/app" Ikat pemasangan direktori saat ini dari host dalam kontainer ke direktori /app.
- node:lts-alpine Gambar yang akan digunakan. Gambar ini adalah gambar dasar untuk aplikasi Anda dari Dockerfile.
- sh -c "yarn install && yarn run dev" Perintah. Ini memulai shell menggunakan sh dan menjalankan yarn install untuk menginstal semua dependensi. Kemudian berjalan yarn run dev. Jika Anda melihat di package.json, skrip dev dimulai nodemon.

Anda dapat menonton log menggunakan docker logs.

docker logs -f <container-id>

$ nodemon src/index.js
[nodemon] 2.0.20
[nodemon] to restart at any time, enter `rs`
[nodemon] watching path(s): *.*
[nodemon] watching extensions: js,mjs,json
[nodemon] starting `node src/index.js`
Using sqlite database at /etc/todos/todo.db
Listening on port 3000

Saat Anda melihat entri akhir di daftar ini, aplikasi sedang berjalan.

Setelah selesai menonton log, pilih kunci apa pun di jendela terminal atau pilih Ctrl+C di jendela eksternal.

Di Visual Studio Code, buka src/static/js/app.js. Ubah teks tombol Tambahkan Item pada baris 109.
```
- {submitting ? 'Adding...' : 'Add Item'}
+ {submitting ? 'Adding...' : 'Add'}
```
Simpan perubahan Anda.
Segarkan browser Anda. Anda akan melihat perubahan.
Hapus node:lts-alpine kontainer.
Di folder app, jalankan perintah berikut untuk menghapus folder node_modules yang dibuat di langkah-langkah sebelumnya.
```
rm -r node_modules
```

Melihat lapisan gambar

Anda dapat melihat lapisan yang membentuk gambar. Jalankan perintah docker image history untuk melihat perintah yang digunakan untuk membuat setiap lapisan dalam gambar.

Gunakan docker image history untuk melihat lapisan dalam gambar memulai yang Anda buat sebelumnya dalam tutorial.

docker image history getting-started

Hasil Anda harus menyerupai output ini.

IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT
a78a40cbf866        18 seconds ago      /bin/sh -c #(nop)  CMD ["node" "/app/src/ind…   0B                  
f1d1808565d6        19 seconds ago      /bin/sh -c yarn install --production            85.4MB              
a2c054d14948        36 seconds ago      /bin/sh -c #(nop) COPY dir:5dc710ad87c789593…   198kB               
9577ae713121        37 seconds ago      /bin/sh -c #(nop) WORKDIR /app                  0B                  
b95baba1cfdb        13 days ago         /bin/sh -c #(nop)  CMD ["node"]                 0B                  
<missing>           13 days ago         /bin/sh -c #(nop)  ENTRYPOINT ["docker-entry…   0B                  
<missing>           13 days ago         /bin/sh -c #(nop) COPY file:238737301d473041…   116B                
<missing>           13 days ago         /bin/sh -c apk add --no-cache --virtual .bui…   5.35MB              
<missing>           13 days ago         /bin/sh -c #(nop)  ENV YARN_VERSION=1.21.1      0B                  
<missing>           13 days ago         /bin/sh -c addgroup -g 1000 node     && addu…   74.3MB              
<missing>           13 days ago         /bin/sh -c #(nop)  ENV NODE_VERSION=12.14.1     0B                  
<missing>           13 days ago         /bin/sh -c #(nop)  CMD ["/bin/sh"]              0B                  
<missing>           13 days ago         /bin/sh -c #(nop) ADD file:e69d441d729412d24…   5.59MB

Masing-masing garis mewakili lapisan dalam gambar. Output menunjukkan dasar di bagian bawah dengan lapisan terbaru di bagian atas. Dengan menggunakan informasi ini, Anda dapat melihat ukuran setiap lapisan, membantu mendiagnosis gambar besar.

Beberapa garis terpotong. Jika Anda menambahkan parameter --no-trunc, Anda akan mendapatkan output lengkap.
```
docker image history --no-trunc getting-started
```

Dependensi cache

Setelah lapisan berubah, semua lapisan hilir juga harus dibuat ulang. Berikut adalah Dockerfile lagi:

FROM node:lts-alpine
WORKDIR /app
COPY . .
RUN yarn install --production
CMD ["node", "/app/src/index.js"]

Setiap perintah dalam Dockerfile menjadi lapisan baru dalam gambar. Untuk meminimalkan jumlah lapisan, Anda dapat merestrukturisasi Dockerfile untuk mendukung penyimpanan cache dependensi. Untuk aplikasi berbasis Node, dependensi tersebut didefinisikan dalam file package.json.

Pendekatannya adalah menyalin hanya file itu terlebih dahulu, menginstal dependensi, dan kemudian menyalin yang lain. Proses ini hanya membuat ulang dependensi benang jika ada perubahan pada package.json.

Perbarui Dockerfile untuk disalin di package.json terlebih dahulu, instal dependensi, lalu salin yang lain. Berikut adalah file baru:

FROM node:lts-alpine
WORKDIR /app
COPY package.json yarn.lock ./
RUN yarn install --production
COPY . .
CMD ["node", "/app/src/index.js"]

Buat gambar baru menggunakan docker build.

docker build -t getting-started .

Anda akan melihat output seperti hasil berikut:

Sending build context to Docker daemon  219.1kB
Step 1/6 : FROM node:lts-alpine
---> b0dc3a5e5e9e
Step 2/6 : WORKDIR /app
---> Using cache
---> 9577ae713121
Step 3/6 : COPY package* yarn.lock ./
---> bd5306f49fc8
Step 4/6 : RUN yarn install --production
---> Running in d53a06c9e4c2
yarn install v1.17.3
[1/4] Resolving packages...
[2/4] Fetching packages...
info fsevents@1.2.9: The platform "linux" is incompatible with this module.
info "fsevents@1.2.9" is an optional dependency and failed compatibility check. Excluding it from installation.
[3/4] Linking dependencies...
[4/4] Building fresh packages...
Done in 10.89s.
Removing intermediate container d53a06c9e4c2
---> 4e68fbc2d704
Step 5/6 : COPY . .
---> a239a11f68d8
Step 6/6 : CMD ["node", "/app/src/index.js"]
---> Running in 49999f68df8f
Removing intermediate container 49999f68df8f
---> e709c03bc597
Successfully built e709c03bc597
Successfully tagged getting-started:latest

Semua lapisan dibangun kembali. Hasil ini diharapkan karena Anda mengubah Dockerfile.

Buat perubahan pada src/static/index.html. Misalnya, ubah judul untuk mengatakan "Aplikasi Todo Yang Mengagumkan".

Buat image Docker sekarang menggunakan docker build lagi. Kali ini, output Anda akan terlihat sedikit berbeda.

Sending build context to Docker daemon  219.1kB
Step 1/6 : FROM node:lts-alpine
---> b0dc3a5e5e9e
Step 2/6 : WORKDIR /app
---> Using cache
---> 9577ae713121
Step 3/6 : COPY package* yarn.lock ./
---> Using cache
---> bd5306f49fc8
Step 4/6 : RUN yarn install --production
---> Using cache
---> 4e68fbc2d704
Step 5/6 : COPY . .
---> cccde25a3d9a
Step 6/6 : CMD ["node", "/app/src/index.js"]
---> Running in 2be75662c150
Removing intermediate container 2be75662c150
---> 458e5c6f080c
Successfully built 458e5c6f080c
Successfully tagged getting-started:latest

Karena Anda menggunakan cache pembangunan, proses tersebut seharusnya berjalan lebih cepat.

Pembangunan multi-tahap

Pembangunan multi-tahap adalah alat yang sangat kuat yang membantu penggunaan beberapa tahap untuk membuat citra. Ada beberapa keuntungan untuk mereka:

Pisahkan dependensi saat build dari dependensi saat runtime
Kurangi ukuran gambar keseluruhan dengan mengirimkan hanya apa yang perlu dijalankan aplikasi Anda

Bagian ini menyediakan contoh singkat.

Contoh Maven/Tomcat

Saat Anda membangun aplikasi berbasis Java, JDK diperlukan untuk mengkompilasi kode sumber ke bytecode Java. JDK tersebut tidak diperlukan dalam produksi. Anda mungkin menggunakan alat seperti Maven atau Gradle untuk membantu membangun aplikasi. Alat-alat tersebut juga tidak diperlukan dalam gambar akhir Anda.

FROM maven AS build
WORKDIR /app
COPY . .
RUN mvn package

FROM tomcat
COPY --from=build /app/target/file.war /usr/local/tomcat/webapps

Contoh ini menggunakan satu tahap, build, untuk melakukan build Java aktual menggunakan Maven. Tahap kedua, dimulai dari "FROM tomcat", menyalin file dari tahap build. Gambar akhir hanya merupakan tahap terakhir yang sedang dibuat, yang dapat ditimpa menggunakan parameter --target.

Contoh React

Saat membangun aplikasi React, Anda memerlukan lingkungan Node untuk mengkompilasi kode JavaScript, lembar gaya Sass, dan lainnya ke html statis, JavaScript, dan CSS. Jika Anda tidak melakukan rendering sisi server, Anda bahkan tidak memerlukan lingkungan Node untuk build produksi.

FROM node:lts-alpine AS build
WORKDIR /app
COPY package* yarn.lock ./
RUN yarn install
COPY public ./public
COPY src ./src
RUN yarn run build

FROM nginx:alpine
COPY --from=build /app/build /usr/share/nginx/html

Contoh ini menggunakan gambar node:lts-alpine untuk melakukan build, yang memaksimalkan cache lapisan, lalu menyalin output ke dalam kontainer nginx .

Membersihkan sumber daya

Simpan semua yang telah Anda lakukan sejauh ini untuk melanjutkan rangkaian tutorial ini.

Langkah berikutnya

Anda telah mempelajari tentang opsi untuk menyimpan data untuk aplikasi kontainer.

Apa yang ingin Anda lakukan selanjutnya?

Bekerja dengan beberapa kontainer dengan menggunakan Docker Compose:

Membuat aplikasi multi-kontainer dengan MySQL dan Docker Compose
Sebarkan ke Azure Container Apps:
- mulai cepat : Menyebarkan ke Azure Container Apps menggunakan Visual Studio Code
- Tutorial : Menyebarkan ke Azure Container Apps
Menyebarkan ke Azure App Service
- Menyebarkan aplikasi dalam kontainer ke Azure

Bagikan melalui