1 / 50
IaC: Wprowadzenie do automatyzacji konfiguracji
Cel slajdu: Slajd wprowadza zagadnienie „IaC: Wprowadzenie do automatyzacji konfiguracji” w kontekście: IaC: Wprowadzenie do automatyzacji konfiguracji.

IaC: Wprowadzenie do automatyzacji konfiguracji

Paradygmat infrastruktury jako kodu i automatyzacja z Ansible

  • Infrastruktura jako kod (IaC – Infrastructure as Code): nowoczesny paradygmat inżynierii systemowej, w którym konfiguracja sprzętu, systemów operacyjnych i usług sieciowych jest definiowana za pomocą czytelnych plików tekstowych podlegających kontroli wersji.
  • Ansible jako wiodące narzędzie automatyzacji: otwartoźródłowy system orkiestracji rozwijany przez firmę Red Hat, charakteryzujący się bezagentową architekturą (agentless) oraz deklaratywnym opisem stanu pożądanego w formacie YAML.
  • Przełamanie barier tradycyjnej administracji: eliminacja błędów manualnych, problemu dryfu konfiguracji (configuration drift) oraz unikalnych, trudnych w utrzymaniu serwerów określanych mianem snowflake servers.
  • Zasada idempotentności (idempotence): gwarancja, że wielokrotne zaaplikowanie tego samego zestawu instrukcji doprowadzi system do identycznego stanu docelowego bez niepożądanych skutków ubocznych.
  • Struktura niniejszego modułu: 50 szczegółowych jednostek tematycznych obejmujących teorię IaC, architekturę transportową SSH, formaty inventory, playbooki YAML, szablony Jinja2, moduły systemowe, procedury obsługi zdarzeń (handlery), role, Ansible Galaxy, szyfrowanie z Ansible Vault oraz warsztat wdrożeniowy serwera WWW.
IaC: Wprowadzenie do automatyzacji konfiguracji: Slajd przedstawia zagadnienie IaC: Wprowadzenie do automatyzacji konfiguracji w ramach tematu IaC: Wprowadzenie do automatyzacji konfiguracji na przykładach poleceń oraz diagnostyki w systemach Linux, Windows i RouterOS. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s01
2 / 50
Cel warsztatu - automatyzacja konfiguracji
Cel slajdu: Slajd określa wymagane efekty uczenia się, czyli wiedzę i umiejętności, które uczestnik opanuje po zajęciach i laboratorium.

Cel warsztatu - automatyzacja konfiguracji

Efekty kształcenia i kompetencje inżynierskie w zakresie Ansible

  • Zrozumienie paradygmatu IaC: dogłębne przyswojenie różnic pomiędzy podejściem deklaratywnym a imperatywnym oraz eliminacja ryzyka dryfu konfiguracji w infrastrukturze rozproszonej.
  • Opanowanie architektury Ansible: bezagentowy model działania, rola węzła sterującego (Control Node) i węzłów zarządzanych (Managed Nodes), mechanizm transportowy SSH oraz generowanie modułów w języku Python.
  • Strukturyzacja zasobów: tworzenie czytelnych inwentarzy (Inventory) w formatach INI i YAML, podział na grupy funkcjonalne, definiowanie zmiennych na poziomie hostów i grup oraz konfiguracja pliku ansible.cfg.
  • Projektowanie playbooków: pisanie deklaratywnych scenariuszy automatyzacji w standardzie YAML, obsługa zmiennych, pobieranie faktów systemowych (gather_facts), dynamiczne szablony Jinja2 oraz obsługa pętli i warunków.
  • Reaktywność i bezpieczeństwo: wyzwalanie procedur obsługi zdarzeń (Handlers), organizacja kodu w wielokrotnego użytku Role, pobieranie gotowych modułów z Ansible Galaxy oraz ochrona danych poufnych za pomocą Ansible Vault.
  • Diagnostyka i wdrożenie: weryfikacja poprawności składniowej (ansible-lint), badanie idempotentności w trybie symulacji dry-run (--check, --diff) oraz opanowanie technik troubleshootingowych.
Cel warsztatu - automatyzacja konfiguracji: Slajd przedstawia zagadnienie Cel warsztatu - automatyzacja konfiguracji w ramach tematu Cel warsztatu - automatyzacja konfiguracji na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s02
3 / 50
Agenda - plan dziesiątej prezentacji
Cel slajdu: Slajd przedstawia kolejność omawianych zagadnień i wskazuje miejsce bieżącego tematu w strukturze wykładu.

Agenda - plan dziesiątej prezentacji

Szczegółowy harmonogram zagadnień teoretycznych i warsztatowych

  • Część I (slajdy 1–12): Fundamenty IaC – paradygmat infrastruktury jako kodu, zjawisko snowflake servers, ewolucja od skryptów powłoki do deklaratywności, idempotentność, pożądany stan, wersjonowanie w Git oraz scenariusze odtwarzania awaryjnego (Disaster Recovery).
  • Część II (slajdy 13–20): Narzędzia i architektura – porównanie narzędzi (Ansible, Puppet, Chef, SaltStack, Terraform), provisioning a zarządzanie konfiguracją, bezagentowa architektura Ansible, transport SSH/WinRM, instalacja węzła sterującego oraz polecenia doraźne ad-hoc.
  • Część III (slajdy 21–30): Struktura projektu i składnia YAML – organizacja katalogów, konfiguracja ansible.cfg, pliki inwentarza w formatach INI i YAML, anatomia playbooka, zmienne, zbieranie faktów (setup module), szablony Jinja2, warunki when i pętle loop.
  • Część IV (slajdy 31–38): Zaawansowane mechanizmy orkiestracji – selekcja tagami, handlery i powiadamianie zdarzeń, kluczowe moduły (copy, template, file, lineinfile, systemd, user), architektura ról (Ansible Roles), repozytorium Ansible Galaxy, bezpieczeństwo z Ansible Vault i dobre praktyki.
  • Część V (slajdy 39–44): Laboratorium wdrożeniowe – konfiguracja węzłów, test ad-hoc ping, instalacja i parametryzacja serwera Nginx, obsługa handlerów restartu, dowód idempotentności w trybie symulacji dry-run (--check, --diff) oraz weryfikacja działania usług.
  • Część VI (slajdy 45–50): Diagnostyka, troubleshooting i ściągawka – błędy składni YAML, problemy autoryzacji SSH, uprawnienia eskalacji become/sudo, poziomy szczegółowości debugowania (-vvvv), najczęstsze awarie oraz zestawienie poleceń CLI.
Agenda - plan dziesiątej prezentacji: Slajd przedstawia zagadnienie Agenda - plan dziesiątej prezentacji w ramach tematu Agenda - plan dziesiątej prezentacji na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s03
4 / 50
Tradycyjne zarządzanie serwerami - problemy
Cel slajdu: Slajd omawia zagadnienie „Tradycyjne zarządzanie serwerami - problemy” w kontekście: Tradycyjne zarządzanie serwerami - problemy.

Tradycyjne zarządzanie serwerami - problemy

Ograniczenia i ryzyka ręcznej administracji systemami operacyjnymi

  • Konfiguracja manualna przez interaktywne powłoki SSH: każdy administrator loguje się bezpośrednio na serwery i wykonuje doraźne polecenia naprawcze lub instalacyjne, nie dokumentując pełnego zakresu wykonanych prac.
  • Brak powtarzalności środowiskowej: odtworzenie identycznej konfiguracji na nowej maszynie jest praktycznie niemożliwe z powodu braku zapisu dokładnej sekwencji poleceń, parametrów jądra i wersji bibliotek.
  • Zjawisko dryfu konfiguracji (Configuration Drift): serwery pierwotnie skonfigurowane w ten sam sposób z czasem zaczynają się drastycznie różnić pod wpływem lokalnych łatek, testów i doraźnych modyfikacji.
  • Podwyższona podatność na błąd ludzki: literówki w plikach konfiguracyjnych, przypadkowe nadpisanie uprawnień (chmod -R) lub pominięcie krytycznego kroku instalacji prowadzą do poważnych awarii produkcyjnych.
  • Utrudniony audyt i brak rozliczalności: brak spójnego dziennika zmian uniemożliwia ustalenie, kto, kiedy i z jakiego powodu zmodyfikował kluczowe parametry produkcyjne, co narusza normy bezpieczeństwa (np. ISO/IEC 27001).
  • Bariera skalowalności: liniowy wzrost nakładu pracy administratora wraz ze wzrostem liczby zarządzanych maszyn uniemożliwia efektywne zarządzanie flotą powyżej kilkunastu urządzeń.
Tradycyjne zarządzanie serwerami - problemy: Slajd przedstawia zagadnienie Tradycyjne zarządzanie serwerami - problemy w ramach tematu Tradycyjne zarządzanie serwerami - problemy na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s04
5 / 50
Snowflake servers - dlaczego to zagrożenie
Cel slajdu: Slajd omawia zagadnienie „Snowflake servers - dlaczego to zagrożenie” w kontekście: Snowflake servers - dlaczego to zagrożenie.

Snowflake servers - dlaczego to zagrożenie

Anatomia serwera unikalnego i konsekwencje długu technologicznego

  • Definicja snowflake server (serwera-płatka śniegu): unikalna, jedyna w swoim rodzaju instancja serwerowa, której dokładna konfiguracja, zainstalowane zależności i lokalne modyfikacje nie są znane ani w pełni udokumentowane.
  • Mechanizm powstawania: wieloletnia eksploatacja przez różnych administratorów, doraźne łaty wgrywane w czasie awarii, brak centralnego rejestru zmian i instalacja oprogramowania ze źródeł zewnętrznych z pominięciem repozytoriów.
  • Strach przed restartem i aktualizacją: administratorzy obawiają się ponownego uruchomienia maszyny lub aktualizacji jądra i pakietów ze strachu, że kluczowe usługi biznesowe nie podniosą się poprawnie.
  • Paraliż procesu skalowania horyzontalnego: niemożność natychmiastowego sklonowania węzła w celu obsłużenia wzmożonego ruchu sieciowego z uwagi na brak powtarzalnego przepisu konfiguracyjnego.
  • Koszmar audytu bezpieczeństwa: brak pewności, które podatności CVE występują na poszczególnych instancjach, które biblioteki są przestarzałe i jakie konta użytkowników pozostały aktywne w systemie.
  • Rozwiązanie IaC: zastąpienie unikalnych maszyn instancjami w pełni powtarzalnymi, budowanymi w ułamku sekundy ze standaryzowanego kodu źródłowego (koncepcja Cattle, not Pets).
Snowflake servers - dlaczego to zagrożenie: Slajd przedstawia zagadnienie Snowflake servers - dlaczego to zagrożenie w ramach tematu Snowflake servers - dlaczego to zagrożenie na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s05
6 / 50
Ewolucja podejść: od ręcznej do deklaratywnej
Cel slajdu: Slajd omawia zagadnienie „Ewolucja podejść: od ręcznej do deklaratywnej” w kontekście: Ewolucja podejść: od ręcznej do deklaratywnej.

Ewolucja podejść: od ręcznej do deklaratywnej

Cztery fazy rozwoju dojrzałości inżynierii konfiguracji systemów

  • Faza 1 – Konfiguracja czysto ręczna (Manual): bezpośrednie logowanie przez SSH, wykonywanie komend ad-hoc, ręczna edycja plików nano/vim; zerowa powtarzalność, brak audytu, całkowita zależność od pamięci konkretnego administratora.
  • Faza 2 – Skrypty imperatywne (Bash/PowerShell): automatyzacja sekwencji poleceń w plikach skryptowych; usprawnienie pracy, lecz podatność na awarie przy ponownym uruchomieniu, brak natywnej idempotentności i brak weryfikacji stanu faktycznego.
  • Faza 3 – Podejście deklaratywne (Configuration Management): narzędzia takie jak Ansible, Puppet czy Chef; administrator opisuje w plikach YAML/DSL stan docelowy (co ma być osiągnięte), a silnik automatyzacji autonomicznie dobiera operacje konfiguracyjne.
  • Faza 4 – Pełny paradygmat IaC i GitOps: kod infrastruktury wersjonowany w repozytorium Git, obowiązkowe procedury Code Review, automatyczne wdrażanie przez potoki CI/CD, testowanie w środowiskach efemerycznych i ciągły monitoring stanu.
  • Zasadnicza różnica: skrypty powłoki są podatne na błędy stanu początkowego; narzędzia deklaratywne zapewniają determinizm i odporność na awarie dzięki wbudowanej pętli reconciliacji.
Ewolucja podejść: od ręcznej do deklaratywnej: Slajd przedstawia zagadnienie Ewolucja podejść: od ręcznej do deklaratywnej w ramach tematu Ewolucja podejść: od ręcznej do deklaratywnej na przykładach poleceń oraz diagnostyki w systemach Linux, Windows i RouterOS. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s06
7 / 50
Idempotentność - kluczowa koncepcja IaC
Cel slajdu: Slajd omawia zagadnienie „Idempotentność - kluczowa koncepcja IaC” w kontekście: Idempotentność - kluczowa koncepcja IaC.

