Gitea Runner untuk Gitea Actions

Panduan lengkap instalasi, konfigurasi, dan penggunaan Gitea Runner untuk menjalankan CI/CD workflows dengan Gitea Actions.

Pengenalan

Gitea Runner adalah aplikasi yang menjalankan jobs dari Gitea Actions. Runner bertindak sebagai worker yang mengeksekusi workflows yang didefinisikan dalam repository Gitea Anda.

Fitur Utama

Multi-Platform: Mendukung Linux, Windows, dan macOS
Docker Support: Dapat menjalankan jobs dalam container Docker
Kubernetes Native: Dapat di-deploy sebagai pod di Kubernetes
Label-Based: Mendukung penugasan jobs berdasarkan labels
Scalable: Dapat menjalankan multiple jobs secara bersamaan

Arsitektur

┌─────────────────┐
│  Gitea Server   │
│   (Actions)     │
└────────┬────────┘
         │
         │ (REST API)
         │
┌────────┴────────┐
│  Gitea Runner   │
│   (Worker)      │
└────────┬────────┘
         │
         │ (Executes)
         │
┌────────┴────────┐
│   Job Executor  │
│  (Docker/Shell) │
└─────────────────┘

Existing Runners Setup

Di environment kita sudah ada 3 Gitea Runners yang aktif dan siap digunakan untuk menjalankan workflows:

Runner Labels

Runner Name	Label	Runs On	Deskripsi
gitea-runner-00	`gitea-runner-00`	`runs-on: ["gitea-runner-00"]`	Runner utama untuk production workloads
gitea-runner-01	`gitea-runner-01`	`runs-on: ["gitea-runner-01"]`	Runner untuk staging/testing
gitea-runner-02	`gitea-runner-02`	`runs-on: ["gitea-runner-02"]`	Runner untuk development/experimental

Cara Menggunakan Runners

1. Menggunakan Runner Spesifik

# .gitea/workflows/production.yml
name: Production Deploy
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ["gitea-runner-00"]  # Gunakan runner production
    steps:
      - uses: actions/checkout@v3
      - name: Deploy to production
        run: |
          echo "Deploying to production..."
          # Your deployment commands

2. Menggunakan Runner untuk Staging

# .gitea/workflows/staging.yml
name: Staging Deploy
on:
  push:
    branches: [staging, develop]

jobs:
  deploy:
    runs-on: ["gitea-runner-01"]  # Gunakan runner staging
    steps:
      - uses: actions/checkout@v3
      - name: Deploy to staging
        run: |
          echo "Deploying to staging..."
          # Your deployment commands

3. Menggunakan Runner untuk Development

