Cara Install Strapi Menggunakan Docker di Ubuntu 24.04

Pengantar

Seiring berkembangnya aplikasi web modern, kebutuhan akan Content Management System (CMS) yang fleksibel dan mudah diintegrasikan dengan berbagai platform juga semakin meningkat. Salah satu solusi yang banyak dipilih oleh developer adalah Strapi, yaitu Headless CMS berbasis Node.js yang memungkinkan Anda mengelola konten melalui dashboard yang intuitif sekaligus menyediakan REST API maupun GraphQL API secara otomatis.

Salah satu cara terbaik untuk menjalankan Strapi adalah menggunakan Docker. Dengan Docker, proses instalasi menjadi lebih cepat, lingkungan aplikasi lebih konsisten, serta lebih mudah dipindahkan atau di-deploy ke server lain. Selain itu, penggunaan container juga membantu mengurangi konflik dependensi yang sering terjadi pada instalasi manual dan mempermudah proses pembaruan maupun pemeliharaan aplikasi.

Pada artikel ini, Anda akan mempelajari cara install Strapi menggunakan Docker di Ubuntu 24.04 secara bertahap, mulai dari menyiapkan server, menginstal Docker dan Docker Compose, membuat container Strapi, hingga mengakses dashboard administrator untuk pertama kalinya.

Mengapa Menggunakan Docker untuk Strapi?

Sebelum memulai proses instalasi, penting untuk memahami alasan mengapa banyak developer memilih menjalankan Strapi menggunakan Docker. Selain mempermudah proses deployment, Docker juga membuat pengelolaan aplikasi menjadi lebih praktis dan efisien.

Berikut beberapa keuntungan menggunakan Docker untuk menjalankan Strapi:

Instalasi lebih cepat. Anda tidak perlu mengatur lingkungan Node.js beserta dependensinya secara manual karena seluruh kebutuhan aplikasi sudah dikemas di dalam container.
Lingkungan aplikasi lebih konsisten. Konfigurasi yang digunakan akan tetap sama meskipun aplikasi dijalankan di server, komputer lokal, maupun lingkungan production.
Memudahkan backup dan migrasi. Data aplikasi serta konfigurasi container dapat dipindahkan ke server lain dengan proses yang lebih sederhana.
Proses update lebih praktis. Pembaruan versi Strapi maupun image Docker dapat dilakukan tanpa harus menginstal ulang seluruh lingkungan aplikasi.
Cocok untuk berbagai kebutuhan. Docker dapat digunakan baik untuk lingkungan development maupun production sehingga memudahkan proses pengembangan hingga implementasi aplikasi.

Dengan berbagai keunggulan tersebut, Docker menjadi salah satu metode yang direkomendasikan untuk menginstal dan menjalankan Strapi, terutama jika Anda menginginkan proses deployment yang lebih mudah, konsisten, dan mudah dikelola.

Persiapan Server

Spesifikasi minimum server yang disarankan:

Prosesor: Minimal 1 vCPU (disarankan 2 vCPU atau lebih).
RAM: Minimal 2 GB (disarankan 4 GB atau lebih untuk lingkungan production).
Penyimpanan: Minimal 20 GB SSD (disarankan 40 GB atau lebih agar tersedia ruang yang cukup untuk image Docker, container, dan data aplikasi).
Sistem Operasi: Ubuntu Server 24.04 LTS.
Jaringan: Koneksi internet yang stabil untuk mengunduh image Docker dan dependensi yang diperlukan.
Docker: Pastikan Docker telah terinstal pada server. Jika belum, Anda dapat mengikuti panduan Cara Install Docker di Ubuntu 24.04.

Install Node.js 22 LTS

Menambahkan Repository NodeSource
Secara bawaan, Ubuntu 24.04 masih menggunakan Node.js versi 18, sedangkan Strapi v5 membutuhkan minimal Node.js 20. Oleh karena itu, gunakan repository resmi NodeSource untuk menginstal Node.js 22 LTS.

Tambahkan repository NodeSource dengan menjalankan perintah berikut.
```
curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
```
Keterangan:
Perintah di atas akan menambahkan repository NodeSource ke sistem sehingga paket Node.js yang diinstal berasal dari repository resmi NodeSource.
Menginstal Node.js 22 LTS
Setelah repository berhasil ditambahkan, lanjutkan proses instalasi Node.js menggunakan perintah berikut.
```
apt install -y nodejs
```
Keterangan:
Perintah tersebut akan menginstal Node.js beserta npm (Node Package Manager) yang diperlukan untuk mengelola package dan dependensi aplikasi Strapi.
Memverifikasi Instalasi Node.js
Pastikan proses instalasi telah berhasil dengan memeriksa versi Node.js, npm, dan npx.
```
node -v
npm -v
npx -v
```
Contoh hasil yang ditampilkan:
```
v22.23.1
10.9.8
10.9.8
```
Keterangan:
Apabila ketiga perintah menampilkan nomor versi seperti contoh di atas, berarti Node.js, npm, dan npx telah berhasil diinstal. Server kini siap digunakan untuk proses instalasi Strapi v5.

