🚀 Perjalanan DevOps Saya: Dari Dasar-Dasar Linux ke Proyek Dockerized — Ikuti di GitHub! 🐧🐳

Selamat datang di perjalanan DevOps saya! Dalam posting blog ini, saya akan mendokumentasikan perjalanan saya dari pemahaman dasar Linux hingga menerapkan proyek-proyek yang sepenuhnya di-Dockerized. Tujuannya adalah untuk berbagi pengalaman, tantangan, dan pembelajaran saya di sepanjang jalan. Saya berharap perjalanan ini dapat menginspirasi dan memberikan panduan praktis bagi siapa pun yang ingin memulai atau meningkatkan keterampilan DevOps mereka. Semua kode dan konfigurasi akan tersedia di GitHub, jadi jangan ragu untuk mengikuti dan berkontribusi!

Mengapa DevOps?

Sebelum kita menyelam lebih dalam, mari kita bahas mengapa DevOps begitu penting. DevOps bukan hanya tentang alat dan teknologi; ini adalah filosofi dan budaya yang berfokus pada kolaborasi, otomatisasi, dan pengiriman berkelanjutan. Manfaat utama DevOps meliputi:

1. Peningkatan Kecepatan Rilis: DevOps memungkinkan tim untuk merilis pembaruan dan fitur lebih cepat dan lebih sering.
2. Peningkatan Kualitas Perangkat Lunak: Dengan otomatisasi pengujian dan pemantauan berkelanjutan, kesalahan terdeteksi lebih awal, sehingga meningkatkan kualitas perangkat lunak.
3. Kolaborasi yang Lebih Baik: DevOps memecah silo antara tim pengembangan dan operasi, mempromosikan komunikasi dan kerjasama yang lebih baik.
4. Reduksi Biaya: Otomatisasi mengurangi pekerjaan manual, mengurangi biaya dan meningkatkan efisiensi.
5. Peningkatan Kepuasan Pelanggan: Dengan pengiriman yang lebih cepat dan kualitas yang lebih baik, pelanggan lebih puas.

Tahap 1: Pondasi – Dasar-Dasar Linux

Setiap perjalanan DevOps yang baik dimulai dengan fondasi yang kokoh dalam Linux. Linux adalah tulang punggung banyak infrastruktur modern, dan pemahaman yang kuat tentangnya sangat penting. Inilah yang saya pelajari di tahap awal ini:

Dasar-Dasar Command Line

Command line adalah alat yang sangat kuat untuk berinteraksi dengan Linux. Saya menghabiskan banyak waktu untuk mempelajari perintah-perintah dasar seperti:

• ls: Daftar file dan direktori.
• cd: Mengubah direktori.
• mkdir: Membuat direktori.
• rm: Menghapus file atau direktori.
• cp: Menyalin file atau direktori.
• mv: Memindahkan atau mengubah nama file atau direktori.
• cat: Menampilkan isi file.
• grep: Mencari pola dalam file.
• sudo: Menjalankan perintah dengan hak akses administrator.

Tips: Luangkan waktu untuk terbiasa dengan perintah-perintah ini. Semakin nyaman Anda dengan command line, semakin efisien Anda akan menjadi.

Manajemen Paket

Manajemen paket adalah proses menginstal, memperbarui, dan menghapus perangkat lunak di Linux. Saya bekerja dengan:

• apt (Debian/Ubuntu): Manajer paket untuk sistem Debian dan Ubuntu.
  • apt update: Memperbarui daftar paket yang tersedia.
  • apt upgrade: Meningkatkan paket yang sudah diinstal ke versi terbaru.
  • apt install <package_name>: Menginstal paket.
  • apt remove <package_name>: Menghapus paket.
• yum (CentOS/Red Hat): Manajer paket untuk sistem CentOS dan Red Hat.
  • yum update: Memperbarui semua paket.
  • yum install <package_name>: Menginstal paket.
  • yum remove <package_name>: Menghapus paket.

Tips: Pelajari cara menggunakan manajer paket yang sesuai dengan distribusi Linux Anda. Ini akan sangat memudahkan Anda dalam mengelola perangkat lunak.

Manajemen Pengguna dan Grup

Memahami cara mengelola pengguna dan grup sangat penting untuk keamanan dan izin. Beberapa perintah yang saya gunakan:

• useradd <username>: Membuat pengguna baru.
• passwd <username>: Mengatur kata sandi untuk pengguna.
• userdel <username>: Menghapus pengguna.
• groupadd <groupname>: Membuat grup baru.
• usermod -aG <groupname> <username>: Menambahkan pengguna ke grup.
• chown <user>:<group> <file>: Mengubah pemilik dan grup dari file.
• chmod <permissions> <file>: Mengubah izin file.

Tips: Selalu ikuti prinsip hak istimewa terendah. Berikan pengguna hanya izin yang mereka butuhkan untuk melakukan pekerjaan mereka.

Networking Dasar

Memahami konsep jaringan sangat penting untuk DevOps. Saya mempelajari dasar-dasar seperti:

• ifconfig atau ip addr: Menampilkan informasi jaringan.
• ping <hostname>: Menguji konektivitas ke host.
• netstat atau ss: Menampilkan koneksi jaringan.
• ssh <username>@<hostname>: Menghubungkan ke server jarak jauh melalui SSH.
• Konsep IP addressing, subnetting, dan routing.

Tips: Latih konfigurasi jaringan dasar, seperti mengatur alamat IP statis dan mengkonfigurasi firewall.

Shell Scripting

Shell scripting adalah cara yang hebat untuk mengotomatiskan tugas-tugas rutin. Saya belajar menulis skrip sederhana untuk:

• Membuat backup.
• Memantau penggunaan sumber daya.
• Mengotomatiskan penyebaran aplikasi.

Contoh sederhana:

#!/bin/bash
# Skrip untuk membuat backup direktori

SOURCE_DIR="/path/to/source/directory"
BACKUP_DIR="/path/to/backup/directory"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

# Membuat direktori backup jika belum ada
mkdir -p "$BACKUP_DIR"

# Membuat arsip tar dari direktori sumber
tar -czvf "$BACKUP_DIR/backup_$TIMESTAMP.tar.gz" "$SOURCE_DIR"

echo "Backup berhasil dibuat di: $BACKUP_DIR/backup_$TIMESTAMP.tar.gz"

Tips: Mulailah dengan skrip kecil dan sederhana, lalu tingkatkan secara bertahap saat Anda menjadi lebih nyaman. Dokumentasikan skrip Anda dengan baik.

Tahap 2: Kontainerisasi dengan Docker

Setelah memiliki fondasi Linux yang solid, saya beralih ke kontainerisasi dengan Docker. Docker memungkinkan Anda untuk mengemas aplikasi dan semua dependensinya ke dalam wadah (container) yang terisolasi, sehingga memudahkan untuk menjalankan aplikasi secara konsisten di lingkungan yang berbeda.

Dasar-Dasar Docker

Saya mulai dengan mempelajari dasar-dasar Docker:

• Docker Image: Templat baca-saja yang digunakan untuk membuat container.
• Docker Container: Instans yang dapat dijalankan dari sebuah image.
• Dockerfile: File teks yang berisi instruksi untuk membuat image Docker.
• Docker Hub: Registri publik untuk berbagi image Docker.

Instalasi dan Konfigurasi Docker

Langkah pertama adalah menginstal Docker di sistem saya. Instruksi instalasi bervariasi tergantung pada sistem operasi Anda. Anda dapat menemukan instruksi instalasi untuk berbagai sistem operasi di situs web Docker resmi.

Setelah Docker diinstal, saya mempelajari cara menjalankan container pertama saya:

docker run hello-world

Perintah ini mengunduh image hello-world dari Docker Hub (jika belum ada) dan menjalankan container dari image tersebut. Container menampilkan pesan “Hello from Docker!” dan kemudian keluar.

Membuat Dockerfile

Selanjutnya, saya belajar cara membuat Dockerfile untuk mengemas aplikasi saya sendiri. Dockerfile berisi serangkaian instruksi yang digunakan untuk membangun image Docker. Contoh Dockerfile sederhana untuk aplikasi Python:

# Menggunakan image dasar Python
FROM python:3.9-slim-buster

# Mengatur direktori kerja
WORKDIR /app

# Menyalin file requirements.txt
COPY requirements.txt .

# Menginstal dependensi
RUN pip install --no-cache-dir -r requirements.txt

# Menyalin kode sumber aplikasi
COPY . .

# Mengatur perintah untuk menjalankan aplikasi
CMD ["python", "app.py"]

Dockerfile ini melakukan hal berikut:

1. Menggunakan image dasar python:3.9-slim-buster sebagai basis.
2. Mengatur direktori kerja di dalam container menjadi /app.
3. Menyalin file requirements.txt ke dalam container.
4. Menginstal dependensi yang tercantum dalam requirements.txt menggunakan pip.
5. Menyalin semua kode sumber aplikasi ke dalam container.
6. Mengatur perintah untuk menjalankan aplikasi sebagai python app.py.

