Przejdź do treści

Proponowana struktura Terraform i Ansible

[DRAFT] Propozycja do sekcji 2, 4 i 7 dokumentu devops-process.md. Punkt wyjścia: logintegra-resources.md.


1. Co wynika z inwentarza

Trzy projekty Scaleway mają zupełnie różne kształty:

Projekt Czym jest Ile maszyn Dominujący wymiar Przykłady
apollo-prod produkcja ~12, patrz uwaga niżej klient drog-bruk, euroglas, wk, neuca
apollo-test testy manualne 23 w WAW 2 + 2 w WAW 1 odbiorca: zespół albo klient wombaty, oposy, kapibary
dev narzędzia dev-ops 10 narzędzie YouTrack, TeamCity, build, VPN

O strukturze kodu przesądzają trzy obserwacje.

apollo-test to jeden wzorzec powtórzony 23 razy. Wszystkie maszyny w WAW 2 nazywają się <odbiorca>-apollo-docker-test. Różnią się praktycznie tylko nazwą i rozmiarem, od GP1-XS do POP2-HC-4C-8G. To podręcznikowy przypadek na for_each po mapie w tfvars: jedno wywołanie modułu opisuje wszystkie 23.

apollo-prod to instancje per klient plus wspólna infrastruktura. Instancje aplikacyjne to np. drog-bruk, wk, serwisy, euroglas-ftp. Obok stoją współdzielone: api-proxy, stepping-stone, redis-main, redis-weglokoks, main-apollo-prod-bak, microservice-parser, infokiosk-prod, neuca-vpn. Ten sam wzorzec for_each, tylko z większą liczbą ról.

Produkcja i testy to dwie różne topologie tej samej aplikacji. To nie są dwa środowiska o jednym kształcie:

apollo-prod apollo-test
Tomcat bezpośrednio na Ubuntu w kontenerze
Redis osobna maszyna: redis-main, redis-weglokoks kontener na tej samej maszynie
Mikroserwisy osobna maszyna: microservice-parser kontenery na tej samej maszynie
Baza, RabbitMQ osobne zasoby kontenery na tej samej maszynie
Kto dostarcza aplikację TeamCity: buduje WAR i wypycha go na Tomcata repozytorium apollo-docker, skrypt bash
Jednostka maszyna = jeden komponent maszyna = całe środowisko jednego odbiorcy

Na produkcji topologia jest rozłożona na wiele maszyn. W testach bazy, Redis, RabbitMQ i mikroserwisy są zwinięte do jednej maszyny, a orkiestruje je apollo-docker. To tłumaczy rozrzut typów instancji w apollo-test: większy typ oznacza cięższy stos, a nie cięższy Tomcat.

Konsekwencja dotyczy mirrora QA, opisuje ją sekcja 7.

Granica odpowiedzialności: cztery warstwy

devops-process.md w sekcji 2 dzieli świat na dwa narzędzia. W praktyce warstwy są cztery, a dwóch ostatnich nie opisywał żaden dokument:

Warstwa Narzędzie Odpowiada za Repo
Zasób w chmurze Terraform instancja, wolumeny, IP, sieć, security group, tagi logintegra-infra
Konfiguracja hosta Ansible użytkownicy, ufw, swap, silnik Dockera, Tomcat, monitoring logintegra-infra
Artefakt aplikacji na produkcji TeamCity budowa WAR-a i wypchnięcie go na Tomcata konfiguracja TeamCity
Topologia aplikacji w testach apollo-docker bazy, Redis, RabbitMQ, mikroserwisy, sam Apollo apollo-docker

Z tego wynika jedna zasada dla obu środowisk. Ansible doprowadza host do stanu gotowego na artefakt i tam się zatrzymuje. Artefakt dostarcza ktoś inny:

  • Na apollo-test Ansible daje silnik Dockera, użytkownika, reguły ufw, klon apollo-docker i jego zależności systemowe. O tym, co stoi w kontenerach, decyduje skrypt.
  • Na apollo-prod Ansible daje Javę, skonfigurowanego Tomcata, katalogi, uprawnienia, logrotate i certyfikaty. WAR-a wgrywa TeamCity. Rola apollo może skonfigurować kontekst aplikacji, ale nie dotyka artefaktu.

