Panduan Setup Rancher: Install Docker & Import K8s 2025

Introduction: Dari Kompleksitas Kubernetes ke Kesederhanaan Rancher

Mengelola cluster Kubernetes secara manual tuh rasanya kayak navigasi labirin sambil tutup mata. Setelah berhasil menyelesaikan migrasi Kubernetes zero-downtime dari Docker Swarm di mana gue belajar menjalankan beberapa platform orkestrasi container secara paralel, gue sadar kalau punya cluster yang kuat itu cuma setengah dari perjuangan aja. Tantangan sebenarnya ada di pengelolaan yang efisien, pemantauan, dan penskalaan di berbagai environment.

Momen terobosan gue dateng pas gue nyadar kalau Kubernetes memang ngasih kemampuan orkestrasi yang luar biasa, tapi kompleksitasnya sering jadi penghalang produktivitas. Pengelolaan lewat command-line, konfigurasi YAML yang tersebar di berbagai file, dan perpindahan konteks yang terus-menerus antar cluster itu ngabisin waktu development yang berharga banget. Di sinilah Rancher mentransformasi seluruh alur kerja DevOps gue.

Rancher berfungsi sebagai platform pengelolaan terpusat yang ngasih antarmuka yang bersih dan intuitif untuk operasi Kubernetes. Daripada ngafal perintah kubectl dan mengelola beberapa file kubeconfig, Rancher konsolidasi semuanya jadi dashboard terpadu di mana lo bisa memantau kesehatan cluster, deploy aplikasi, mengelola resource, dan menangani kebijakan security di berbagai environment Kubernetes.

Di panduan komprehensif ini, gue bakal memandu lo cara setup Rancher pakai Docker, konfigurasi dengan custom port biar nggak bentrok, dan mengimpor cluster Kubernetes yang udah ada. Pendekatan ini mengambil strategi instalasi paralel yang gue pake waktu migrasi Docker Swarm, memastikan lo bisa mengadopsi Rancher tanpa ganggu operasi yang udah jalan.

Prerequisites: Asumsi Docker Udah Terinstall

Untuk panduan ini, gue asumsikan lo udah punya Docker yang terinstall dan jalan di sistem lo. Kalau lo ngikutin artikel gue sebelumnya tentang instalasi Kubernetes ultra-safe, lo udah punya Docker dan containerd yang jalan paralel, yang jadi fondasi sempurna untuk setup Rancher ini.

Memahami Arsitektur Rancher

Sebelum masuk ke instalasi, penting banget untuk ngerti apa yang Rancher bawa ke meja. Rancher beroperasi sebagai lapisan pengelolaan yang duduk di atas cluster Kubernetes lo, menyediakan:

Core Components

Rancher Server: Komponen management utama yang nyediain web UI dan API
Rancher Agents: Komponen ringan yang di-deploy di cluster terkelola untuk komunikasi
Local K3s Cluster: Rancher menjalankan cluster Kubernetes tertanam sendiri untuk menyimpan data pengelolaan
Authentication Integration: Support untuk LDAP, Active Directory, SAML, dan identity provider lainnya

Management Capabilities

Multi-Cluster Management: Kontrol terpusat dari beberapa cluster Kubernetes di berbagai environment
Application Catalog: Helm chart yang udah dikonfigurasi untuk aplikasi dan service umum
Project and User Management: Role-based access control dengan izin yang terperinci
Monitoring Integration: Prometheus dan Grafana bawaan untuk pemantauan cluster
Backup and Disaster Recovery: Solusi backup otomatis untuk status cluster dan data

Menjalankan Rancher dengan Custom Port: Setup Siap Produksi

Kerennya menjalankan Rancher lewat Docker itu karena kesederhanaan dan isolasinya. Tidak seperti instalasi multi-node yang kompleks, pendekatan ini ngasih platform pengelolaan lengkap dalam satu container aja, sempurna untuk mengelola beberapa cluster remote.

Strategi Konfigurasi Port

