Ikhtisar:

• Menyiapkan Roxy Linux Container Management
• Mengelola container, image dan pod dengan Podman
• Menyiapkan rootless service dengan systemd
• Mengelola Podman secara remote

Tulisan ini diawali dengan penjelasan secara singkat proses instalasi Roxy Linux sebagai server container. Alasan penulis menggunakan RoxyLinux adalah karena dukungan dari pengembang distro ini cukup panjang hingga 10 tahun, selain itu proses instalasi dan konfigurasinya cukup simpel. Untuk memudahkan pengelolaan, server dilengkapi dengan antarmuka berbasis web bernama Cockpit.

Podman adalah container management yang digunakan untuk membuat, menjalankan dan mengelola container. Podman singkatan dari Pod Manager. Pod adalah konsep yang populer dalam projek Kubernetes, pod memuat satu atau lebih container yang saling bekerja sama, berbagi sumber daya yang sama, dengan pod ini proses deploy container di Kubernetes menjadi lebih mudah.

Salah satu hal penting di server Linux adalah service yang menjalankan aplikasi secara otomatis saat komputer menyala dan berjalan di background. Rootless service, sesuai namanya tanpa root, yaitu menjalankan service dengan user biasa, dengan menggunakan rootless sistem menjadi lebih aman. Di sini akan saya sajikan cara menjalankan Podman menggunakan systemd secara rootless.

Menyiapkan Roxy Linux Container Management

Roxy Linux adalah sebuah distribusi Linux yang diinisiasi oleh Co-founder CentOS Gregory Krutzer pada tahun 2021. Alasan dibuatnya distribusi ini adalah karena pada 8 Desember 2020 RedHat mengumumkan akan menghentikan pengembangan CentOS. Roxy Linux adalah sistem operasi enterprise open source yang didesain 100% bug-for-bug dengan RedHat Enterprise Linux.

Roxy Linux didistribusikan dalam tiga paket ISO, yaitu: Minimal, DVD dan Boot. Penulis menggunakan Boot ISO dengan pilihan mode Server dan paket tambahan Container Management. Setelah proses instalasi selesai, Podman sudah terpasang, tinggal melakukan beberapa konfigurasi yang akan saya jelaskan kemudian.

Untuk memudahkan dalam pengelolaan server bisa mengaktifkan Cockpit, dengan menjalankan perintah:

sudo systemctl enable --now cockpit.socket

Selain menggunakan Cockpit, administrasi server Linux yang paling populer menggunakan SSH. Anda dapat me-remote server tanpa password (passwordless), passwordless diperlukan untuk mengelola Podman secara remote, yang akan saya jelaskan di bagian akhir tulisan ini.

Langkah-langkah membuat koneksi SSH tanpa password:

Buat SSH key dengan perintah:

ssh-keygen -t rsa

Buka Cockpit: https://[server_address]:9090, kemudian login dengan user linux yang telah dibuat sebelumnya. Klik menu Account di samping kiri, klik nama anda, pada Authorized public SSH keys klik tombol Add key, masukkan isi teks id_rsa.pub yang telah dibuat menggunakan ssh-keygen, lalu simpan. Sekarang anda bisa login ke server dengan mode password less.

Sekarang anda dapat login SSH ke server tanpa menggunakan password menggunakan Putty atau SSH client di Windows, Windows 11 sudah disertai SSH client.

Mengelola container, image dan pod dengan Podman

Podman dikembangkan untuk meningkatkan desain dari Docker. Berikut perbandingan antara Podman dengan Docker:

Fitur Podman yang paling signifikan adalah kemampuan berjalan dalam mode rootless.

Menjalankan Podman Mode Rootless dengan Systemd

loginctl enable-linger
systemctl --user enable --now podman.socket
podman --remote info
mkdir -p $HOME/.config/systemd/user
podman generate systemd myapp > $HOME/.config/systemd/user/myapp.service
systemctl --user enable --now myapp

Mengelola Podman secara remote

Podman juga dapat di kelola secara remote, penulis me-remote Podman menggunakan terminal Windows 11. Langkah-langkah mengaktifkan Podman remote sebagai berikut:

Install Podman di Windows, saya menggunakan Podman versi yang sama dengan server yaitu 4.2.0. Podman for Windows dapat diunduh di: GitHub.

Buat koneksi Podman ke server dengan perintah seperti berikut (hanya contoh, tiap user tidak sama):

podman system connection add suyadi --identity c:\Users\Suyadi\.ssh\id_rsa ssh://suyadi@192.168.1.2:22/run/user/1000/podman/podman.sock

Keterangan:

• suyadi adalah nama koneksi
• c:\Users\Suyadi\.ssh\id_rsa adalah file yang dibuat dengan perintah ssh-keygen -t rsa
• /run/user/1000/podman/podman.sock adalah file socket Podman untuk user suyadi.

Test koneksi dengan perintah:

podman -c suyadi info