Ansible nie odtwarza w YAML-u topologii z apollo-docker ani kroku deployu z TeamCity. W obu przypadkach powstałoby drugie źródło prawdy.

Granica działa też w drugą stronę. Jeśli apollo-docker albo build deployujący potrzebuje czegoś na hoście, to jest wymaganie do roli Ansible. Chodzi np. o pakiet, katalog, limit systemowy, użytkownika albo wpis w /etc/hosts. Skrypt nie powinien doinstalowywać takich rzeczy przy każdym uruchomieniu. Obie listy wymagań warto spisać przy pisaniu ról.

Uwaga: brakuje tabeli instancji dla apollo-prod

logintegra-resources.md ma dla produkcji tylko wolumeny i snapshoty. Listę ~12 maszyn powyżej wyprowadziłem z kolumny „Attached to”, więc to nie jest spis potwierdzony. Fazę E, czyli zastąpienie produkcji, trzeba poprzedzić uzupełnieniem tej tabeli. Nie da się zastąpić maszyny, o której nie wiemy, co robi.


2. Terraform: warstwy modułów

Moduły mają dwie warstwy. Prymitywy opisują, czym zasób jest w chmurze. Archetypy opisują, czym maszyna jest u nas. Żadna z warstw nie zawiera konkretnej nazwy serwera.

terraform/
├── modules/
│   ├── network/                  # VPC + private network + public gateway (jeden na środowisko)
│   ├── security-group/           # reguły in/out sterowane listą
│   ├── instance/                 # PRYMITYW: serwer + wolumen root + wolumeny dodatkowe
│   │                             #           + flexible IP + tagi + user_data (cloud-init)
│   └── archetypes/               # cienkie nakładki na `instance`, same wartości domyślne
│       ├── tomcat-node/          #   ZROBIONE: tagi [tomcat], sg tomcat (dysk pod logi - TODO)
│       ├── docker-node/          #   tagi [docker] (+ apollo-docker), większy dysk, prune cron
│       ├── proxy-node/           #   tagi [nginx], flexible IP obowiązkowe
│       ├── redis-node/           #   tagi [redis], bez publicznego IP
│       └── bastion-node/         #   tagi [stepping-stone], sg tylko 22/tcp
└── environments/
    ├── prod/                     # projekt apollo-prod
    ├── qa/                       # ZROBIONE: projekt apollo-qa, mirror produkcji, tomcat-node
    ├── test/                     # ZROBIONE: projekt apollo-test, hosty apollo-docker (docker-node)
    └── dev/                      # projekt dev

Po co warstwa archetypów. Zasada mirrora QA mówi, że prod/main.tf i qa/main.tf mają być identyczne, a cała różnica siedzi w tfvars. Wartości domyślne roli muszą więc mieszkać poza obydwoma środowiskami. Przykład takiej wartości: serwer Tomcat ma osobny wolumen na logi i security group tomcat. Bez archetypów trzeba by ją powielić w prod/main.tf i qa/main.tf i pilnować, żeby się nie rozjechały. Archetyp to zwykle 30–40 linii przekazania zmiennych.

Lżejsza alternatywa: jeden moduł instance plus moduł-słownik modules/role-defaults, który zwraca mapę wartości domyślnych per rola. Daje mniej katalogów, ale mniej czytelne wywołania.

Jedno środowisko = jeden state = jeden projekt Scaleway. Klucze state mają postać <env>/terraform.tfstate. QA dostaje nowy projekt apollo-qa zamiast miejsca w apollo-test. Daje to czyste rozliczenie kosztów mirrora i bezpieczny zasięg terraform destroy. Faza D zakłada regularne destroy + apply na QA. Robienie tego w projekcie z 23 maszynami testowymi prosi się o wypadek.

Jak wygląda opis maszyn testowych

environments/test/main.tf ma jedno wywołanie, niezależnie od liczby maszyn:

module "docker_test" {
  source   = "../../modules/archetypes/docker-node"
  for_each = var.docker_test_servers