# .gitea/workflows/dev.yml
name: Development Build
on:
  push:
    branches: [dev, feature/*]

jobs:
  build:
    runs-on: ["gitea-runner-02"]  # Gunakan runner development
    steps:
      - uses: actions/checkout@v3
      - name: Build and test
        run: |
          npm install
          npm run build
          npm test

4. Multi-Runner Strategy (Parallel Execution)

# .gitea/workflows/parallel.yml
name: Parallel Testing
on: [push, pull_request]

jobs:
  test-unit:
    runs-on: ["gitea-runner-00"]
    steps:
      - uses: actions/checkout@v3
      - name: Run unit tests
        run: npm test

  test-integration:
    runs-on: ["gitea-runner-01"]
    steps:
      - uses: actions/checkout@v3
      - name: Run integration tests
        run: npm run test:integration

  test-e2e:
    runs-on: ["gitea-runner-02"]
    steps:
      - uses: actions/checkout@v3
      - name: Run E2E tests
        run: npm run test:e2e

5. Load Balancing Across Runners

# .gitea/workflows/load-balance.yml
name: Load Balanced Build
on: [push]

jobs:
  build:
    strategy:
      matrix:
        runner: ["gitea-runner-00", "gitea-runner-01", "gitea-runner-02"]
        node-version: [18, 20]
    runs-on: [${{ matrix.runner }}]
    steps:
      - uses: actions/checkout@v3
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node-version }}
      - name: Build
        run: npm run build

Best Practices untuk Multiple Runners

1. Environment-Based Runner Selection

name: Smart Deploy
on:
  push:
    branches: [main, staging, dev]

jobs:
  deploy:
    runs-on: |
      ${{ 
        github.ref == 'refs/heads/main' && '["gitea-runner-00"]' ||
        github.ref == 'refs/heads/staging' && '["gitea-runner-01"]' ||
        '["gitea-runner-02"]'
      }}
    steps:
      - uses: actions/checkout@v3
      - name: Deploy
        run: ./deploy.sh

2. Fallback Runner Strategy

name: Deploy with Fallback
on: [push]

jobs:
  deploy:
    # Coba runner utama, fallback ke runner lain jika busy
    runs-on: ["gitea-runner-00"]
    steps:
      - uses: actions/checkout@v3
      - name: Deploy
        run: ./deploy.sh
  
  deploy-fallback:
    needs: [deploy]
    if: failure()
    runs-on: ["gitea-runner-01"]
    steps:
      - uses: actions/checkout@v3
      - name: Retry deploy on fallback runner
        run: ./deploy.sh

3. Resource-Based Allocation

name: Resource Optimized
on: [push]

jobs:
  # Heavy workload -> Runner 00
  build-docker:
    runs-on: ["gitea-runner-00"]
    steps:
      - uses: actions/checkout@v3
      - name: Build Docker image
        run: docker build -t myapp:latest .
  
  # Medium workload -> Runner 01
  run-tests:
    runs-on: ["gitea-runner-01"]
    steps:
      - uses: actions/checkout@v3
      - name: Run tests
        run: npm test
  
  # Light workload -> Runner 02
  lint:
    runs-on: ["gitea-runner-02"]
    steps:
      - uses: actions/checkout@v3
      - name: Lint code
        run: npm run lint

Monitoring Runners

Check Runner Status

# Via Gitea UI
# Navigate to: Site Administration → Actions → Runners
# Cek status masing-masing runner (idle, busy, offline)

# Via API
curl -H "Authorization: token YOUR_TOKEN" \
  https://gitea.example.com/api/v1/admin/runners

Runner Health Check Workflow

# .gitea/workflows/runner-health.yml
name: Runner Health Check
on:
  schedule:
    - cron: '0 */6 * * *'  # Every 6 hours

jobs:
  check-runner-00:
    runs-on: ["gitea-runner-00"]
    steps:
      - name: Health check
        run: |
          echo "Runner 00 is healthy"
          df -h
          free -h
  
  check-runner-01:
    runs-on: ["gitea-runner-01"]
    steps:
      - name: Health check
        run: |
          echo "Runner 01 is healthy"
          df -h
          free -h
  
  check-runner-02:
    runs-on: ["gitea-runner-02"]
    steps:
      - name: Health check
        run: |
          echo "Runner 02 is healthy"
          df -h
          free -h

Runner Configuration Info

Setiap runner dikonfigurasi dengan:

Capacity: 2-4 concurrent jobs
Docker Support: Docker-in-Docker enabled
Network: Access ke internal network dan internet
Storage: Ephemeral workspace dengan auto-cleanup
Labels: Custom labels untuk targeting spesifik

Troubleshooting

Runner Tidak Tersedia

# Check runner status di Gitea UI
# Site Administration → Actions → Runners

# Jika runner offline, check pod status
kubectl get pods -n gitea -l app=gitea-runner

# Check logs
kubectl logs -n gitea gitea-runner-00

Job Stuck in Queue

# Pastikan label benar
runs-on: ["gitea-runner-00"]  # ✅ Benar

# Bukan:
runs-on: gitea-runner-00      # ❌ Salah (bukan array)
runs-on: ["ubuntu-latest"]    # ❌ Salah (label tidak ada)

All Runners Busy

# Gunakan strategy untuk distribute load
strategy:
  matrix:
    runner: ["gitea-runner-00", "gitea-runner-01", "gitea-runner-02"]
runs-on: [${{ matrix.runner }}]

Instalasi Runner Baru (Opsional)

Jika Anda perlu menambah runner baru di luar 3 runner yang sudah ada:

Metode 1: Binary Installation (Linux)

Download Gitea Runner:

# Download latest release
wget https://dl.gitea.com/act_runner/latest/act_runner-latest-linux-amd64 -O act_runner

# Berikan permission executable
chmod +x act_runner

# Pindahkan ke system path
sudo mv act_runner /usr/local/bin/

Verifikasi Instalasi:

act_runner --version

Metode 2: Docker Installation

# Pull image
docker pull gitea/act_runner:latest

# Jalankan container
docker run -d \
  --name gitea-runner \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v $PWD/data:/data \
  gitea/act_runner:latest

Metode 3: Kubernetes Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gitea-runner
  namespace: gitea
spec:
  replicas: 2
  selector:
    matchLabels:
      app: gitea-runner
  template:
    metadata:
      labels:
        app: gitea-runner
    spec:
      containers:
      - name: runner
        image: gitea/act_runner:0.2.6
        env:
        - name: GITEA_INSTANCE_URL
          value: "https://gitea.example.com"
        - name: GITEA_RUNNER_REGISTRATION_TOKEN
          valueFrom:
            secretKeyRef:
              name: gitea-runner-secret
              key: token
        - name: GITEA_RUNNER_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: GITEA_RUNNER_LABELS
          value: "ubuntu-latest:docker://node:20-bookworm,ubuntu-22.04:docker://node:20-bookworm"
        volumeMounts:
        - name: docker-sock
          mountPath: /var/run/docker.sock
        - name: runner-data
          mountPath: /data
        securityContext:
          privileged: true
      volumes:
      - name: docker-sock
        hostPath:
          path: /var/run/docker.sock
      - name: runner-data
        persistentVolumeClaim:
          claimName: gitea-runner-data
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: gitea-runner-data
  namespace: gitea
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
---
apiVersion: v1
kind: Secret
metadata:
  name: gitea-runner-secret
  namespace: gitea
type: Opaque
stringData:
  token: "YOUR_REGISTRATION_TOKEN_HERE"

Registrasi Runner

Mendapatkan Registration Token

Login ke Gitea sebagai administrator
Navigasi ke Site Administration → Actions → Runners
Klik Create new Runner
Copy Registration Token yang ditampilkan

Registrasi via Command Line

# Generate config file
act_runner generate-config > config.yaml

# Edit config sesuai kebutuhan
nano config.yaml

# Registrasi runner
act_runner register \
  --instance https://gitea.example.com \
  --token YOUR_REGISTRATION_TOKEN \
  --name my-runner \
  --labels ubuntu-latest:docker://node:20-bookworm

Registrasi Interactive

act_runner register --no-interactive

Anda akan diminta memasukkan:

Gitea instance URL
Registration token
Runner name
Runner labels

Konfigurasi Runner

File Konfigurasi (config.yaml)

log:
  level: info

runner:
  file: .runner
  capacity: 1
  envs: {}
  env_file: .env
  timeout: 3h
  insecure: false
  fetch_timeout: 5s
  fetch_interval: 2s
  labels:
    - "ubuntu-latest:docker://node:20-bookworm"
    - "ubuntu-22.04:docker://catthehacker/ubuntu:act-22.04"

cache:
  enabled: true
  dir: ""
  host: ""
  port: 0
  external_server: ""

container:
  network: ""
  privileged: false
  options: ""
  workdir_parent: ""
  valid_volumes: []
  docker_host: ""
  force_pull: false

host:
  workdir_parent: ""

Penjelasan Konfigurasi Penting

Runner Capacity

runner:
  capacity: 2  # Jumlah maksimal jobs yang berjalan bersamaan

Runner Labels

Labels menentukan jenis environment yang dapat dijalankan runner:

runner:
  labels:
    - "ubuntu-latest:docker://node:20-bookworm"
    - "ubuntu-20.04:docker://catthehacker/ubuntu:act-20.04"
    - "self-hosted:host://-self-hosted"

Format: label:executor://image

label: Nama yang digunakan dalam workflow
executor: docker atau host
image: Docker image (untuk docker executor)

Container Configuration

container:
  network: "bridge"           # Network mode untuk container
  privileged: false           # Jalankan container dalam privileged mode
  options: "--cpus 2"         # Options tambahan untuk docker
  docker_host: ""             # Custom docker host
  force_pull: true            # Selalu pull image terbaru

Menjalankan Runner

Metode 1: Foreground

act_runner daemon --config config.yaml

Metode 2: Background (dengan systemd)

Buat systemd service file:

sudo nano /etc/systemd/system/gitea-runner.service

[Unit]
Description=Gitea Actions Runner
After=network.target

[Service]
Type=simple
User=gitea-runner
WorkingDirectory=/home/gitea-runner
ExecStart=/usr/local/bin/act_runner daemon --config /home/gitea-runner/config.yaml
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Enable dan start service:

sudo systemctl daemon-reload
sudo systemctl enable gitea-runner
sudo systemctl start gitea-runner
sudo systemctl status gitea-runner

Metode 3: Docker Compose

version: '3.8'

services:
  gitea-runner:
    image: gitea/act_runner:0.2.6
    container_name: gitea-runner
    restart: unless-stopped
    environment:
      GITEA_INSTANCE_URL: https://gitea.example.com
      GITEA_RUNNER_REGISTRATION_TOKEN: ${REGISTRATION_TOKEN}
      GITEA_RUNNER_NAME: docker-runner-01
      GITEA_RUNNER_LABELS: ubuntu-latest:docker://node:20-bookworm
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./data:/data
      - ./config.yaml:/config.yaml
    command: daemon --config /config.yaml

Membuat Workflow untuk Gitea Actions

Basic Workflow Example

Buat file .gitea/workflows/ci.yml:

name: CI Pipeline
on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  build:
    runs-on: ["gitea-runner-00"]  # Gunakan runner yang tersedia
    steps:
      - name: Checkout code
        uses: actions/checkout@v3
      
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '20'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run tests
        run: npm test
      
      - name: Build
        run: npm run build

  lint:
    runs-on: ["gitea-runner-01"]  # Parallel execution di runner berbeda
    steps:
      - uses: actions/checkout@v3
      
      - name: Run linter
        run: |
          npm ci
          npm run lint

Advanced Workflow dengan Matrix

name: Multi-Platform Build
on: [push, pull_request]

jobs:
  test:
    runs-on: [${{ matrix.runner }}]
    strategy:
      matrix:
        runner: ["gitea-runner-00", "gitea-runner-01", "gitea-runner-02"]
        node: [18, 20, 21]
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Node ${{ matrix.node }}
        uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node }}
      
      - name: Install and Test
        run: |
          npm ci
          npm test

