Cara Membangun Citra Docker NGINX Kustom

Menjalankan NGINX di dalam container Docker dapat menyediakan layanan web andal di banyak lingkungan. Anda mungkin sedang mengerjakan situs pribadi, layanan web ringan, atau proyek lab rumahan. Docker membantu menjaga konsistensi di berbagai mesin dan pengaturan. Pendekatan ini menawarkan cara untuk menjalankan NGINX dengan kekhawatiran overhead yang lebih sedikit saat berpindah antara pengembangan dan produksi. Mengandalkan Docker untuk pengemasan server web yang sederhana adalah hal yang umum, sehingga memudahkan berbagi proyek tanpa langkah manual yang berantakan.

Artikel ini menjelaskan cara menjalankan image NGINX siap pakai, cara menyajikan konten dari mesin lokal Anda, dan cara membangun image dengan fitur kustom. Artikel ini juga membahas langkah penyiapan untuk reverse proxy, serta penggunaan Docker Compose untuk deployment multi-layanan. Pada akhirnya, Anda akan melihat cara mengelola container dengan beberapa perintah sederhana dan mendapatkan gambaran detail tentang cara mengintegrasikan Docker dan NGINX untuk tugas-tugas praktis.

Jika Anda baru mengenal Docker, pastikan untuk membaca panduan Docker untuk Pemula untuk mempelajari hal-hal penting. 

Apa itu Docker NGINX?

Docker NGINX mengacu pada menjalankan server web NGINX di dalam container ringan. Container Docker mirip paket kecil yang memuat aplikasi dan semua dependensi yang dibutuhkannya. 

NGINX adalah server web populer yang dikenal memiliki performa kuat, konfigurasi mudah, dan penanganan trafik HTTP yang fleksibel. Memadukan NGINX dengan Docker menarik karena menjaga lingkungan tetap konsisten. Baik Anda melakukan deployment di macOS, Windows, atau Linux, isi container tetap sama. Artinya, perilakunya identik, terlepas dari sistem operasi host.

Image Docker khas untuk NGINX mencakup perangkat lunak server, konfigurasi default, dan struktur direktori untuk file yang dihosting. Anda dapat langsung menjalankan container tersebut atau menyesuaikannya dengan memetakan folder tertentu, menyesuaikan file konfigurasi, atau membangun image berdasarkan Dockerfile Anda sendiri. Dengan cara itu, Anda bisa menambahkan modul atau skrip kustom untuk menyesuaikan NGINX bagi aplikasi Anda.

Untuk mempelajari lebih lanjut cara mengontainerkan aplikasi, lihat tutorial Cara Mengontainerkan Aplikasi Menggunakan Docker kami. Tutorial ini membahas lebih detail tentang cara mengontainerkan aplikasi machine learning dengan Docker secara ramah pemula. 

Prasyarat

Sebelum mulai menjalankan container NGINX, pastikan Docker telah terpasang. Docker memiliki installer resmi untuk macOS, Windows, dan berbagai distribusi Linux. Dokumentasi Docker menyediakan proses langkah demi langkah untuk setiap sistem operasi. 

Lihat kursus Pengantar Docker kami untuk panduan komprehensif tentang cara memulai dengan Docker. 

Uji instalasi Anda dengan perintah cepat seperti:

docker version
derrickmwiti@Derricks-MacBook-Pro% docker version
Client:
 Version:           28.0.1
 API version:       1.48
 Go version:        go1.23.6
 Git commit:        068a01e
 Built:             Wed Feb 26 10:38:16 2025
 OS/Arch:           darwin/arm64
 Context:           desktop-linux
Server: Docker Desktop 4.39.0 (184744)
 Engine:
  Version:          28.0.1
  API version:      1.48 (minimum version 1.24)
  Go version:       go1.23.6
  Git commit:       bbd0a17
  Built:            Wed Feb 26 10:40:57 2025
  OS/Arch:          linux/arm64
  Experimental:     false
 containerd:
  Version:          1.7.25
  GitCommit:        bcc810d6b9066471b0b6fa75f557a15a1cbf31bb
 runc:
  Version:          1.2.4
  GitCommit:        v1.2.4-0-g6c52b3f
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0Didukung oleh