Apabila muncul kira-kira seperti berikut, berarti Podman remote sudah siap digunakan, semua perintah Podman bisa dijalankan secara remote:

...
version:
  APIVersion: 4.2.0
  Built: 1668531608
  BuiltTime: Tue Nov 15 12:00:08 2022
  GitCommit: ""
  GoVersion: go1.18.4
  Os: linux
  OsArch: linux/amd64
  Version: 4.2.0

GitLab merupakan platform DevOps yang cukup lengkap, semua proses pengembangan hingga deployment dapat diotomasi. Dengan otomasi ini, pengembangan dan perbaikan perangkat lunak dapat dilakukan dengan cepat. Apabila ada bug dari program baru, mudah untuk melakukan rollback ke versi sebelumnya.

Skenario DevOps dengan GitLab dapat diatur sendiri, contohnya akan kami paparkan dalam tulisan ini.

Skenario: Ketika pengembang mebuat sebuah tag baru, GitLab membuat job tertentu misalnya build. Kemudian Gitlab Runner akan mengerjakan job tersebut dengan membuild Docker Image lalu melakukan push ke Docker Registry.

Prasyarat

• Docker Registry. Docker registry adalah sebuah repositori yang menyimpan Docker Image yang nantinya akan diunduh dan dijalankan oleh server produksi. GitLab dapat digunakan sebagai docker registry, cara mengaktifkan dapat dilihat di sini.
• Gitlab Runner. Gitlab Runner adalah perangkat lunak open source yang digunakan untuk menjalankan job dan mengirim hasilnya ke Gitlab. Dokumentasi Gitlab Runner dapat dilihat di sini.

Langkah-langkah

Menjalankan GitLab Runner Register

Penulis menggunakan Docker sebagai eksekutor dengan menjalankan perintah seperti berikut:

sudo gitlab-runner register -n \
  --url https://gitlab.ums.ac.id/ \
  --registration-token xxxxxxxxxxxxxxxxxxx \
  --executor docker \
  --description "UMS Runner" \
  --docker-image "docker:19.03.12" \
  --docker-volumes /var/run/docker.sock:/var/run/docker.sock

Keterangan:

• url adalah alamat Gitlab server
• registration-token diperoleh dari menu: Project -> Settings -> Runners
• agar bisa menjalankan docker executor, harus terpasang docker pada mesin yang menjalankan gitlab runner, dan user gitlab runner tergabung dalam group docker.

Membuat Trigger

Trigger di sini yang akan mengotomasi membuat job ketika aksi tertentu. Pada contoh ini job akan dibuat ketika ada tag baru. Untuk membuat trigger, cukup dengan membuat file .gitlab-ci.yml di root direktori project kita. Contoh:

image: docker:19.03.12

stages:
  - test
  - build

before_script:
  - echo "MEMULAI STAGE..."

test:
  stage: test
  script:
    - docker info
  only:
    - tags

build:
  stage: build
  script:
    - docker build -t gitlab.ums.ac.id:5050/suyadi/dirman:$CI_COMMIT_TAG .
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker push gitlab.ums.ac.id:5050/suyadi/dirman:$CI_COMMIT_TAG
  only:
    - tags

Setiap ada tag baru, akan dibuat job yang akan membuild dan push Image ke registry.

Bersambung…

Pada post yang lalu telah dibahas cara membangun Docker Image, membuat dan menjalanakan sebuah container. Kali ini akan kita bahas cara membuat dan menjalankan beberapa container sekaligus menggunakan tool: docker-compose.

Langkah pertama adalah memasang docker-compose dengan perintah:

sudo apt install docker-compose

Selanjutnya, buat file docker-compose.yml yang isinya seperti berikut:

version: '3'
services:
#Registry
  registry:
    image: registry:2
    restart: always
    environment:
      REGISTRY_AUTH: htpasswd
      REGISTRY_AUTH_HTPASSWD_REALM: Registry-Realm
      REGISTRY_AUTH_HTPASSWD_PATH: /auth/registry.passwd
      REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY: /data
    volumes:
      - ./data:/data
      - ./auth:/auth
    networks:
      - registry-ui-net
#Registry UI Service
  ui:
    image: joxit/docker-registry-ui:static
    restart: always
    ports:
      - 8080:80
    environment:
      - REGISTRY_TITLE=My Private Docker Registry
      - REGISTRY_URL=http://registry:5000
    depends_on:
      - registry
    networks:
      - registry-ui-net
#Docker Networks
networks:
  registry-ui-net:
    driver: bridge

Lalu jalankan perintah:

docker-compose up -d

Perintah tersebut akan membuat dan menjalankan 2 buah container yang bernama registry dan ui.

Catatan:

registry yang kita buat di atas, digunakan sebagai privat repostory seperti hub.docker.com, yang menyimpan berbagai image yang kita buat di jaringan lokal.

Bersambung…