Docker Build Workflow

name: Docker Build and Push
on:
  push:
    tags:
      - 'v*'

jobs:
  docker:
    runs-on: ["gitea-runner-00"]  # Production runner untuk Docker build
    steps:
      - uses: actions/checkout@v3
      
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v2
      
      - name: Login to Container Registry
        uses: docker/login-action@v2
        with:
          registry: gitea.example.com
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
      
      - name: Build and push
        uses: docker/build-push-action@v4
        with:
          context: .
          push: true
          tags: registry.example.com/myapp:${{ github.ref_name }}

Complete Production Workflow Example

name: Complete CI/CD Pipeline
on:
  push:
    branches: [main, staging, develop]
  pull_request:
    branches: [main, staging]

jobs:
  # Lint pada runner development
  lint:
    runs-on: ["gitea-runner-02"]
    steps:
      - uses: actions/checkout@v3
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '20'
      - name: Install dependencies
        run: npm ci
      - name: Run ESLint
        run: npm run lint
      - name: Run Prettier
        run: npm run format:check

  # Unit tests pada runner staging
  test-unit:
    runs-on: ["gitea-runner-01"]
    needs: [lint]
    steps:
      - uses: actions/checkout@v3
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '20'
      - name: Install dependencies
        run: npm ci
      - name: Run unit tests
        run: npm test
      - name: Upload coverage
        uses: actions/upload-artifact@v3
        with:
          name: coverage
          path: coverage/

  # Build pada runner production
  build:
    runs-on: ["gitea-runner-00"]
    needs: [test-unit]
    steps:
      - uses: actions/checkout@v3
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '20'
      - name: Install dependencies
        run: npm ci
      - name: Build application
        run: npm run build
      - name: Upload build artifact
        uses: actions/upload-artifact@v3
        with:
          name: build
          path: build/

  # Docker build and push
  docker:
    runs-on: ["gitea-runner-00"]
    needs: [build]
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v3
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v2
      - name: Login to Registry
        uses: docker/login-action@v2
        with:
          registry: registry.example.com
          username: ${{ secrets.REGISTRY_USERNAME }}
          password: ${{ secrets.REGISTRY_PASSWORD }}
      - name: Build and push
        uses: docker/build-push-action@v4
        with:
          context: .
          push: true
          tags: |
            registry.example.com/myapp:latest
            registry.example.com/myapp:${{ github.sha }}
          cache-from: type=registry,ref=registry.example.com/myapp:buildcache
          cache-to: type=registry,ref=registry.example.com/myapp:buildcache,mode=max

  # Deploy to Kubernetes
  deploy:
    runs-on: ["gitea-runner-00"]
    needs: [docker]
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v3
      - name: Deploy to Kubernetes
        env:
          KUBECONFIG: ${{ secrets.KUBECONFIG }}
        run: |
          kubectl set image deployment/myapp \
            myapp=registry.example.com/myapp:${{ github.sha }} \
            -n production
          kubectl rollout status deployment/myapp -n production