Idempotentność - kluczowa koncepcja IaC

Determinizm operacyjny i bezpieczne ponawianie zadań automatyzacji

  • Formalna definicja idempotentności: właściwość operacji, zgodnie z którą jej wielokrotne zaaplikowanie do systemu daje dokładnie taki sam rezultat końcowy, jak wykonanie jednokrotne: f(f(x)) = f(x).
  • Przykłady operacji nieidempotentnych (skrypty powłoki):
    • mkdir /tmp/app – ponowne uruchomienie kończy się kodem błędu (katalog istnieje).
    • echo 'alias ll="ls -la"' >> ~/.bashrc – każde uruchomienie dopisuje kolejną, zduplikowaną linię.
    • iptables -A INPUT -p tcp --dport 80 -j ACCEPT – tworzy zduplikowane reguły filtrujące w pamięci jądra.
  • Mechanizm idempotentny w Ansible: moduł najpierw bada stan rzeczywisty węzła; jeżeli jest on w 100% zgodny z deklaracją, żadne operacje nie są podejmowane.
  • Precyzyjna informacja zwrotna: status ok (brak konieczności zmian, stan zgodny), status changed (wykonano niezbędną modyfikację stanu), status failed (błąd krytyczny).
  • Kluczowa korzyść: możliwość bezpiecznego, cyklicznego uruchamiania playbooków w harmonogramie cron lub potokach CI/CD bez obawy o uszkodzenie działających usług produkcyjnych.
Idempotentność - kluczowa koncepcja IaC: Slajd przedstawia zagadnienie Idempotentność - kluczowa koncepcja IaC w ramach tematu Idempotentność - kluczowa koncepcja IaC na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s07
8 / 50
Pożądany stan (Desired State) - jak to działa
Cel slajdu: Slajd omawia zagadnienie „Pożądany stan (Desired State) - jak to działa” w kontekście: Pożądany stan (Desired State) - jak to działa.

Pożądany stan (Desired State) - jak to działa

Model deklaratywny a konwergencja i reconciliacja infrastruktury

  • Paradygmat pożądanego stanu (Desired State Configuration): administrator definiuje w pliku playbooka docelowe parametry systemu (np. pakiet zainstalowany, plik obecny z uprawnieniami 0644, usługa aktywna w systemd).
  • Różnica między podejściem imperatywnym a deklaratywnym:
    • Imperatywne (Jak zrobić): skrypt krok po kroku instruuje jądro i powłokę, wykonując instrukcje apt update, apt install, edycję sed i restart usługi.
    • Deklaratywne (Co ma być osiągnięte): definiujemy docelowy stan obiektów, pozostawiając logikę osiągnięcia tego stanu dedykowanym modułom wykonawczym.
  • Pętla reconciliacji (Reconciliation Loop): silnik Ansible odpytuje system o stan faktyczny, wyznacza różnicę (delta) i aplikuje wyłącznie te operacje, które niwelują rozbieżność.
  • Semantyka raportowania wyników zadań:
    • ok – stan rzeczywisty węzła był w 100% zgodny ze stanem zadeklarowanym; brak interwencji.
    • changed – wykryto rozbieżność i pomyślnie zmodyfikowano zasób w celu uzyskania stanu pożądanego.
    • failed – wystąpił błąd uniemożliwiający osiągnięcie stanu (np. brak łączności z repozytorium, konflikt uprawnień).
  • Analogia do języka SQL: zapytanie SELECT deklaruje, jakie dane chcemy otrzymać, a optymalizator bazy danych samodzielnie wyznacza plan wykonania (Execution Plan).
Pożądany stan - jak to działa (ang. Desired State): Slajd przedstawia zagadnienie Pożądany stan (Desired State) - jak to działa w ramach tematu Pożądany stan (Desired State) - jak to działa na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s08
9 / 50
Kontrola wersji konfiguracji - Git jako podstawa
Cel slajdu: Slajd omawia zagadnienie „Kontrola wersji konfiguracji - Git jako podstawa” w kontekście: Kontrola wersji konfiguracji - Git jako podstawa.

Kontrola wersji konfiguracji - Git jako podstawa

Repozytorium jako jedyne źródło prawdy (Single Source of Truth)

  • Playbooki i pliki inwentarza jako kod źródłowy: konfiguracja zdefiniowana w czytelnych plikach tekstowych YAML i INI doskonale integruje się z systemem kontroli wersji Git.
  • Pełna audytowalność i rozliczalność (Audit Trail): historia commitów rejestruje dokładny czas zmiany, tożsamość autora oraz precyzyjne uzasadnienie biznesowe w komunikacie commita.
  • Mechanizm natychmiastowego wycofywania zmian (Rollback): w przypadku wystąpienia awarii po wdrożeniu polecenie git revert przywraca poprzednią, stabilną wersję konfiguracji w ułamku sekundy.
  • Procedury kontroli jakości (Code Review i Pull Requests): żadna zmiana nie trafia na serwery produkcyjne bez uprzedniej weryfikacji i zatwierdzenia przez co najmniej jednego doświadczonego członka zespołu.
  • Zarządzanie gałęziami (Branching Strategy): separacja środowisk rozwojowych (development), testowych (staging) oraz produkcyjnych (main/production) w oparciu o model GitFlow lub Trunk-Based Development.
  • Integracja z potokami CI/CD: automatyczne uruchamianie testów statycznych (ansible-lint, yamllint) oraz wdrożeń testowych na maszynach wirtualnych przy każdym zatwierdzeniu kodu.
Kontrola wersji konfiguracji - Git jako podstawa: Slajd przedstawia zagadnienie Kontrola wersji konfiguracji - Git jako podstawa w ramach tematu Kontrola wersji konfiguracji - Git jako podstawa na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s09
10 / 50
Korzyści z IaC - podsumowanie
Cel slajdu: Slajd omawia zagadnienie „Korzyści z IaC - podsumowanie” w kontekście: Korzyści z IaC - podsumowanie.

Korzyści z IaC - podsumowanie

Strategiczne i operacyjne zyski z wdrożenia automatyzacji w przedsiębiorstwie

  • Stuprocentowa powtarzalność środowisk: każdy serwer w klastrze jest wdrażany w identyczny sposób, bez względu na to, który członek zespołu uruchamia proces automatyzacji.
  • Radykalne skrócenie czasu wdrożenia (Time-to-Market): przygotowanie w pełni skonfigurowanego węzła serwerowego zajmuje minuty zamiast wielu godzin lub dni ręcznej konfiguracji.
  • Eliminacja długu technologicznego i błędów ludzkich: eliminacja pomyłek wpisywania komend, literówek w plikach konfiguracyjnych i niekompatybilności wersji bibliotek.
  • Znakomita odporność na awarie i Disaster Recovery: całkowite odtworzenie całego centrum danych po awarii sprzętowej sprowadza się do uruchomienia repozytorium playbooków na świeżych maszynach.
  • Zgodność regulacyjna i transparentność audytu: pełna rozliczalność konfiguracji w oparciu o historię Git, spełniająca wyśrubowane wymagania norm ISO/IEC 27001, PCI-DSS oraz RODO.
  • Efektywność kosztowa i skalowalność: pojedynczy inżynier jest w stanie bezpiecznie i stabilnie zarządzać flotą tysięcy serwerów bez utraty kontroli nad ich stanem.
Korzyści z IaC - podsumowanie: Slajd przedstawia zagadnienie Korzyści z IaC - podsumowanie w ramach tematu Korzyści z IaC - podsumowanie na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s10
11 / 50
Scenariusz: odtworzenie serwera po awarii
Cel slajdu: Slajd omawia zagadnienie „Scenariusz: odtworzenie serwera po awarii” w kontekście: Scenariusz: odtworzenie serwera po awarii.

Scenariusz: odtworzenie serwera po awarii

Porównanie procedur Disaster Recovery: podejście ręczne a automatyzacja IaC

  • Scenariusz katastrofy: krytyczny serwer produkcyjny ulega fizycznej awarii sprzętowej lub całkowitemu uszkodzeniu systemu plików w wyniku błędu macierzy dyskowej.
  • Tradycyjne odtwarzanie ręczne (od kilku godzin do wielu dni):
    • Instalacja bazowego systemu operacyjnego z nośnika instalacyjnego.
    • Ręczne poszukiwanie niepełnych notatek i fragmentarycznej dokumentacji na wewnętrznych stronach wiki.
    • Instalacja pakietów z pamięci, próby dopasowania zgodnych wersji bibliotek i kompilatorów.
    • Ręczne odtwarzanie skomplikowanych konfiguracji zapory sieciowej, certyfikatów i wirtualnych hostów.
    • Ryzyko pominięcia kluczowych łatek bezpieczeństwa lub błędnego skonfigurowania uprawnień.
  • Nowoczesne odtworzenie z Ansible i IaC (od kilkunastu sekund do kilku minut):
    • Powołanie świeżej, czystej maszyny wirtualnej lub instancji bare-metal ze standardowego obrazu.
    • Wpisanie adresu IP nowego węzła do pliku inwentarza (lub automatyczna aktualizacja DNS).
    • Uruchomienie pojedynczego polecenia: ansible-playbook -i hosts.ini site.yml.
    • Pełna, w 100% deterministyczna rekonstrukcja całego stosu aplikacyjnego bez udziału człowieka.
Scenariusz: odtworzenie serwera po awarii: odtworzenie serwera po awarii: Slajd przedstawia zagadnienie Scenariusz: odtworzenie serwera po awarii w ramach tematu Scenariusz: odtworzenie serwera po awarii na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s11
12 / 50
Podsumowanie wprowadzenia do IaC
Cel slajdu: Slajd omawia zagadnienie „Podsumowanie wprowadzenia do IaC” w kontekście: Podsumowanie wprowadzenia do IaC.

Podsumowanie wprowadzenia do IaC

Synteza paradygmatu: od rzemiosła do profesjonalnej inżynierii systemów

  • Kluczowe filary dojrzałej infrastruktury jako kodu:
    • Deklaratywność: skupienie na stanie pożądanym (Co?), a nie na imperatywnych krokach wykonawczych (Jak?).
    • Idempotentność: bezpieczeństwo wielokrotnego uruchamiania procesów bez ryzyka duplikacji zasobów.
    • Wersjonowanie: traktowanie definicji systemów z taką samą dyscypliną jak kodu źródłowego oprogramowania.
  • Radykalna redukcja długu technologicznego: definitywny koniec ery serwerów-płatków śniegu i zjawiska dryfu konfiguracji pomiędzy środowiskami testowymi a produkcją.
  • Konwergencja zespołów Dev i Ops: wspólny język opisu architektury eliminuje silosy organizacyjne i pozwala na wdrożenie zwinnych metodyk wytwarzania oprogramowania.
  • Fundament pod architekturę chmurową i mikroserwisową: dynamiczne skalowanie horyzontalne i orkiestracja kontenerów wymagają stuprocentowej automatyzacji warstwy systemowej.
  • Kolejny krok w edukacji inżynierskiej: przejście od założeń konceptualnych do konkretnych narzędzi wykonawczych i dogłębnej analizy architektury systemu Ansible.
Podsumowanie wprowadzenia do IaC: Slajd przedstawia zagadnienie Podsumowanie wprowadzenia do IaC w ramach tematu Podsumowanie wprowadzenia do IaC na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s12
13 / 50
Przegląd narzędzi automatyzacji konfiguracji
Cel slajdu: Slajd omawia zagadnienie „Przegląd narzędzi automatyzacji konfiguracji” w kontekście: Przegląd narzędzi automatyzacji konfiguracji.

Przegląd narzędzi automatyzacji konfiguracji

Porównanie architektury i modeli wykonawczych systemów klasy IaC

  • Ansible (Red Hat):
    • Architektura: całkowicie bezagentowa (agentless); wykorzystuje protokoły OpenSSH oraz WinRM.
    • Język opisu: standard YAML oraz szablony Jinja2; prosty próg wejścia, brak konieczności programowania.
    • Model: Push (węzeł sterujący aktywnie inicjuje połączenia i przesyła zadania do węzłów).
  • Puppet (Puppet Labs / Perforce):
    • Architektura: agentowa (serwer Puppet Master oraz demony klienckie Puppet Agent na każdym węźle).
    • Język opisu: dedykowany deklaratywny język Puppet DSL (oparty na składni języka Ruby).
    • Model: Pull (agenci cyklicznie odpytują serwer nadrzędny o aktualny katalog konfiguracji).
  • Chef (Progress):
    • Architektura: agentowa (Chef Server, stacja robocza Workstation oraz agenci Chef Client).
    • Język opisu: czysty język programowania Ruby (Cookbooks i Recipes); bardzo wysoka elastyczność, lecz stroma krzywa uczenia.
  • SaltStack (VMware / Broadcom):
    • Architektura: hybrydowa (ultraszybki model agentowy Salt-Minion oparty na magistrali ZeroMQ lub bezagentowy Salt-SSH).
  • Terraform / OpenTofu (HashiCorp / Linux Foundation):
    • Specjalizacja: wiodące narzędzie do orkiestracji i tworzenia zasobów chmurowych (Cloud Provisioning) w języku HCL.