  name          = "${each.key}-apollo-docker-test"
  zone          = each.value.zone
  instance_type = each.value.type
  root_volume_gb = each.value.root_gb
  extra_tags    = each.value.extra_tags
  schedule_tags = each.value.schedule_tags
}

Konkrety siedzą tylko w environments/test/test.tfvars:

docker_test_servers = {
  # zespoły testerskie
  "wombaty"           = { type = "POP2-HC-4C-8G", root_gb = 80, extra_tags = ["wombaty"] }
  "wombaty-automaty"  = { type = "GP1-XS",        root_gb = 80, extra_tags = ["wombaty", "automaty"] }
  "oposy"             = { type = "GP1-XS",        root_gb = 80, extra_tags = ["oposy"] }
  "oposy-automaty"    = { type = "GP1-XS",        root_gb = 80, extra_tags = ["oposy", "automaty"] }
  "kapibary"          = { type = "GP1-XS",        root_gb = 80, extra_tags = ["kapibary"] }
  "kapibary-automaty" = { type = "PRO2-XS",       root_gb = 80, extra_tags = ["kapibary", "automaty"] }

  # stagingi klienckie
  "mowi"       = { type = "GP1-XS",  root_gb = 40, extra_tags = ["mowi"] }
  "drogbruk"   = { type = "GP1-XS",  root_gb = 40, extra_tags = ["drog-bruk"] }
  "semmelrock" = { type = "GP1-XS",  root_gb = 40, extra_tags = ["semmelrock"] }
  # ...

  # przeznaczenia wspólne
  "sandbox" = { type = "GP1-XS",  root_gb = 40, schedule_tags = ["stoppable", "stop-at-end-of-day"] }
  "pentest" = { type = "PRO2-S",  root_gb = 40, schedule_tags = ["stoppable"] }
}

Wartości root_gb powyżej są przykładowe. Istniejących maszyn nie importujemy, tylko zastępujemy je nowymi, więc rozmiary dobieramy na nowo. Następcy dostają nazwy według konwencji, np. test-apollo-wombaty-docker-01 zamiast wombaty-apollo-docker-test. Procedurę opisuje devops-process.md w części „Zastępowanie istniejących maszyn”.

Nowa maszyna testowa to jedna linijka w tfvars i PR, a nie klikanie w konsoli. Zmienna zone ma domyślnie pl-waw-2, bo cały apollo-test siedzi w WAW 2.


3. Konwencja nazewnicza: brakujący wymiar

Rozszerzoną konwencję wraz z listą dopuszczalnych wartości członów zawiera devops-process.md w sekcji 4. Tutaj zostaje uzasadnienie.

Pierwsza wersja brzmiała <środowisko>-<produkt>-<rola>-<lp> i nie miała miejsca na odbiorcę. A to u nas wymiar dominujący. Na produkcji maszyny są per klient, np. drog-bruk, euroglas, wk. W testach są per zespół: wombaty, oposy, kapibary. Stąd rozszerzenie:

<środowisko>-<produkt>-<odbiorca>-<rola>-<lp>      # odbiorca opcjonalny
Dzisiaj Według konwencji
drog-bruk-apollo-prod prod-apollo-drogbruk-tomcat-01
wombaty-apollo-docker-test test-apollo-wombaty-docker-01
stepping-stone-apollo-prod prod-apollo-bastion-01
redis-weglokoks-apollo-prod prod-apollo-weglokoks-redis-01

Nazwa hosta jest kluczem inwentarza i wpisem w TeamCity, monitoringu i DNS. Zmienia się razem z całą maszyną, przy jej zastąpieniu. Odpowiadają za to kroki „TeamCity” i „Przełączenie” procedury w devops-process.md.


4. Ansible: najpierw rozdzielić dwa rodzaje pracy

Przejrzałem wszystkie 30 playbooków. 26 z nich ma dosłownie hosts: all. Trzy to nakładki importujące perform-server-action-and-wait.yml, a jeden ma hosts: "{{ target_hosts | default('all') }}".

Żaden playbook nie wie więc, na czym działa. Zasięg wybiera się wyłącznie plikiem inwentarza i -l. Całe dzisiejsze Ansible jest operacyjne: wykonuje czynność. Brakuje części stanowej, która doprowadza serwer do opisanego stanu. To dwa różne rodzaje pracy i potrzebują różnej struktury:

Operacje (playbooks/) Stan docelowy (roles/)
Pytanie „zrób X na wskazanym hoście” „czym ma być ten serwer”
Wywołanie ręcznie albo z TeamCity, z parametrami site.yml, cyklicznie
Idempotencja nieistotna, np. stop-server-api obowiązkowa
Przykłady start/stop serwera, pobranie logów Tomcat, Docker, ufw, użytkownicy
Stan na początku projektu 30 playbooków 2 role: server_checks, users

Prawa kolumna była właściwą luką. Bez niej mirror QA nie ma z czego powstać: Terraform postawi maszynę, ale nie powie, co ma być w środku. Kryterium fazy D brzmi „destroy + apply odtwarza całe QA” i bez ról jest nieosiągalne.

Proponowane role

Warstwa bazowa dotyczy każdego hosta, niezależnie od projektu:

Rola Zakres Skąd się bierze
common apt, strefa czasowa, NTP, pakiety bazowe, sysctl nowa
users użytkownicy, klucze i grupy, deklaratywnie istnieje, dane w inventory/group_vars/all.yml
ssh konfiguracja sshd, klucze root scw-refresh-root-ssh-keys.yml
ufw pełny zestaw reguł z group_vars add-ufw-rule.yml + delete-ufw-rule.yml
swap plik swap według rozmiaru RAM add-swap-to-server.yml
site24x7 agent monitoringu site24x7/install-server-monitor.yaml
server_checks raporty zdrowia istnieje

Warstwa aplikacyjna zależy od tagu, czyli roli maszyny:

Rola Dla kogo Stan i zakres
java tomcat-node ZROBIONE: Corretto 11 z apt.corretto.aws
tomcat tomcat-node ZROBIONE: Tomcat 9, CATALINA_BASE=/opt/tomcat/current. Logrotate z compress-and-move-tomcat-logs.yml jest TODO.
tomcat_deploy tomcat-node ZROBIONE: to, czego wymaga deploy WAR-a z TeamCity. Sudo na tomcat.service, katalogi backupu i uploadu.
teamcity_access tomcat-node, docker-node z apollo-docker ZROBIONE: konto teamcity, klucze agentów, SSH na porcie 666. Wspólne dla obu celów deployu.
apollo tomcat-node TODO, jeśli okaże się potrzebna. Kontekst aplikacji, setenv.sh, katalogi danych, konfiguracja per klient. Bez deployu WAR-a.
docker_host docker-node ZROBIONE, na bazie create-docker-prune-cron.yaml + create-buildx-container.yml
apollo_docker docker-node z tagiem apollo-docker ZROBIONE: tylko warunki wstępne. Klon repo apollo-docker, zależności systemowe, katalogi, uprawnienia. Stos uruchamia skrypt.
nginx_proxy proxy-node nowa
redis redis-node nowa
db_backup docker-db-backup create-and-rotate-docker-db-backup.yaml
teamcity_agent agenci TeamCity clean-old-teamcity-libs-and-backups.yml + create-teamcity-reports-cleanup-cron.yml
certificates proxy-node, tomcat-node upload-ssl-certificates.yml

Playbooki, które dostają stanowy odpowiednik

Pięć playbooków zarządza użytkownikami: create-user-with-key, add-ssh-key-for-user, delete-user, remove-all-keys-from-user, update-user-password. Dwa kolejne obsługują ufw: add-ufw-rule i delete-ufw-rule. Wszystkie siedem zmienia stan, który powinien być opisany w repo, a ich efektu nigdzie nie widać. Z rolami users i ufw dodanie użytkownika to zmiana w group_vars i PR. Dostajemy code review, historię i automatyczne odtworzenie na nowej maszynie.

Playbooki zostają. Rola powstaje obok playbooka i przejmuje opis stanu. Playbook operacyjny czyta te same dane co rola. Potem buildy TeamCity przechodzą na state/, a na końcu playbook znika osobnym commitem. Kolejność i uzasadnienie opisuje devops-process.md w sekcji 7, „Wygaszanie playbooków operacyjnych”.