Runner Labels dan Executors

Jenis Executor

1. Docker Executor

Menjalankan jobs dalam Docker container (recommended):

labels:
  - "ubuntu-latest:docker://node:20-bookworm"

Keuntungan:

Isolated environment
Reproducible builds
Easy cleanup

2. Host Executor

Menjalankan jobs langsung di host machine:

labels:
  - "self-hosted:host://-self-hosted"

Keuntungan:

Lebih cepat (no container overhead)
Akses langsung ke host resources

Kerugian:

Tidak isolated
Bisa meninggalkan artifacts

Custom Labels

Anda dapat membuat custom labels untuk kebutuhan spesifik:

labels:
  - "gpu-enabled:docker://nvidia/cuda:12.0-runtime"
  - "high-memory:docker://node:20-bookworm"
  - "arm64:docker://arm64v8/node:20"

Gunakan dalam workflow:

jobs:
  gpu-job:
    runs-on: ["gpu-enabled"]  # Custom label jika ada runner dengan GPU
    steps:
      - name: Run GPU task
        run: nvidia-smi

Monitoring dan Troubleshooting

Melihat Status Runner

Via Web UI:

Login ke Gitea
Site Administration → Actions → Runners
Lihat status, last seen, dan job history

Via Command Line:

# Lihat logs runner
journalctl -u gitea-runner -f