Membuat Project Strapi

Membuat Direktori Project Strapi
Buat direktori yang akan digunakan sebagai lokasi penyimpanan seluruh file aplikasi Strapi.
```
mkdir ~/strapi
cd ~/strapi
```
Keterangan:
Perintah mkdir digunakan untuk membuat direktori baru, sedangkan cd digunakan untuk berpindah ke direktori tersebut sebelum memulai proses instalasi.
Menjalankan Installer Strapi
Setelah berada di dalam direktori project, jalankan installer resmi Strapi menggunakan perintah berikut.
```
npx create-strapi@latest .
```
Keterangan:
Tanda titik (.) di akhir perintah menunjukkan bahwa Strapi akan diinstal pada direktori saat ini, sehingga tidak membuat folder baru.
Menjawab Pertanyaan Selama Instalasi
Selama proses instalasi berlangsung, installer akan menampilkan beberapa pertanyaan konfigurasi.

Apabila muncul pertanyaan berikut:
```
Please log in or sign up
```
Pilih:
```
Skip
```
Selanjutnya gunakan konfigurasi berikut:
- Default database : Yes
- Example structure : Yes
- Typescript : Yes
- Install dependencies : Yes
- Initialize Git : Yes
Keterangan:
Konfigurasi tersebut akan membuat project Strapi menggunakan database SQLite bawaan, struktur contoh (example project), dukungan TypeScript, menginstal seluruh dependensi secara otomatis, serta menginisialisasi repository Git.
Memastikan Instalasi Berhasil
Tunggu hingga seluruh proses instalasi selesai. Kecepatan instalasi bergantung pada spesifikasi server dan koneksi internet.

Apabila berhasil, akan muncul pesan seperti berikut:
```
Strapi  Your application was created!
```
Keterangan:
Munculnya pesan tersebut menandakan bahwa proses instalasi Strapi telah berhasil diselesaikan dan aplikasi siap dijalankan.

Menjalankan Strapi

Menjalankan Strapi
Setelah proses instalasi selesai, jalankan Strapi untuk memastikan project berhasil dibuat dan dapat berjalan dengan baik.
```
npm run develop
```
Keterangan:
Perintah npm run develop akan menjalankan Strapi dalam mode pengembangan (development mode). Pada mode ini, setiap perubahan konfigurasi atau kode akan langsung diterapkan tanpa perlu menjalankan ulang aplikasi.
Memastikan Strapi Berhasil Berjalan
Tunggu hingga proses startup selesai. Apabila berhasil, terminal akan menampilkan informasi seperti berikut.
```
Strapi started successfully
```
Keterangan:
Pesan tersebut menunjukkan bahwa aplikasi Strapi telah berhasil dijalankan dan siap menerima koneksi dari browser.
Mengakses Dashboard Administrator
Setelah Strapi berhasil dijalankan, buka browser kemudian akses alamat berikut.
```
http://IP_SERVER:1337/admin
```
Apabila berhasil, halaman administrator Strapi akan tampil. Pada saat pertama kali mengakses dashboard, Anda akan diminta membuat akun administrator dengan mengisi nama, alamat email, dan password.

Keterangan:
Pastikan port 1337 telah diizinkan pada firewall server agar dashboard Strapi dapat diakses dari browser.

Membuat Dockerfile

Membuat File Dockerfile
Setelah memastikan project Strapi berjalan dengan normal, langkah berikutnya adalah membuat file Dockerfile. File ini digunakan sebagai panduan Docker untuk membangun image aplikasi Strapi.
```
nano Dockerfile
```
Masukkan konfigurasi berikut ke dalam file Dockerfile.
```
FROM node:22-bookworm

WORKDIR /opt/app

COPY package*.json ./

RUN npm install

COPY . .

RUN npm run build

EXPOSE 1337

CMD ["npm", "run", "start"]
```
Setelah selesai, simpan file dengan menekan CTRL + X, kemudian tekan Y, lalu tekan Enter.

