Private Container Registry — using Gitlab Self-hosted

Seiring meningkatnya adopsi container dalam lingkungan Kubernetes, dan CI/CD, kebutuhan akan registry image yang private, aman, dan terintegrasi menjadi semakin krusial. Terdapat berbagai platform yang dapat digunakan untuk memenuhi kebutuhan tersebut, namun sebagian besar solusi tersebut dilabeli sebagai enterprise, dan memerlukan biaya tambahan.

Sebagai alternatif, salah satu solusi yang dapat dimanfaatkan adalah menggunakan GitLab, baik melalui layanan GitLab.com maupun dengan melakukan instalasi GitLab Self-hosted secara lokal. GitLab versi cloud sendiri menyediakan kuota penyimpanan hingga 10 GB untuk akun gratis sebagai tahap awal atau uji coba.

Namun, dalam seris implementasi ini, pendekatan yang digunakan adalah GitLab Self-hosted, yang diinstal pada perangkat pribadi maupun node server yang dimiliki, sehingga memberikan kontrol penuh terhadap infrastruktur, keamanan, dan pengelolaan container registry secara internal.

Berikut merupakan alur, dan arsitektur yang akan diimplementasikan.

Architecture — Flowing

Perlu diingat bahwa arsitektur ini bersifat referensi, dan bukan merupakan ketentuan wajib, sehingga dapat disesuaikan dengan kebutuhan, dan resource yang dimiliki. Untuk kebutuhan, dan skenario yang lebih kompleks, dapat merujuk pada dokumentasi resmi GitLab terkait Reference Architectures.

[embed]Reference architectures Recommended deployments at scale.docs.gitlab.com

Berikut merupakan spesifikasi virtual machine (VM) yang akan digunakan dalam proses implementasi:

VM-1

OS Ubuntu 25.04

Hardware

• RAM: 8 GB
• vCPU: 4 vCPU
• Disk: 80 GB
• NIC: 1 Interface

Software

• Docker
• Docker Compose
• OpenSSL

VM-2

OS Ubuntu 25.04

Hardware

• RAM: 4 GB
• vCPU: 2 vCPU
• Disk: 80 GB
• NIC: 1 Interface

Software

• Docker
• Docker Compose

Pada seris implementasi kali ini, metode instalasi yang akan digunakan adalah Docker Compose, sehingga seluruh komponen akan dijalankan secara terkontainerisasi (full containerization). Oleh karena itu, diharapkan telah memahami dasar-dasar containerisasi, khususnya penggunaan perintah-perintah dasar Docker.

Pada tahap awal, implementasi akan difokuskan pada proses instalasi, dan konfigurasi komponen utama berikut:

• GitLab Server

Langkah pertama dalam implementasi ini adalah melakukan konfigurasi DNS lokal dengan memanfaatkan file /etc/hosts untuk memetakan alamat IP, dan nama domain yang akan digunakan. Sebenarnya, proses instalasi juga dapat dilakukan menggunakan localhost tergantung pada kebutuhan implementasi. Namun, dalam skenario real-world atau lingkungan produksi, penggunaan DNS yang terpercaya (trusted DNS) sangat disarankan sebagai bagian dari kontrol akses, dan keamanan sistem.

Oleh karena itu, pada implementasi kali ini digunakan pendekatan pembuatan sertifikat SSL/TLS berbasis Certificate Authority (CA) menggunakan OpenSSL. Sertifikat ini akan digunakan untuk mengamankan akses ke layanan GitLab, dan Container Registry melalui domain yang telah dikonfigurasikan.

Contoh isi file /etc/hosts

127.0.0.1       localhost
172.31.248.163  gitlab-local.init

Langkah ini perlu dilakukan pada VM GitLab Server, dan VM GitLab Runner agar keduanya dapat mengenali domain yang sama.

Selanjutnya, dilakukan pembuatan sertifikat SSL/TLS menggunakan OpenSSL. Sertifikat ini akan digunakan untuk mengamankan akses ke GitLab, dan Container Registry.

Buat direktori untuk menyimpan sertifikat:

mkdir -p gitlab/gitlab-ssl
cd gitlab/gitlab-ssl
~/gitlab/gitlab-ssl$