# Atau jika menggunakan Docker
docker logs -f gitea-runner

Common Issues

Runner tidak terhubung ke Gitea

Solusi:

Periksa network connectivity:

curl -I https://gitea.example.com

Verifikasi registration token masih valid
Periksa firewall rules

Jobs gagal dengan "No available runner"

Solusi:

Pastikan runner memiliki label yang sesuai dengan runs-on di workflow
Periksa runner capacity tidak penuh
Verifikasi runner dalam status "idle"

Docker pull rate limit

Solusi:

container:
  docker_host: ""
  force_pull: false  # Jangan selalu pull

Atau gunakan registry mirror/cache

Permission denied errors

Solusi:

# Tambahkan user ke docker group
sudo usermod -aG docker gitea-runner

# Restart runner service
sudo systemctl restart gitea-runner

Debug Mode

Jalankan runner dalam debug mode untuk troubleshooting:

act_runner daemon --config config.yaml --log-level debug

Best Practices

1. Security

# Jangan gunakan privileged mode kecuali benar-benar diperlukan
container:
  privileged: false

# Batasi valid volumes
container:
  valid_volumes:
    - /tmp
    - /home/runner/workspace

2. Resource Management

# Batasi concurrent jobs
runner:
  capacity: 2
  timeout: 1h  # Set timeout untuk mencegah jobs hang

# Gunakan resource limits di Kubernetes
resources:
  limits:
    cpu: "2"
    memory: "4Gi"
  requests:
    cpu: "1"
    memory: "2Gi"

3. High Availability

Deploy multiple runners:

# Kubernetes: scale deployment
kubectl scale deployment gitea-runner --replicas=5 -n gitea

# Atau jalankan multiple instances dengan nama berbeda
act_runner daemon --name runner-01 &
act_runner daemon --name runner-02 &

4. Caching

Enable caching untuk mempercepat builds:

cache:
  enabled: true
  dir: /tmp/cache

Gunakan cache actions dalam workflow:

- name: Cache dependencies
  uses: actions/cache@v3
  with:
    path: ~/.npm
    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}

5. Monitoring

Setup Prometheus metrics (jika tersedia):

# Expose metrics endpoint
metrics:
  enabled: true
  listen: ":9090"

Log aggregation:

# Kirim logs ke centralized logging
journalctl -u gitea-runner -f | your-log-shipper

Upgrade Runner

Binary Upgrade

# Stop runner
sudo systemctl stop gitea-runner

# Backup config
cp config.yaml config.yaml.backup

# Download versi baru
wget https://dl.gitea.com/act_runner/0.2.7/act_runner-0.2.7-linux-amd64 -O act_runner
chmod +x act_runner
sudo mv act_runner /usr/local/bin/

# Start runner
sudo systemctl start gitea-runner

Docker Upgrade

# Pull image baru
docker pull gitea/act_runner:0.2.7

# Update compose file atau deployment
# Restart container
docker-compose up -d

Kubernetes Upgrade

# Update image version di deployment
kubectl set image deployment/gitea-runner \
  runner=gitea/act_runner:0.2.7 -n gitea

# Atau apply manifest yang sudah diupdate
kubectl apply -f gitea-runner-deployment.yaml

Practical Workflow Examples untuk 3 Runners

Berikut contoh-contoh praktis menggunakan ketiga runner yang tersedia:

Example 1: Environment-Based Deployment

# .gitea/workflows/deploy.yml
name: Environment Deploy
on:
  push:
    branches: [main, staging, develop]