Docker adalah sebuah teknologi container software open source yang memungkinkan Anda untuk membangun, menguji, dan menyebarkan aplikasi terdistribusi dalam lingkungan yang terisolasi. Banyak manfaat dari Docker, seperti dalam tulisan mas Katon Fergiawan B, Lebih Produktif dengan Docker.

Tuliasan ini saya buat untuk mengulas kembali saat saya mencoba praktek deploy Django ke Docker di komputer saya dengan sistem operasi Ubuntu 20.04. Proses instalasi Docker dan pembuatan aplikasi dengan Django saya lewati. Anggap saja di komputer sudah terpasang Docker (instalasi Docker di Ubuntu dapat dilihat di sini), Django project dan requirements.txt juga sudah ada.

Baiklah, kita mulai.

Di direktori project Django, buat file Dockerfile yang isinya sbb:

FROM python:3.8-alpine
ENV PYTHONUNBUFFERED 1

# set work directory
WORKDIR /app

# copy project
COPY . .

# install dependencies
RUN apk add --no-cache --virtual .build-deps \
    build-base ca-certificates gcc linux-headers musl-dev \
    libffi-dev jpeg-dev zlib-dev openldap-dev \
    libsasl postgresql-dev \
    && pip install --upgrade pip \
    && pip install -U setuptools \
    && pip install -r requirements.txt \
    && find /usr/local \
        \( -type d -a -name test -o -name tests \) \
        -o \( -type f -a -name '*.pyc' -o -name '*.pyo' \) \
        -exec rm -rf '{}' + \
    && runDeps="$( \
        scanelf --needed --nobanner --recursive /usr/local \
                | awk '{ gsub(/,/, "\nso:", $2); print "so:" $2 }' \
                | sort -u \
                | xargs -r apk info --installed \
                | sort -u \
    )" \
    && apk add --virtual .rundeps $runDeps \
    && apk del .build-deps

# run django
CMD exec uvicorn dirman.asgi:application --host=0.0.0.0 --port=8000

Jalankan perintah berikut untuk membuat image dengan nama dirman:

docker build -t dirman .

Tunggu sampai proses selesai, mungkin memerlukan waktu lama, karena mengunduh file-file yang dibutuhkan dari internet.

Jalankan perintah berikut untuk membuat container dengan nama dirman, dan menjalankannya di port 8000:

docker run \
    -d \
    --rm \ 
    --name dirman \
    -p 8000:8000 \
    -v ~/:/data \
    --log-driver=journald \
    dirman

Parameter -v ~/:/data adalah parameter tambahan untuk mengaitkan direktori /data ke home directory kita.

Log disimpan di journald, untuk membaca log, jalankan perintah:

sudo journalctl -b CONTAINER_NAME=dirman

Sekarang kita bisa mengakses django kita dengan membuka alamat http://localhost:8000/ dengan browser kesayangan kita.

Dockerfile dapat dibuat lebih kompleks seperti contoh di bawah, bandingkan dengan contoh di atas.

FROM python:3.8-alpine
ENV PYTHONUNBUFFERED 1

# set work directory
WORKDIR /app

# copy project
COPY . .
COPY dirman/settings_docker.py dirman/settings.py

# install dependencies
RUN apk add --no-cache --virtual .build-deps \
    build-base ca-certificates gcc linux-headers musl-dev \
    libffi-dev jpeg-dev zlib-dev openldap-dev \
    libsasl postgresql-dev mariadb-dev \
    mariadb-client python3-dev \
    && pip install --upgrade pip \
    && pip install -U setuptools \
    && pip install -r requirements.txt \
    && find /usr/local \
        \( -type d -a -name test -o -name tests \) \
        -o \( -type f -a -name '*.pyc' -o -name '*.pyo' \) \
        -exec rm -rf '{}' + \
    && runDeps="$( \
        scanelf --needed --nobanner --recursive /usr/local \
                | awk '{ gsub(/,/, "\nso:", $2); print "so:" $2 }' \
                | sort -u \
                | xargs -r apk info --installed \
                | sort -u \
    )" \
    && apk add --virtual .rundeps $runDeps \
    && apk del .build-deps

# run django
CMD uvicorn dirman.asgi:application --host=0.0.0.0 --port=8000

Selamat mencoba.

Bersambung…

You’ll find this post in your _posts directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run jekyll serve, which launches a web server and auto-regenerates your site when a file is updated.

Jekyll requires blog post files to be named according to the following format:

YEAR-MONTH-DAY-title.MARKUP

Where YEAR is a four-digit number, MONTH and DAY are both two-digit numbers, and MARKUP is the file extension representing the format used in the file. After that, include the necessary front matter. Take a look at the source for this post to get an idea about how it works.

Jekyll also offers powerful support for code snippets:

def print_hi(name)
  puts "Hi, #{name}"
end
print_hi('Tom')
#=> prints 'Hi, Tom' to STDOUT.

Check out the Jekyll docs for more info on how to get the most out of Jekyll. File all bugs/feature requests at Jekyll’s GitHub repo. If you have questions, you can ask them on Jekyll Talk.