Penjelasan konfigurasi:
- FROM node:22-bookworm menggunakan image Node.js 22 berbasis Debian Bookworm.
- WORKDIR /opt/app menentukan direktori kerja di dalam container.
- COPY package*.json ./ menyalin file package.json dan package-lock.json ke dalam container.
- RUN npm install menginstal seluruh dependensi aplikasi.
- COPY . . menyalin seluruh source code Strapi ke dalam container.
- RUN npm run build membangun aplikasi agar siap dijalankan pada mode production.
- EXPOSE 1337 membuka port 1337 yang digunakan oleh Strapi.
- CMD ["npm", "run", "start"] menjalankan Strapi saat container dijalankan.
Catatan:
Pada pengujian artikel ini digunakan image node:22-bookworm. Penggunaan image node:22-alpine menyebabkan proses npm install gagal karena dependensi sharp tidak dapat dibangun dengan benar. Oleh karena itu, disarankan menggunakan node:22-bookworm agar proses build Strapi berjalan lebih stabil.

Membuat File .dockerignore

Membuat File .dockerignore
Selanjutnya, buat file .dockerignore. File ini digunakan untuk menentukan file atau direktori yang tidak perlu disalin ke dalam image Docker saat proses build.
```
nano .dockerignore
```
Masukkan konfigurasi berikut ke dalam file .dockerignore.
```
node_modules
dist
.tmp
.cache
.git
```
Setelah selesai, simpan file dengan menekan CTRL + X, kemudian tekan Y, lalu tekan Enter.

Penjelasan setiap direktori:
- node_modules berisi seluruh package hasil instalasi npm yang akan dibuat kembali saat proses build.
- dist merupakan hasil build aplikasi yang akan dibuat ulang di dalam container.
- .tmp berisi file sementara (temporary files).
- .cache digunakan sebagai penyimpanan cache yang tidak diperlukan di dalam image.
- .git berisi riwayat repository Git yang tidak perlu disertakan ke dalam container.
Keterangan:
Penggunaan file .dockerignore membuat proses build Docker menjadi lebih cepat dan efisien karena file maupun direktori yang tidak diperlukan tidak ikut disalin ke dalam image. Selain itu, ukuran image yang dihasilkan juga menjadi lebih kecil.

Membuat docker-compose.yml

Membuat File Docker Compose
Setelah Dockerfile selesai dibuat, langkah berikutnya adalah membuat file docker-compose.yml. File ini digunakan untuk mengatur konfigurasi container Strapi agar lebih mudah dijalankan dan dikelola.
```
nano docker-compose.yml
```
Masukkan konfigurasi berikut ke dalam file docker-compose.yml.
```
services:
  strapi:
    build: .
    container_name: strapi
    restart: unless-stopped

    ports:
      - "1337:1337"

    environment:
      NODE_ENV: production

    volumes:
      - ./public/uploads:/opt/app/public/uploads
      - ./.tmp:/opt/app/.tmp
```
Setelah selesai, simpan file dengan menekan CTRL + X, kemudian tekan Y, lalu tekan Enter.

Penjelasan konfigurasi:
- build: . membangun image Docker menggunakan Dockerfile yang berada pada direktori saat ini.
- container_name: strapi memberikan nama container menjadi strapi.
- restart: unless-stopped membuat container otomatis berjalan kembali setelah server restart, kecuali dihentikan secara manual.
- ports memetakan port 1337 pada host ke port 1337 di dalam container.
- NODE_ENV: production menjalankan Strapi dalam mode production.
- ./public/uploads:/opt/app/public/uploads menyimpan file upload di luar container agar tidak hilang ketika container dibuat ulang.
- ./.tmp:/opt/app/.tmp menyimpan file sementara Strapi pada host.
Keterangan:
Dengan menggunakan Docker Compose, proses menjalankan, menghentikan, maupun memperbarui container menjadi lebih mudah karena seluruh konfigurasi disimpan dalam satu file.
Membangun Docker Image
Setelah file docker-compose.yml selesai dibuat, bangun Docker image menggunakan perintah berikut.
```
docker compose build --no-cache
```
Parameter --no-cache digunakan agar Docker membangun image dari awal tanpa menggunakan cache sehingga seluruh perubahan pada project ikut diterapkan.

Apabila proses build berhasil, akan muncul pesan serupa berikut.
```
Image strapi-strapi Built
```
Keterangan:
Munculnya pesan tersebut menandakan bahwa Docker image Strapi berhasil dibuat dan siap digunakan untuk menjalankan container.

Menjalankan Container

Menjalankan Container Strapi
Setelah Docker image berhasil dibuat, jalankan container Strapi menggunakan Docker Compose.
```
docker compose up -d
```
Keterangan:
Parameter -d (detached mode) membuat container berjalan di latar belakang sehingga terminal tetap dapat digunakan untuk menjalankan perintah lainnya.
Memastikan Container Berjalan
Pastikan container Strapi telah berhasil dijalankan dengan menjalankan perintah berikut.
```
docker ps
```
Apabila pada kolom STATUS menampilkan informasi Up, berarti container Strapi telah berjalan dengan baik.