jobs:
  deploy-production:
    if: github.ref == 'refs/heads/main'
    runs-on: ["gitea-runner-00"]
    environment: production
    steps:
      - uses: actions/checkout@v3
      - name: Deploy to production
        run: |
          echo "Deploying to production cluster..."
          kubectl apply -f k8s/production/ -n production
          kubectl rollout status deployment/myapp -n production

  deploy-staging:
    if: github.ref == 'refs/heads/staging'
    runs-on: ["gitea-runner-01"]
    environment: staging
    steps:
      - uses: actions/checkout@v3
      - name: Deploy to staging
        run: |
          echo "Deploying to staging cluster..."
          kubectl apply -f k8s/staging/ -n staging
          kubectl rollout status deployment/myapp -n staging

  deploy-development:
    if: github.ref == 'refs/heads/develop'
    runs-on: ["gitea-runner-02"]
    environment: development
    steps:
      - uses: actions/checkout@v3
      - name: Deploy to development
        run: |
          echo "Deploying to development cluster..."
          kubectl apply -f k8s/development/ -n development

Example 2: Microservices Pipeline

# .gitea/workflows/microservices.yml
name: Microservices CI/CD
on: [push, pull_request]

jobs:
  # Frontend pada runner-02 (lightest workload)
  build-frontend:
    runs-on: ["gitea-runner-02"]
    steps:
      - uses: actions/checkout@v3
      - name: Build frontend
        run: |
          cd frontend
          npm ci
          npm run build
      - name: Push frontend image
        run: |
          docker build -t registry.example.com/frontend:${{ github.sha }} ./frontend
          docker push registry.example.com/frontend:${{ github.sha }}

  # Backend API pada runner-01
  build-backend:
    runs-on: ["gitea-runner-01"]
    steps:
      - uses: actions/checkout@v3
      - name: Build backend
        run: |
          cd backend
          npm ci
          npm run build
      - name: Push backend image
        run: |
          docker build -t registry.example.com/backend:${{ github.sha }} ./backend
          docker push registry.example.com/backend:${{ github.sha }}

  # Database migrations pada runner-00 (production-safe)
  migrate-database:
    runs-on: ["gitea-runner-00"]
    needs: [build-backend]
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v3
      - name: Run migrations
        run: |
          cd backend
          npm run migrate:up

  # Deploy all services
  deploy-all:
    runs-on: ["gitea-runner-00"]
    needs: [build-frontend, build-backend, migrate-database]
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v3
      - name: Deploy microservices
        run: |
          kubectl set image deployment/frontend frontend=registry.example.com/frontend:${{ github.sha }} -n production
          kubectl set image deployment/backend backend=registry.example.com/backend:${{ github.sha }} -n production
          kubectl rollout status deployment/frontend -n production
          kubectl rollout status deployment/backend -n production

Example 3: Testing Strategy Across Runners

# .gitea/workflows/test-strategy.yml
name: Comprehensive Testing
on: [push, pull_request]

jobs:
  # Quick tests pada runner-02
  quick-checks:
    runs-on: ["gitea-runner-02"]
    steps:
      - uses: actions/checkout@v3
      - name: Lint
        run: npm run lint
      - name: Type check
        run: npm run type-check
      - name: Security audit
        run: npm audit

  # Unit tests pada runner-01
  unit-tests:
    runs-on: ["gitea-runner-01"]
    needs: [quick-checks]
    steps:
      - uses: actions/checkout@v3
      - name: Run unit tests
        run: |
          npm ci
          npm run test:unit -- --coverage
      - name: Upload coverage
        uses: actions/upload-artifact@v3
        with:
          name: coverage-unit
          path: coverage/

  # Integration tests pada runner-00
  integration-tests:
    runs-on: ["gitea-runner-00"]
    needs: [quick-checks]
    services:
      postgres:
        image: postgres:15
        env:
          POSTGRES_PASSWORD: test
      redis:
        image: redis:7
    steps:
      - uses: actions/checkout@v3
      - name: Run integration tests
        run: |
          npm ci
          npm run test:integration
        env:
          DATABASE_URL: postgresql://postgres:test@postgres:5432/testdb
          REDIS_URL: redis://redis:6379

  # E2E tests pada runner-00 (heavy workload)
  e2e-tests:
    runs-on: ["gitea-runner-00"]
    needs: [unit-tests, integration-tests]
    steps:
      - uses: actions/checkout@v3
      - name: Start test environment
        run: docker-compose -f docker-compose.test.yml up -d
      - name: Run E2E tests
        run: npm run test:e2e
      - name: Cleanup
        if: always()
        run: docker-compose -f docker-compose.test.yml down

Example 4: Monorepo Build Optimization

# .gitea/workflows/monorepo.yml
name: Monorepo Build
on:
  push:
    branches: [main, develop]

