Jak vytvořit CI/CD na Linuxovém serveru pomocí Dockeru a Gitu

Vytvoření CI/CD na serveru Linux, zřídit zabezpečeného hostitele, připojit váš Git repozitář, nainstalovat CI runner nebo orchestrátor (Jenkins, GitHub Actions Runner nebo GitLab Runner), definovat úlohy pipeline nebo YAML pro sestavení, testování a zabalení vaší aplikace a poté ji nasadit do staging/produkce přes SSH nebo kontejnery s tajnými klíči management, vrácení zpět a monitorování.

V této příručce se naučíte, jak vytvořit CI/CD na Linuxovém serveru pomocí osvědčených postupů DevOps. Probereme několik přístupů, jako jsou Jenkins, samohostované runnery GitHub Actions, GitLab Runner a odlehčený Bash pipeline, abyste si mohli vybrat ten, který vyhovuje vašemu stacku a rozpočtu.

Podělím se s vámi o praktické kroky, příkazy a bezpečnostní tipy z více než 12 let zkušeností s budováním technologií pro webhosting a cloudová prostředí.

---

Co je CI/CD na Linuxovém serveru?

Mezi základní nástroje patří Git, Docker, Jenkins, GitHub Actions, GitLab CI a Nginx.

---

Pro koho je to určeno a co postavíte

Tento tutoriál je ideální pro vývojáře, správce systémů a malé týmy, kteří chtějí bezpečný a snadno udržovatelný systém. CI/CD potrubíNastavíte server založený na Ubuntu/Debianu, přidáte CI agenta, nakonfigurujete pipeline a nasadíte kontejnerizovanou webovou aplikaci za Nginxem s rollbackem. Probereme také tajné kódy, firewally, logy a monitorování.

Předpoklady a doporučený stack

• Linuxový server (doporučeno Ubuntu 22.04+ nebo Debian 12)
• Přístup root nebo sudo, SSH klíče
• Git repozitář (GitHub, GitLab, Bitbucket)
• Docker a Docker Compose (nebo běhové prostředí jazyka jako Node.js/Python/Java)
• Doména a DNS (volitelné, ale doporučené pro HTTPS)

Tip na hostování: VPS nebo cloudová instance s 2–4 vCPU a 4–8 GB RAM je vhodná pro většinu malých úloh CI/CD. Pokud dáváte přednost... managepomoc, YouStableVPS hosting si managePlány serveru D usnadňují nasazení CI/CD s předpřipravenými obrazy, snapshoty a nepřetržitou podporou.

---

Krok 1: Základní nastavení serveru (zabezpečení na prvním místě)

Před instalací nástrojů CI zabezpečte server. Použijte uživatele bez oprávnění root, SSH klíče, firewall a základní balíčky.

# Create a non-root user
sudo adduser ci
sudo usermod -aG sudo,docker ci

# SSH hardening (on your local machine)
ssh-copy-id ci@your_server_ip

# Basic packages and updates
sudo apt update && sudo apt -y upgrade
sudo apt -y install git curl ufw fail2ban ca-certificates gnupg lsb-release

# Enable firewall
sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw --force enable

# Install Docker (official repo)
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt -y install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Allow ci user to run docker without sudo (re-login required)
sudo usermod -aG docker ci

Volitelné: Nainstalujte Nginx pro reverzní proxy vaší aplikace a ukončete TLS pomocí Zašifrujeme.

sudo apt -y install nginx
sudo ufw allow "Nginx Full"

# Example minimal reverse proxy (adjust server_name and upstream)
sudo bash -c 'cat >/etc/nginx/sites-available/app.conf' <<EOF
server {
    listen 80;
    server_name app.example.com;

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}
EOF
sudo ln -s /etc/nginx/sites-available/app.conf /etc/nginx/sites-enabled/app.conf
sudo nginx -t && sudo systemctl reload nginx

---

Krok 2: Vyberte si architekturu CI/CD

• Samostatně hostovaný běžec akcí GitHubu: Těsná integrace s GitHubem, YAML pipeline, rychlé pro mono repozitáře.
• Běžec GitLabu: Funguje s GitLab CI/CD pomocí exekutorů shellu, Dockeru nebo Kubernetes.
• Jenkins: Vysoce rozšiřitelný, bohatý na pluginy, skvělý pro komplexní orchestraci s více repozitáři.
• Lehký bash: Malé týmy mohou skriptovat sestavování/testování/nasazení spouštěné webhooky nebo cronem.

Vyberte si jednu z níže uvedených primárních cest. Můžete je kombinovat (např. Actions pro CI a Ansible pro CD) při škálování.

Možnost A: Samostatně hostovaný běžec akcí GitHubu

Spouštějte pracovní postupy na vlastním Linuxovém serveru pro plnou kontrolu a lokalitu mezipaměti. Zaregistrujte běžec v nastavení repozitáře GitHub > Akce > Běžci.