Przegląd narzędzi automatyzacji konfiguracji: Slajd przedstawia zagadnienie Przegląd narzędzi automatyzacji konfiguracji w ramach tematu Przegląd narzędzi automatyzacji konfiguracji na przykładach poleceń oraz diagnostyki w systemach Linux, Windows i RouterOS. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s13
14 / 50
Provisioning vs configuration management
Cel slajdu: Slajd omawia zagadnienie „Provisioning vs configuration management” w kontekście: Provisioning vs configuration management.

Provisioning vs configuration management

Rozgraniczenie i synergia orkiestracji zasobów oraz konfiguracji systemów

  • Tworzenie zasobów (Cloud/Infrastructure Provisioning):
    • Cel: powołanie do życia fizycznych lub logicznych komponentów infrastruktury: maszyn wirtualnych, dysków, podsieci sieciowych (VPC), zbalansowanych tras routingu, reguł zapór sieciowych i load balancerów.
    • Wiodące narzędzia: Terraform, OpenTofu, AWS CloudFormation, Azure ARM/Bicep, Google Cloud Deployment Manager.
    • Stan: zarządzanie cyklem życia zasobów w oparciu o stan infrastruktury (State File).
  • Zarządzanie konfiguracją (Configuration Management):
    • Cel: przygotowanie warstwy systemowej i aplikacyjnej wewnątrz powołanych wcześniej instancji: instalacja bibliotek i pakietów, konfiguracja demonów, zakładanie użytkowników, wdrażanie certyfikatów i kodu aplikacji.
    • Wiodące narzędzia: Ansible, Puppet, Chef, SaltStack.
  • Wzorzec synergii produkcyjnej (Best Practice Workflow):
    • Krok 1: Terraform powołuje pulę maszyn wirtualnych w chmurze lub klastrze Proxmox/VMware.
    • Krok 2: Terraform generuje dynamiczny plik inwentarza (Dynamic Inventory) z adresami IP nowych węzłów.
    • Krok 3: Ansible łączy się z nowymi maszynami i w sposób w pełni zautomatyzowany konfiguruje środowisko produkcyjne.
Provisioning vs configuration management: Slajd przedstawia zagadnienie Provisioning vs configuration management w ramach tematu Provisioning vs configuration management na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s14
15 / 50
Architektura Ansible - bezagentowa i prosta
Cel slajdu: Slajd omawia zagadnienie „Architektura Ansible - bezagentowa i prosta” w kontekście: Architektura Ansible - bezagentowa i prosta.

Architektura Ansible - bezagentowa i prosta

Model węzła sterującego, węzłów zarządzanych i cykl wykonania zadania

  • Węzeł sterujący (Control Node):
    • Komputer lub serwer z systemem Linux/Unix (np. Ubuntu, Debian, RHEL, macOS), na którym zainstalowany jest Ansible.
    • Zawiera pliki projektu: inwentarz (Inventory), playbooki, role, szablony i plik konfiguracyjny ansible.cfg.
    • Uwaga techniczna: węzeł sterujący nie może być uruchomiony bezpośrednio na natywnym systemie Windows (wymaga środowiska WSL).
  • Węzły zarządzane (Managed Nodes / Hosts):
    • Serwery fizyczne, maszyny wirtualne, kontenery, zapory sieciowe, przełączniki i routery podlegające automatyzacji.
    • Brak konieczności instalowania jakichkolwiek dedykowanych aplikacji klienckich czy demonów Ansible.
  • Kanał transportowy (Transport Layer):
    • Systemy Linux/Unix: standardowy protokół OpenSSH (port TCP 22).
    • Systemy Microsoft Windows: protokół WinRM (porty TCP 5985/5986) lub natywny OpenSSH for Windows.
    • Urządzenia sieciowe: SSH CLI, protokoły NETCONF lub RESTCONF/API.
  • Wewnętrzny cykl wykonawczy modułu (Execution Flow):
    1. Węzeł sterujący generuje autonomiczny skrypt w języku Python łączący kod modułu z przekazanymi parametrami.
    2. Skrypt jest przesyłany przez bezpieczny kanał SFTP/SCP do katalogu tymczasowego ~/.ansible/tmp/ na węźle docelowym.
    3. Skrypt jest zdalnie wykonywany przez lokalny interpreter Pythona i zwraca ustrukturyzowany wynik w formacie JSON na standardowe wyjście (stdout).
    4. Węzeł sterujący odbiera odpowiedź JSON, interpretuje kody powrotu i usuwa skrypt z katalogu tymczasowego.
Architektura Ansible - bezagentowa i prosta: Slajd przedstawia zagadnienie Architektura Ansible - bezagentowa i prosta w ramach tematu Architektura Ansible - bezagentowa i prosta na przykładach poleceń oraz diagnostyki w systemach Linux, Windows i RouterOS. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s15
16 / 50
SSH w Ansible - klucz do komunikacji
Cel slajdu: Slajd omawia zagadnienie „SSH w Ansible - klucz do komunikacji” w kontekście: SSH w Ansible - klucz do komunikacji.

SSH w Ansible - klucz do komunikacji

Mechanizmy transportowe, uwierzytelnianie asymetryczne i optymalizacja ControlPersist

  • Protokół OpenSSH (openssh.com) jako fundament bezpieczeństwa: Ansible wykorzystuje natywnego klienta OpenSSH systemu operacyjnego, dziedzicząc wszystkie jego zalety: silną kryptografię, audytowalność i odporność na podsłuch.
  • Zalecane uwierzytelnianie kluczami asymetrycznymi (Public-Key Authentication):
    • Generowanie nowoczesnej pary kluczy opartej na krzywych eliptycznych: ssh-keygen -t ed25519 -C "ansible-control".
    • Dystrybucja klucza publicznego na węzły zarządzane za pomocą polecenia: ssh-copy-id -i ~/.ssh/id_ed25519.pub user@host.
    • Eliminacja podatnego na ataki logowania hasłem (konfiguracja PasswordAuthentication no w /etc/ssh/sshd_config).
  • Multiplexing połączeń (ControlMaster i ControlPersist):
    • Tradycyjne nawiązywanie nowego połączenia TCP/SSH dla każdego zadania playbooka powoduje ogromne opóźnienia sieciowe.
    • Mechanizm ControlPersist utrzymuje aktywne gniazdo uniksowe połączenia SSH przez określony czas (np. 60 sekund) po zakończeniu zadania.
    • Kolejne zadania playbooka wykorzystują istniejące, uwierzytelnione gniazdo, skracając czas wykonania playbooka o 60–80%.
  • Bezpieczna konfiguracja pliku ansible.cfg: definiowanie ścieżki do klucza prywatnego (private_key_file) oraz kontrola sprawdzania kluczy hostów (host_key_checking).
SSH w Ansible - klucz do komunikacji: Slajd przedstawia zagadnienie SSH w Ansible - klucz do komunikacji w ramach tematu SSH w Ansible - klucz do komunikacji na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s16
17 / 50
Instalacja Ansible na kontrolerze
Cel slajdu: Slajd omawia zagadnienie „Instalacja Ansible na kontrolerze” w kontekście: Instalacja Ansible na kontrolerze.

Instalacja Ansible na kontrolerze

Metody dystrybucji pakietów, wirtualne środowiska Python i podział ekosystemu

  • Różnica pomiędzy pakietem ansible-core a pakietem bateryjnym ansible:
    • ansible-core – lekki, bazowy silnik wykonawczy, interpreter playbooków, narzędzia CLI i minimalny zestaw wbudowanych modułów (ansible.builtin).
    • ansible (pakiet społecznościowy) – kompletny zestaw bateryjny zawierający silnik ansible-core oraz setki oficjalnych kolekcji dostarczanych przez społeczność i producentów sprzętu (Cisco, VMware, AWS, Azure).
  • Instalacja za pomocą menedżerów pakietów dystrybucji Linux:
    • Ubuntu/Debian: sudo apt update && sudo apt install -y ansible (wersja zależy od wydania dystrybucji, np. 13.1.0 w Ubuntu 26.04; po instalacji zawsze sprawdź ansible --version).
    • RHEL / Rocky Linux / AlmaLinux: sudo dnf install -y epel-release && sudo dnf install -y ansible.
  • Rekomendowane podejście inżynierskie – wirtualne środowisko Python (venv):
    • Tworzenie izolowanego środowiska: python3 -m venv ~/ansible-venv
    • Aktywacja środowiska: source ~/ansible-venv/bin/activate
    • Instalacja najnowszych, powtarzalnych wersji: pip install --upgrade pip && pip install ansible ansible-lint
    • Zapewnia pełną niezależność od pakietów systemowych systemu operacyjnego kontrolera.
  • Weryfikacja poprawności instalacji: polecenie ansible --version prezentuje wersję silnika, ścieżkę do interpretera Pythona oraz lokalizację aktywnego pliku konfiguracyjnego.
Instalacja Ansible na kontrolerze: Slajd przedstawia zagadnienie Instalacja Ansible na kontrolerze w ramach tematu Instalacja Ansible na kontrolerze na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s17
18 / 50
Wymagania dla zarządzanych węzłów
Cel slajdu: Slajd omawia zagadnienie „Wymagania dla zarządzanych węzłów” w kontekście: Wymagania dla zarządzanych węzłów.

Wymagania dla zarządzanych węzłów

Przesłanki środowiskowe: systemy Linux, Unix, Windows i infrastruktura sieciowa

  • Wymagania dla węzłów z systemami Linux oraz Unix:
    • Obecność serwera SSH (OpenSSH daemon sshd) uruchomionego i nasłuchującego na porcie TCP 22.
    • Zainstalowany interpreter języka Python w wersji 3.9 lub nowszej na węźle sterującym oraz Python 3.7 lub nowszy na węzłach zarządzanych, zgodnie z tabelą wsparcia ansible-core (przewodnik instalacji Ansible); w większości nowoczesnych dystrybucji interpreter jest obecny domyślnie w ścieżce /usr/bin/python3).
    • Konto użytkownika z uprawnieniami do eskalacji uprawnień administracyjnych (mechanizm sudo, zalecana konfiguracja bez hasła NOPASSWD w pliku /etc/sudoers).
    • Obecność podstawowych narzędzi systemowych: tar, gzip/bzip2 (niezbędne do rozpakowywania modułów przesyłanych przez kontroler).
  • Wymagania dla węzłów z systemem Microsoft Windows:
    • Środowisko PowerShell w wersji minimum 5.1 oraz środowisko uruchomieniowe .NET Framework 4.5+.
    • Włączony i skonfigurowany protokół WinRM (Windows Remote Management) z bezpiecznym nasłuchiwaniem HTTPS (port 5986) lub natywny OpenSSH for Windows.
    • Skonfigurowany moduł uwierzytelniania: NTLM, Kerberos lub certyfikaty x509.
  • Wymagania dla urządzeń sieciowych (Switches, Routers, Firewalls):
    • Obsługa połączeń interaktywnych SSH z dedykowanymi wtyczkami sieciowymi (np. ansible.netcommon.network_cli).
    • W nowoczesnych urządzeniach: interfejsy API oparte na protokołach NETCONF (port 830) lub RESTCONF (porty HTTPS).
Wymagania dla zarządzanych węzłów: Slajd przedstawia zagadnienie Wymagania dla zarządzanych węzłów w ramach tematu Wymagania dla zarządzanych węzłów na przykładach poleceń oraz diagnostyki w systemach Linux, Windows i RouterOS. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s18
19 / 50
Moduły Ansible - podstawowe narzędzia pracy
Cel slajdu: Slajd omawia zagadnienie „Moduły Ansible - podstawowe narzędzia pracy” w kontekście: Moduły Ansible - podstawowe narzędzia pracy.

Moduły Ansible - podstawowe narzędzia pracy