Buat file konfigurasi OpenSSL

cat > gitlab-local.init.cnf <<EOF
[req]
default_bits = 2048
prompt = no
default_md = sha256
distinguished_name = dn
req_extensions = v3_req

[dn]
C=ID
ST=West Java
L=Bandung
O=MyCompany
CN=gitlab-local.init

[v3_req]
subjectAltName = @alt_names

[alt_names]
DNS.1 = gitlab-local.init
DNS.2 = *.gitlab-local.init
IP.1 = 172.31.248.163
EOF

Generate sertifikat dengan Subject Alternative Name (SAN):

openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout gitlab-local.init.key \
  -out gitlab-local.init.crt \
  -config gitlab-local.init.cnf \
  -extensions v3_req

~/gitlab/gitlab-ssl$ ls
gitlab-local.init.cnf  gitlab-local.init.crt  gitlab-local.init.key

Setelah sertifikat tersedia, langkah berikutnya adalah membuat file docker-compose.yml untuk menjalankan GitLab Server menggunakan Docker Compose.

Struktur file konfigurasi GitLab adalah sebagai berikut:

services:
  gitlab:
    image: gitlab/gitlab-ce:latest
    container_name: gitlab
    restart: always
    hostname: 'gitlab-local.init'
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        external_url 'https://gitlab-local.init'

        # Disable Let's Encrypt
        letsencrypt['enable'] = false

        # SSL Configuration
        nginx['ssl_certificate'] = "/etc/gitlab/ssl/gitlab-local.init.crt"
        nginx['ssl_certificate_key'] = "/etc/gitlab/ssl/gitlab-local.init.key"
        nginx['redirect_http_to_https'] = true

        # Container Registry Configuration
        registry_external_url 'https://gitlab-local.init:5050'
        gitlab_rails['registry_enabled'] = true

        # Registry SSL
        registry_nginx['ssl_certificate'] = "/etc/gitlab/ssl/gitlab-local.init.crt"
        registry_nginx['ssl_certificate_key'] = "/etc/gitlab/ssl/gitlab-local.init.key"

        # Registry storage path
        gitlab_rails['registry_path'] = "/var/opt/gitlab/gitlab-rails/shared/registry"

    ports:
      - '80:80'
      - '443:443'
      - '2222:22'    # Port akses SSH
      - '5050:5050'  # Port untuk Container Registry
    volumes:
      - '$GITLAB_HOME/config:/etc/gitlab'
      - '$GITLAB_HOME/logs:/var/log/gitlab'
      - '$GITLAB_HOME/data:/var/opt/gitlab'
      - '~/gitlab/gitlab-ssl:/etc/gitlab/ssl'  # Mount SSL
    shm_size: '256m'

Selanjutnya, buat file .env untuk mendefinisikan variabel direktori penyimpanan data GitLab:

~/gitlab$ nano .env

Isi File .env:

GITLAB_HOME=~/gitlab/metadata

Sebelum menjalankan perintah docker-compose up -d, sertifikat CA yang telah dibuat perlu ditambahkan ke trusted CA pada sistem operasi, dan Docker daemon. Hal ini diperlukan karena implementasi ini tidak menggunakan DNS publik atau sertifikat dari CA resmi. Langkah berikut dilakukan pada VM GitLab Server, dan VM GitLab Runner.

Tambahkan sertifikat ke sistem operasi:

sudo cp gitlab-local.init.crt /usr/local/share/ca-certificates/gitlab-local.init.crt

sudo update-ca-certificates 
Updating certificates in /etc/ssl/certs...
0 added, 0 removed; done.
Running hooks in /etc/ca-certificates/update.d...
done.

Tambahkan sertifikat ke Docker daemon untuk Container Registry:

sudo mkdir -p /etc/docker/certs.d/gitlab-local.init:5050
sudo cp gitlab-local.init.crt /etc/docker/certs.d/gitlab-local.init:5050/ca.crt
sudo systemctl restart docker.service

Setelah seluruh konfigurasi selesai, GitLab Server dapat dijalankan menggunakan Docker Compose:

~/gitlab$ docker-compose up -d

Setelah GitLab Server berhasil dijalankan menggunakan Docker Compose, struktur direktori pada host akan terbentuk seperti berikut:

~/gitlab$ tree 
.
├── docker-compose.yml
├── gitlab-ssl
│   ├── gitlab-local.init.cnf
│   ├── gitlab-local.init.crt
│   └── gitlab-local.init.key
└── metadata
    ├── config
    │   ├── gitlab-secrets.json
    │   ├── gitlab.rb
    │   ├── initial_root_password
    │   ├── ssh_host_ecdsa_key
    │   ├── ssh_host_ecdsa_key.pub
    │   ├── ssh_host_ed25519_key
    │   ├── ssh_host_ed25519_key.pub
    │   ├── ssh_host_rsa_key
    │   ├── ssh_host_rsa_key.pub
    │   ├── ssl
    │   └── trusted-certs
    ├── data
    │   ├── alertmanager  [error opening dir]
    │   ├── backups  [error opening dir]
    │   ├── bootstrapped
    │   ├── git-data
    │   │   └── repositories  [error opening dir]
    │   ├── gitaly  [error opening dir]
    │   ├── gitlab-ci
    │   │   └── builds  [error opening dir]
    │   ├── gitlab-exporter
    │   │   ├── RUBY_VERSION
    │   │   └── gitlab-exporter.yml
    │   ├── gitlab-kas  [error opening dir]
    │   ├── gitlab-rails
    │   │   ├── REVISION
    │   │   ├── RUBY_VERSION
    │   │   ├── VERSION
    │   │   ├── etc  [error opening dir]
    │   │   ├── shared  [error opening dir]
    │   │   ├── sockets  [error opening dir]
    │   │   ├── tmp  [error opening dir]
    │   │   ├── upgrade-status  [error opening dir]
    │   │   ├── uploads  [error opening dir]
    │   │   └── working  [error opening dir]
    │   ├── gitlab-shell  [error opening dir]
    │   ├── gitlab-workhorse  [error opening dir]
    │   ├── logrotate  [error opening dir]
    │   ├── nginx  [error opening dir]
    │   ├── postgres-exporter  [error opening dir]
    │   ├── postgresql
    │   │   ├── VERSION
    │   │   └── data  [error opening dir]
    │   ├── prometheus  [error opening dir]
    │   ├── public_attributes.json
    │   ├── redis  [error opening dir]
    │   ├── registry  [error opening dir]
    │   └── trusted-certs-directory-hash
    └── logs
        ├── alertmanager  [error opening dir]
        ├── gitaly  [error opening dir]
        ├── gitlab-exporter  [error opening dir]
        ├── gitlab-kas  [error opening dir]
        ├── gitlab-rails  [error opening dir]
        ├── gitlab-shell  [error opening dir]
        ├── gitlab-workhorse  [error opening dir]
        ├── logrotate  [error opening dir]
        ├── nginx  [error opening dir]
        ├── postgres-exporter  [error opening dir]
        ├── postgresql  [error opening dir]
        ├── prometheus  [error opening dir]
        ├── puma  [error opening dir]
        ├── reconfigure
        │   ├── 1767777611.log
        │   └── 1767782255.log
        ├── redis  [error opening dir]
        ├── redis-exporter  [error opening dir]
        ├── registry  [error opening dir]
        ├── sidekiq  [error opening dir]
        └── sshd
            ├── @40000000695e37751811bc4c.u
            ├── current
            └── lock

54 directories, 27 files

Struktur ini dihasilkan dari proses mounting volume Docker yang didefinisikan pada file docker-compose.yml, dan berfungsi sebagai penyimpanan persistensi data GitLab.

Penjelasan fungsi setiap direktori adalah sebagai berikut.

File docker-compose.yml

Berisi konfigurasi utama Docker Compose yang digunakan untuk menjalankan GitLab Server, termasuk pengaturan container, port, volume, SSL, dan Container Registry.

Direktori gitlab-ssl

Direktori ini digunakan untuk menyimpan file sertifikat SSL/TLS yang dibuat menggunakan OpenSSL. Sertifikat ini dipakai oleh GitLab Nginx, dan GitLab Container Registry untuk menyediakan akses HTTPS.

Isi direktori ini meliputi:

• File .cnf sebagai konfigurasi OpenSSL
• File .crt sebagai sertifikat publik
• File .key sebagai private key

Direktori metadata

Direktori ini merupakan root direktori persistensi data GitLab yang dimapping ke dalam container. Seluruh data penting GitLab akan disimpan di sini agar tidak hilang ketika container dihentikan atau dibuat ulang.

Direktori metadata/config Digunakan untuk menyimpan file konfigurasi GitLab Omnibus, antara lain:

• gitlab.rb sebagai konfigurasi utama GitLab
• gitlab-secrets.json untuk menyimpan secret internal GitLab
• initial_root_password untuk password awal user root
• *sshhost** untuk kunci SSH GitLab
• ssl, dan trusted-certs untuk sertifikat tambahan yang dipercaya oleh GitLab

Perubahan konfigurasi GitLab umumnya dilakukan melalui file gitlab.rb pada direktori ini.

Direktori metadata/data Berisi seluruh data operasional GitLab, termasuk:

• repository Git (git-data)
• data Container Registry
• database PostgreSQL
• Redis
• artefak CI/CD
• uploads, dan file hasil build

Direktori ini merupakan komponen paling kritikal karena menyimpan seluruh data aplikasi GitLab.

Pesan [error opening dir] muncul karena direktori tersebut dimiliki oleh user internal container GitLab, dan bukan oleh user host.

Direktori metadata/logs Digunakan untuk menyimpan log dari seluruh service GitLab, seperti:

• gitlab-rails
• nginx
• registry
• sidekiq
• puma
• postgresql
• redis
• sshd

Log pada direktori ini sangat penting untuk proses troubleshooting, monitoring, dan audit.

Dengan struktur ini, GitLab Server berjalan secara terkontainerisasi, namun seluruh konfigurasi, data, dan log tetap tersimpan secara persisten di host. Pendekatan ini memungkinkan GitLab untuk dengan mudah direstart, di-upgrade, atau dipindahkan tanpa kehilangan data.

• GitLab Runner

GitLab menyediakan agen CI/CD tersendiri yang disebut GitLab Runner. Komponen ini merupakan bagian penting dalam implementasi CI/CD pada GitLab, karena GitLab Runner bertanggung jawab untuk menjalankan seluruh proses pipeline seperti build, pengujian, deployment, dan tugas CI/CD lainnya yang didefinisikan di dalam file .gitlab-ci.yml.

Pada implementasi kali ini, metode instalasi GitLab Runner menggunakan pendekatan yang sama dengan GitLab Server, yaitu dengan memanfaatkan Docker Compose, sehingga GitLab Runner dijalankan sepenuhnya dalam bentuk container.

Buat direktori untuk GitLab Runner:

mkdir -p gitlab-runner
cd gitlab-runner/

Buat file docker-compose.yml:

~/gitlab-runner$ nano docker-compose.yml

Isi file docker-compose.yml sebagai berikut:

 services:
  gitlab-runner:
    image: gitlab/gitlab-runner:latest
    container_name: gitlab-runner
    restart: always
    volumes:
      - '/var/run/docker.sock:/var/run/docker.sock'
      - '$GITLAB_RUNNER_HOME/config:/etc/gitlab-runner'
      - '$GITLAB_RUNNER_HOME/data:/home/gitlab-runner'
      - '/etc/ssl/certs:/etc/ssl/certs:ro'
      - '/etc/docker/certs.d:/etc/docker/certs.d:ro'

Mounting */var/run/docker.sock digunakan agar GitLab Runner dapat menjalankan job berbasis Docker, seperti melakukan build, dan push image ke Container Registry. Sementara itu, direktori /etc/ssl/certs, dan /etc/docker/certs.d* dimount sebagai read-only untuk memastikan GitLab Runner mempercayai sertifikat CA yang digunakan oleh GitLab Server, dan Container Registry.

Buat file environment .env:

~/gitlab-runner$ nano .env

Isi file .env:

GITLAB_RUNNER_HOME=~/gitlab-runner/metadata

Setelah konfigurasi selesai, GitLab Runner dapat dijalankan menggunakan perintah:

~/gitlab-runner$ docker-compose up -d

