Powrót do dziennika
Jak zautomatyzować aktualizację i utrzymanie strony AI – agenty, webhooks i CI/CD

Jak zautomatyzować aktualizację i utrzymanie strony AI – agenty, webhooks i CI/CD

GitHub Actions → Coolify → Directus → n8n → Claude Managed Agents. Pelny pipeline automatyzacji strony: CI/CD z rollbackiem, content pipeline 5-agentowy, monitoring CWV co 6h, broken links co tydzien, SSL expiry check – z gotowymi YAML, docker-compose i workflow JSON. Koszt: EUR 15-28/mies.

9 min czytania
automatyzacjacicdgithub-actionsn8ncoolifywebhooksclaude-agentsmcpdevopsdirectus

Wiekszosc poradnikow o tworzeniu stron z AI konczy sie w tym samym miejscu: strona jest online, wyglada dobrze, wszystko dziala. I pozostawiaja Cie sam na sam z pytaniem, ktorego nie zadaja – co dalej?

Bo strona, ktora nie jest aktualizowana, traci pozycje w Google. Strona, ktorej nikt nie monitoruje, moze lezec przez cala noc zanim ktos to zauwazy. A pipeline contentu, ktory opiera sie na Twoim recznym dzialaniu, jest tak dobry jak Twoja konsekwencja – czyli zmienny.

Ten post jest o wyjsciu poza "zrob i zapomnij". O pipeline'ach, ktore dzialaja zanim wstaniesz rano. O agentach, ktore sprawdzaja Twoja strone, zanim Google to zrobi. I o CI/CD, ktore deployuje Twoja strone zanim skonczyles pisac commit message.

To zaawansowany material. Jesli zaczynasz przygode ze stronami AI, najpierw przeczytaj wczesniejsze posty z tej serii. Jesli juz jestes w produkcji – chodzmy.

Architektura automatyzacji strony w 2026

Zanim przejdziemy do konfiguracji, zrozumiejmy warstwy, z ktorych sklada sie nowoczesna automatyzacja strony:

┌─────────────────────────────────────────────────────┐
│  WARSTWA 4: AI AGENCI                               │
│  Claude Managed Agents, n8n AI Agent Node           │
│  Multi-agent pipelines, MCP servers                 │
├─────────────────────────────────────────────────────┤
│  WARSTWA 3: AUTOMATYZACJA WORKFLOW                  │
│  n8n (self-hosted), GitHub Actions, webhooks        │
├─────────────────────────────────────────────────────┤
│  WARSTWA 2: CI/CD & DEPLOYMENT                      │
│  GitHub Actions → Coolify webhook → VPS             │
│  Lub: Vercel/Netlify auto-deploy z GitHub           │
├─────────────────────────────────────────────────────┤
│  WARSTWA 1: INFRASTRUKTURA                          │
│  VPS (Hetzner) + Docker + Coolify + Nginx           │
│  lub Netlify/Vercel managed                         │
└─────────────────────────────────────────────────────┘

Kazda warstwa jest niezalezna – mozesz miec managed hosting w warstwie 1 i pelna automatyzacje w warstwie 3. Warstwy dobiera sie niezaleznie.

Warstwa 2: CI/CD – automatyczny deployment bez FTP

Reczny deployment to pulapka. Kopiowanie plikow przez FTP, reczne git pull na serwerze, klikanie "Deploy" w panelu – kazda z tych operacji ma koszt i ryzyko pomylki.

Cel: kazdy push do galezi main = automatyczny deployment na produkcje.

Sciezka A: GitHub Actions → Coolify (self-hosted)

Coolify ma natywna integracje z GitHub Actions. Proces jest pieciokrokowy:

Krok 1: Wlacz Coolify API – Settings → Configuration → Advanced → zaznacz "API Access"

Krok 2: Wygeneruj API Token – Keys & Tokens → API Tokens → Create → uprawnienie "Deploy"

Krok 3: Pobierz Coolify Webhook URL – konfiguracja aplikacji → Webhook → skopiuj "Deploy webhook URL"

Krok 4: Dodaj sekrety do GitHub repo – Settings → Secrets and variables → Actions:

  • COOLIFY_WEBHOOK = deploy webhook URL
  • COOLIFY_TOKEN = API token

Krok 5: Stworz workflow .github/workflows/deploy.yml:

name: Build & Deploy

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Run tests
        run: npm test --if-present

      - name: Build
        run: npm run build
        env:
          NODE_ENV: production

      - name: Deploy to Coolify
        if: success()
        run: |
          curl --request GET \
            "${{ secrets.COOLIFY_WEBHOOK }}" \
            --header "Authorization: Bearer ${{ secrets.COOLIFY_TOKEN }}"

Kluczowy warunek: if: success() – deployment uruchamia sie TYLKO gdy testy i build przejda pomyslnie. Zero deploymentow psutego kodu na produkcje.

Efekt: push do main → GitHub builduje → testuje → (jesli OK) triggeruje Coolify → Coolify pobiera najnowszy obraz i restartuje kontener. Caly proces zajmuje 2-4 minuty.

Sciezka B: GitHub → Netlify/Vercel (managed)

Jesli uzywasz Netlify lub Vercel, CI/CD masz gotowe od pierwszego polaczenia repo – kazdy push automatycznie triggeruje build i deployment. Nie potrzebujesz nic konfigurowac.

Wartosc dodana GitHub Actions: mozesz dodac Lighthouse CI jako quality gate przed deploymentem:

name: QA Gate

on:
  push:
    branches: [main]

jobs:
  quality-gate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Lighthouse CI
        run: |
          npm install -g @lhci/cli
          lhci autorun --upload.target=temporary-public-storage
        env:
          LHCI_GITHUB_APP_TOKEN: ${{ secrets.LHCI_GITHUB_APP_TOKEN }}

Warstwa 3: n8n – automatyzacja contentu i monitoring

n8n to mozg automatyzacji. Uruchamiasz go w Dockerze (jeden kontener na Twoim VPS), laczysz przez Coolify i masz 422+ integracji dostepnych przez UI.

Instalacja n8n w Docker Compose