Katalog modułów wykonawczych: zarządzanie pakietami, plikami i procesami

  • Czym jest moduł Ansible: wyspecjalizowana, autonomiczna jednostka kodu (głównie w języku Python lub PowerShell), odpowiedzialna za realizację konkretnego zadania na węźle zarządzanym.
  • Klasyfikacja kluczowych modułów systemowych:
    • Menedżery pakietów oprogramowania:
      • ansible.builtin.apt – obsługa repozytoriów i pakietów deb w systemach Debian/Ubuntu.
      • ansible.builtin.dnf / yum – obsługa pakietów rpm w ekosystemie RHEL/Rocky/Fedora.
      • ansible.builtin.package – moduł uniwersalny (wykrywa lokalny menedżer na podstawie faktów).
    • Zarządzanie usługami i demonami: ansible.builtin.systemd oraz uniwersalny service.
    • Operacje na systemie plików: copy (przesyłanie plików), template (szablony Jinja2), file (zarządzanie atrybutami, katalogami i linkami), lineinfile (precyzyjna modyfikacja pojedynczych linii tekstu).
    • Zarządzanie tożsamością i uprawnieniami: user (konta użytkowników) oraz group (grupy systemowe).
  • Moduły uruchamiania poleceń bezpośrednich – zasady doboru:
    • command – moduł domyślny, bezpieczny; wykonuje polecenie bezpośrednio bez powłoki (brak obsługi potoków | i przekierowań).
    • shell – uruchamia polecenie przez powłokę /bin/sh; obsługuje potoki, zmienne środowiskowe i operatory logiczne (wymaga ostrożności).
    • raw – wykonuje polecenie przez SSH z całkowitym pominięciem podsystemu modułów; niezbędny na urządzeniach bez zainstalowanego Pythona.
Moduły Ansible - podstawowe narzędzia pracy: Slajd przedstawia zagadnienie Moduły Ansible - podstawowe narzędzia pracy w ramach tematu Moduły Ansible - podstawowe narzędzia pracy na przykładach poleceń oraz diagnostyki w systemach Linux, Windows i RouterOS. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s19
20 / 50
Komendy ad-hoc w Ansible
Cel slajdu: Slajd omawia zagadnienie „Komendy ad-hoc w Ansible” w kontekście: Komendy ad-hoc w Ansible.

Komendy ad-hoc w Ansible

Błyskawiczne operacje administracyjne w wierszu poleceń CLI

  • Zastosowanie poleceń doraźnych (Ad-Hoc Commands): jednorazowe, natychmiastowe operacje diagnostyczne, audytowe lub ratunkowe wykonywane na grupie hostów bez konieczności tworzenia pełnego pliku playbooka YAML.
  • Anatomia polecenia CLI:
    ansible <grupa_hostów> -m <nazwa_modułu> -a "<argumenty>" -i <inwentarz> [opcje]
  • Kluczowe przykłady z praktyki administratora:
    • Weryfikacja łączności i uwierzytelniania:
      ansible all -m ping -i hosts.ini
    • Szybka inspekcja czasu pracy i obciążenia procesorów:
      ansible web -m command -a "uptime" -i hosts.ini
    • Błyskawiczny restart krytycznej usługi z eskalacją uprawnień:
      ansible web -m systemd -a "name=nginx state=restarted" -b -i hosts.ini
    • Zbieranie wybranego faktu sprzętowego (ilość pamięci RAM):
      ansible db -m setup -a "filter=ansible_memtotal_mb" -i hosts.ini
    • Masowa aktualizacja pakietu bezpieczeństwa na wszystkich węzłach:
      ansible all -m apt -a "name=openssh-server state=latest" -b -i hosts.ini
  • Flagi przydatne w poleceniach ad-hoc: -b (become – eskalacja uprawnień sudo), -u <user> (użytkownik SSH), -k (zapytaj o hasło SSH), -K (zapytaj o hasło sudo).
Komendy ad-hoc w Ansible: Slajd przedstawia zagadnienie Komendy ad-hoc w Ansible w ramach tematu Komendy ad-hoc w Ansible na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s20
21 / 50
Struktura projektu Ansible - katalogi i pliki
Cel slajdu: Slajd omawia zagadnienie „Struktura projektu Ansible - katalogi i pliki” w kontekście: Struktura projektu Ansible - katalogi i pliki.

Struktura projektu Ansible - katalogi i pliki

Organizacja repozytorium automatyzacji zgodnie z wzorcem produkcyjnym

  • Standardowy układ drzewa katalogów w projekcie Ansible:
    projekt-ansible/
    ├── ansible.cfg            # Globalna konfiguracja projektu i zachowania CLI
    ├── hosts.ini              # Plik inwentarza produkcyjnego (lub plik YAML)
    ├── hosts_staging.ini      # Plik inwentarza środowiska testowego
    ├── site.yml               # Nadrzędny playbook orkiestracji (Master Playbook)
    ├── webservers.yml         # Playbook dedykowany dla warstwy WWW
    ├── dbservers.yml          # Playbook dedykowany dla baz danych
    ├── group_vars/            # Zmienne specyficzne dla grup hostów
    │   ├── all.yml            # Zmienne globalne, wspólne dla wszystkich maszyn
    │   ├── web.yml            # Zmienne aplikowane wyłącznie do grupy web
    │   └── db.yml             # Zmienne aplikowane wyłącznie do grupy db
    ├── host_vars/             # Zmienne specyficzne dla pojedynczych hostów
    │   └── srv-web-01.yml     # Zmienne dedykowane dla konkretnej maszyny
    └── roles/                 # Reużywalne, modularne role Ansible
        └── common/            # Rola wspólna (użytkownicy, SSH, NTP)
        └── nginx/             # Rola instalacji i konfiguracji serwera WWW
  • Zasada separacji logiki i danych: kod wykonawczy (zadania w playbookach i rolach) jest ściśle oddzielony od danych konfiguracyjnych (zmienne w group_vars i host_vars).
  • Skalowalność i czytelność: czytelna struktura ułatwia pracę w zespole programistyczno-administratorskim i umożliwia płynne wdrażanie nowych środowisk.
Struktura projektu Ansible - katalogi i pliki: Slajd przedstawia zagadnienie Struktura projektu Ansible - katalogi i pliki w ramach tematu Struktura projektu Ansible - katalogi i pliki na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s21
22 / 50
Inventory - definiowanie zarządzanych węzłów
Cel slajdu: Slajd omawia zagadnienie „Inventory - definiowanie zarządzanych węzłów” w kontekście: Inventory - definiowanie zarządzanych węzłów.

Inventory - definiowanie zarządzanych węzłów

Fundamenty inwentarza: grupy, hierarchie i formaty INI oraz YAML

  • Rola pliku inwentarza (Inventory): rejestr wszystkich maszyn podlegających automatyzacji; mapuje logiczne nazwy hostów na adresy IP lub domeny FQDN oraz organizuje serwery w grupy funkcjonalne.
  • Dwa oficjalnie wspierane formaty statyczne:
    • Format INI: tradycyjny, płaski, kompaktowy i niezwykle czytelny dla prostych struktur.
    • Format YAML: ustrukturyzowany, ściśle zhierarchizowany, natywnie obsługujący złożone typy danych (listy, słowniki).
  • Grupy wbudowane (predefiniowane w Ansible):
    • all – grupa nadrzędna zawierająca bezwzględnie wszystkie hosty zdefiniowane w inwentarzu.
    • ungrouped – grupa zawierająca hosty, które nie zostały przypisane do żadnej jawnej grupy użytkownika.
  • Zagnieżdżanie grup (Group Nesting):
    • Format INI: dyrektywa [nazwa_grupy:children] pozwala na tworzenie grup metanadrzędnych (np. grupa datacenter_warszawa składająca się z podgrup web i db).
    • Format YAML: sekcja children: definiująca relacje potomne w ustrukturyzowanym drzewie.
  • Inwentarze dynamiczne (Dynamic Inventory): skrypty lub wtyczki pobierające listę serwerów w czasie rzeczywistym z API chmur publicznych (AWS EC2, Azure, GCP) lub systemów wirtualizacji (VMware, Proxmox).
Inventory - definiowanie zarządzanych węzłów: Slajd przedstawia zagadnienie Inventory - definiowanie zarządzanych węzłów w ramach tematu Inventory - definiowanie zarządzanych węzłów na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s22
23 / 50
Przykład pliku inventory (hosts.ini i hosts.yml)
Cel slajdu: Slajd omawia zagadnienie „Przykład pliku inventory (hosts.ini i hosts.yml)” w kontekście: Przykład pliku inventory (hosts.ini i hosts.yml).

Przykład pliku inventory (hosts.ini i hosts.yml)

Praktyczne zestawienie składni inwentarza w formacie INI oraz YAML

  • Reprezentacja w formacie INI (hosts.ini):
    [web]
    web01.firma.pl ansible_host=192.168.10.11 http_port=80
    web02.firma.pl ansible_host=192.168.10.12 http_port=80
    
    [db]
    db01.firma.pl  ansible_host=192.168.10.21 db_role=primary
    db02.firma.pl  ansible_host=192.168.10.22 db_role=replica
    
    [serwery:children]
    web
    db
    
    [serwery:vars]
    ansible_user=deploy
    ansible_ssh_private_key_file=~/.ssh/id_ed25519
  • Równoważna reprezentacja w formacie YAML (hosts.yml):
    all:
      children:
        serwery:
          vars:
            ansible_user: deploy
            ansible_ssh_private_key_file: ~/.ssh/id_ed25519
          children:
            web:
              hosts:
                web01.firma.pl: { ansible_host: 192.168.10.11, http_port: 80 }
                web02.firma.pl: { ansible_host: 192.168.10.12, http_port: 80 }
            db:
              hosts:
                db01.firma.pl: { ansible_host: 192.168.10.21, db_role: primary }
                db02.firma.pl: { ansible_host: 192.168.10.22, db_role: replica }
  • Kluczowe zmienne specjalne Ansible: ansible_host (rzeczywisty adres IP/FQDN), ansible_port (port SSH jeśli inny niż 22), ansible_user (użytkownik zdalny), ansible_connection (np. ssh, winrm, local).
Przykład pliku inventory (ang. hosts.ini i hosts.yml): Slajd przedstawia zagadnienie Przykład pliku inventory (hosts.ini i hosts.yml) w ramach tematu Przykład pliku inventory (hosts.ini i hosts.yml) na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s23
24 / 50
Plik ansible.cfg - konfiguracja globalna
Cel slajdu: Slajd omawia zagadnienie „Plik ansible.cfg - konfiguracja globalna” w kontekście: Plik ansible.cfg - konfiguracja globalna.

Plik ansible.cfg - konfiguracja globalna

Dostrajanie parametrów wykonawczych silnika orkiestracji Ansible

  • Hierarchia przeszukiwania pliku konfiguracyjnego (od najwyższego priorytetu):
    1. Zmienna środowiskowa: ANSIBLE_CONFIG (wskazuje konkretną ścieżkę do pliku).
    2. Plik ansible.cfg w bieżącym katalogu roboczym (rekomendowany standard projektowy).
    3. Ukryty plik ~/.ansible.cfg w katalogu domowym bieżącego użytkownika.
    4. Plik systemowy /etc/ansible/ansible.cfg (konfiguracja globalna całego systemu operacyjnego).
  • Wzorcowy plik ansible.cfg dla projektu produkcyjnego:
    [defaults]
    inventory          = ./hosts.ini
    roles_path         = ./roles
    remote_user        = ansible
    host_key_checking  = False
    forks              = 10
    timeout            = 30
    retry_files_enabled = False
    
    [privilege_escalation]
    become             = True
    become_method      = sudo
    become_user        = root
    become_ask_pass    = False
    
    [ssh_connection]
    pipelining         = True
    control_path       = /tmp/ansible-ssh-%%h-%%p-%%r
  • Kluczowe parametry wydajnościowe: forks (liczba równolegle obsługiwanych węzłów, domyślnie 5), pipelining = True (redukuje liczbę operacji transferu SSH, drastycznie przyspieszając pracę).
Plik ansible.cfg - konfiguracja globalna: Slajd przedstawia zagadnienie Plik ansible.cfg - konfiguracja globalna w ramach tematu Plik ansible.cfg - konfiguracja globalna na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s24
25 / 50
Playbook - podstawowa jednostka automatyzacji
Cel slajdu: Slajd omawia zagadnienie „Playbook - podstawowa jednostka automatyzacji” w kontekście: Playbook - podstawowa jednostka automatyzacji.

Playbook - podstawowa jednostka automatyzacji

Anatomia scenariusza automatyzacji: deklaracja Play i sekwencja zadań Tasks

  • Czym jest Playbook: plik tekstowy w formacie YAML zawierający jeden lub więcej scenariuszy (tzw. Plays), które mapują określoną grupę zarządzanych hostów na uporządkowaną sekwencję zadań automatyzacji.
  • Anatomia pojedynczego Play (Scenariusza):
    • name – czytelna, opisowa nazwa scenariusza wyświetlana w konsoli podczas wykonywania.
    • hosts – wzorzec hostów docelowych z inwentarza (np. web, db, all).
    • become – flaga eskalacji uprawnień administracyjnych (sudo).
    • vars – lokalne zmienne specyficzne dla danego scenariusza.
    • tasks – lista konkretnych zadań wykonywanych kolejno od góry do dołu.
  • Anatomia pojedynczego Task (Zadania):
    - name: Instalacja serwera Nginx w najnowszej wersji
      ansible.builtin.apt:
        name: nginx
        state: latest
        update_cache: yes
  • Reguła atomowości i raportowania: każde zadanie wywołuje jeden moduł; silnik wykonuje zadanie na wszystkich docelowych hostach równolegle, po czym przechodzi do następnego kroku dopiero po zakończeniu zadania na wszystkich maszynach (model synchroniczny).