Setelah GitLab Runner dijalankan menggunakan Docker Compose, struktur direktori pada host akan terbentuk seperti berikut:

~/gitlab-runner$ tree 
.
├── docker-compose.yml
└── metadata
    ├── config
    │   └── config.toml
    └── data

4 directories, 2 files

Seperti pada GitLab Server, direktori metadata pada GitLab Runner digunakan sebagai lokasi penyimpanan konfigurasi, dan data secara persisten di sisi host, sehingga konfigurasi tetap tersimpan meskipun container GitLab Runner dihentikan atau dibuat ulang.

Langkah selanjutnya adalah melakukan proses registrasi GitLab Runner ke GitLab Server agar runner dapat digunakan oleh pipeline CI/CD. Pada GitLab, setiap runner harus didaftarkan menggunakan sebuah token.

Token GitLab Runner berfungsi sebagai mekanisme autentikasi yang menghubungkan GitLab Runner dengan GitLab Server. Dengan token ini, GitLab Server dapat mengenali runner, menentukan scope penggunaannya (project, group, atau instance), dan mengontrol runner tersebut untuk mengeksekusi job CI/CD.

Secara konsep, token ini memastikan bahwa hanya runner yang sah, dan terdaftar yang diperbolehkan menjalankan pipeline pada GitLab.

Token GitLab Runner dapat dibuat melalui GitLab Server dengan langkah sebagai berikut:

• Fitur Runner pada GitLab Web UI

• Membuat Runner

• Salin registration token yang tersedia

Setelah token diperoleh, lakukan proses registrasi runner dari sisi host GitLab Runner dengan menjalankan perintah berikut:

~/gitlab-runner$ docker exec -it gitlab-runner gitlab-runner register

Proses registrasi akan memandu beberapa input sebagai berikut:

Runtime platform                                    arch=amd64 os=linux pid=16 revision=cc7f9277 version=18.7.1
Running in system-mode.