services:
  n8n:
    image: n8nio/n8n:latest
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - N8N_HOST=n8n.twoja-domena.pl
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=https://n8n.twoja-domena.pl/
      - N8N_COMMUNITY_PACKAGES_ENABLED=true
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=${N8N_DB_PASSWORD}
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      - postgres

  postgres:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      - POSTGRES_DB=n8n
      - POSTGRES_USER=n8n
      - POSTGRES_PASSWORD=${N8N_DB_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  n8n_data:
  postgres_data:

Workflow 1: Directus → n8n → SEO audit → auto-publish

To core pipeline dla bloga opartego na Directus (czyli tego bloga):

Trigger: Directus Trigger Node – status = review_ready, kolekcja posts

Schemat workflow:

[Directus Trigger: posts.updated, status=review_ready]
    ↓
[HTTP Request: Claude API – SEO audit]
  Prompt: "Przejrzyj post SEO. Zwroc JSON:
  - seo_score (0-100)
  - suggested_title (max 60 znakow)
  - suggested_description (max 155 znakow)
  - readability_issues (lista)"
    ↓
[IF: seo_score >= 75]
    ↓ TAK
[Directus: Update Item → status: published, SEO_Title, SEO_Description, date_published]
    ↓
[Slack: "Opublikowano: {{Title}} (SEO: {{seo_score}})"]

    ↓ NIE (seo_score < 75)
[Directus: Update Item → status: draft, seo_audit_notes]
    ↓
[Slack: "Wymaga poprawek SEO: {{Title}} (score: {{seo_score}})"]

Konfiguracja Directus Trigger Node:

  1. W n8n: dodaj node Directus Trigger
  2. Resource: Items, Collection: posts, Event: Updated
  3. Aktywuj workflow – n8n automatycznie tworzy Flow (webhook) w Directus
  4. Wymagane: n8n dostepny publicznie przez HTTPS

Workflow 2: Monitoring Core Web Vitals – co 6 godzin

[Schedule Trigger: 0 */6 * * *]
    ↓
[HTTP Request: PageSpeed Insights API]
  URL: https://www.googleapis.com/pagespeedonline/v5/runPagespeed
  Params: url=https://twoja-domena.pl, strategy=mobile, key={{PAGESPEED_API_KEY}}
    ↓
[Parse JSON: wyciagnij lcp, inp, cls z audits]
    ↓
[IF: lcp > 2500 OR inp > 200 OR cls > 0.1]
    ↓
[Slack Alert: "Core Web Vitals ponizej progu!
LCP: {{lcp}}ms / INP: {{inp}}ms / CLS: {{cls}}"]
    ↓
[Directus: Create Item w 'monitoring_log']

PageSpeed Insights API jest darmowe do 25 000 requestow dziennie – w zupelosci wystarczy.

Workflow 3: Content pipeline – 5 wyspecjalizowanych agentow AI

Wzorowany na pipeline n8n Lab (5 agentow, od researchu do publikacji):

[Schedule Trigger / Manual Trigger]
    ↓
[HTTP Request: RSS/News feed branzy]
    ↓
[AI Agent #1 – Research Agent (Claude)]
  "Przeanalizuj artykuly i zaproponuj 3 tematy postow dla bloga
  'Jak zbudowac strone z AI'. Dla kazdego: tytul, angle, primary_keyword,
  estimated_search_volume (low/medium/high)"
    ↓
[IF: wybierz temat z najwyzszym search_volume]
    ↓
[AI Agent #2 – SEO Agent (Claude)]
  "Dla tematu: outline H2/H3 (min 5 sekcji),
  LSI keywords, FAQ schema (min 4 pytania),
  meta title (50-60 znakow), description (150-155 znakow)"
    ↓
[AI Agent #3 – Writing Agent (Claude)]
  "Napisz post (min 1500 slow) wedlug outline.
  Ton: ekspercki, bezposredni, z przykladami kodu."
    ↓
[AI Agent #4 – Image Agent (Claude + DALL-E API)]
  "Wygeneruj prompt dla cover image, nastepnie wygeneruj grafike"
    ↓
[Directus: Upload File → image_id]
    ↓
[Directus: Create Item w 'posts']
  - status: "draft"
  - Title, Content, FAQ_Data, SEO_Title, SEO_Description, Cover_Image
    ↓
[Slack: "Draft gotowy do review: {{Title}}
https://cms.twoja-domena.pl/content/posts/{{id}}"]

Human-in-the-loop jest celowy. Post trafia do Directus jako draft. Edytujesz, dodajesz wlasne doswiadczenia → zmieniasz status na review_ready → Workflow 1 przejmuje i publishuje po audycie SEO.

Warstwa 4: Claude Managed Agents + MCP

To najnowsza warstwa (publiczna beta od maja 2026). Claude Managed Agents to cos innego niz n8n – to dlugoterminowi agenci, ktorzy maja dostep do Twoich narzedzi przez MCP i dzialaja autonomicznie w petli.

Czym rozni sie od n8n

n8n: Ty projektujesz sekwencje krokow node po node – deterministyczny pipeline.
Claude Managed Agents: Ty dajesz agentowi narzedzia i cel, agent sam decyduje jak go osiagnac.

Kiedy uzyc n8n: publish pipeline, monitoring co X minut, broken links check – rzeczy z przewidywalna sciezka.
Kiedy Managed Agents: analiza regresji po deploymencie, content audit strony, zadania wymagajace rozumowania.

MCP servers dla webmastera

MCP (Model Context Protocol) to standard umozliwiajacy agentowi AI polaczenie z zewnetrznymi narzedziam przez standaryzowany protokol:

  • GitHub MCP (api.githubcopilot.com/mcp/) – czyta repo, tworzy issues i PRs
  • Directus MCP (community) – rozumie schemat kolekcji, moze tworzyc/edytowac content
  • PostgreSQL MCP – odpytuje baze danych, analizuje logi
  • Playwright MCP – symuluje przegladarke, sprawdza UX strony

Od maja 2026 Managed Agents obsluguje MCP tunnels – agent laczy sie z serwisami w prywatnej sieci bez inbound firewall rules. Serwis nie musi byc publiczny.

Przyklad konfiguracji agenta (Python SDK):

import anthropic

client = anthropic.Anthropic()

agent = client.beta.agents.create(
    name="Site Health Monitor",
    model="claude-opus-4-5",
    mcp_servers=[
        {"type": "url", "name": "github",
         "url": "https://api.githubcopilot.com/mcp/"},
        {"type": "url", "name": "playwright",
         "url": "https://playwright-mcp.twoja-domena.pl/mcp"}
    ],
    tools=[
        {"type": "agent_toolset_20260401"},
        {"type": "mcp_toolset", "mcp_server_name": "github"},
        {"type": "mcp_toolset", "mcp_server_name": "playwright"}
    ]
)

Uruchamiasz agenta przez n8n (HTTP Request do Managed Agents API) lub scheduled cron job na VPS.

Directus MCP server

# W Docker Compose obok innych serwisow:
services:
  directus-mcp:
    image: directus/mcp-server:latest
    environment:
      - DIRECTUS_URL=http://directus:8055
      - DIRECTUS_TOKEN=${DIRECTUS_ADMIN_TOKEN}
    ports:
      - "3100:3100"

Z Directus MCP agent Claude wie: jakie kolekcje istnieja, jakie maja pola, jakie relacje – bez Twojego wyjasniania schematu w kazdym prompcie.

Monitoring: minimum ktore musisz miec

UptimeRobot (darmowy, do 50 monitorow)

  1. Konto na uptimerobot.com
  2. Add Monitor → HTTP(S) → URL: https://twoja-domena.pl
  3. Alert contacts: email + Slack webhook
  4. Check interval: 5 minut

Alert email + Slack gdy strona padnie. Gratisowo.

SSL expiry monitoring w n8n

[Schedule: co tydzien]
    ↓  
[Execute Command: 
  echo | openssl s_client -connect twoja-domena.pl:443 2>/dev/null 
  | openssl x509 -noout -dates | grep notAfter
]
    ↓
[Parse: oblicz dni do wygasniecia]
    ↓
[IF: days_remaining < 30]
    ↓
[Slack Alert: "SSL certyfikat wygasa za {{days_remaining}} dni!"]

Deployment z rollbackiem

name: Deploy with Rollback

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm run build
      - run: npm test

      - name: Deploy to Coolify
        id: deploy
        run: |
          curl --request GET \
            "${{ secrets.COOLIFY_WEBHOOK }}" \
            --header "Authorization: Bearer ${{ secrets.COOLIFY_TOKEN }}"

      - name: Wait for deployment
        run: sleep 60

      - name: Health check
        run: |
          STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
            https://twoja-domena.pl/api/health)
          if [ "$STATUS" != "200" ]; then exit 1; fi

      - name: Notify success
        if: success()
        run: |
          curl -X POST ${{ secrets.SLACK_WEBHOOK }} \
            -H 'Content-type: application/json' \
            --data '{"text":"Deploy OK: ${{ github.sha }}"}'

      - name: Rollback on failure
        if: failure()
        run: |
          git revert HEAD --no-edit && git push

Koszty pelnego stacku automatyzacji

Komponent Narzedzie Koszt/mies.
VPS hosting Hetzner CX32 EUR 7,99
Orchestration Coolify (self-hosted) EUR 0
Automatyzacja n8n (self-hosted) EUR 0
CI/CD GitHub Actions (free tier) USD 0
Monitoring uptime UptimeRobot (free tier) USD 0
LLM (content + SEO audit) Claude API (pay-per-use) ~USD 5-15
Image generation DALL-E API (pay-per-use) ~USD 2-5
LACZNIE   ~EUR 15-28/mies.

Dla porownania: n8n Cloud USD 20 + Vercel Pro USD 20 + monitoring USD 15-30 = USD 55-70/mies. tylko za infrastrukture.

Plan wdrozenia – 6 tygodni

Nie musisz miec wszystkiego naraz. Oto kolejnosc:

  1. Tydzien 1: CI/CD – GitHub Actions → Coolify deploy. Jeden plik YAML, 30 minut. Koniec z recznym deploymentem.

  2. Tydzien 2: Uptime monitoring – UptimeRobot 5 minut. Darmowy. Dowiesz sie o awarii przed uzytkownikami.

  3. Tydzien 3: n8n – Zainstaluj, podlacz Directus, prosty workflow (nowy post → Slack). Naucz sie systemu na malym use case.

  4. Tydzien 4: Content pipeline – Workflow research → draft → human review. Zacznij od jednego Writing Agenta.

  5. Miesiac 2: Monitoring CWV – PageSpeed API + n8n alert gdy metryki spadaja ponizej progu.

  6. Miesiac 3+: Claude Managed Agents – Gdy znasz n8n i masz dzialajace workflows, dodaj MCP layer dla bardziej autonomicznych zadan.

Kazdy krok daje wartosc sam w sobie.

Wszystkie wpisy