# As ci user
mkdir -p ~/actions-runner && cd ~/actions-runner
# Download the latest runner from GitHub (replace version/URL from GitHub UI)
curl -o actions-runner.tar.gz -L https://github.com/actions/runner/releases/download/vX.Y.Z/actions-runner-linux-x64-X.Y.Z.tar.gz
tar xzf actions-runner.tar.gz

# Configure (use the token from GitHub Runner setup)
./config.sh --url https://github.com/your-org/your-repo --token YOUR_TOKEN --labels self-hosted,linux,prod

# Install as a service
sudo ./svc.sh install
sudo ./svc.sh start
sudo systemctl status actions.runner.*

Příklad pracovního postupu akcí GitHubu pro sestavení, testování, Dockerizaci a nasazení pomocí Docker Compose lokálně na serveru:

name: CI/CD
on:
  push:
    branches: [ "main" ]
jobs:
  build-test-deploy:
    runs-on: self-hosted
    steps:
      - uses: actions/checkout@v4

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install deps & test
        run: |
          npm ci
          npm test --if-present

      - name: Build Docker image
        run: |
          docker build -t registry.example.com/myapp:${GITHUB_SHA::7} .
          docker tag registry.example.com/myapp:${GITHUB_SHA::7} registry.example.com/myapp:latest

      - name: Push image (if using private registry)
        env:
          REGISTRY_USER: ${{ secrets.REGISTRY_USER }}
          REGISTRY_PASS: ${{ secrets.REGISTRY_PASS }}
        run: |
          echo "$REGISTRY_PASS" | docker login registry.example.com -u "$REGISTRY_USER" --password-stdin
          docker push registry.example.com/myapp:${GITHUB_SHA::7}
          docker push registry.example.com/myapp:latest

      - name: Deploy with Compose
        run: |
          docker compose pull || true
          docker compose up -d --remove-orphans
          docker image prune -f

Vytvořte ve svém repozitáři minimální soubor docker-compose.yml:

services:
  app:
    image: registry.example.com/myapp:latest
    restart: unless-stopped
    ports:
      - "8080:8080"
    env_file:
      - .env

Možnost B: GitLab Runner na Linuxu

Použijte GitLab CI/CD se shellem nebo Docker executorem. Zaregistrujte svůj runner pomocí tokenu projektu nebo skupiny.

curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.deb.sh | sudo bash
sudo apt -y install gitlab-runner

# Register runner (shell executor for simplicity)
sudo gitlab-runner register \
  --url https://gitlab.com/ \
  --registration-token YOUR_TOKEN \
  --executor shell \
  --description "linux-shell-runner"

Ukázka souboru .gitlab-ci.yml:

stages: [test, build, deploy]

variables:
  DOCKER_HOST: "unix:///var/run/docker.sock"

test:
  stage: test
  script:
    - npm ci
    - npm test --if-present

build:
  stage: build
  script:
    - docker build -t registry.example.com/myapp:$CI_COMMIT_SHORT_SHA .
    - docker tag registry.example.com/myapp:$CI_COMMIT_SHORT_SHA registry.example.com/myapp:latest
    - echo $REGISTRY_PASS | docker login registry.example.com -u $REGISTRY_USER --password-stdin
    - docker push registry.example.com/myapp:$CI_COMMIT_SHORT_SHA
    - docker push registry.example.com/myapp:latest
  only:
    - main

deploy:
  stage: deploy
  script:
    - docker compose pull
    - docker compose up -d --remove-orphans
    - docker image prune -f
  environment:
    name: production
  only:
    - main

Možnost C: Jenkins Pipeline v Linuxu

Jenkins je zkušený specialista na komplexní pracovní postupy a propagaci ve více prostředích.

# Install Java and Jenkins
sudo apt -y install openjdk-17-jre
curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key | sudo tee \
  /usr/share/keyrings/jenkins-keyring.asc > /dev/null
echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \
  https://pkg.jenkins.io/debian-stable binary/ | sudo tee \
  /etc/apt/sources.list.d/jenkins.list > /dev/null
sudo apt update && sudo apt -y install jenkins
sudo systemctl enable --now jenkins
# Access: http://your_server_ip:8080 (retrieve initial admin password)

Příklad souboru Jenkinsfile (deklarativní):

pipeline {
  agent any
  environment {
    REGISTRY = 'registry.example.com'
    IMAGE = 'myapp'
  }
  stages {
    stage('Checkout') {
      steps { checkout scm }
    }
    stage('Test') {
      steps {
        sh 'npm ci'
        sh 'npm test --if-present'
      }
    }
    stage('Build & Push Image') {
      steps {
        withCredentials([usernamePassword(credentialsId: 'registry-creds', usernameVariable: 'USER', passwordVariable: 'PASS')]) {
          sh '''
            echo "$PASS" | docker login $REGISTRY -u "$USER" --password-stdin
            TAG=$(git rev-parse --short HEAD)
            docker build -t $REGISTRY/$IMAGE:$TAG .
            docker tag $REGISTRY/$IMAGE:$TAG $REGISTRY/$IMAGE:latest
            docker push $REGISTRY/$IMAGE:$TAG
            docker push $REGISTRY/$IMAGE:latest
          '''
        }
      }
    }
    stage('Deploy') {
      steps {
        sh 'docker compose pull && docker compose up -d --remove-orphans'
      }
    }
  }
  post {
    always { sh 'docker image prune -f || true' }
  }
}