jobs:
  # Detect changes
  changes:
    runs-on: ["gitea-runner-02"]
    outputs:
      frontend: ${{ steps.changes.outputs.frontend }}
      backend: ${{ steps.changes.outputs.backend }}
      shared: ${{ steps.changes.outputs.shared }}
    steps:
      - uses: actions/checkout@v3
      - uses: dorny/paths-filter@v2
        id: changes
        with:
          filters: |
            frontend:
              - 'packages/frontend/**'
            backend:
              - 'packages/backend/**'
            shared:
              - 'packages/shared/**'

  # Build hanya yang berubah
  build-frontend:
    runs-on: ["gitea-runner-02"]
    needs: [changes]
    if: needs.changes.outputs.frontend == 'true'
    steps:
      - uses: actions/checkout@v3
      - name: Build frontend
        run: |
          cd packages/frontend
          npm ci
          npm run build

  build-backend:
    runs-on: ["gitea-runner-01"]
    needs: [changes]
    if: needs.changes.outputs.backend == 'true'
    steps:
      - uses: actions/checkout@v3
      - name: Build backend
        run: |
          cd packages/backend
          npm ci
          npm run build

  build-shared:
    runs-on: ["gitea-runner-02"]
    needs: [changes]
    if: needs.changes.outputs.shared == 'true'
    steps:
      - uses: actions/checkout@v3
      - name: Build shared
        run: |
          cd packages/shared
          npm ci
          npm run build

Example 5: Canary Deployment

# .gitea/workflows/canary.yml
name: Canary Deployment
on:
  push:
    tags: ['v*']

jobs:
  # Build pada runner production
  build:
    runs-on: ["gitea-runner-00"]
    steps:
      - uses: actions/checkout@v3
      - name: Build and push
        run: |
          docker build -t registry.example.com/myapp:${{ github.ref_name }} .
          docker push registry.example.com/myapp:${{ github.ref_name }}

  # Deploy canary (10%)
  deploy-canary:
    runs-on: ["gitea-runner-00"]
    needs: [build]
    steps:
      - uses: actions/checkout@v3
      - name: Deploy canary
        run: |
          kubectl set image deployment/myapp-canary \
            myapp=registry.example.com/myapp:${{ github.ref_name }} \
            -n production
          kubectl scale deployment/myapp-canary --replicas=1 -n production

  # Monitor canary
  monitor-canary:
    runs-on: ["gitea-runner-01"]
    needs: [deploy-canary]
    steps:
      - name: Wait and monitor
        run: |
          sleep 300  # Wait 5 minutes
          # Check metrics, error rates, etc.
          
  # Full rollout atau rollback
  promote-or-rollback:
    runs-on: ["gitea-runner-00"]
    needs: [monitor-canary]
    steps:
      - name: Promote to full deployment
        run: |
          kubectl set image deployment/myapp \
            myapp=registry.example.com/myapp:${{ github.ref_name }} \
            -n production
          kubectl rollout status deployment/myapp -n production

Runner Selection Tips

Gunakan gitea-runner-00 untuk:

Production deployments
Docker builds yang heavy
Database migrations
Critical operations yang butuh stability

Gunakan gitea-runner-01 untuk:

Staging deployments
Integration testing
Medium workloads
Parallel testing

Gunakan gitea-runner-02 untuk:

Development/feature builds
Linting dan code quality checks
Unit tests
Experimental workflows

Kesimpulan

Gitea Runner adalah komponen essential untuk menjalankan CI/CD workflows di Gitea. Dengan 3 runners yang tersedia (gitea-runner-00, gitea-runner-01, gitea-runner-02), Anda dapat:

✅ Menjalankan multiple jobs secara parallel
✅ Memisahkan workloads berdasarkan environment
✅ Optimasi resource allocation
✅ Meningkatkan throughput CI/CD pipeline

Best Practices Summary

Gunakan label yang tepat: Sesuaikan runner dengan jenis workload
Parallel execution: Manfaatkan multiple runners untuk speed
Environment separation: Production di runner-00, staging di runner-01, dev di runner-02
Load balancing: Distribute jobs evenly across runners
Monitoring: Regular health checks untuk semua runners

Langkah Selanjutnya

CI/CD Pipeline Overview - Pelajari cara merancang pipeline
Workflow Examples - Contoh workflow untuk berbagai use case
Kubernetes Deployment - Deploy aplikasi ke Kubernetes

Pengenalan​

Fitur Utama​

Arsitektur​

Existing Runners Setup​

Runner Labels​

Cara Menggunakan Runners​

1. Menggunakan Runner Spesifik​

2. Menggunakan Runner untuk Staging​