Port standar 80 dan 443 sering udah kepake di environment production. Di setup gue, port-port ini udah melayani aplikasi lain, jadi perlu konfigurasi custom port. Ini command siap-produksi yang gue pake:

# Buat direktori khusus untuk persistensi data Rancher
sudo mkdir -p /opt/rancher/data

# Jalankan Rancher dengan custom port dan persistensi data
docker run -d --restart=unless-stopped \
  --name rancher-server \
  -p 8020:80 -p 8021:443 \
  -v /opt/rancher/data:/var/lib/rancher \
  --privileged \
  rancher/rancher:stable

Memahami Konfigurasi

Yuk kita uraikan setiap komponen dari command ini:

--name rancher-server: Ngasih nama yang mudah diingat untuk pengelolaan container yang lebih gampang
-p 8020:80 -p 8021:443: Mapping custom external port ke internal HTTP/HTTPS port Rancher
-v /opt/rancher/data:/var/lib/rancher: Persist data Rancher di luar container untuk backup dan upgrade
--privileged: Diperlukan untuk cluster K3s tertanam Rancher biar bisa fungsi dengan benar
rancher/rancher:stable: Pake stable tag daripada latest untuk keandalan production

Initial Setup dan Security

Setelah start container, monitor proses inisialisasi:

# Cek status container
docker ps | grep rancher-server

# Monitor log inisialisasi
docker logs -f rancher-server

# Tunggu pesan "Bootstrap Password"
docker logs rancher-server 2>&1 | grep "Bootstrap Password"

Bootstrap password bakal muncul di log, biasanya kayak gini:

[INFO] Bootstrap Password: k8s-admin-password-here

Mengakses Antarmuka Web Rancher

Navigasi ke https://your-server-ip:8021 di browser lo. Lo bakal ketemu warning self-signed certificate, ini normal untuk setup awal. Terima warning itu dan lanjut ke antarmuka Rancher.

Rancher welcome screen showing bootstrap password setup and login interface Image #1: Welcome screen Rancher yang menampilkan interface setup awal dengan instruksi bootstrap password untuk instalasi Docker dan Helm.

Konfigurasi Pertama Kali

Bootstrap Password: Masukin bootstrap password dari log container
Set Admin Password: Buat password yang aman untuk pengguna admin
Server URL: Konfigurasi URL yang bakal dipake Rancher untuk komunikasi cluster
- Untuk pengembangan lokal: https://localhost:8021
- Untuk production: https://your-domain:8021 atau pake domain yang tepat dengan SSL

Konfigurasi Sertifikat SSL

Untuk environment production, ganti self-signed certificate dengan sertifikat SSL yang tepat:

# Stop container yang udah ada
docker stop rancher-server
docker rm rancher-server

# Jalankan dengan custom SSL certificate
docker run -d --restart=unless-stopped \
  --name rancher-server \
  -p 8020:80 -p 8021:443 \
  -v /opt/rancher/data:/var/lib/rancher \
  -v /path/to/your/cert.pem:/etc/rancher/ssl/cert.pem \
  -v /path/to/your/key.pem:/etc/rancher/ssl/key.pem \
  --privileged \
  rancher/rancher:stable \
  --no-cacerts

Mengimpor Cluster Kubernetes yang Udah Ada: Panduan Komprehensif

Salah satu fitur paling kuat dari Rancher adalah kemampuannya untuk mengimpor dan mengelola cluster Kubernetes yang udah ada. Fungsionalitas ini sangat penting banget di alur kerja gue, terutama setelah membangun instalasi Kubernetes paralel yang dijelasin di artikel sebelumnya.

Verifikasi Pra-Impor

Sebelum mengimpor cluster, pastikan target cluster Kubernetes memenuhi persyaratan ini:

# Verifikasi konektivitas cluster
kubectl cluster-info

# Cek status node cluster
kubectl get nodes

# Verifikasi kompatibilitas versi (Rancher mendukung K8s 1.23+)
kubectl version