Playbook - podstawowa jednostka automatyzacji: Slajd przedstawia zagadnienie Playbook - podstawowa jednostka automatyzacji w ramach tematu Playbook - podstawowa jednostka automatyzacji na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s25
26 / 50
Składnia YAML - podstawy dla Ansible
Cel slajdu: Slajd omawia zagadnienie „Składnia YAML - podstawy dla Ansible” w kontekście: Składnia YAML - podstawy dla Ansible.

Składnia YAML - podstawy dla Ansible

Reguły formatowania dokumentów, struktury danych i pułapki składniowe

  • Standard YAML (YAML Ain't Markup Language): czytelny dla człowieka format serializacji danych, stanowiący fundament zapisu playbooków i zmiennych w Ansible.
  • Rygorystyczne reguły formatowania:
    • Początek dokumentu: dokument YAML standardowo rozpoczyna się od trzech myślników (---).
    • Kategoryczny zakaz tabulatorów: wcięcia muszą być realizowane wyłącznie za pomocą spacji (najczęściej 2 spacje na każdy poziom zagnieżdżenia); użycie znaku tabulacji powoduje błąd parsowania parsera.
    • Wrażliwość na wielkość liter (Case Sensitive): klucze State i state reprezentują dwa różne parametry.
  • Trzy fundamentalne typy struktur danych w YAML:
    • Skalary (wartości proste): ciągi znaków (ciągi ze znakami specjalnymi lub nawiasami klamrowymi wymagają cudzysłowów), liczby całkowite, wartości logiczne (true, false, yes, no).
    • Listy (sekwencje uporządkowane): elementy poprzedzone myślnikiem i spacją:
      pakiety:
        - nginx
        - curl
        - htop
    • Słowniki (mapy par klucz: wartość): dwukropek musi być bezwzględnie oddzielony od wartości spacją:
      usluga:
        name: nginx
        state: started
        enabled: yes
Składnia YAML - podstawy dla Ansible: Slajd przedstawia zagadnienie Składnia YAML - podstawy dla Ansible w ramach tematu Składnia YAML - podstawy dla Ansible na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s26
27 / 50
Zmienne w Ansible - vars i fakty
Cel slajdu: Slajd omawia zagadnienie „Zmienne w Ansible - vars i fakty” w kontekście: Zmienne w Ansible - vars i fakty.

Zmienne w Ansible - vars i fakty

Parametryzacja playbooków, zbieranie faktów systemowych i hierarchia precedensu

  • Zmienne zdefiniowane przez użytkownika (User Variables):
    • Pozwalają na parametryzację kodu: dynamiczne określanie portów, nazw pakietów, ścieżek do katalogów i nazw użytkowników.
    • Definiowane w sekcji vars: playbooka, w plikach group_vars/, host_vars/ lub przekazywane z wiersza poleceń (-e "wersja=1.2.3").
  • Fakty systemowe (Ansible Facts):
    • Ustrukturyzowane metadane sprzętowe i systemowe pobierane automatycznie z węzła zarządzanego przez wbudowany moduł setup na początku każdego Play (zadanie Gathering Facts).
    • Przykłady dostępnych faktów:
      • ansible_facts['os_family'] – rodzina systemu (np. 'Debian', 'RedHat').
      • ansible_facts['distribution_version'] – wersja dystrybucji (np. '22.04').
      • ansible_facts['default_ipv4']['address'] – domyślny adres IP interfejsu wyjściowego.
      • ansible_facts['memtotal_mb'] – całkowita pamięć RAM w megabajtach.
    • Optymalizacja wydajnościowa: wyłączenie zbierania faktów (gather_facts: no) przyspiesza wykonanie playbooka, gdy fakty nie są wykorzystywane.
  • Hierarchia precedensu zmiennych (Variable Precedence):
    • Ansible rozpoznaje 22 poziomy pierwszeństwa zmiennych w nowoczesnych wydaniach (hierarchia zależy od wersji, szczegóły w dokumencie precedence rules).
    • Zasada ogólna: zmienne z wiersza poleceń (extra vars -e) mają najwyższy priorytet i nadpisują wszystko; zmienne domyślne roli (defaults/main.yml) mają najniższy priorytet.
Zmienne w Ansible - vars i fakty: Slajd przedstawia zagadnienie Zmienne w Ansible - vars i fakty w ramach tematu Zmienne w Ansible - vars i fakty na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s27
28 / 50
Szablony Jinja2 - dynamiczne pliki konfiguracyjne
Cel slajdu: Slajd omawia zagadnienie „Szablony Jinja2 - dynamiczne pliki konfiguracyjne” w kontekście: Szablony Jinja2 - dynamiczne pliki konfiguracyjne.

Szablony Jinja2 - dynamiczne pliki konfiguracyjne

Generowanie plików konfiguracyjnych w oparciu o silnik szablonów Jinja2

  • Silnik szablonów Jinja2 (dokumentacja Jinja2): dojrzały, ekspresywny system szablonowania języka Python, zintegrowany bezpośrednio z modułem ansible.builtin.template.
  • Zasada działania szablonów w IaC:
    • Plik szablonu zapisywany jest z rozszerzeniem .j2 (np. nginx.conf.j2) na węźle sterującym.
    • Węzeł sterujący przetwarza szablon, wstawiając w miejsce znaczników wartości zmiennych i faktów, po czym przesyła gotowy, wyrenderowany plik tekstowy na węzeł zarządzany.
  • Podstawowe konstrukcje składniowe Jinja2:
    • Wstawianie wartości zmiennych: {{ nazwa_zmiennej }}
    • Instrukcje sterujące (pętle i warunki): {% for item in lista %} ... {% endfor %} oraz {% if warunek %} ... {% endif %}
    • Komentarze wewnętrzne szablonu: {# To jest komentarz Jinja2 niewidoczny w pliku wynikowym #}
  • Filtry danych Jinja2 (Filters): modyfikacja wartości w locie za pomocą potoku:
    • {{ nazwa | upper }} – konwersja na wielkie litery.
    • {{ port | default(80) }} – wartość domyślna w przypadku braku definicji zmiennej.
    • {{ lista_hostow | join(', ') }} – łączenie elementów listy w ciąg znaków.
  • Przykład użycia modułu template w zadaniu:
    - name: Wdrożenie pliku konfiguracyjnego Nginx z szablonu
      ansible.builtin.template:
        src: templates/vhost.conf.j2
        dest: /etc/nginx/sites-available/default
        owner: root
        group: root
        mode: '0644'
Szablony Jinja2 - dynamiczne pliki konfiguracyjne: Slajd przedstawia zagadnienie Szablony Jinja2 - dynamiczne pliki konfiguracyjne w ramach tematu Szablony Jinja2 - dynamiczne pliki konfiguracyjne na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s28
29 / 50
Warunki (when) - wykonywanie warunkowe
Cel slajdu: Slajd omawia zagadnienie „Warunki (when) - wykonywanie warunkowe” w kontekście: Warunki (when) - wykonywanie warunkowe.

Warunki (when) - wykonywanie warunkowe

Sterowanie przepływem zadań w oparciu o stan logiczny środowiska

  • Klauzula when w zadaniach Ansible: mechanizm ewaluacji logicznej decydujący o tym, czy dane zadanie ma zostać wykonane na konkretnym węźle, czy też pominięte (status skipping).
  • Główne zastosowania w praktyce inżynierskiej:
    • Zapewnienie wieloplatformowości (różne pakiety dla systemów z rodzin Debian i Red Hat).
    • Dostosowanie operacji do wersji systemu operacyjnego (np. Ubuntu 20.04 vs 22.04 vs 24.04).
    • Warunkowanie zadań parametrami sprzętowymi (np. instalacja sterowników RAID tylko na maszynach fizycznych bare-metal).
    • Wykonywanie zadań w oparciu o wyniki wcześniejszych kroków (zmienne rejestrowane register).
  • Składnia i operatory logiczne:
    • Wyrażenie wewnątrz when jest ewaluowane bezpośrednio jako kod Python/Jinja2 (nie wymaga stosowania nawiasów klamrowych {{ }}).
    • Operatory porównania: ==, !=, >, <, >=, <=, in.
    • Operatory logiczne: and, or, not.
  • Przykłady praktyczne:
    - name: Restart serwera przy krytycznej aktualizacji jądra
      ansible.builtin.reboot:
      when: reboot_required_file.stat.exists and environment_type == "staging"
    
    - name: Instalacja Apache w systemach RedHat
      ansible.builtin.dnf:
        name: httpd
        state: present
      when: ansible_facts['os_family'] == "RedHat"
Warunki - wykonywanie warunkowe (ang. when): Slajd przedstawia zagadnienie Warunki (when) - wykonywanie warunkowe w ramach tematu Warunki (when) - wykonywanie warunkowe na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s29
30 / 50
Pętle - powtarzanie zadań
Cel slajdu: Slajd omawia zagadnienie „Pętle - powtarzanie zadań” w kontekście: Pętle - powtarzanie zadań.

Pętle - powtarzanie zadań

Iteracja po listach, słownikach i sekwencjach danych w zadaniach Ansible

  • Koncepcja pętli w zadaniach automatyzacji: wykonywanie tego samego zadania wielokrotnie dla różnych elementów danych wejściowych bez konieczności powielania kodu zadania.
  • Nowoczesna dyrektywa loop (standard od Ansible 2.5+):
    • Zastąpiła starsze, zdeprecjonowane konstrukcje with_items, with_dict czy with_fileglob.
    • Bieżący element iteracji jest dostępny wewnątrz zadania pod specjalną zmienną item.
  • Iteracja po prostej liście skalarów:
    - name: Instalacja podstawowych narzędzi administracyjnych
      ansible.builtin.apt:
        name: "{{ item }}"
        state: present
      loop:
        - htop
        - iotop
        - tcpdump
        - rsync
        - tmux
  • Iteracja po ustrukturyzowanej liście słowników:
    - name: Tworzenie kont użytkowników systemowych z grupami
      ansible.builtin.user:
        name: "{{ item.name }}"
        groups: "{{ item.groups }}"
        shell: "{{ item.shell }}"
        state: present
      loop:
        - { name: 'admin1', groups: 'sudo', shell: '/bin/bash' }
        - { name: 'audytor', groups: 'users', shell: '/bin/sh' }
  • Uwaga optymalizacyjna dla menedżerów pakietów: moduły apt i dnf akceptują całą listę pakietów bezpośrednio w parametrze name: "{{ lista }}", co jest znacznie szybsze niż pętla loop (wywołuje instalację w jednej transakcji).
Pętle - powtarzanie zadań: Slajd przedstawia zagadnienie Pętle - powtarzanie zadań w ramach tematu Pętle - powtarzanie zadań na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s30
31 / 50
Tagi - wybiórcze uruchamianie zadań
Cel slajdu: Slajd omawia zagadnienie „Tagi - wybiórcze uruchamianie zadań” w kontekście: Tagi - wybiórcze uruchamianie zadań.

Tagi - wybiórcze uruchamianie zadań

Selektywna orkiestracja zadań za pomocą etykiet w środowisku produkcyjnym

  • Koncepcja tagowania zadań (Tags): mechanizm kategoryzacji zadań wewnątrz playbooka, umożliwiający administratorowi uruchomienie lub pominięcie określonego fragmentu scenariusza bez modyfikacji kodu.
  • Definiowanie tagów w zadaniach:
    - name: Aktualizacja pliku konfiguracyjnego wirtualnego hosta
      ansible.builtin.template:
        src: vhost.conf.j2
        dest: /etc/nginx/sites-available/app.conf
      tags:
        - config
        - nginx
    
    - name: Restart demona Nginx
      ansible.builtin.systemd:
        name: nginx
        state: restarted
      tags:
        - service
        - nginx
  • Precyzyjna kontrola z wiersza poleceń CLI:
    • Uruchomienie wyłącznie zadań z określonym tagiem: ansible-playbook site.yml --tags "config"
    • Pominięcie wybranych, długotrwałych zadań: ansible-playbook site.yml --skip-tags "backup,upgrade"
    • Inspekcja dostępnych tagów w playbooku: ansible-playbook site.yml --list-tags
  • Specjalne tagi wbudowane:
    • always – zadanie z tym tagiem wykonuje się zawsze, chyba że zostanie jawnie pominięte przez --skip-tags always.
    • never – zadanie jest pomijane domyślnie; uruchamia się wyłącznie przy jawnym wskazaniu jego nazwy w --tags.
Tagi - wybiórcze uruchamianie zadań: Slajd przedstawia zagadnienie Tagi - wybiórcze uruchamianie zadań w ramach tematu Tagi - wybiórcze uruchamianie zadań na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s31
32 / 50
Handlery - reagowanie na zmiany
Cel slajdu: Slajd omawia zagadnienie „Handlery - reagowanie na zmiany” w kontekście: Handlery - reagowanie na zmiany.

Handlery - reagowanie na zmiany

Asynchroniczne procedury obsługi zdarzeń wyzwalane modyfikacją stanu zasobów

  • Istota handlerów (Handlers): wyspecjalizowane zadania pasywne, które pozostają w uśpieniu i wykonują się wyłącznie wtedy, gdy inne zadanie wprowadziło rzeczywistą zmianę w systemie (status changed: true) i wyemitowało powiadomienie (notify).
  • Klasyczny przypadek użycia – restart demonów usługowych: usługa (np. serwer WWW lub baza danych) powinna zostać zrestartowana lub przeładowana tylko wtedy, gdy jej plik konfiguracyjny uległ faktycznej modyfikacji.
  • Konstrukcja powiadomienia i handlera:
    tasks:
      - name: Aktualizacja konfiguracji głównej Nginx
        ansible.builtin.template:
          src: nginx.conf.j2
          dest: /etc/nginx/nginx.conf
        notify: Przeładuj serwis Nginx
    
    handlers:
      - name: Przeładuj serwis Nginx
        ansible.builtin.systemd:
          name: nginx
          state: reloaded
  • Trzy żelazne reguły działania handlerów:
    1. Idempotencja wywołań: nawet jeśli 10 różnych zadań powiadomi ten sam handler, wykona się on dokładnie jeden raz.
    2. Moment wykonania: domyślnie handlery uruchamiają się na samym końcu danego Play, po pomyślnym zakończeniu wszystkich standardowych zadań.
    3. Wymuszenie natychmiastowego wykonania: zadanie specjalne meta: flush_handlers zmusza silnik do natychmiastowego wykonania oczekujących handlerów w środku scenariusza.
Handlery - reagowanie na zmiany: Slajd przedstawia zagadnienie Handlery - reagowanie na zmiany w ramach tematu Handlery - reagowanie na zmiany na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s32
33 / 50
Moduł copy i lineinfile - zarządzanie plikami
Cel slajdu: Slajd omawia zagadnienie „Moduł copy i lineinfile - zarządzanie plikami” w kontekście: Moduł copy i lineinfile - zarządzanie plikami.

Moduł copy i lineinfile - zarządzanie plikami

Przesyłanie plików statycznych oraz precyzyjna modyfikacja pojedynczych linii tekstu

  • Moduł ansible.builtin.copy – transfer plików statycznych:
    • Kopiuje pliki lub całe katalogi z węzła sterującego na węzły zarządzane.
    • Weryfikuje sumy kontrolne SHA1/SHA256; transfer następuje wyłącznie w razie wykrycia różnic (pełna idempotentność).
    • Obsługa atrybutów bezpieczeństwa: owner, group, mode (rekomendowany zapis ósemkowy np. '0644').
    • Opcja backup: yes automatycznie tworzy kopię bezpieczeństwa pliku docelowego z datownikiem przed jego nadpisaniem.
  • Moduł ansible.builtin.lineinfile – precyzyjna chirurgia tekstu:
    • Zaprojektowany do modyfikowania lub zapewniania obecności konkretnej pojedynczej linii tekstu w istniejącym pliku konfiguracyjnym.
    • Wykorzystuje wyrażenia regularne (regexp) do lokalizowania i bezpiecznego zastępowania linii.
  • Przykłady zastosowania w twardnieniu systemu (Hardening):
    - name: Bezpieczna konfiguracja demona SSH (blokada logowania root)
      ansible.builtin.lineinfile:
        path: /etc/ssh/sshd_config
        regexp: '^#?PermitRootLogin'
        line: 'PermitRootLogin no'
        state: present
        validate: '/usr/sbin/sshd -t -f %s'
      notify: Restart demona SSH
  • Rekomendacja architektoniczna: dla całych plików konfiguracyjnych stosuj moduły template lub copy; dla pojedynczych flag w plikach dostarczanych przez pakiety stosuj lineinfile.
Moduł copy i lineinfile - zarządzanie plikami: Slajd przedstawia zagadnienie Moduł copy i lineinfile - zarządzanie plikami w ramach tematu Moduł copy i lineinfile - zarządzanie plikami na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s33
34 / 50
Moduł service/systemd - zarządzanie usługami
Cel slajdu: Slajd omawia zagadnienie „Moduł service/systemd - zarządzanie usługami” w kontekście: Moduł service/systemd - zarządzanie usługami.

Moduł service/systemd - zarządzanie usługami

Zarządzanie cyklem życia demonów i procesów w oparciu o menedżer systemd

  • Kluczowe moduły zarządzania usługami systemowymi:
    • ansible.builtin.systemd – nowoczesny, dedykowany moduł zoptymalizowany pod kątem systemd (standard w większości współczesnych dystrybucji Linuksa).
    • ansible.builtin.service – moduł uniwersalny (obsługuje systemd, SysVinit, Upstart, OpenRC).
  • Główne stany pożądane (parametr state):
    • started – usługa ma być uruchomiona (jeśli proces już działa, moduł nie podejmuje akcji).
    • stopped – usługa ma być zatrzymana.
    • restarted – bezwarunkowy restart usługi (zatrzymanie i ponowne uruchomienie).
    • reloaded – bezprzerwowe przeładowanie konfiguracji procesu sygnałem SIGHUP.
  • Zarządzanie autostartem (parametr enabled):
    • enabled: yes – utworzenie dowiązań symbolicznych w /etc/systemd/system/ (autostart przy bootowaniu).
    • enabled: no – usunięcie z autostartu systemowego.
  • Zaawansowane parametry modułu systemd:
    • daemon_reload: yes – ponowne odczytanie plików unitów z dysku (odpowiednik systemctl daemon-reload po modyfikacji pliku .service).
    • masked: yes – całkowite zablokowanie możliwości uruchomienia usługi (dowiązanie do /dev/null).
Moduł service/systemd - zarządzanie usługami: Slajd przedstawia zagadnienie Moduł service/systemd - zarządzanie usługami w ramach tematu Moduł service/systemd - zarządzanie usługami na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s34
35 / 50
Moduł user - zarządzanie użytkownikami
Cel slajdu: Slajd omawia zagadnienie „Moduł user - zarządzanie użytkownikami” w kontekście: Moduł user - zarządzanie użytkownikami.

Moduł user - zarządzanie użytkownikami

Automatyzacja zarządzania tożsamością, uprawnieniami i kluczami w systemie Linux

  • Rola modułu ansible.builtin.user: kompleksowe, w pełni deklaratywne zarządzanie kontami użytkowników lokalnych w systemach z rodziny Linux i Unix (bazy /etc/passwd i /etc/shadow).
  • Kluczowe parametry konfiguracyjne:
    • name – unikalna nazwa logowania użytkownika systemowego (parametr wymagany).
    • state – stan pożądany konta: present (użytkownik istnieje) lub absent (usunięty).
    • uid oraz group – jawne zdefiniowanie numerycznego identyfikatora UID oraz grupy podstawowej.
    • groups – lista grup dodatkowych (np. sudo, wheel, docker).
    • append: yes – kluczowa flaga gwarantująca, że nowe grupy zostaną dopisane bez usuwania użytkownika z grup dotychczasowych.
    • shell – powłoka logowania (np. /bin/bash dla ludzi lub /usr/sbin/nologin dla kont usługowych).
    • create_home: yes – automatyczne utworzenie katalogu domowego /home/użytkownik z prawidłowymi uprawnieniami.
  • Zarządzanie hasłami – zasady cyberbezpieczeństwa:
    • Kategoryczny zakaz podawania haseł jawnym tekstem w kodzie playbooka.
    • Wymagany bezpieczny skrót kryptograficzny (SHA-512 crypt z solą), generowany narzędziem systemowym (np. mkpasswd -m sha-512 z pakietu whois: sudo apt install -y whois; alternatywnie openssl passwd -6) i zabezpieczony w Ansible Vault.
  • Zarządzanie autoryzacją SSH: dedykowany moduł ansible.builtin.authorized_key pozwala na automatyczne deponowanie kluczy publicznych w pliku ~/.ssh/authorized_keys.
Moduł user - zarządzanie użytkownikami: Slajd przedstawia zagadnienie Moduł user - zarządzanie użytkownikami w ramach tematu Moduł user - zarządzanie użytkownikami na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s35
36 / 50
Moduł file - uprawnienia i własność plików
Cel slajdu: Slajd omawia zagadnienie „Moduł file - uprawnienia i własność plików” w kontekście: Moduł file - uprawnienia i własność plików.

Moduł file - uprawnienia i własność plików

Operacje na metadanych systemu plików, uprawnieniach POSIX i dowiązaniach

  • Przeznaczenie modułu ansible.builtin.file: zarządzanie atrybutami, własnością i uprawnieniami istniejących plików oraz tworzenie katalogów i dowiązań (nie służy do modyfikowania treści plików).
  • Tryby pracy modułu (parametr state):
    • directory – rekurencyjne tworzenie struktury katalogów (odpowiednik mkdir -p).
    • touch – utworzenie pustego pliku lub aktualizacja znaczników czasu dostępu (mtime/atime).
    • link – utworzenie dowiązania symbolicznego (symlink; wymaga podania parametru src).
    • hard – utworzenie dowiązania twardego (hardlink).
    • absent – rekurencyjne, całkowite usunięcie pliku, linku lub katalogu (odpowiednik rm -rf).
  • Zarządzanie bezpieczeństwem uprawnień POSIX:
    • Właściciel i grupa: parametry owner: www-data oraz group: www-data.
    • Prawa dostępu w notacji ósemkowej: mode: '0755' (katalogi) lub mode: '0640' (pliki).
    • Zalecenie składniowe: wartość mode zawsze ujmuj w apostrofy, aby uniknąć błędnej interpretacji przez parser YAML.
    • Modyfikacja rekurencyjna: parametr recurse: yes aplikuje uprawnienia do całej zawartości drzewa katalogów.
Moduł file - uprawnienia i własność plików: Slajd przedstawia zagadnienie Moduł file - uprawnienia i własność plików w ramach tematu Moduł file - uprawnienia i własność plików na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s36
37 / 50
Role - organizacja kodu na większą skalę
Cel slajdu: Slajd omawia zagadnienie „Role - organizacja kodu na większą skalę” w kontekście: Role - organizacja kodu na większą skalę.

Role - organizacja kodu na większą skalę

Modularność, separacja odpowiedzialności i struktura ról w ekosystemie Ansible

  • Czym jest Rola Ansible (Ansible Role): w pełni ustandaryzowany, samowystarczalny pakiet automatyzacji grupujący zadania, handlery, zmienne, szablony i pliki w jednolitą strukturę katalogów.
  • Oficjalna struktura katalogów wewnątrz roli:
    roles/nginx/
    ├── tasks/main.yml       # Główna lista zadań wykonywanych przez rolę
    ├── handlers/main.yml    # Procedury obsługi zdarzeń (np. restart Nginx)
    ├── templates/           # Szablony dynamiczne Jinja2 (np. vhost.conf.j2)
    ├── files/               # Statyczne pliki do wdrożenia (np. ssl_ciphers.conf)
    ├── vars/main.yml        # Zmienne o wysokim priorytecie (wewnętrzne roli)
    ├── defaults/main.yml    # Zmienne domyślne o najniższym priorytecie (konfigurowalne)
    └── meta/main.yml        # Metadane roli: autor, licencja, zależności od innych ról
  • Wykorzystanie ról w nadrzędnym playbooku:
    - name: Wdrożenie klastra aplikacji WWW
      hosts: web
      roles:
        - role: common
        - role: nginx
          vars:
            nginx_port: 8080
  • Generowanie wzorcowej struktury z CLI: polecenie ansible-galaxy role init <nazwa_roli> tworzy kompletny szkielet katalogów i plików main.yml w ułamku sekundy.
Role - organizacja kodu na większą skalę: Slajd przedstawia zagadnienie Role - organizacja kodu na większą skalę w ramach tematu Role - organizacja kodu na większą skalę na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s37
38 / 50
Best practices, Ansible Galaxy i Vault
Cel slajdu: Slajd omawia zagadnienie „Best practices, Ansible Galaxy i Vault” w kontekście: Best practices, Ansible Galaxy i Vault.

Best practices, Ansible Galaxy i Vault

Ekosystem społeczności, dobre praktyki wytwarzania kodu i ochrona danych poufnych

  • Repozytorium Ansible Galaxy (galaxy.ansible.com):
    • Oficjalny, globalny rejestr otwartoźródłowych ról i kolekcji tworzonych przez firmę Red Hat, partnerów technologicznych i społeczność.
    • Instalacja gotowych komponentów: ansible-galaxy role install geerlingguy.nginx
    • Zarządzanie zależnościami projektu za pomocą pliku requirements.yml:
      roles:
        - name: geerlingguy.nginx
          version: 3.1.1
      collections:
        - name: community.general
          version: ">=8.0.0"
  • Bezpieczeństwo danych poufnych – Ansible Vault:
    • Szyfrowanie haseł, kluczy prywatnych i tokenów API algorytmem AES-256 w trybie CTR z uwierzytelnieniem HMAC-SHA256 i funkcją PBKDF2 (nagłówek $ANSIBLE_VAULT;1.1;AES256, szczegóły w dokumentacji formatu Vault) bezpośrednio w repozytorium Git.
    • Tworzenie i edycja zaszyfrowanych plików: ansible-vault create secret.yml oraz ansible-vault edit secret.yml.
    • Szyfrowanie pojedynczych ciągów znaków (in-line): ansible-vault encrypt_string 'tajne_haslo' --name 'db_password'.
    • Uruchamianie playbooka z hasłem skarbca: ansible-playbook site.yml --ask-vault-pass lub z plikiem klucza --vault-password-file ~/.vault_key.
  • Złote zasady dobrych praktyk inżynierskich (Best Practices):
    • Zawsze nadawaj czytelne nazwy zadaniom (name); stosuj linter ansible-lint.
    • Unikaj modułów command i shell, gdy istnieje dedykowany moduł deklaratywny.
    • Utrzymuj środowiska w repozytorium Git z separacją zmiennych staging i production.
Best practices, Ansible Galaxy i Vault: Slajd przedstawia zagadnienie Best practices, Ansible Galaxy i Vault w ramach tematu Best practices, Ansible Galaxy i Vault na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s38
39 / 50
Laboratorium: przygotowanie środowiska
Cel slajdu: Slajd omawia zagadnienie „Laboratorium: przygotowanie środowiska” w kontekście: Laboratorium: przygotowanie środowiska.

Laboratorium: przygotowanie środowiska

Topologia sieciowa, założenia laboratoryjne i konfiguracja węzłów

  • Architektura środowiska laboratoryjnego:
    • Węzeł sterujący (Control Node): maszyna z systemem Linux (np. Ubuntu 22.04 LTS), zainstalowanym pakietem Ansible oraz narzędziami diagnostycznymi.
    • Węzeł zarządzany (Managed Node - target): serwer z systemem Linux przeznaczony do automatycznego wdrożenia usług sieciowych.
    • Warstwa sieciowa: wspólna sieć lokalna LAN z bezpośrednią osiągalnością protokołu IP oraz portu TCP 22.
  • Przygotowanie wstępne węzła zarządzanego:
    • Utworzenie dedykowanego użytkownika automatyzacji: sudo adduser --disabled-password --gecos "" deploy
    • Konfiguracja bezhasłowej eskalacji uprawnień w katalogu /etc/sudoers.d/deploy:
      deploy ALL=(ALL) NOPASSWD:ALL
  • Konfiguracja węzła sterującego:
    • Wygenerowanie nowoczesnej pary kluczy SSH Ed25519 na kontrolerze:
      ssh-keygen -t ed25519 -N "" -f ~/.ssh/id_ed25519
    • Wgranie klucza publicznego na węzeł zarządzany:
      ssh-copy-id -i ~/.ssh/id_ed25519.pub deploy@<IP_WEZLA_DOCELOWEGO>
    • Weryfikacja bezpośredniego logowania bezhasłowego przez SSH.
  • Utworzenie czystego katalogu projektowego: przygotowanie struktury pod pliki inwentarza, konfiguracji ansible.cfg oraz playbooka.
Laboratorium: przygotowanie środowiska: przygotowanie środowiska: Slajd przedstawia zagadnienie Laboratorium: przygotowanie środowiska w ramach tematu Laboratorium: przygotowanie środowiska na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s39
40 / 50
Krok 1: test połączenia ad-hoc
Cel slajdu: Slajd omawia zagadnienie „Krok 1: test połączenia ad-hoc” w kontekście: Krok 1: test połączenia ad-hoc.

Krok 1: test połączenia ad-hoc

Inicjalizacja projektu, plik hosts.ini i weryfikacja modułem ping

  • Inicjalizacja katalogu roboczego projektu na węźle sterującym:
    mkdir -p ~/warsztat-ansible && cd ~/warsztat-ansible
  • Utworzenie lokalnego pliku konfiguracyjnego ansible.cfg:
    [defaults]
    inventory = hosts.ini
    remote_user = deploy
    host_key_checking = False
  • Utworzenie pliku inwentarza hosts.ini:
    [web]
    serwer-www ansible_host=192.168.10.100

    (Wartość ansible_host należy zastąpić rzeczywistym adresem IP węzła zarządzanego w sieci laboratoryjnej).

  • Test łączności i środowiska za pomocą modułu ping:
    ansible web -m ping
  • Interpretacja odpowiedzi sukcesu w formacie JSON:
    serwer-www | SUCCESS => {
        "ansible_facts": {
            "discovered_interpreter_python": "/usr/bin/python3"
        },
        "changed": false,
        "ping": "pong"
    }
  • Wnioski diagnostyczne: kontroler pomyślnie uwierzytelnił się kluczem SSH, wykrył interpreter Pythona na węźle docelowym i zweryfikował dwukierunkową komunikację.
Krok 1: test połączenia ad-hoc: test połączenia ad-hoc: Slajd przedstawia zagadnienie Krok 1: test połączenia ad-hoc w ramach tematu Krok 1: test połączenia ad-hoc na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s40
41 / 50
Krok 2: pierwszy playbook - instalacja Nginx
Cel slajdu: Slajd omawia zagadnienie „Krok 2: pierwszy playbook - instalacja Nginx” w kontekście: Krok 2: pierwszy playbook - instalacja Nginx.

Krok 2: pierwszy playbook - instalacja Nginx

Konstrukcja i pierwsze uruchomienie playbooka instalacyjnego Nginx

  • Tworzenie pliku install_nginx.yml na węźle sterującym:
    ---
    - name: Wdrożenie i konfiguracja serwera WWW Nginx
      hosts: web
      become: yes
    
      tasks:
        - name: Aktualizacja pamięci podręcznej i instalacja pakietu Nginx
          ansible.builtin.apt:
            name: nginx
            state: latest
            update_cache: yes
    
        - name: Zapewnienie uruchomienia i autostartu demona Nginx
          ansible.builtin.systemd:
            name: nginx
            state: started
            enabled: yes
  • Uruchomienie playbooka z poziomu wiersza poleceń CLI:
    ansible-playbook install_nginx.yml
  • Analiza podsumowania wykonania (Play Recap):
    PLAY RECAP -------------------------------------------------------------
    serwer-www    : ok=3    changed=2    unreachable=0    failed=0    skipped=0
  • Interpretacja wyników:
    • ok=3 – wykonano 3 zadania (Gathering Facts, instalacja pakietu, aktywacja usługi).
    • changed=2 – dwie operacje zmodyfikowały stan maszyny (zainstalowano pakiet oraz włączono usługę).
    • failed=0 – brak jakichkolwiek błędów wykonawczych.
Krok 2: pierwszy playbook - instalacja Nginx: pierwszy playbook - instalacja Nginx: Slajd przedstawia zagadnienie Krok 2: pierwszy playbook - instalacja Nginx w ramach tematu Krok 2: pierwszy playbook - instalacja Nginx na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s41
42 / 50
Krok 3: dodanie strony i handlera
Cel slajdu: Slajd omawia zagadnienie „Krok 3: dodanie strony i handlera” w kontekście: Krok 3: dodanie strony i handlera.

Krok 3: dodanie strony i handlera

Wdrażanie zasobów statycznych oraz reaktywna obsługa przeładowania demona

  • Przygotowanie lokalnego pliku strony files/index.html na kontrolerze:
    mkdir -p files
    cat << 'EOF' > files/index.html
    <!DOCTYPE html>
    <html>
    <head><meta charset="utf-8"><title>Infrastruktura IaC z Ansible</title></head>
    <body>
    <h1>Serwer WWW wdrożony w pełni automatycznie za pomocą Ansible!</h1>
    <p>Stan pożądany osiągnięty zgodnie z paradygmatem Infrastructure as Code.</p>
    </body>
    </html>
    EOF
  • Rozbudowa playbooka install_nginx.yml o zadanie copy i sekcję handlers:
        - name: Wdrożenie dedykowanej strony głównej index.html
          ansible.builtin.copy:
            src: files/index.html
            dest: /var/www/html/index.html
            owner: www-data
            group: www-data
            mode: '0644'
          notify: Przeładuj Nginx
    
      handlers:
        - name: Przeładuj Nginx
          ansible.builtin.systemd:
            name: nginx
            state: reloaded
  • Mechanizm powiązania: zadanie copy w razie zmodyfikowania pliku docelowego emituje sygnał notify, który po zakończeniu wszystkich zadań wywołuje bezprzerwowe przeładowanie reloaded demona Nginx.
Krok 3: dodanie strony i handlera: dodanie strony i handlera: Slajd przedstawia zagadnienie Krok 3: dodanie strony i handlera w ramach tematu Krok 3: dodanie strony i handlera na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s42
43 / 50
Krok 4: tryb dry-run i dowód idempotentności
Cel slajdu: Slajd omawia zagadnienie „Krok 4: tryb dry-run i dowód idempotentności” w kontekście: Krok 4: tryb dry-run i dowód idempotentności.

Krok 4: tryb dry-run i dowód idempotentności

Badanie bezpieczeństwa zmian w trybie symulacji oraz empiryczny dowód idempotentności

  • Tryb symulacji dry-run (flaga --check):
    • Ansible wykonuje pełną analizę stanu systemu i symuluje wykonanie każdego zadania, nie wprowadzając żadnych fizycznych zmian na węźle zarządzanym.
    • Pozwala na bezpieczną inspekcję, czy playbook wprowadzi jakiekolwiek modyfikacje na serwerach produkcyjnych.
  • Prezentacja różnic w konfiguracji (flaga --diff):
    • W połączeniu z --check wyświetla w konsoli ujednolicony diff (w stylu gita), pokazujący dokładnie, które linie plików ulegną zmianie.
    • Polecenie wykonawcze: ansible-playbook install_nginx.yml --check --diff
  • Empiryczny dowód idempotentności w praktyce laboratoryjnej:
    • Uruchamiamy playbook po raz pierwszy: raportuje changed=1 (skopiowano nowy plik index.html i wywołano handler).
    • Uruchamiamy ten sam playbook po raz drugi bez żadnych modyfikacji w plikach:
      PLAY RECAP -------------------------------------------------------------
      serwer-www    : ok=4    changed=0    unreachable=0    failed=0    skipped=0
  • Konkluzja inżynierska: wartość changed=0 stanowi twardy dowód, że system osiągnął stan pożądany; ponowne wykonanie jest w 100% bezpieczne i nie wywołuje żadnych skutków ubocznych.
Krok 4: tryb dry-run i dowód idempotentności: tryb dry-run i dowód idempotentności: Slajd przedstawia zagadnienie Krok 4: tryb dry-run i dowód idempotentności w ramach tematu Krok 4: tryb dry-run i dowód idempotentności na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s43
44 / 50
Krok 5: weryfikacja działania serwera
Cel slajdu: Slajd omawia zagadnienie „Krok 5: weryfikacja działania serwera” w kontekście: Krok 5: weryfikacja działania serwera.

Krok 5: weryfikacja działania serwera

Automatyczne i manualne metody walidacji wdrożonych usług sieciowych

  • Zasada ograniczonego zaufania w automatyzacji: profesjonalny inżynier nigdy nie kończy pracy na samym uruchomieniu playbooka; niezbędna jest formalna weryfikacja dostępności usługi w warstwie sieciowej i aplikacyjnej.
  • Metoda 1 – Weryfikacja stanu demona przez polecenie doraźne ad-hoc:
    ansible web -m command -a "systemctl status nginx" --become

    Potwierdza obecność aktywnego procesu (Active: active (running)) oraz brak błędów w dzienniku systemd.

  • Metoda 2 – Weryfikacja odpowiedzi protokołu HTTP z węzła sterującego:
    curl -I http://192.168.10.100

    Oczekiwana odpowiedź nagłówka: HTTP/1.1 200 OK z poprawnym identyfikatorem Server: nginx.

  • Metoda 3 – Pełna automatyzacja testu w playbooku za pomocą modułu uri:
    - name: Weryfikacja dostępności strony WWW kodem HTTP 200
      ansible.builtin.uri:
        url: "http://localhost"
        status_code: 200
      delegate_to: serwer-www
  • Podsumowanie fazy laboratoryjnej: serwer WWW Nginx został w pełni automatycznie zainstalowany, skonfigurowany, zabezpieczony i pomyślnie przeszedł wszystkie testy odbiorcze.
Krok 5: weryfikacja działania serwera: weryfikacja działania serwera: Slajd przedstawia zagadnienie Krok 5: weryfikacja działania serwera w ramach tematu Krok 5: weryfikacja działania serwera na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s44
45 / 50
Troubleshooting: błędy składni YAML
Cel slajdu: Slajd omawia zagadnienie „Troubleshooting: błędy składni YAML” w kontekście: Troubleshooting: błędy składni YAML.

Troubleshooting: błędy składni YAML

Diagnoza, lokalizacja i usuwanie anomalii formatowania dokumentów YAML

  • Przyczyna numer jeden awarii playbooków: rygorystyczne wymagania formatowania struktury danych w standardzie YAML.
  • Najczęstsze błędy składniowe w praktyce inżynierskiej:
    • Znak tabulacji zamiast spacji: wklejenie tabulatora ( ) natychmiast wywołuje błąd parsera: syntax error: mapping values are not allowed here lub found character ' ' that cannot start any token.
    • Brak spacji po dwukropku: zapis name:nginx jest błędem; prawidłowy zapis wymaga spacji: name: nginx.
    • Niespójne wcięcia poziomów: wymieszanie wcięć 2-spacyjnych z 4-spacyjnymi w ramach tego samego bloku słownika.
    • Brak cudzysłowów przy wąsach Jinja2 na początku wartości: zapis src: {{ plik }} powoduje błąd interpretacji; poprawny zapis to src: "{{ plik }}".
  • Profesjonalne narzędzia diagnostyczne i lintery:
    • Szybka weryfikacja składni bez łączenia się z hostami: ansible-playbook site.yml --syntax-check
    • Głęboki audyt zgodności ze standardami inżynierskimi: ansible-lint site.yml
    • Rygorystyczny linter formatowania YAML: yamllint -c ~/.yamllint site.yml
Troubleshooting: błędy składni YAML: błędy składni YAML: Slajd przedstawia zagadnienie Troubleshooting: błędy składni YAML w ramach tematu Troubleshooting: błędy składni YAML na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s45
46 / 50
Troubleshooting: problemy z połączeniem SSH
Cel slajdu: Slajd omawia zagadnienie „Troubleshooting: problemy z połączeniem SSH” w kontekście: Troubleshooting: problemy z połączeniem SSH.

Troubleshooting: problemy z połączeniem SSH

Rozwiązywanie problemów autoryzacji, weryfikacji kluczy hosta i stanu UNREACHABLE

  • Objaw błędu: komunikat oznaczony kolorem czerwonym: fatal: [host] => UNREACHABLE! => {"msg": "Failed to connect to the host via ssh..."}.
  • Metodyka diagnostyki krok po kroku:
    1. Weryfikacja warstwy sieciowej IP (L3): sprawdzenie osiągalności węzła poleceniem ping <IP> lub traceroute <IP>.
    2. Weryfikacja warstwy transportowej (L4): sprawdzenie czy port TCP 22 jest otwarty: nc -zv <IP> 22 lub telnet <IP> 22.
    3. Uruchomienie szczegółowej diagnostyki SSH w Ansible: dodanie potrójnej flagi gadatliwości: ansible web -m ping -vvv.
  • Najczęstsze przyczyny awarii i metody ich usunięcia:
    • Niewłaściwe uprawnienia do klucza prywatnego na kontrolerze: OpenSSH odmawia użycia zbyt otwartego klucza; naprawa: chmod 600 ~/.ssh/id_ed25519.
    • Niewłaściwe uprawnienia katalogu .ssh na węźle docelowym: naprawa: chmod 700 ~/.ssh && chmod 600 ~/.ssh/authorized_keys.
    • Blokada weryfikacji klucza hosta (Host Key Verification Failed): zmiana adresu IP lub reinstalacja serwera; usunięcie starego klucza: ssh-keygen -R <IP> lub tymczasowe wyłączenie w ansible.cfg: host_key_checking = False.
Troubleshooting: problemy z połączeniem SSH: problemy z połączeniem SSH: Slajd przedstawia zagadnienie Troubleshooting: problemy z połączeniem SSH w ramach tematu Troubleshooting: problemy z połączeniem SSH na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s46
47 / 50
Troubleshooting: błędy uprawnień i become
Cel slajdu: Slajd omawia zagadnienie „Troubleshooting: błędy uprawnień i become” w kontekście: Troubleshooting: błędy uprawnień i become.

Troubleshooting: błędy uprawnień i become

Rozwiązywanie problemów eskalacji uprawnień administracyjnych w mechanizmie sudo

  • Typowe komunikaty błędów eskalacji uprawnień:
    • user is not allowed to execute sudo on this host – konto użytkownika nie posiada uprawnień w konfiguracji sudoers.
    • Missing sudo password lub Timeout waiting for privilege escalation prompt – system żąda interaktywnego podania hasła, którego Ansible nie może wprowadzić.
  • Procedura diagnostyczna na węźle zarządzanym:
    • Zaloguj się na węzeł i sprawdź uprawnienia konta automatyzacji:
      sudo -l -U deploy
    • Upewnij się, że użytkownik należy do grupy administracyjnej (sudo w Debian/Ubuntu, wheel w RHEL/CentOS/Rocky).
  • Konfiguracja bezhasłowej eskalacji NOPASSWD (Standard Enterprise):
    • Utwórz dedykowany plik reguł: /etc/sudoers.d/deploy
    • Wprowadź zawartość: deploy ALL=(ALL) NOPASSWD: ALL
    • Ustaw restrykcyjne uprawnienia pliku: chmod 0440 /etc/sudoers.d/deploy
    • Zawsze weryfikuj poprawność składni narzędziem: visudo -c
  • Doraźne podanie hasła sudo z wiersza poleceń CLI:

    Jeśli polityka bezpieczeństwa zabrania NOPASSWD, wymuś zapytanie o hasło eskalacji flagą -K (lub --ask-become-pass):

    ansible-playbook site.yml -K
Troubleshooting: błędy uprawnień i become: błędy uprawnień i become: Slajd przedstawia zagadnienie Troubleshooting: błędy uprawnień i become w ramach tematu Troubleshooting: błędy uprawnień i become na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s47
48 / 50
Debugowanie playbooków w Ansible
Cel slajdu: Slajd omawia zagadnienie „Debugowanie playbooków w Ansible” w kontekście: Debugowanie playbooków w Ansible.

Debugowanie playbooków w Ansible

Techniki zaawansowanej inspekcji zmiennych, faktów i przepływu zadań

  • Hierarchia poziomów szczegółowości konsoli (flaga -v):
    • -v – podstawowe informacje: zrzut wyników zadań (stdout/stderr).
    • -vv – konfiguracja zadań, użyte moduły i ścieżki do plików.
    • -vvv – szczegółowe informacje o połączeniu transportowym SSH.
    • -vvvv – pełny zrzut środowiska wykonawczego, zmiennych i wtyczek (connection debugging).
  • Wykorzystanie dedykowanego modułu ansible.builtin.debug:
    • Zrzut wartości zmiennej lub faktu systemowego:
      - name: Inspekcja adresu IP węzła zarządzanego
        ansible.builtin.debug:
          var: ansible_facts['default_ipv4']['address']
    • Wyświetlenie czytelnego komunikatu diagnostycznego:
      - name: Komunikat o środowisku
        ansible.builtin.debug:
          msg: "Węzeł {{ inventory_hostname }} pracuje pod kontrolą {{ ansible_facts['distribution'] }}"
  • Rejestrowanie wyników zadań za pomocą dyrektywy register: przechwycenie pełnego obiektu odpowiedzi modułu w zmiennej roboczej do późniejszej analizy.
  • Zaawansowane mechanizmy sterowania przepływem: ignore_errors: yes (kontynuacja mimo błędu), failed_when: warunek (własne kryteria błędu) oraz moduł assert (asercje testowe).
Debugowanie playbooków w Ansible: Slajd przedstawia zagadnienie Debugowanie playbooków w Ansible w ramach tematu Debugowanie playbooków w Ansible na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s48
49 / 50
Typowe problemy w Ansible - podsumowanie
Cel slajdu: Slajd omawia zagadnienie „Typowe problemy w Ansible - podsumowanie” w kontekście: Typowe problemy w Ansible - podsumowanie.

Typowe problemy w Ansible - podsumowanie

Macierz diagnostyczna: objawy, przyczyny źródłowe i procedury naprawcze

  • Przegląd najczęstszych awarii i incydentów operacyjnych:
    1. Błąd składni YAML (Syntax Error):
      • Objaw: syntax error: mapping values are not allowed here.
      • Naprawa: usuń tabulatory, zweryfikuj wcięcia spacji, uruchom ansible-playbook --syntax-check.
    2. Host nieosiągalny (UNREACHABLE):
      • Objaw: brak możliwości zestawienia sesji SSH / WinRM.
      • Naprawa: sprawdź łączność IP (ping), port TCP 22/5986, uprawnienia kluczy (0600) oraz ssh -vvv.
    3. Odrzucenie eskalacji uprawnień (Permission Denied / Sudo Error):
      • Objaw: monit o hasło lub brak praw do wykonania operacji.
      • Naprawa: skonfiguruj wpis NOPASSWD w /etc/sudoers.d/ lub przekaż flagę -K.
    4. Brak Pythona na węźle zarządzanym (Python Interpreter Not Found):
      • Objaw: /usr/bin/python: not found na minimalistycznych obrazach kontenerowych.
      • Naprawa: użyj modułu raw do zainstalowania pakietu python3 lub wskaż ścieżkę w ansible_python_interpreter.
    5. Utrata idempotentności przez nadużywanie modułu shell:
      • Objaw: zadanie stale raportuje changed: true mimo braku zmian.
      • Naprawa: zastąp surowe komendy dedykowanymi modułami deklaratywnymi lub dodaj parametr creates: /sciezka/plik.
Typowe problemy w Ansible - podsumowanie: Slajd przedstawia zagadnienie Typowe problemy w Ansible - podsumowanie w ramach tematu Typowe problemy w Ansible - podsumowanie na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s49
50 / 50
Cheat sheet - najważniejsze polecenia Ansible
Cel slajdu: Slajd omawia zagadnienie „Cheat sheet - najważniejsze polecenia Ansible” w kontekście: Cheat sheet - najważniejsze polecenia Ansible.

Cheat sheet - najważniejsze polecenia Ansible

Podręczne zestawienie poleceń CLI inżyniera automatyzacji Ansible

  • Zarządzanie połączeniami i polecenia doraźne (Ad-Hoc CLI):
    • ansible all -m ping -i hosts.ini – test łączności ze wszystkimi maszynami.
    • ansible web -m command -a "uptime" -i hosts.ini – wykonanie polecenia na grupie web.
    • ansible all -m setup -a "filter=ansible_distribution*" – inspekcja faktów dystrybucji.
  • Wykonywanie i weryfikacja playbooków (ansible-playbook):
    • ansible-playbook site.yml – standardowe uruchomienie playbooka.
    • ansible-playbook site.yml --check --diff – symulacja dry-run z prezentacją różnic.
    • ansible-playbook site.yml --syntax-check – szybka weryfikacja poprawności składniowej YAML.
    • ansible-playbook site.yml --limit web01 – ograniczenie wykonania do konkretnego hosta.
    • ansible-playbook site.yml --tags "nginx" – wykonanie wyłącznie zadań z określonym tagiem.
    • ansible-playbook site.yml -K – monit o hasło do eskalacji uprawnień sudo.
  • Zarządzanie bezpieczeństwem danych (ansible-vault):
    • ansible-vault create secret.yml – utworzenie nowego zaszyfrowanego pliku.
    • ansible-vault edit secret.yml – bezpieczna edycja w locie w domyślnym edytorze.
    • ansible-vault encrypt_string 'haslo' --name 'tajemnica' – szyfrowanie pojedynczej zmiennej.
  • Ekosystem, inwentarz i dokumentacja modułów:
    • ansible-doc <nazwa_modułu> – wyświetlenie pełnej dokumentacji i przykładów użycia modułu.
    • ansible-inventory --graph – wizualizacja hierarchii drzewa inwentarza.
    • ansible-galaxy role init <rola> – wygenerowanie szkieletu nowej roli.
Cheat sheet - najważniejsze polecenia Ansible: Slajd przedstawia zagadnienie Cheat sheet - najważniejsze polecenia Ansible w ramach tematu Cheat sheet - najważniejsze polecenia Ansible na przykładach konfiguracji i diagnostyki w systemie Linux. Składnię plików opisu i szablonów określają specyfikacja YAML i dokumentacja Ansible, a transport zadań wykorzystuje standardowo SSH.
ASK_prez10_s50