Membangun dan Menjalankan Image Docker

Setelah memiliki Dockerfile, saya dapat membangun image Docker menggunakan perintah docker build:

docker build -t my-python-app .

Perintah ini membangun image dengan nama my-python-app dari Dockerfile yang berada di direktori saat ini.

Setelah image dibangun, saya dapat menjalankan container dari image tersebut menggunakan perintah docker run:

docker run -p 5000:5000 my-python-app

Perintah ini menjalankan container dari image my-python-app dan memetakan port 5000 di host ke port 5000 di dalam container. Ini memungkinkan saya untuk mengakses aplikasi Python saya melalui browser web di http://localhost:5000.

Docker Compose

Docker Compose adalah alat untuk mendefinisikan dan menjalankan aplikasi multi-kontainer. Ini menggunakan file YAML untuk mengkonfigurasi layanan aplikasi. File docker-compose.yml mendefinisikan layanan, jaringan, dan volume yang dibutuhkan aplikasi Anda.

Contoh sederhana docker-compose.yml:

version: "3.9"
services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - db
  db:
    image: postgres:13
    environment:
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
      POSTGRES_DB: mydb

Dalam contoh ini, kita mendefinisikan dua layanan: web dan db. Layanan web dibangun dari Dockerfile di direktori saat ini dan bergantung pada layanan db, yang menggunakan image PostgreSQL. Docker Compose secara otomatis membuat dan mengkonfigurasi jaringan dan volume yang diperlukan untuk menghubungkan layanan-layanan ini.

Untuk menjalankan aplikasi dengan Docker Compose, gunakan perintah:

docker-compose up

Ini akan membangun dan menjalankan semua layanan yang didefinisikan dalam file docker-compose.yml.

Tahap 3: Proyek Dockerized

Setelah memahami dasar-dasar Docker, saya mulai mengerjakan proyek-proyek yang sepenuhnya di-Dockerized. Ini melibatkan pengemasan semua aplikasi dan dependensi saya ke dalam container Docker dan menggunakan Docker Compose untuk mengelola aplikasi multi-kontainer.

Proyek 1: Aplikasi Web Sederhana

Proyek pertama saya adalah aplikasi web sederhana yang ditulis dengan Python dan Flask. Saya membuat Dockerfile untuk mengemas aplikasi dan semua dependensinya ke dalam container Docker. Saya juga membuat file docker-compose.yml untuk mendefinisikan layanan aplikasi dan jaringan yang diperlukan.

Berikut adalah struktur direktori proyek:

my-web-app/
├── app.py
├── requirements.txt
├── Dockerfile
└── docker-compose.yml

File app.py berisi kode sumber aplikasi Flask:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello, Docker!"

if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0")

File requirements.txt berisi daftar dependensi Python:

Flask

Dockerfile:

FROM python:3.9-slim-buster

WORKDIR /app

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["python", "app.py"]

File docker-compose.yml:

version: "3.9"
services:
  web:
    build: .
    ports:
      - "5000:5000"

Dengan menjalankan docker-compose up, aplikasi web berjalan di dalam container Docker dan dapat diakses melalui http://localhost:5000.

Proyek 2: Aplikasi dengan Database

Proyek kedua saya sedikit lebih kompleks dan melibatkan aplikasi web yang terhubung ke database PostgreSQL. Saya menggunakan Docker Compose untuk mengelola aplikasi web dan database sebagai layanan terpisah. Ini memungkinkan saya untuk dengan mudah menskalakan dan mengelola aplikasi dan database secara independen.

Struktur direktori proyek:

my-app-with-db/
├── app.py
├── requirements.txt
├── Dockerfile
└── docker-compose.yml

File app.py (contoh sederhana):

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
import os

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL', 'postgresql://user:password@db:5432/mydb')
db = SQLAlchemy(app)