# Pastikan izin yang cukup (cluster-admin direkomendasikan)
kubectl auth can-i '*' '*' --all-namespaces

Proses Impor Langkah-demi-Langkah

Akses Rancher Dashboard: Navigasi ke antarmuka Rancher di https://your-ip:8021
Buat Cluster Baru: Klik “Add Cluster” dan pilih “Import an existing cluster”
Konfigurasi Cluster:
- Nama Cluster: Pilih nama yang deskriptif (misal production-k8s, staging-cluster)
- Deskripsi: Tambahin detail yang relevan tentang tujuan cluster
- Label: Tag cluster biar lebih gampang organisasi dan penyaringan

Generate Perintah Impor: Rancher bakal ngasih kubectl command mirip kayak gini:

curl --insecure -sfL https://your-rancher-ip:8021/v3/import/xyz123.yaml | kubectl apply -f -

Eksekusi di Target Cluster: Jalanin command yang udah dikasih di target cluster dengan hak admin

Rancher dashboard showing cluster management interface with local cluster and import options Image #2: Dashboard utama Rancher yang menampilkan interface management cluster dengan local cluster yang aktif dan opsi untuk manage, import, atau buat cluster baru.

Eksekusi Perintah Impor

Di target cluster Kubernetes lo, eksekusi perintah impor:

# Download dan terapkan Rancher agent
curl --insecure -sfL https://your-rancher-ip:8021/v3/import/xyz123.yaml | kubectl apply -f -

# Verifikasi pembuatan namespace cattle-system
kubectl get namespace cattle-system

# Pantau deployment agent
kubectl get pods -n cattle-system

# Cek log agent kalau diperluin
kubectl logs -n cattle-system -l app=cattle-cluster-agent

Mengatasi Masalah Impor

Masalah Konektivitas Jaringan:

# Tes konektivitas dari target cluster ke Rancher
curl -k https://your-rancher-ip:8021/ping

# Cek firewall rule
sudo ufw status
sudo iptables -L

# Verifikasi DNS resolution
nslookup your-rancher-domain

Masalah Izin:

# Verifikasi izin pengguna sekarang
kubectl auth whoami

# Cek cluster-admin binding
kubectl get clusterrolebinding | grep cluster-admin

# Buat admin binding kalau diperlukan
kubectl create clusterrolebinding cluster-admin-binding \
  --clusterrole=cluster-admin \
  --user=$(kubectl config view --minify -o jsonpath='{.contexts[0].context.user}')

Konfigurasi Lanjutan Rancher

Pengelolaan Project dan Namespace

Rancher memperkenalkan konsep “Projects” yang mengelompokkan namespace dan ngasih kemampuan pengelolaan tambahan:

# Contoh struktur project
apiVersion: management.cattle.io/v3
kind: Project
metadata:
    name: frontend-apps
    namespace: cluster-id
spec:
    clusterName: production-cluster
    displayName: "Frontend Applications"
    description: "Semua aplikasi dan service yang berkaitan dengan frontend"
    resourceQuota:
        limit:
            requests.cpu: "10"
            requests.memory: "20Gi"
            limits.cpu: "20"
            limits.memory: "40Gi"

Pengguna dan Role-Based Access Control

Konfigurasi RBAC untuk mengelola akses tim:

Izin Global: Mengelola akses ke Rancher itu sendiri
Izin Cluster: Kontrol akses ke cluster spesifik
Izin Project: Akses terperinci ke namespace dalam project

# Buat peran khusus untuk developer
kubectl apply -f - <<EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: developer-role
rules:
- apiGroups: ["", "apps", "extensions"]
  resources: ["*"]
  verbs: ["get", "list", "watch", "create", "update", "patch"]
- apiGroups: [""]
  resources: ["secrets"]
  verbs: ["get", "list"]
EOF

Setup Pemantauan dan Observabilitas

Aktifkan Pemantauan Bawaan

Rancher ngasih pemantauan terintegrasi lewat Prometheus dan Grafana:

Navigasi ke Cluster: Pilih cluster yang diimpor
Apps & Marketplace: Masuk ke bagian Apps
Install Monitoring: Cari “Rancher Monitoring” dan install

Deployment ini mencakup:

Prometheus: Pengumpulan dan penyimpanan metrics
Grafana: Visualisasi dan dashboard
AlertManager: Perutean alert dan pengelolaan
Node Exporter: Pengumpulan metrics level node

Konfigurasi Pemantauan Khusus

# ServiceMonitor khusus untuk metrics aplikasi
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
    name: app-metrics
    namespace: monitoring-system
spec:
    selector:
        matchLabels:
            app: my-application
    endpoints:
        - port: metrics
          interval: 30s
          path: /metrics

Deployment Aplikasi Melalui Rancher

Menggunakan App Catalog

App Catalog Rancher menyederhanakan deployment aplikasi umum:

Akses Apps & Marketplace: Navigasi ke bagian Apps di cluster lo
Jelajahi Catalog: Jelajahi Helm chart yang tersedia
Konfigurasi Aplikasi: Atur nilai dan deploy

Deployment Aplikasi Khusus

Deploy aplikasi menggunakan pengelolaan workload Rancher:

# Contoh deployment melalui Rancher
apiVersion: apps/v1
kind: Deployment
metadata:
    name: web-application
    namespace: production
    labels:
        app: web-app
spec:
    replicas: 3
    selector:
        matchLabels:
            app: web-app
    template:
        metadata:
            labels:
                app: web-app
        spec:
            containers:
                - name: web-app
                  image: nginx:1.21
                  ports:
                      - containerPort: 80
                  resources:
                      requests:
                          memory: "128Mi"
                          cpu: "100m"
                      limits:
                          memory: "256Mi"
                          cpu: "200m"
---
apiVersion: v1
kind: Service
metadata:
    name: web-app-service
    namespace: production
spec:
    selector:
        app: web-app
    ports:
        - port: 80
          targetPort: 80
    type: ClusterIP

Praktik Terbaik Keamanan

Kebijakan Jaringan

Implementasikan segmentasi jaringan menggunakan Kubernetes Network Policy:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
    name: frontend-netpol
    namespace: production
spec:
    podSelector:
        matchLabels:
            tier: frontend
    policyTypes:
        - Ingress
        - Egress
    ingress:
        - from:
              - namespaceSelector:
                    matchLabels:
                        name: ingress-system
          ports:
              - protocol: TCP
                port: 80
    egress:
        - to:
              - namespaceSelector:
                    matchLabels:
                        name: production
              - podSelector:
                    matchLabels:
                        tier: backend
          ports:
              - protocol: TCP
                port: 8080

Standar Keamanan Pod

Konfigurasi Pod Security Standards untuk keamanan yang ditingkatkan:

apiVersion: v1
kind: Namespace
metadata:
    name: secure-namespace
    labels:
        pod-security.kubernetes.io/enforce: restricted
        pod-security.kubernetes.io/audit: restricted
        pod-security.kubernetes.io/warn: restricted

Backup dan Pemulihan Bencana

Konfigurasi Backup Otomatis

Setup backup otomatis untuk server Rancher lo:

# Buat script backup
cat << EOF > /opt/rancher/backup.sh
#!/bin/bash
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR="/opt/rancher/backups"
mkdir -p $BACKUP_DIR

# Stop container Rancher
docker stop rancher-server

# Buat tar backup dari data
tar -czf $BACKUP_DIR/rancher_backup_$DATE.tar.gz -C /opt/rancher data

# Restart container Rancher
docker start rancher-server

# Bersihkan backup lama (simpan 7 hari terakhir)
find $BACKUP_DIR -name "rancher_backup_*.tar.gz" -mtime +7 -delete

echo "Backup completed: rancher_backup_$DATE.tar.gz"
EOF

chmod +x /opt/rancher/backup.sh

# Schedule backup harian via cron
echo "0 2 * * * /opt/rancher/backup.sh" | crontab -

Backup Status Cluster