Jika Anda melihat detail versi, berarti Docker siap digunakan. Selain Docker itu sendiri, Anda memerlukan akses internet untuk menarik image NGINX dari Docker Hub. Jika berencana membuat image sendiri, Anda memerlukan editor teks untuk menulis Dockerfile. Editor teks apa pun bisa, pilih yang paling nyaman untuk Anda.

Menyiapkan NGINX di Container Docker

Menjalankan NGINX dari image siap pakai biasanya merupakan metode tercepat. Anda dapat menariknya dari Docker Hub dalam hitungan detik lalu meluncurkan container. Setelah itu, Anda akan melihat halaman default di browser. Proses singkat ini sering kali menjadi langkah pertama di banyak penyiapan server berbasis Docker.

Menarik image Docker NGINX

Image NGINX resmi tersedia publik di Docker Hub dengan nama nginx. 

Tarik seperti ini:

docker pull nginx
derrickmwiti@Derricks-MacBook-Pro % docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
4c7c1a5bd3af: Download complete 
bef2ee7fab45: Download complete 
d9b636547744: Downloading [======================>                            ]  12.58MB/28.04MB
0994e771ba34: Downloading [===>                                               ]  3.146MB/40.56MB
589701e352f8: Download complete 
13f89c653285: Download complete 
8e77214beb25: Download complete Didukung oleh

Perintah ini menuju ke registry dan mengambil versi terbaru. Setelah selesai, Anda dapat memeriksa bahwa image tersebut ada di mesin Anda:

docker images
derrickmwiti@Derricks-MacBook-Pro% docker images
REPOSITORY                                                                     TAG                                                                           IMAGE ID       CREATED         SIZE

nginx                                                                          latest                                                                        124b44bfc9cc   6 weeks ago     280MB
keras-custom-training-container                                                latest                                                                                                                                     <none>                                                                        7de0f04013e5   7                                                  Didukung oleh

Perintah tersebut menampilkan daftar image di pustaka lokal Anda. Anda seharusnya melihat image nginx di tabel. Itu berarti Anda siap membuat container darinya. Temukan daftar image yang mungkin Anda perlukan untuk proyek data science dari tutorial 12 Image Docker Teratas untuk Machine Learning dan AI kami. 

Menjalankan container NGINX

Setelah image NGINX ada di sistem Anda, Anda dapat memulai container dengan satu perintah:

docker run --name mynginx -p 8080:80 -d nginx
derrickmwiti@Derricks-MacBook-Pro % docker run --name mynginx -p 8080:80 -d nginx
ec44d1a43016e9684b602437b967c0ed8e11c933a8a76b341b68c25168d2af70Didukung oleh

Perintah ini melakukan beberapa hal. Perintah ini menjalankan container bernama mynginx di latar belakang (karena opsi -d). Perintah ini memetakan port 8080 di mesin host Anda ke port 80 di dalam container. Pemetaan port itu berarti Anda dapat mengunjungi http://localhost:8080 di browser dan melihat halaman default NGINX. Container menggunakan image nginx yang ditarik dari Docker Hub.

Container baru seharusnya tetap berjalan karena NGINX aktif. Jika Anda memeriksa log dengan:

docker logs mynginx
derrickmwiti@Derricks-MacBook-Pro % docker logs mynginx
/docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
/docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
/docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
10-listen-on-ipv6-by-default.sh: info: Getting the checksum of /etc/nginx/conf.d/default.conf
10-listen-on-ipv6-by-default.sh: info: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
/docker-entrypoint.sh: Sourcing /docker-entrypoint.d/15-local-resolvers.envsh
/docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
/docker-entrypoint.sh: Launching /docker-entrypoint.d/30-tune-worker-processes.sh
/docker-entrypoint.sh: Configuration complete; ready for start up
2025/03/20 04:33:10 [notice] 1#1: using the "epoll" event method
2025/03/20 04:33:10 [notice] 1#1: nginx/1.27.4
2025/03/20 04:33:10 [notice] 1#1: built by gcc 12.2.0 (Debian 12.2.0-14) 
2025/03/20 04:33:10 [notice] 1#1: OS: Linux 6.10.14-linuxkit
2025/03/20 04:33:10 [notice] 1#1: getrlimit(RLIMIT_NOFILE): 1048576:1048576
2025/03/20 04:33:10 [notice] 1#1: start worker processes
2025/03/20 04:3Didukung oleh