class Todo(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    task = db.Column(db.String(200))

    def __repr__(self):
        return f"<Todo {self.task}>"

@app.route("/")
def index():
    todos = Todo.query.all()
    output = ', '.join([todo.task for todo in todos])
    return f"Todos: {output}"

if __name__ == "__main__":
    with app.app_context():
        db.create_all() # Create database tables
    app.run(debug=True, host="0.0.0.0")

File requirements.txt:

Flask
Flask-SQLAlchemy
psycopg2-binary

Dockerfile (sama seperti sebelumnya, tetapi dengan dependensi yang berbeda):

FROM python:3.9-slim-buster

WORKDIR /app

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["python", "app.py"]

File docker-compose.yml:

version: "3.9"
services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - db
    environment:
      DATABASE_URL: postgresql://myuser:mypassword@db:5432/mydb
  db:
    image: postgres:13
    environment:
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
      POSTGRES_DB: mydb

Dengan docker-compose up, aplikasi web dan database berjalan sebagai layanan terpisah, terhubung melalui jaringan Docker. Ini memungkinkan skalabilitas dan isolasi yang lebih baik.

Tahap 4: Otomatisasi dengan CI/CD

Langkah selanjutnya dalam perjalanan DevOps saya adalah mengotomatiskan proses pengujian, pembangunan, dan penyebaran aplikasi saya menggunakan CI/CD (Continuous Integration/Continuous Deployment). Ini melibatkan penggunaan alat seperti Jenkins, GitLab CI, atau CircleCI untuk secara otomatis menjalankan pengujian, membangun image Docker, dan menyebarkan aplikasi ke lingkungan produksi setiap kali ada perubahan kode.

Jenkins

Jenkins adalah server otomatisasi sumber terbuka yang banyak digunakan untuk CI/CD. Saya menggunakan Jenkins untuk mengotomatiskan alur kerja pembangunan dan penyebaran aplikasi saya.

Langkah-langkah dasar untuk mengkonfigurasi Jenkins:

1. Instalasi Jenkins: Instal Jenkins di server atau container Docker.
2. Konfigurasi Jenkins: Konfigurasi kredensial dan plugin yang diperlukan (seperti Docker plugin).
3. Membuat Job Jenkins: Buat job baru yang akan menjalankan alur kerja CI/CD Anda.
4. Konfigurasi Source Code Management: Konfigurasi Jenkins untuk memantau repositori kode sumber Anda (misalnya, GitHub).
5. Menentukan Build Steps: Tentukan langkah-langkah yang akan dieksekusi Jenkins (misalnya, menjalankan pengujian, membangun image Docker, menyebarkan aplikasi).

Contoh sederhana Jenkinsfile (Pipeline as Code):

pipeline {
    agent any
    stages {
        stage('Checkout') {
            steps {
                git 'https://github.com/yourusername/yourrepository.git'
            }
        }
        stage('Build') {
            steps {
                sh 'docker build -t my-app .'
            }
        }
        stage('Test') {
            steps {
                sh 'docker run my-app:latest pytest'
            }
        }
        stage('Deploy') {
            steps {
                sh 'docker push my-app:latest'
            }
        }
    }
}

Ini adalah contoh sangat dasar. Alur kerja yang lebih kompleks mungkin melibatkan integrasi dengan alat pengujian tambahan, analisis statis kode, dan strategi penyebaran yang lebih canggih.

GitLab CI

GitLab CI adalah sistem CI/CD yang terintegrasi langsung ke GitLab. Ini memungkinkan Anda untuk mengotomatiskan alur kerja pembangunan dan penyebaran Anda langsung dari repositori GitLab Anda.

Konfigurasi GitLab CI dilakukan melalui file .gitlab-ci.yml di akar repositori Anda.

Contoh sederhana .gitlab-ci.yml:

stages:
  - build
  - test
  - deploy

build:
  stage: build
  image: docker:latest
  services:
    - docker:dind
  script:
    - docker build -t my-app .
  artifacts:
    paths:
      - ./my-app.tar

test:
  stage: test
  image: python:3.9-slim-buster
  script:
    - pip install pytest
    - pytest

deploy:
  stage: deploy
  image: docker:latest
  services:
    - docker:dind
  script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker load -i my-app.tar
    - docker push $CI_REGISTRY_IMAGE:latest

File ini mendefinisikan tiga stage: build, test, dan deploy. Setiap stage menjalankan serangkaian perintah untuk membangun, menguji, dan menyebarkan aplikasi Anda. Variabel lingkungan seperti CI_REGISTRY_USER, CI_REGISTRY_PASSWORD, dan CI_REGISTRY_IMAGE dikonfigurasi di pengaturan proyek GitLab Anda.

Tahap 5: Orchestration dengan Kubernetes

Setelah memiliki dasar CI/CD yang solid, saya mulai menjelajahi orchestration dengan Kubernetes. Kubernetes adalah platform orchestrasi container open-source yang memungkinkan Anda untuk mengotomatiskan penyebaran, penskalaan, dan pengelolaan aplikasi yang di-containerized.

Dasar-Dasar Kubernetes

Saya mempelajari dasar-dasar Kubernetes:

• Pod: Unit terkecil dari penyebaran di Kubernetes. Pod berisi satu atau lebih container yang saling berbagi sumber daya dan jaringan.
• Deployment: Objek yang mengelola replika Pod dan memastikan jumlah replika yang diinginkan selalu berjalan.
• Service: Abstrak yang menyediakan titik akses stabil ke Pod, bahkan jika Pod dibuat ulang atau dipindahkan.
• Namespace: Cara untuk mengorganisasikan dan mengisolasi sumber daya di dalam kluster Kubernetes.
• kubectl: Alat baris perintah untuk berinteraksi dengan kluster Kubernetes.

Menjalankan Aplikasi di Kubernetes

Langkah-langkah dasar untuk menyebarkan aplikasi ke Kubernetes:

1. Membuat Image Docker: Buat image Docker dari aplikasi Anda (seperti yang dijelaskan sebelumnya).
2. Membuat File Deployment: Buat file YAML yang mendefinisikan Deployment aplikasi Anda.
3. Membuat File Service: Buat file YAML yang mendefinisikan Service untuk aplikasi Anda.
4. Menyebarkan ke Kluster: Gunakan kubectl untuk menyebarkan Deployment dan Service ke kluster Kubernetes Anda.

Contoh Deployment YAML (deployment.yaml):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: your-docker-registry/my-app:latest
        ports:
        - containerPort: 5000

Contoh Service YAML (service.yaml):

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 5000
  type: LoadBalancer

Menyebarkan ke kluster:

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

Ini akan membuat Deployment dengan tiga replika Pod dan Service yang mengekspos aplikasi Anda melalui LoadBalancer.

Minikube

Minikube adalah implementasi Kubernetes ringan yang memungkinkan Anda menjalankan kluster Kubernetes single-node di laptop Anda. Ini sangat berguna untuk pengembangan dan pengujian lokal.

Untuk menggunakan Minikube:

1. Instal Minikube: Unduh dan instal Minikube dari situs web resminya.
2. Mulai Kluster: Gunakan perintah minikube start untuk memulai kluster Minikube.
3. Gunakan kubectl: Konfigurasi kubectl untuk terhubung ke kluster Minikube Anda.

Pelajaran yang Dipetik dan Tips

Sepanjang perjalanan DevOps saya, saya telah belajar banyak hal. Berikut adalah beberapa pelajaran utama dan tips yang ingin saya bagikan:

• Mulailah dari yang Kecil: Jangan mencoba untuk mempelajari semuanya sekaligus. Mulailah dengan dasar-dasar dan secara bertahap bangun keterampilan Anda.
• Berlatih: Cara terbaik untuk belajar DevOps adalah dengan berlatih. Kerjakan proyek-proyek kecil dan eksperimen dengan alat dan teknologi yang berbeda.
• Bergabunglah dengan Komunitas: Bergabunglah dengan komunitas DevOps online dan offline. Berpartisipasilah dalam diskusi, ajukan pertanyaan, dan bagikan pengetahuan Anda.
• Otomatiskan Segalanya: Otomatisasi adalah kunci untuk DevOps. Otomatiskan sebanyak mungkin tugas, termasuk pengujian, pembangunan, dan penyebaran.
• Pantau Segalanya: Pemantauan sangat penting untuk memastikan aplikasi Anda berjalan dengan baik. Pantau metrik sistem, log aplikasi, dan peringatan.
• Terus Belajar: DevOps terus berkembang. Teruslah belajar dan ikuti perkembangan teknologi dan tren terbaru.
• Dokumentasikan Segalanya: Dokumentasikan proses, konfigurasi, dan kode Anda. Ini akan membantu Anda dan orang lain untuk memahami dan memelihara sistem Anda.

Ikuti Perjalanan Saya di GitHub

Semua kode dan konfigurasi yang saya gunakan dalam proyek-proyek ini tersedia di GitHub. Jangan ragu untuk mengikuti dan berkontribusi!

[Tautan ke Repositori GitHub]

Kesimpulan

Perjalanan DevOps saya adalah perjalanan yang berkelanjutan. Saya terus belajar dan meningkatkan keterampilan saya. Saya harap posting blog ini telah memberikan wawasan dan inspirasi bagi Anda. Ingat, DevOps bukan hanya tentang alat dan teknologi; ini adalah tentang budaya kolaborasi, otomatisasi, dan pengiriman berkelanjutan. Selamat mencoba!