Rola users przeszła już krok „wspólne źródło danych” i czyta inventory/group_vars/all.yml. ufw czeka na zebranie reguł z maszyn.

Playbooki, które zostają operacjami

start-server-api, stop-server-api, start-server-and-wait, stop-server-and-wait, reboot-server-and-wait, perform-server-action-and-wait, get-server-api, download-tomcat-logs-from-tmp, check-diskspace, cve-2026-43284-mitigate-dirty-frag.

To wywołania API Scaleway i jednorazowe akcje, które niczego nie konfigurują. Zostają playbookami i nie wchodzą do Terraforma. Stan zasilania maszyn z tagami stoppable i stop-at-end-of-day świadomie zostawiamy harmonogramom TeamCity. Terraform pilnuje, że maszyna istnieje i ma właściwy tag. Czy akurat jest włączona, to nie jego sprawa: gdyby zarządzał stanem zasilania, nocne gaszenie byłoby dryfem.

Docelowy układ

ansible/
├── inventory/
│   ├── <env>_scw.yml         # ZROBIONE: prod, qa, test, dev
│   └── group_vars/           # ZROBIONE: w inventory/, bo stamtąd Ansible je czyta
│       ├── all.yml           #   baza dla wszystkiego (dziś: lista kont)
│       ├── tag_tomcat.yml    #   wersja Tomcata, opcje JVM, ścieżki
│       ├── tag_apollo_docker.yml  # ZROBIONE: klucz Bitbucket (klucze TeamCity w all.yml)
│       ├── env_prod.yml      #   rozmiary, retencja, hosty backupu
│       └── env_qa.yml        #   to samo, mniejsze
├── host_vars/
├── roles/
│   ├── users/                # ZROBIONE
│   └── server_checks/
├── playbooks/
│   ├── state/                # ZROBIONE
│   │   ├── site.yml          #   stan docelowy całego stada
│   │   ├── base.yml          #   warstwa bazowa
│   │   ├── tomcat-nodes.yml  #   ZROBIONE: tag tomcat -> java, tomcat, tomcat_deploy
│   │   ├── docker-nodes.yml         # ZROBIONE: tag docker -> docker_host
│   │   └── apollo-docker-nodes.yml  # ZROBIONE: tag apollo-docker -> apollo_docker
│   └── <30 istniejących>     # operacje bez zmiany ścieżek, TeamCity je woła
└── ansible.cfg

Playbooki operacyjne zostają w playbooks/ na płasko. Katalog playbooks/ops/ byłby czystszy, ale AnsibleConstants.kt woła /home/ansible/playbooks/<nazwa>.yml. Po tych ścieżkach triggery cron gaszą serwery, więc nie warto ich ruszać przy okazji. Podział realizuje podkatalog state/: nowe rzeczy trafiają w nowe miejsce, a stare ścieżki zostają nietknięte.


5. Inwentarze: 18 plików to za dużo

Stary układ ma osobny plik na każdy tag, a każdy plik osobno odpytuje API Scaleway. Wtyczka scaleway.scaleway.scaleway obsługuje keyed_groups, groups i compose, co sprawdziłem w wersji 2.7.2. To samo da się więc opisać czterema plikami:

# ansible/inventory/test_scw.yml
plugin: scaleway.scaleway.scaleway
api_url: https://api.scaleway.com
zones: [pl-waw-1, pl-waw-2]
hostnames: [hostname]
tags: [test]
keyed_groups:
  - key: tags
    prefix: tag
    separator: "_"
variables:
  ansible_host: public_ipv4
  host_status: state
  id: id
  tags: tags
  zone: zone

Każdy projekt ma jeden plik: prod_scw.yml, test_scw.yml, qa_scw.yml, dev_scw.yml. Grupy takie jak tag_tomcat, tag_wombaty czy tag_stoppable powstają same. Zamiast -i inventory/tomcat_inventory_scw.yml piszemy -i inventory/prod_scw.yml -l tag_tomcat. Przy okazji dostajemy przecięcia, których stary układ nie dawał: -l 'tag_tomcat:&tag_wombaty'.