Anda dapat melihat pesan apa pun yang ditulis NGINX. 

Menyajikan Konten Kustom Dengan NGINX

Anda mungkin ingin menyajikan halaman HTML, bukan halaman default yang disertakan dalam image container. Anda dapat membuat file sederhana di mesin lokal lalu me-mount-nya ke dalam container. Ini menjaga konten Anda terpisah dari container. Kapan pun Anda mengutak-atik halaman, Anda bisa menyegarkan browser untuk melihat perubahannya.

Membuat halaman HTML kustom

Pilih lokasi yang nyaman di mesin lokal Anda. Mungkin folder bernama html_content di direktori home Anda. Buat file index.html di sana. Contohnya seperti ini:

<html>
<head>
    <title>My NGINX Page</title>
</head>
<body>
    <h1>Hello from my Docker NGINX setup!</h1>
    <p>This is a custom page served from a local folder.</p>
</body>
</html>Didukung oleh

Itu halaman HTML dasar. Anda bisa menaruh teks atau gaya apa pun yang diinginkan. Tambahkan gambar atau JavaScript, atau apa pun yang sesuai kebutuhan Anda.

Mount halaman HTML ke container NGINX

Image NGINX resmi secara default menyajikan konten dari /usr/share/nginx/html. Anda dapat memetakan folder lokal Anda ke lokasi tersebut di dalam container. Ini dilakukan dengan flag -v (volume) di Docker. Hentikan container bernama mynginx yang ada untuk menghindari konflik port:

docker stop mynginx
docker rm mynginxDidukung oleh

Lalu mulai container baru:

docker run --name mynginx -p 8080:80 -d \
    -v /Users/derrickmwiti/Documents/html_content:/usr/share/nginx/html \
    nginx
6f68085733eeac418c3302e5c580a4f7c5c0c36d3591d8e2a7f35f69f6308d18Didukung oleh

Ganti /path/to/html_content  dengan path sebenarnya di komputer Anda. Dengan cara ini, kapan pun Anda membuka http://localhost:8080, container akan menyajikan file HTML yang Anda tempatkan di html_content. Secara default, jika Anda menamainya index.html, NGINX akan memuat file tersebut secara otomatis.

Pendekatan itu bermanfaat ketika Anda ingin menyesuaikan konten secara berkala. Anda tidak perlu membangun ulang container setiap saat. Server mengambil konten dari folder lokal Anda secara langsung. 

Jika Anda melihat peringatan terkait izin, pastikan pengguna lokal Anda dan Docker dapat membaca folder tersebut. 

Di Linux, itu mungkin berarti menyesuaikan kepemilikan atau izin file. Di Windows atau macOS, itu mungkin berarti memberi Docker izin untuk mengakses drive Anda.

Membangun Image Docker NGINX Kustom

Mount folder lokal adalah solusi cepat untuk pengujian sederhana. Anda mungkin menginginkan modul tambahan, konfigurasi khusus, atau penyesuaian lain. Di sinilah membangun image dapat membantu. 

Docker memudahkan Anda membuat file resep kecil, yang disebut Dockerfile, untuk menyiapkan container persis seperti yang Anda inginkan. Kemudian Anda akan memiliki image yang dapat dibagikan kepada orang lain atau didorong ke registry. Ini bisa lebih nyaman daripada menyuruh orang me-mount banyak file lokal.

Membuat Dockerfile

Dockerfile hanyalah file teks biasa. Anda bisa menamainya Dockerfile atau memilih nama lain jika Anda mau. Letakkan di direktori baru. Berikut contoh sederhana:

FROM nginx:latest

COPY index.html /usr/share/nginx/html/index.htmlDidukung oleh