Enter the GitLab instance URL (for example, https://gitlab.com/):
https://gitlab-local.init

Enter the registration token:
glrt-qL46gQcQtywrYqjeJ03SeW86MQp0OjEKdTozCw.01.120g1glgp

Verifying runner... is valid
Enter a name for the runner. This is stored only in the local config.toml file:
runner-1

Enter an executor:
docker

Enter the default Docker image:
docker:dind

Penjelasan dari setiap input registrasi:

• GitLab instance URL adalah alamat GitLab Server yang akan digunakan oleh runner.
• Registration token digunakan untuk mengautentikasi runner ke GitLab Server.
• Runner name digunakan sebagai identitas runner, dan disimpan di file konfigurasi lokal.
• Executor menentukan bagaimana job CI/CD akan dijalankan. Pada implementasi ini digunakan executor Docker.
• Default Docker image digunakan sebagai image dasar ketika job dijalankan oleh runner.

Setelah proses selesai, akan muncul pesan berikut:

Runner registered successfully.
Configuration (with the authentication token) was saved in "/etc/gitlab-runner/config.toml"

Hal ini menandakan bahwa GitLab Runner telah berhasil terdaftar, dan konfigurasi runner telah disimpan pada file config.toml di dalam container, yang dipersistensikan ke direktori metadata/config di host.

Pada tahap ini, GitLab Runner sudah siap digunakan untuk menjalankan pipeline CI/CD.

Setelah proses instalasi selesai, tahap selanjutnya adalah memahami cara mengoperasikan, dan mengelola Container Registry.

Pada implementasi ini, terdapat dua metode yang dapat digunakan untuk membangun, dan mendistribusikan image container. Metode pertama yang akan dibahas adalah Metode Manual Dasar, yang bertujuan untuk memahami alur kerja Container Registry secara fundamental sebelum masuk ke otomasi CI/CD.

Metode Manual Dasar

— Menyiapkan Repository Git

Langkah pertama adalah melakukan clone repository GitLab yang akan digunakan untuk menyimpan Dockerfile, dan artefak build container.

git clone https://gitlab-local.init/vanaticava/build-container-registry.git

Karena repository masih kosong, selanjutnya dibuat branch utama (main), dan file README sebagai inisialisasi awal repository.

cd /build-container-registry
~/build-container-registry$ git switch --create main
~/build-container-registry$ touch README.md
~/build-container-registry$ nano README.md
~/build-container-registry$ git add README.md
~/build-container-registry$ git commit -m "add README"
~/build-container-registry$ git push --set-upstream origin main

— Membuat Dockerfile & Aplikasi Sederhana

Setelah repository siap, langkah berikutnya adalah membuat Dockerfile untuk membangun image container.

FROM nginx:alpine
COPY src/index.html /usr/share/nginx/html/index.html

Kemudian dibuat direktori src yang berisi file index.html sebagai konten web sederhana.

<h1>Hello World</h1>

— Login ke GitLab Container Registry

Sebelum melakukan push image, Docker client harus login ke GitLab Container Registry.

~/build-container-registry$ docker login gitlab-local.init:5050

Masukan Gitlab Username & Password

Username: vanaticava
Password: 

Login Succeeded

— Build Image Container

Image container dibangun dengan format penamaan sesuai standar GitLab Container Registry:

~/build-container-registry$ docker build -t gitlab-local.init:5050/vanaticava/build-container-registry/hello-world:v1 .

— Push Image ke Container Registry

Setelah image berhasil dibangun, image didorong ke GitLab Container Registry.

~/build-container-registry$ docker push gitlab-local.init:5050/vanaticava/build-container-registry/hello-world:v1

Image yang telah dipush dapat diverifikasi menggunakan perintah:

~/build-container-registry$ docker images
REPOSITORY                                                               TAG       IMAGE ID       CREATED              SIZE
gitlab-local.init:5050/vanaticava/build-container-registry/hello-world   v1        40256e0988ec   About a minute ago   53.7MB

Melalui Web UI

— Menjalankan Container dari Registry

Sebagai validasi akhir, image yang tersimpan di Container Registry dijalankan sebagai container.

~/build-container-registry$ docker run --name hello-world -p 8080:80 -d \
gitlab-local.init:5050/vanaticava/build-container-registry/hello-world:v1

Status container dapat dicek menggunakan:

~/build-container-registry$ docker ps -a
CONTAINER ID   IMAGE                                                                       COMMAND                  CREATED             STATUS                    PORTS                                                                                                                                                                NAMES
2be2ccb9f8be   gitlab-local.init:5050/vanaticava/build-container-registry/hello-world:v1   "/docker-entrypoint.…"   6 seconds ago       Up 5 seconds              0.0.0.0:8080->80/tcp, [::]:8080->80/tcp                                                                                                                              hello-world

Jika container berjalan dengan baik, aplikasi dapat diakses melalui browser pada port 8080.

Setelah memahami dasar penggunaan Container Registry pada GitLab melalui metode manual, tahap selanjutnya adalah mengimplementasikan proses otomatisasi build, dan distribusi image container menggunakan pipeline bawaan GitLab CI/CD.

Metode Otomatis (Automation) Menggunakan GitLab CI/CD

Metode otomatis ini memanfaatkan GitLab CI/CD yang dijalankan oleh GitLab Runner melalui sebuah file konfigurasi bernama .gitlab-ci.yml. Dengan pendekatan ini, proses build, dan push image container ke GitLab Container Registry dapat dilakukan secara otomatis setiap kali terjadi perubahan kode, tanpa perlu menjalankan perintah Docker secara manual di server.

Masuk ke repository project pada GitLab.

Pilih New File.

Buat file dengan nama .gitlab-ci.yml pada repository.

Berikut adalah contoh pipeline CI/CD sederhana untuk membangun, dan mengirim image ke GitLab Container Registry.

Penjelasan File .gitlab-ci.yml

— stages

stages:
  - build

Bagian ini mendefinisikan urutan tahapan pipeline.

Pada contoh ini hanya terdapat satu tahap, yaitu build, yang digunakan untuk proses pembuatan image container.

— job: build_registry

build_registry:
  stage: build
  image: docker
  services:
    - docker:dind
  variables:
    IMAGE_NAME: $CI_REGISTRY_IMAGE/hello-world
  script:
    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" "$CI_REGISTRY"
    - docker build -t $IMAGE_NAME:$CI_COMMIT_SHORT_SHA .
    - docker push $IMAGE_NAME:$CI_COMMIT_SHORT_SHA
  tags:
    - runner-1

Job build_registry merupakan job utama pada pipeline yang berjalan di stage build, menggunakan image docker, dan service docker:dind agar GitLab Runner dapat menjalankan perintah Docker di dalam environment CI. Pada job ini didefinisikan variabel IMAGE_NAME yang mengarah ke GitLab Container Registry milik project, kemudian pada bagian script dilakukan proses login ke registry menggunakan kredensial bawaan GitLab ( $CI_REGISTRY_USER — $CI_REGISTRY_PASSWORD), dilanjutkan dengan proses build image Docker, dan pemberian tag berdasarkan $CI_COMMIT_SHORT_SHA agar setiap image memiliki identitas unik sesuai commit, lalu image tersebut dipush ke GitLab Container Registry. Job ini dijalankan oleh GitLab Runner dengan tag runner-1, dan akan tereksekusi secara otomatis setiap kali terjadi perubahan kode (commit atau push) pada repository sesuai dengan konfigurasi pipeline yang telah ditentukan. Commit file .gitlab-ci.yml menjadi pemicu utama dimulainya proses pipeline ini.

Setelah pipeline berhasil dijalankan, GitLab akan menampilkan status job build_registry sebagai passed pada menu CI/CD → Pipelines. Jika pipeline tersebut dibuka, akan terlihat log proses yang mencakup tahap login ke registry, proses build image Docker, hingga push image ke GitLab Container Registry.

Hasil dari proses tersebut dapat dilihat langsung melalui GitLab UI di dalam project pada menu Deploy → Container Registry. Pada halaman tersebut akan muncul repository image dengan path seperti:

Variabel Bawaan GitLab CI/CD yang dapat digunakan Digunakan

Berikut beberapa variabel bawaan GitLab CI/CD yang umum, dan penting digunakan dalam pipeline container registry:

— Registry & Authentication

**CI_REGISTRY** —Alamat GitLab Container Registry.

**CI_REGISTRY_IMAGE —**Path registry berdasarkan project.

**CI_REGISTRY_USER —**Username otomatis untuk registry.

**CI_REGISTRY_PASSWORD —**Password/token otomatis untuk registry.

— Repository & Commit

**CI_COMMIT_SHA —**Full commit hash.

**CI_COMMIT_SHORT_SHA —**Commit hash pendek (untuk tagging image).

**CI_COMMIT_BRANCH —**Nama branch.

**CI_COMMIT_REF_SLUG —**Versi aman nama branch.

**CI_COMMIT_TAG —**Nama Git tag (jika pipeline dipicu oleh tag).

— Project & Pipeline

**CI_PROJECT_NAME —**Nama project.

**CI_PROJECT_PATH —**Namespace + project.

**CI_PIPELINE_ID —**ID pipeline.

**CI_PIPELINE_SOURCE —**Sumber trigger pipeline.

Setelah memahami, dan mengetahui bagaimana GitLab dapat berperan sebagai Private Container Registry, diharapkan pemaparan, dan implementasi yang disampaikan dapat membantu, dan menjadi salah satu solusi yang relevan bagi kebutuhan penggunaan container di lingkungan industri, khususnya dalam membangun proses CI/CD yang terintegrasi, aman, dan efisien sesuai dengan resource yang dimiliki.

Berikut beberapa referensi, dan dokumentasi untuk dipelajari lebih lanjut terkait seris implementasi kali ini.

[embed]Docker Documentation is the official Docker library of resources, manuals, and guides to help you containerize…docs.docker.com

[embed]Docker Compose Learn how to use Docker Compose to define and run multi-container applications with this detailed introduction to the…docs.docker.com

[embed]Install GitLab in a Docker container Learn about the prerequisites, strategies, and steps for installing GitLab in a Docker container.docs.gitlab.com

[embed]Run GitLab Runner in a container Run GitLab Runner in a Docker container.docs.gitlab.com

[embed]Get started with GitLab CI/CD Build and test your application.docs.gitlab.com

[embed]GitLab container registry Use the GitLab Container Registry to store container images for your GitLab project.docs.gitlab.com

Demikian yang dapat disampaikan, Terima kasih.