# Proponowana struktura Terraform i Ansible

\[DRAFT\] Propozycja do sekcji 2, 4 i 7 dokumentu [`devops-process.md`](<https://docs.logintegra.com/logintegra-ansible/devops-process/index.md>). Punkt wyjścia: [`logintegra-resources.md`](<https://docs.logintegra.com/logintegra-ansible/logintegra-resources/index.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ę](<https://docs.logintegra.com/logintegra-ansible/teamcity-dynamic-targets/index.md>).

### 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.