Ini menggunakan image resmi nginx:latest sebagai basis. Lalu, menyalin file lokal bernama index.html ke folder konten web default di container. Anda bisa menambahkan lebih banyak baris jika diperlukan. Misalnya, Anda dapat menyalin nginx.conf kustom atau menambahkan modul yang ingin diinstal. Itu bergantung pada kebutuhan Anda. Jika Anda hanya ingin menaruh halaman statis, cuplikan di atas sudah cukup.

Setelah Dockerfile siap, tambahkan index.html kustom di folder yang sama. Lalu Anda bisa membangunnya. Perintah yang umum adalah:

docker build -t mynginximage .
[+] Building 2.6s (7/7) FINISHED                                                                                                                                                       docker:desktop-linux
 => [internal] load build definition from Dockerfile                                                                                                                                                   0.0s
 => => transferring dockerfile: 245B                                                                                                                                                                   0.0s
 => [internal] load metadata for docker.io/library/nginx:latest                                                                                                                                        0.0s
 => [internal] load .dockerignore                                                                                                                                                                      0.0s
 => => transferring context: 2B                                                                                                                                                                        0.0s
 => [internal] load build context                                                                                                                                                                      0.0s
 => => transferring context: 365B                                                                                                                                                                      0.0s
 => [1/2] FROM docker.io/library/nginx:latest@sha256:124b44bfc9ccd1f3cedf4b592d4d1e8bddb78b51ec2ed5056c52d3692baebc19                                                                                  2.3s
 => => resolve docker.io/library/nginx:latest@sha256:124b44bfc9ccd1f3cedf4b592d4d1e8bddb78b51ec2ed5056c52d3692baebc19                                                                                  2.3s
 => [2/2] COPY index.html /usr/share/nginx/html/index.html                                                                                                                                             0.0s
 => exporting to image                                                                                                                                                                                 0.1s
 => => exporting layers                                                                                                                                                                                0.0s
 => => exporting manifest sha256:19dd719772fd7ac839fadb7d49862f84422f4571a442994ffaca152e9674553a                                                                                                      0.0s
 => => exporting config sha256:e974f3ab92a0278e419f0fe4c5a6fc43fafb4a75da27895d90c4f2d5d385daa1                                                                                                        0.0s
 => => exporting attestation manifest sha256:e391b0212e5a100bd9132fbbd6cb4052e288dbbcba093839b55f8b197131372b                                                                                          0.0s
 => => exporting manifest list sha256:d35c2bbe10ab0b7e46d1ef8fba6c6cb28628eb9c283db02607e32e95b62e14d5                                                                                                 0.0s
 => => naming to docker.io/library/mynginximage:latest                                                                                                                                                 0.0s
 => => unpacking to docker.io/library/mynginximage:latest                                                                                                                                              0.0sDidukung oleh

Titik di akhir menunjukkan direktori saat ini sebagai konteks build. Docker membaca Dockerfile di direktori itu. Anda akan mendapatkan image bernama mynginximage di sistem lokal Anda. Periksa dengan:

docker images
mynginximage                                                                   latest                                                                        d35c2bbe10ab   36 seconds ago   281MBDidukung oleh

Anda seharusnya melihat nama baru tersebut di daftar. Pendekatan ini berarti Dockerfile dan HTML Anda digabungkan menjadi satu image. Anda tidak perlu me-mount apa pun saat runtime.

Membangun dan menjalankan image kustom

Sekarang setelah Anda memiliki mynginximage yang sudah dibangun, Anda bisa menjalankannya:

docker run --name mycustomnginx -p 8080:80 -d mynginximageDidukung oleh

Pastikan untuk menghentikan container sebelumnya agar tidak terjadi konflik port. 

Container ini otomatis menyajikan halaman yang Anda tempatkan di Dockerfile. Jika Anda membuka browser ke http://localhost:8080, Anda akan melihat teks HTML tersebut. 

Anda dapat membagikan Dockerfile Anda kepada orang lain atau mendorong image yang telah dibangun ke registry. Dengan begitu, rekan tim atau kolega dapat menjalankannya tanpa menyalin folder lokal.