Ważniejszy jest skutek uboczny. group_vars/tag_tomcat.yml zaczyna działać automatycznie, bo nazwy grup odpowiadają tagom. To domyka pętlę Terraform -> tag -> grupa -> zmienne -> rola.

Wtyczka nie filtruje po projekcie, bo opcja project_id nie jest używana przy listowaniu instancji. Środowisko rozróżnia więc wyłącznie tag, np. test albo qa, i ten tag jest obowiązkowy.

To zmiana łamiąca zgodność z TeamCity, bo buildy mają zaszyte ścieżki do plików inwentarza. Dlatego najpierw dodajemy cztery nowe pliki obok istniejących, potem przepinamy buildy pojedynczo, a stare pliki kasujemy na końcu. Oba układy mogą żyć równolegle dowolnie długo.

Cztery nowe pliki leżą obok osiemnastu starych i żaden build nie jest jeszcze na nie przepięty. qa_scw.yml zwraca pustą listę, dopóki w qa nie powstanie pierwsza maszyna.


6. Ryzyka wynikające z inwentarza

Block Storage Legacy 5K na całej produkcji. Wszystkie wolumeny prod poza jednym mają typ legacy, który Scaleway wycofuje. Problem rozwiązuje zastępowanie maszyn. Nowe maszyny dostają sbs_volume z modułu instance, a stare dyski znikają razem ze starymi maszynami.

Snapshoty automatyczne nie mogą wejść do state. apollo-test ma 36 obrazów -auto-, a dev ma 24. Powstają z harmonogramu i rotują się codziennie. Skoro nie importujemy, do Terraforma nie trafią przypadkiem. Przy nowych maszynach trzeba jednak zdecydować, czy harmonogram snapshotów jest dalej potrzebny, skoro maszynę odtwarzamy z kodu. Jeśli ma zostać zasobem Terraforma, opisujemy politykę, a nie same snapshoty. Snapshoty starych maszyn kasujemy razem z nimi.

infokiosk-test stoi na wolumenie infokiosk-prod-auto-2024-08. Maszyna testowa z produkcyjnego snapshotu prawdopodobnie trzyma produkcyjne dane, do sprawdzenia.

Maszyny do skasowania bez następcy. Chodzi o youtrack-dev-decom, youtrack-dev-old, old-apollo-docker-test, obrazy *-end-of-life i *-decom-* oraz dwa odpięte wolumeny w apollo-prod. To materiał na proposal.md z fazy A, bez następców w Terraformie.

teamcity-agents-apollo-test leży w projekcie apollo-test, a jest infrastrukturą dev-ops. Albo przenosimy ją do dev, albo nazywamy wyjątek od zasady „jeden projekt = jeden state”.

docker system prune -af w cron.daily na maszynach z apollo-docker. Playbook create-docker-prune-cron.yaml zakłada /etc/cron.daily/docker-prune z tym poleceniem. Usuwa ono zatrzymane kontenery, a potem wszystkie obrazy bez kontenera, łącznie z obrazami zbudowanymi lokalnie.

Na maszynie z tagiem stoppable albo stop-at-end-of-day może to wyglądać tak. Wieczorem maszyna gaśnie, a rano o 6:15 wstaje. Anacron nadrabia wtedy zaległy cron.daily. Jeśli kontenery stosu nie mają polityki restartu, znikają razem z obrazami, a kolejne uruchomienie wymaga pełnego przebudowania.

Nie wiem, czy to się faktycznie dzieje. Zależy to od polityk restartu w apollo-docker i od tego, czy obrazy są budowane lokalnie, czy pobierane z rejestru. To jednak dokładnie ten rodzaj sprzężenia, który ginie z pola widzenia, gdy każda warstwa mieszka w innym repo. Rola docker_host używa węższego sprzątania: docker image prune -f i docker builder prune -f --filter until=168h.

Stare generacje instancji. DEV1-*, GP1-* i PLAY2-* to wycofywane linie. Dziś niczego nie blokują. Przy zastąpieniu maszyny typ dobieramy od nowa, a później jego zmiana to jedna linijka w tfvars.


7. Kolejność i mirror QA