3. Menggunakan Runner untuk Development​

4. Multi-Runner Strategy (Parallel Execution)​

5. Load Balancing Across Runners​

Best Practices untuk Multiple Runners​

1. Environment-Based Runner Selection​

2. Fallback Runner Strategy​

3. Resource-Based Allocation​

Monitoring Runners​

Check Runner Status​

Runner Health Check Workflow​

Runner Configuration Info​

Troubleshooting​

Runner Tidak Tersedia​

Job Stuck in Queue​

All Runners Busy​

Instalasi Runner Baru (Opsional)​

Metode 1: Binary Installation (Linux)​

Metode 2: Docker Installation​

Metode 3: Kubernetes Deployment​

Registrasi Runner​

Mendapatkan Registration Token​

Registrasi via Command Line​

Registrasi Interactive​

Konfigurasi Runner​

File Konfigurasi (config.yaml)​

Penjelasan Konfigurasi Penting​

Runner Capacity​

Runner Labels​

Container Configuration​

Menjalankan Runner​

Metode 1: Foreground​

Metode 2: Background (dengan systemd)​

Metode 3: Docker Compose​

Membuat Workflow untuk Gitea Actions​

Basic Workflow Example​

Advanced Workflow dengan Matrix​

Docker Build Workflow​

Complete Production Workflow Example​

Runner Labels dan Executors​

Jenis Executor​

1. Docker Executor​

2. Host Executor​

Custom Labels​

Monitoring dan Troubleshooting​

Melihat Status Runner​

Common Issues​

Runner tidak terhubung ke Gitea​

Jobs gagal dengan "No available runner"​

Docker pull rate limit​

Permission denied errors​

Debug Mode​

Best Practices​

1. Security​

2. Resource Management​

3. High Availability​

4. Caching​

5. Monitoring​

Upgrade Runner​

Binary Upgrade​

Docker Upgrade​

Kubernetes Upgrade​

Practical Workflow Examples untuk 3 Runners​

Example 1: Environment-Based Deployment​

Example 2: Microservices Pipeline​

Example 3: Testing Strategy Across Runners​

Example 4: Monorepo Build Optimization​

Example 5: Canary Deployment​

Runner Selection Tips​

Kesimpulan​

Best Practices Summary​

Langkah Selanjutnya​

Resources​

Pengenalan

Fitur Utama

Arsitektur

Existing Runners Setup

Runner Labels

Cara Menggunakan Runners

1. Menggunakan Runner Spesifik

2. Menggunakan Runner untuk Staging

3. Menggunakan Runner untuk Development

4. Multi-Runner Strategy (Parallel Execution)

5. Load Balancing Across Runners

Best Practices untuk Multiple Runners

1. Environment-Based Runner Selection

2. Fallback Runner Strategy

3. Resource-Based Allocation

Monitoring Runners

Check Runner Status

Runner Health Check Workflow

Runner Configuration Info

Troubleshooting

Runner Tidak Tersedia

Job Stuck in Queue

All Runners Busy

Instalasi Runner Baru (Opsional)

Metode 1: Binary Installation (Linux)

Metode 2: Docker Installation

Metode 3: Kubernetes Deployment

Registrasi Runner

Mendapatkan Registration Token

Registrasi via Command Line

Registrasi Interactive

Konfigurasi Runner

File Konfigurasi (config.yaml)

Penjelasan Konfigurasi Penting

Runner Capacity

Runner Labels

Container Configuration

Menjalankan Runner

Metode 1: Foreground

Metode 2: Background (dengan systemd)

Metode 3: Docker Compose

Membuat Workflow untuk Gitea Actions

Basic Workflow Example

Advanced Workflow dengan Matrix

Docker Build Workflow

Complete Production Workflow Example

Runner Labels dan Executors

Jenis Executor

1. Docker Executor

2. Host Executor

Custom Labels

Monitoring dan Troubleshooting

Melihat Status Runner

Common Issues

Runner tidak terhubung ke Gitea

Jobs gagal dengan "No available runner"

Docker pull rate limit

Permission denied errors

Debug Mode

Best Practices

1. Security

2. Resource Management

3. High Availability

4. Caching

5. Monitoring

Upgrade Runner

Binary Upgrade

Docker Upgrade

Kubernetes Upgrade

Practical Workflow Examples untuk 3 Runners

Example 1: Environment-Based Deployment

Example 2: Microservices Pipeline

Example 3: Testing Strategy Across Runners

Example 4: Monorepo Build Optimization

Example 5: Canary Deployment

Runner Selection Tips

Kesimpulan

Best Practices Summary

Langkah Selanjutnya

Resources