Itu melengkapi proses membangun image NGINX kustom minimal. Anda mulai dari basis resmi, menyalin satu-dua file, dan menghasilkan container baru yang memuat situs kustom Anda. Anda dapat memperluas Dockerfile lebih jauh. Misalnya, Anda mungkin ingin mengganti konfigurasi untuk menangani PHP dengan php-fpm dalam build multi-tahap atau menambahkan modul kustom yang tidak disertakan NGINX secara default.

Pendekatan ini menonjolkan fleksibilitas Docker: setiap layer dalam Dockerfile dapat menangani tugas tertentu, dan image final dapat didistribusikan dengan mudah. Anda memiliki kendali atas konten web, plus opsi untuk menyetel konfigurasi agar container sesuai dengan proyek Anda. 

Jelajahi 10 Ide Proyek Docker ini untuk belajar Docker lewat proyek praktis yang berfokus pada pembangunan dan pengoptimalan aplikasi data science.

Menyiapkan NGINX sebagai Reverse Proxy

NGINX dapat mengarahkan permintaan yang masuk ke layanan lain di sistem yang sama atau bahkan ke layanan yang berjalan pada mesin terpisah. Ini biasanya disebut pengaturan reverse proxy. Anda mungkin menempatkan NGINX di depan sekelompok aplikasi sehingga permintaan melewati satu titik masuk.

Ini umum ketika Anda memiliki banyak container Docker yang mendengarkan pada port berbeda, dan Anda menginginkan satu nama domain untuk semuanya. NGINX mendengarkan pada port standar, seperti 80 atau 443, lalu merutekan trafik ke layanan yang tepat berdasarkan path, hostname, atau faktor lainnya.

Memahami reverse proxy

Ketika NGINX dikonfigurasi seperti ini, klien tidak mengetahui komunikasi di latar belakang. NGINX bertindak sebagai wajah publik, menerima dan meneruskan permintaan lalu mengirimkan respons kembali ke klien. 

Desain ini menyederhanakan struktur jaringan Anda. Ini juga memberi kesempatan untuk menyesuaikan caching, menambahkan sertifikat TLS, menangani load balancing, atau melakukan tugas lanjutan lainnya. Sering kali lebih mudah mengelola tugas-tugas ini di satu tempat, daripada menyebarkannya di banyak layanan.

Skenario umum mungkin melibatkan container yang menjalankan NGINX pada port 80, yang mengirim permintaan ke container aplikasi pada port 3000. Sementara klien mengunjungi http://yourdomain.com, trafik diarahkan ke container terpisah di balik layar. 

Itu memungkinkan container aplikasi Anda mempertahankan port defaultnya, dengan overhead minimal bagi pengguna. Alasan lain melakukan ini adalah Anda mungkin ingin menyembunyikan detail internal layanan Anda atau menyajikan struktur URL yang seragam.

Mengonfigurasi NGINX untuk reverse proxy

Untuk mencapainya, Anda memerlukan file konfigurasi untuk NGINX kustom yang menggunakan direktif proxy. Anda bisa melakukannya dengan me-mount file konfigurasi baru saat menjalankan container, atau dengan membangun image kustom yang menyertakannya. Berikut contoh sederhana untuk mengilustrasikan gagasan umum:

server {
    listen 80;

    location / {
        proxy_pass http://myapp:3000/;
    }
}Didukung oleh

Pada cuplikan di atas, setiap permintaan yang tiba di container NGINX Anda pada port 80 akan dikirim ke myapp:3000. Nama myapp menunjukkan ada container lain yang dapat dijangkau dengan nama itu, yang umum saat Anda menggunakan jaringan Docker. 

Jika Anda menggunakan container berdiri sendiri, Anda dapat memetakan alamat IP container atau menggunakan IP host. Anda juga dapat menambahkan pengaturan yang lebih lanjut, seperti proxy_set_header Host $host, atau menyesuaikan nilai timeout agar sesuai dengan aplikasi Anda.

Jika Anda memilih untuk me-mount file ini saat runtime, Anda dapat melakukan sesuatu seperti ini:

docker run --name nginxproxy -p 8080:80 -d \
    -v /path/to/nginx.conf:/etc/nginx/conf.d/default.conf \
    --network mynetwork \
    nginxDidukung oleh