Možnost D: Lehká Bash CI/CD (bez Orchestratoru)

Pro velmi malé projekty použijte k sestavení a nasazení Git hook spouštěný pomocí funkce post receive nebo skript spouštěný cronem. Udržujte to jednoduché, ale bezpečné.

#!/usr/bin/env bash
set -euo pipefail

REPO_DIR=/opt/myapp
cd "$REPO_DIR"

echo "==> Pulling latest..."
git fetch --all
git checkout main
git pull --ff-only

echo "==> Running tests..."
npm ci
npm test --if-present

echo "==> Building & deploying..."
docker build -t myapp:latest .
docker compose up -d --build --remove-orphans
docker image prune -f

Tajemství, proměnné prostředí a vrácení změn

• Ukládejte tajné kódy (tajné kódy GitHubu, proměnné CI GitLabu, přihlašovací údaje Jenkinse) na platformě. Nikdy neposkytujte commit souborů .env.
• Použijte konfigurace specifické pro dané prostředí: .env.staging a .env.production s bezpečnými tajnými klíči managepokud možno.
• Označte vydání (např. sémantické verze) a ponechte předchozí verzi dostupnou pro rychlé vrácení zpět pomocí Docker Compose nebo symbolicky odkazovaného adresáře vydání.
• Modrozelené nebo kanárkově řízené nasazení snižují riziko pro aplikace s vysokou návštěvností.

Kontrolní seznam pro posílení zabezpečení

• Princip nejmenších privilegií: spouštět běžce s uživateli bez oprávnění root; omezit sudo.
• Síť: Uzavřete nepoužívané porty pomocí UFW; pokud možno izolujte sítě pro sestavení a produkci.
• SSH: ověřování na základě klíče, zakázat přihlašování heslem, pravidelně střídat klíče.
• Závislosti: Naskenujte obrázky pomocí Trivy nebo Grype; připněte základní obrázky a často je opravujte.
• Záznamy a upozornění: povolit fail2ban; odesílat protokoly do centrálního systému; monitorovat služby runnerů.
• Zálohy a snímky: automatizujte prostřednictvím vašeho hostingového panelu; testujte obnovu měsíčně.

Řešení problémů a pozorovatelnost

• Zkontrolujte služby: Stav systemctl jenkins, gitlab runner nebo actions.runner.*
• Záznamy běžce: journalctl -u „actions.runner*“ -e, journalctl -u gitlab-runner -e
• Dockerské protokoly: Docker PS, Docker logy , události Dockeru
• Nginx: sudo tail -f /var/log/nginx/access.log /var/log/nginx/error.log
• Časté poruchy: chybějící proměnné prostředí, nesprávné přihlašovací údaje do registru, firewall blokující odchozí registr nebo zrcadla balíčků.

Úvahy o nákladech a škálování

• Začněte s 2–4 vCPU a 4–8 GB RAM; přidejte CPU pro sestavení a RAM pro vrstvy Dockeru.
• Pro urychlení používejte mezipaměti sestavení a běžce připnuté k serveru, na kterém je hostován váš registr kontejnerů.
• Oddělte úlohy CI od produkčních úloh s rostoucím počtem zaměstnanců, abyste se vyhnuli konfliktu o zdroje.
• Pokud potřebujete předvídatelný výkon, zvažte použití více běžců a vyhrazeného registru.

Příklad komplexního řešení: Od push do produkce

• Vývojář odesílá kód do hlavní složky; CI stahuje kód.
• Spouštějte jednotkové testy a linting.
• Vytvořte obraz Dockeru, označte ho SHA kódem commitu a nejnovějším kódem.
• Odeslat do registru a aktualizovat Docker Compose na serveru.
• Compose znovu vytvoří kontejner s nulovou nebo minimální prostoji.
• Koncový bod kontroly stavu potvrzuje úspěch; v případě selhání se spustí upozornění.

Tento tok je odolný, auditovatelný a snadno replikovatelný pro přípravu i produkci s různými proměnnými a záznamy DNS.

Nejlepší postupy pro udržení zdravého stavu CI/CD

• Udržujte potrubí rychlé: závislosti na mezipaměti a paralelizace testů.
• Zdůrazněte selhání: selhávat rychle, upozorňovat Slack/e-mail a přidávat protokoly.
• Neměnné artefakty: jednou sestavit, propagovat prostřednictvím prostředí se stejným image.
• Idempotentní nasazení: Dvojité spuštění příkazu deploy by nemělo vaši aplikaci poškodit.
• Vše zdokumentujte: Soubory README, runbooky, kroky vrácení zpět.

---

Nejčastější dotazy