Keterangan:
Selain status Up, pastikan container menggunakan port 1337 sesuai konfigurasi pada file docker-compose.yml.
Melihat Log Container
Apabila ingin memantau proses startup atau mencari penyebab apabila terjadi error, lihat log container menggunakan perintah berikut.
```
docker compose logs -f
```
Keterangan:
Parameter -f (follow) akan menampilkan log secara real-time sehingga Anda dapat memantau aktivitas Strapi saat container berjalan.
Mengakses Dashboard Administrator Strapi
Setelah container berjalan dengan normal, buka browser kemudian akses halaman administrator Strapi melalui alamat berikut.
```
http://IP_SERVER:1337/admin
```
Apabila berhasil, halaman Create your first administrator akan ditampilkan. Pada tahap ini, buat akun administrator dengan melengkapi informasi berikut.
- First Name
- Last Name
- Email
- Password
Setelah seluruh data terisi, klik tombol Let's Start. Strapi akan menyimpan akun administrator dan mengarahkan Anda ke dashboard utama.

Keterangan:
Apabila halaman administrator tidak dapat diakses, pastikan container masih berstatus Up, port 1337 telah dibuka pada firewall, serta tidak sedang digunakan oleh aplikasi lain di server.
Memastikan Dashboard Strapi Berhasil Diakses
Setelah proses registrasi administrator selesai, dashboard Strapi akan ditampilkan seperti gambar berikut.

Melalui dashboard ini, Anda dapat mulai mengelola aplikasi Strapi, antara lain:
- Membuat dan mengelola Content Type.
- Menambahkan, mengubah, maupun menghapus konten.
- Mengelola Media Library untuk menyimpan gambar dan file.
- Mengatur pengguna (Users) beserta hak akses (Roles & Permissions).
- Melakukan konfigurasi plugin dan pengaturan aplikasi Strapi.
Keterangan:
Jika dashboard berhasil ditampilkan tanpa kendala, berarti Strapi telah berhasil dijalankan menggunakan Docker dan siap digunakan sebagai Headless CMS untuk kebutuhan pengembangan website maupun aplikasi.

Tips

Gunakan Node.js 22 LTS agar kompatibel dengan Strapi v5 dan memperoleh dukungan pembaruan jangka panjang (LTS).
Disarankan menggunakan image node:22-bookworm dibandingkan node:22-alpine karena lebih kompatibel dengan dependensi seperti sharp sehingga proses build dan instalasi berjalan lebih stabil.
Pastikan port 1337 telah diizinkan pada firewall server maupun Security Group apabila menggunakan layanan cloud agar dashboard Strapi dapat diakses dari browser.
Setelah deployment berhasil, sebaiknya gunakan Nginx Reverse Proxy yang dikombinasikan dengan sertifikat SSL (HTTPS) agar koneksi ke aplikasi lebih aman dan dapat diakses menggunakan nama domain tanpa menampilkan nomor port.
Untuk lingkungan produksi, gunakan database seperti PostgreSQL atau MySQL/MariaDB sebagai pengganti SQLite agar memperoleh performa, keandalan, dan skalabilitas yang lebih baik.
Lakukan backup secara berkala terhadap database dan direktori public/uploads agar data serta file yang telah diunggah dapat dipulihkan apabila terjadi kegagalan sistem.
Selalu gunakan image Docker dan versi Strapi terbaru yang stabil untuk memperoleh pembaruan fitur, peningkatan performa, dan perbaikan keamanan.

Kesimpulan

Menginstal Strapi menggunakan Docker di Ubuntu 24.04 merupakan solusi yang praktis untuk membangun lingkungan aplikasi yang konsisten, mudah dikelola, dan mudah dipindahkan ke server lain. Pada Strapi v5, proses instalasi memang sedikit berbeda dibandingkan versi sebelumnya karena project perlu dibuat terlebih dahulu menggunakan Node.js sebelum dikemas menjadi Docker image.

Dengan mengikuti panduan ini, Anda telah mempelajari cara menginstal Node.js, membuat project Strapi, menguji aplikasi dalam mode pengembangan, membangun Docker image, hingga menjalankan Strapi menggunakan Docker Compose. Pendekatan ini memudahkan proses deployment, pembaruan aplikasi, serta pengelolaan lingkungan pengembangan maupun produksi.

Untuk penggunaan pada server produksi, disarankan mengombinasikan Strapi dengan reverse proxy seperti Nginx, menggunakan sertifikat SSL (HTTPS), serta memanfaatkan database PostgreSQL atau MySQL/MariaDB agar aplikasi memiliki performa, keamanan, dan skalabilitas yang lebih baik.