Perintah ini menjalankan container NGINX, me-mount nginx.conf lokal Anda sebagai konfigurasi default. Perintah ini juga menghubungkan container ke jaringan Docker bernama mynetwork, tempat container lain Anda (myapp) berada. Itu sering menjadi pendekatan paling sederhana jika Anda ingin menyimpan konfigurasi di luar container. 

Anda juga dapat menaruh file itu ke dalam Dockerfile jika menginginkan pengaturan statis. Keduanya bisa berfungsi, selama referensi sesuai dengan penamaan container dan jaringan Anda.

Desain ini memberi Anda kemampuan untuk memiliki satu domain atau IP untuk semua layanan web Anda, bersama dengan port umum. Jika Anda menangani banyak container back-end, Anda bisa mendefinisikan beberapa lokasi di konfigurasi, masing-masing menunjuk ke port container yang berbeda. NGINX kemudian dapat merutekan ke setiap layanan berdasarkan path URL. Ini adalah pendekatan populer untuk microservices karena mengonsolidasikan titik masuk secara rapi.

Menggunakan Docker Compose untuk Deployment NGINX

Reverse proxy sering menjadi lebih berguna ketika Anda memiliki beberapa container yang bekerja bersama. Docker Compose adalah alat yang memungkinkan Anda mendefinisikan banyak layanan dalam satu file. Lalu, Anda dapat menyalakan atau mematikannya dengan satu perintah. Ini mengurangi kemungkinan kesalahan dalam pembuatan container atau pemetaan port karena semua detail tersimpan di file standar.

Pengantar Docker Compose

Docker Compose memungkinkan Anda mengelola sekumpulan container. Anda mendeskripsikan setiap layanan, menentukan image yang digunakan, port yang dipublikasikan, volume yang di-mount, dan jaringan yang diikuti. Lalu satu perintah sederhana (docker compose up -d) akan memulai semuanya sekaligus. 

Pendekatan ini praktis untuk pengembangan lokal atau lingkungan staging di mana Anda perlu mengoordinasikan banyak container Docker. Format file yang biasa digunakan adalah YAML.

Meskipun Docker Compose dapat digunakan di berbagai sistem operasi, pastikan bahwa alat ini telah terpasang dan dikenali. Instalasi Docker Desktop modern sering kali sudah menyertakannya. Periksa versi Anda dengan:

docker compose version
Docker Compose version v2.33.1-desktop.1Didukung oleh

Jika Anda melihat detail versi, Anda siap melanjutkan. Jika tidak, lihat dokumentasi Docker tentang cara mengaktifkan atau memasang Docker Compose.

Membuat file docker-compose.yml

File ini biasanya mencakup bagian services. Berikut contoh sederhana file docker-compose.yml yang menyiapkan satu container NGINX untuk menyajikan konten statis: 

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/htmlDidukung oleh

Berikut cara menafsirkan file tersebut:

• services: Mendefinisikan layanan (container) yang membentuk aplikasi Anda.

• web: Layanan ini menggunakan image NGINX terbaru.
• ports: Memetakan port 80 di dalam container ke port 8080 di mesin host Anda. Ini memungkinkan Anda mengakses server web melalui http://localhost:8080.
• volumes: Me-mount direktori lokal html ke direktori konten default NGINX di dalam container (/usr/share/nginx/html). Penyiapan ini memungkinkan NGINX menyajikan konten statis kustom Anda.

Mendeploy layanan dengan Docker Compose

Di direktori yang sama dengan file docker-compose.yml Anda, buat subdirektori bernama html.

Tempatkan file HTML statis Anda (misalnya, index.html) di dalam direktori html ini. Dalam kasus ini, saya membuat halaman bergaya Bootstrap sederhana untuk demonstrasi. 

Buka terminal dan arahkan ke direktori proyek Anda yang memuat file docker-compose.yml.

Jalankan perintah berikut untuk memulai layanan:

docker compose up -d
[+] Running 1/1
 ✔ Container html_content-web-1  Started Didukung oleh

Flag -d menjalankan container dalam mode detached, memungkinkan berjalan di latar belakang.

Docker Compose melihat file docker-compose.yml di direktori saat ini. Ia menarik image yang belum ada lalu meluncurkan setiap container. 