Untuk cluster yang diimpor, pastikan lo punya strategi backup untuk:

etcd snapshot: Status inti cluster
Data aplikasi: Persistent volume dan database
Konfigurasi: ConfigMap, Secret, dan custom resource

# Buat etcd snapshot (untuk cluster dengan akses etcd langsung)
sudo /opt/rke/bin/etcd snapshot save \
  --endpoints=https://127.0.0.1:2379 \
  --cert=/opt/rke/bin/kube_etcd_127.0.0.1.pem \
  --key=/opt/rke/bin/kube_etcd_127.0.0.1-key.pem \
  --cacert=/opt/rke/bin/kube_ca.pem \
  /opt/etcd-backups/snapshot-$(date +%Y%m%d_%H%M%S).db

Optimisasi Kinerja dan Penskalaan

Alokasi Sumber Daya

Pantau dan optimisasi sumber daya server Rancher:

# Pantau penggunaan sumber daya container Rancher
docker stats rancher-server

# Cek memory dan CPU utilization
docker exec rancher-server cat /proc/meminfo
docker exec rancher-server cat /proc/loadavg

Optimisasi Database

Untuk environment production, pertimbangkan database eksternal:

# Jalankan Rancher dengan MySQL/PostgreSQL eksternal
docker run -d --restart=unless-stopped \
  --name rancher-server \
  -p 8020:80 -p 8021:443 \
  -v /opt/rancher/data:/var/lib/rancher \
  --privileged \
  rancher/rancher:stable \
  --db-host=mysql.example.com \
  --db-port=3306 \
  --db-user=rancher \
  --db-pass=password \
  --db-name=rancher

Mengatasi Masalah Umum

Masalah Startup Container

# Cek container log untuk error
docker logs rancher-server

# Verifikasi ketersediaan port
sudo netstat -tulpn | grep :8021

# Cek disk space
df -h /opt/rancher

# Verifikasi privileged mode
docker inspect rancher-server | grep Privileged

Kegagalan Impor Cluster

# Verifikasi konektivitas kubectl
kubectl cluster-info

# Cek status Rancher agent
kubectl get pods -n cattle-system

# Review log agent
kubectl logs -n cattle-system -l app=cattle-cluster-agent --tail=100

# Tes konektivitas jaringan
curl -k https://your-rancher-ip:8021/ping

Masalah Kinerja

# Pantau sumber daya sistem
top
free -h
iostat -x 1

# Cek status Docker daemon
sudo systemctl status docker

# Tinjau batas sumber daya container
docker exec rancher-server cat /sys/fs/cgroup/memory/memory.limit_in_bytes

Kesimpulan: Mentransformasi Pengelolaan Kubernetes

Implementasi Rancher sebagai platform pengelolaan terpusat udah secara fundamental mentransformasi cara gue mendekati operasi Kubernetes. Kombinasi UI yang intuitif, pengelolaan multi-cluster yang kuat, dan integrasi yang mulus dengan infrastruktur yang udah ada menciptakan fondasi yang kuat untuk penskalaan aplikasi containerized.

Perjalanan dari manual kubectl command ke dashboard pengelolaan terpadu itu nggak cuma soal efisiensi operasional, tapi tentang demokratisasi akses Kubernetes untuk anggota tim yang mungkin kesulitan dengan kompleksitas command-line. Pendekatan ini selaras sempurna dengan strategi instalasi paralel yang gue terapin selama migrasi Docker Swarm, memastikan bahwa adopsi tool baru itu meningkatkan daripada mengganggu alur kerja yang udah ada.

Entah lo mengelola satu cluster pengembangan atau mengorkestrasi puluhan environment production di beberapa cloud provider, Rancher ngasih kontrol terpusat dan visibilitas yang dibutuhin untuk orkestrasi container yang efektif di skala besar. Investasi di setup yang tepat, konfigurasi keamanan, dan pemantauan itu balik modal banget dalam bentuk pengurangan beban operasional dan peningkatan keandalan sistem.