Proponowana kolejność zastępowania w fazie E: QA od zera, potem apollo-test, dev i na końcu apollo-prod.

  • apollo-test idzie pierwsze, bo 23 maszyny to jeden wzorzec. Archetyp docker-node jest gotowy, a koszt pomyłki najmniejszy.
  • dev z YouTrackiem i TeamCity ćwiczy przenoszenie stanu.
  • Produkcja idzie na końcu, według sprawdzonej procedury.

Czym jest mirror QA

apollo-docker zmienia postać tego pytania. Wybór nie dotyczy tego, czy Tomcat stoi w kontenerze. Dotyczy tego, którą topologię mirror ma odtwarzać, a te różnią się liczbą maszyn.

Pierwszy wariant: QA odwzorowuje produkcję. To wiele maszyn, Tomcat na Ubuntu, osobno Redis i mikroserwisy. Tylko w tym wariancie terraform destroy + apply na QA jest testem odtworzenia produkcji, a to jest sens całego mirrora. Jest droższy i wymaga ról java, tomcat i tomcat_deploy, których nie da się pożyczyć z apollo-docker.

Drugi wariant: QA to kolejna maszyna apollo-docker. Jest tani, szybki i bliski pracy testerów. Nie odpowiada jednak na pytanie, czy umiemy odtworzyć produkcję, bo to kolejne środowisko testowe.

Decyzja z 2026-09-25: potrzebne są oba warianty, pod różnymi nazwami. qa to mirror produkcji na hostach Tomcata: archetyp tomcat-node, projekt apollo-qa, WAW 1. test to środowiska testerów na hostach apollo-docker: archetyp docker-node, projekt apollo-test, WAW 2. Oba mają osobne katalogi w terraform/environments/.

Mirror QA wymaga też zmiany w TeamCity

WAR-a na produkcję wypycha TeamCity. Mirror QA jest więc gotowy dopiero wtedy, gdy ten sam build umie wypchnąć WAR-a na QA. Terraform postawi maszyny, a Ansible skonfiguruje Tomcaty. Bez zmiany w TeamCity mirror zostanie jednak pustym środowiskiem. Ten warunek trzeba dopisać do kryterium zakończenia fazy D.

Skalę zmiany wyznacza sposób, w jaki build wybiera maszyny docelowe. Dziś lista hostów jest zaszyta w AppName.kt i ServerConstants.kt. Każda nowa maszyna oznacza więc zmianę w konfiguracji TeamCity i kolejne miejsce, o którym trzeba pamiętać.

Rekomendacja: build pyta o maszyny inwentarz Ansible, np. -i inventory/qa_scw.yml -l tag_tomcat. Lista bierze się wtedy z tagów, czyli z Terraforma. Nowa maszyna z tagiem tomcat sama wchodzi do deployu, bez dotykania TeamCity. To domyka pętlę Terraform -> tag -> inwentarz -> grupa -> rola. Pasuje też do ograniczenia z fazy F: jeden sparametryzowany build na krok, z wyborem środowiska. Szczegółowy plan opisuje TeamCity bez commitu na maszynę.

Otwarte pytania

  1. Przepięcie TeamCity z zaszytej listy hostów na inwentarz jest wciąż otwarte.
  2. Gdzie mieszka konfiguracja per odbiorca, np. wombaty, oposy albo mowi: w repo apollo-docker czy na maszynie? Jeśli na maszynie, to jest stan, którego nikt nie odtworzy po destroy. Trzeba go wtedy przenieść do repo albo do group_vars.

Wiadomo już, kto uruchamia apollo-docker: robi to TeamCity po SSH, według RebuildTemplate.kt. Łączy się jako teamcity na porcie 666, repo leży w /home/teamcity/projects/apollo-docker (DeployConstants.APOLLO_DOCKER_DIR). Build robi git switch na wybraną gałąź i uruchamia apollo-docker.sh setup. Rola apollo_docker przygotowuje dokładnie to i nie instaluje żadnej jednostki systemd ani crona.

Ostatnia zmiana: 2026-09-28 · Dariusz Bąkowski
Zbudowano: 2026-11-20 10:32 UTC · wersja 1.0.0 · rewizja: 19fcdc12e