Buka browser web Anda dan arahkan ke http://localhost:8080.

Anda seharusnya melihat konten statis Anda disajikan oleh NGINX.

Anda dapat memeriksa status layanan yang berjalan dengan mengecek:

docker compose psDidukung oleh

Jika Anda perlu membongkar semuanya, satu perintah dapat menghapus container:

docker compose downDidukung oleh

Perintah itu menghentikan dan menghapus semuanya sekaligus. Jika Anda ingin mereplikasi seluruh lingkungan, cukup salin file Docker Compose dan kode terkait ke mesin baru, lalu jalankan perintah yang sama. Ini memastikan Anda mendapatkan hasil yang konsisten dengan langkah manual minimal.

Mengelola Container NGINX

Walaupun pendekatan Docker Compose populer untuk alur kerja multi-layanan, terkadang Anda hanya perlu mengelola satu container atau klaster kecil. Docker menyediakan beberapa perintah dasar yang membantu Anda melihat apa yang berjalan, menjeda atau menghentikan container, dan menghapusnya jika diperlukan. 

Ini penting untuk pekerjaan pemeliharaan, terutama jika Anda bereksperimen dengan banyak container NGINX atau build berulang.

Melihat container yang berjalan

Kapan pun Anda ingin melihat container mana yang berjalan, Anda dapat menggunakan:

docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                  NAMES
2d386c085129   mynginximage   "/docker-entrypoint.…"   4 minutes ago   Up 4 minutes   0.0.0.0:8080->80/tcp   mycustomnginxDidukung oleh

Perintah itu mencetak tabel container aktif, masing-masing dengan ID, image, nama, dan lainnya. Jika Anda perlu melihat semua container, termasuk yang telah berhenti, gunakan:

docker ps -aDidukung oleh

Perintah ini menampilkan setiap container yang ada di sistem Anda, bahkan yang sudah keluar. Ini sering membantu untuk melihat container mana yang masih ada dari run sebelumnya. Anda mungkin memiliki container bernama mynginx, mycustomnginx, atau lainnya jika Anda telah bereksperimen dengan banyak image.

Menghentikan dan menghapus container

Saat selesai dengan sebuah container, Anda dapat menghentikannya berdasarkan nama:

docker stop mynginx
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                  NAMES
2d386c085129   mynginximage   "/docker-entrypoint.…"   4 minutes ago   Up 4 minutes   0.0.0.0:8080->80/tcp   mycustomnginxDidukung oleh

Perintah itu memberi tahu Docker untuk mengirim sinyal stop ke container, yang seharusnya membuat NGINX berhenti dengan rapi. Jika Anda ingin menghapus container sesudahnya, Anda bisa menjalankan:

docker rm mynginxDidukung oleh

Jika Anda lebih suka satu perintah yang menghentikan dan menghapus sekaligus, coba:

docker rm -f mynginxDidukung oleh

Perintah itu memaksa penghapusan, menghentikan container jika masih berjalan. Berhati-hatilah saat menggunakan pendekatan itu di lingkungan produksi, karena ini menghentikan container tanpa memberi waktu shutdown yang anggun. Perintah pemeliharaan lain adalah docker rmi, yang menghapus image dari sistem Anda. 

Itu berguna jika Anda tidak lagi membutuhkan image tertentu dan ingin mengosongkan ruang. Namun, Docker hanya menghapus image yang tidak digunakan oleh container yang sedang berjalan.

Kesimpulan

NGINX di Docker adalah cara praktis untuk menyajikan halaman web atau merutekan trafik ke layanan lain. Anda dapat menjalankan image resmi atau membangun sendiri dengan Dockerfile sederhana. Docker Compose dapat mengoordinasikan banyak container, sehingga penyiapan kompleks lebih mudah ditangani. 

Dengan metode-metode ini, Anda dapat menyajikan konten, menangani penerusan, dan mempertahankan lingkungan yang andal untuk proyek web. 

Jika Anda membutuhkan pendekatan lebih praktis untuk mempelajari Docker, lihat Kursus Pengantar Docker kami untuk mengetahui pentingnya dalam perangkat kerja profesional data.