Docker pod kątem zastosowań programisty C++

Wprowadzenie

Docker jest narzędziem, o którym wielu już słyszało, wielu go też używało pośrednio, lub bezpośrednio. Mówiąc w skrócie jest to narzędzie tworzące niezależne wirtualne izolowane środowisko. Coś jak bardzo lekka maszyna wirtualna. Narzędzie to posiada bardzo dużą ilość zaawansowanych funkcji, których nawet nie tknę w tym artykule. Najczęściej używaną funkcjonalnością jest możliwość postawienia izolowanego systemu operacyjnego zawierającego wszystkie zależności do aplikacji, której planujemy użyć bez skomplikowanej instalacji i konfiguracji. Poza samymi funkcjonalnościami tworzenia środowiska pod naszą aplikacje Docker umożliwia nam w łatwy sposób migrować między wersjami, rozpowszechniać naszą aplikacje, tworzyć migawki itp. Kluczowe jest, że raz przygotowany obraz będzie działał na różnorakich systemach, dzięki temu nie musimy pisać naszej aplikacji pod różne systemy operacyjne w różnych wersjach i dystrybucjach. Kontenery stosujemy min. w sytuacji, gdy chcemy "zainstalować" aplikacje bez troszczenia się o zależności oraz bez obaw, że coś zostanie w systemie.

Podstawowe pojęcia

Obraz dockera - plik obrazu bez możliwości edycji. Obrazy mogą być pobierane z repozytorium obrazów lub tworzone własnoręcznie. W przeciwieństwie do maszyn wirtualnych każdy kontener dockera pochodzący powstały na bazie obrazu używa jądra maszyny hosta, a nie własnego.
Instancja kontenera - plik obrazu z możliwością zapisu i odczytu. Kontenery tworzone są na bazie obrazów. Przeznaczeniem instancji kontenera jest wykonywanie pojedynczego zadania (procesu), możliwe stany kontenera: created, running, restarting, exited, paused. dead.

Aby dobrze zrozumieć czym w dockerze jest obraz wyobraźmy sobie, że mamy płytę z systemem operacyjnym (lub obraz *.iso), po zainstalowaniu mamy już instancje systemu operacyjnego, którą sobie zmieniamy a obraz zostaje bez zmian. Z jednego obrazu możemy tworzyć wiele instancji, a instancje dockera możemy zmienić na obraz. Obrazu mogą zawierać własne systemy operacyjne, zaimplementowane na pokładzie bazy danych, aplikacje, serwisy.

Instalacja Dockera

Zasadniczo możemy go zainstalować na dowolnym Linuxie (nawet Raspberry PI), możemy też na Windowsie od wersji 7 wzwyż. Instalacja na Linuxie jest dość prosta, przykładowo na debiano-pochodnych systemach wystarczy:


W niniejszym artykule skupię się wyłącznie na używanie Dockera na Linuxach. Posiadaczy Windowsa odsyłam do innego artykułu.

Pobieranie obrazów dockera

Obrazy możemy sobie pozyskać z m.in. z własnego archiwum (obraz utworzony wcześniej), z internetu (repozytoria kontenerów) lub wygenerować obraz własnoręcznie (uruchamiając plik z instrukcjami pozwalającego zbudować własny obraz dockera, czyli używając tzw. Dockerfile).

Strona https://hub.docker.com/ jest oficjalnym repozytorium obrazów, tam możemy wyszukiwać interesujące obrazy dostępne. Istotnym aspektem jest możliwość filtrowania wyników po "Verified publisher" lub "Official image", również mamy możliwość wyboru kategorii, przykładowo:
Jeśli nie mamy "zweryfikowanego dostawcy" lub "Official image" możemy pokusić się o pobranie obrazu jeśli jest on Open Source - tą kwestie możemy sprawdzić jeśli albo znamy dostawcę obrazu, albo możemy też próbować wejść w szczegóły obrazu i tam poszukać jakiś odniesień do Githuba, gdzie powinien być Dockerfile. Można też na Githubie kliknąć zakładkę Packages, gdzie będzie instrukcja jak pobrać konkretny obraz dla konkretnej wersji (wśród tych udostępnionych). Przykładowo dla projektu Hyperledger Iroha mamy kilka pakietów, a pobrać je możemy w następujący sposób - z Dockerhuba robimy to komendę:

Przykładowe uruchomienie komendy w celu pobrania obrazu:


zrzucanie obrazu do/z pliku archiwum TAR:


Polecenie poniżej wypisuje wszystkie obraz opisując stan ich uruchomienia:

Kasowanie obrazu Dockera:

Zatrzymanie, uruchomienie i sprawdzenie instancji kontenerów dockera

Najprostrzym poleceniem uruchomienia kontenera jest polecenie . W tym wypadku zostanie uruchomiony kontener, którego obraz zostanie automatycznie uruchomiony. W sytuacji, gdy obraz nie istnieje jest automatycznie pobierany.

Przykładowo jak chcemy zainstalować sobie bazę danych Postgres to po zainstalowaniu dockera możemy wywołać np.:

W powyższym przykładzie uruchomiona zostanie instancja dockera z przygotowanego obrazu , użytkownik i hasło będzie odpowiednio  i . Nazwa instancji , co prawda możemy jej nie podawać, wtedy nazwa będzie losowa. Parametr  oznacza, że do bazy danych możemy się dostać przed adres serwera . Bez parametru  po wywołaniu powyższej komendy byśmy byli podpięci do  bazy danych, zupełnie tak jakbyśmy ją uruchomili ręcznie. W ramach instancji dockera będzie uruchomiona komenda odpowiedzialna za uruchomienie procesu serwera bazy danych.


Można sterować tak uruchomionym kontenerem. Poniżej opisano listę komend, które można wykorzystać w tym zadaniu.

Uruchomienie instancji kontenera

Restart instancji kontenera:

Zatrzymanie instancji kontenera

Usunięcie instancji kontenera

Ogólny przegląd stanu instancji kontenera

Przegląd szczegółów instancji kontenera

Są to takie szczegóły jak m.in. adres IP, wolumeny (o tym może później będzie), argumenty uruchomienia, zmapowane ścieżki i wiele innych, można zwrócić przy pomocy komendy:

Aktualizacja szczegółów instancji kontenera

Zdarza się, że w uruchomionej instancji zmienić konfigurację kontenera. Do tego celu używamy:

Np. jeśli chcemy ustawić aby kontener po awarii był automatycznie ponownie uruchamiany:

poza powyższym możliwe jest m.in. ograniczenie zasobów używanych przez dockera (np. ilość pamięci RAM itp)

Wyświetlenie statystyk (użycia zasobów) instancji kontenera

Robimy to komendą:

I otrzymujemy podobne wyjście:

Wywołanie komendy na instancji kontenera

Bardzo często na uruchomionej instancji dockera chcemy zawołać jakąś komendę, nr. doinstalować brakujące wtyczki. Robimy to przy pomocy polecenia:
Gdy chcemy dostać się do konsoli bashowej należy wprowadzić polecenie:

dzięki podpinamy się do stdout i stdin.

Analogicznie do powyższego możemy podpiąć się do stdout i stdin uruchomionej w kontenerze komendy przez zawołanie:

W przypadku wcześniej uruchomionej bazy danych postgres podepniemy się tym sposobem do głównego procesu bazy.

Komendy dokumentacji

Możliwości konfiguracyjne dockera, oraz zestaw komend jest znacznie obszerniejszy, dlatego wiele możemy przejrzeć przez powszechnie znaną komendę , której możemy użyć na różnych szczeblach zagnieżdzenia:

Jak chcemy posprzątać jedną komendą

System operacyjny w instancji dockera

Przykładową instancje systemu operacyjnego z obrazu Ubuntu możemy pobrać zawołaniem:
Gdzie:

• --interactive
   oznacza tryb interaktywny, czyli STDIN oczekujące na wejście
• --tty
  dzięki temu STDOUT jest widoczne
• --name
  nazwa kontenera, po której możemy operować na kontenerze

W odpowiedzi pojawi się nam bashowa konsola roota obrazu, gdzie możemy zacząć działać, coś zainstalować, zbudować itp.

Dostęp do wnętrza kontenera poprzez SSH

Doszliśmy do tego jak uruchomić obraz dockera, teraz warto sobie wejść na niego przez SSH. Jak pamiętamy mamy obecnie tylko użytkownika , pamiętajmy też, że nie mamy jeszcze openssh, dlatego musimy wykonać kilka komend (poniżej zakładam, że chcemy się logować przez SSH na roota).
Mając powyższe trzeba by pobrać adres naszej instancji, w tym celu wołamy:

a następnie szukamy: , albo po prostu wołamy:

Mając adres łączymy się przez ssh:

Przykład gotowego kontenera

Poniżej przedstawiono listingi dla przykładowej instancji kontenera. Warto powiedzieć, że w opisanym powyżej listingu numer  to skrócone id_instancji oraz  nazwa_kontenera.
Możemy też chcieć zobaczyć pełną uruchomioną komendę, wtedy dodajemy dodatkowy parametr wyłączający przycinanie:

Dostęp do stdout i stderr instancji kontenera

przykład wszystkich informacji zwróconych przez instancje dockera uruchomienego poleceniem :

Zagrożenia konteneryzacji z Dockerem

Nie jest tak, że zawsze należy używać dockera do wszystkiego. Kiedy jest to odradzane zostało opisane w stosownym artykule. Jednakże ja wychodzę z założenia, że warto przeczytać do końca ten artykuł i potem zdecydować czy warto pójść w dockery czy nie. Wszak dopóki czegoś nie znamy wiemy jak żyć bez tego, a odkrywszy możemy sobie ułatwić życie.

Docker mimo iż jest izolowany niesie pewne zagrożenia, najpopularniejszym jest możliwość zapchania zasobów kontenera (CPU, RAM, dysk, ilość procesów) jak i też możliwość zablokowania określonych portów. Ale jeśli dokonamy mapowania ścieżek systemu operacyjnego dla instancji kontenera to mogą one być wykorzystane przez złośliwe oprogramowanie lub nasze omyłkowe  (taka sytuacja miała miejsce w pewnej firmie i backupy też usunęło). Poza tym docker ma dostęp do pełnych zasobów (o ile nie ograniczymy ich dla kontenera), w tym do RAMu, czyli może wpisać coś złośliwego do RAMu, dlatego też warto limitować dostęp do pamięci dla kontenera. Inne częste problemy z bezpieczeństwem dockera znajdują się w innym artykule.

Obraz dockera z instancji kontenera

Dzięki tej możliwości jak będziemy mieli już skonfigurowaną instancje kontenera dockera możemy ją przerobić na obraz. Aby to zrobić piszemy:

co dla skonfigurowanego klienta SSH może wyglądać tak:
Taki obraz możemy zrzucić do pliku:

czyli dla powyższego

Obraz taki oczywiście można komuś wysłać i potem zainportować:

Komunikacja kontenera ze światem

Powyżej dowiedzieliśmy się, że jest to środowisko izolowane, no ale co jeśli chcemy przekazać pewne dane z serwera goszczącego? Właśnie temu zagadnieniu będzie poruszony ten rozdział.

Mapowanie katalogów między systemem gospodarzem a systemem gościem

Robi się to przez dodanie argumentu  w następujący sposób:

Przykładowo możemy instancje uruchomić w następujący sposób:

Powyższa komenda uruchamia instancje obrazu  o nazwie  która na zmapowanym katalogu  w ścieżce roboczej  wykona komendę , po czym dzięki fladze  przestanie istnieć po wykonaniu polecenia. A tak prościej: w ramach chwilowej instancji dockera zostanie w nim zawołana komenda .

Można ten mechanizm wykorzystać do skompilowania i uruchomienia projektu bez szkody dla systemu operacyjnego, ale wtedy zamiast  trzeba by było dołożyć komendy instalujące , dlatego też warto na potrzeby jednorazowej kompilacji skorzystać z obrazu, który już ma kompilator (bo np. sami takowy przygotowaliśmy, lub z gotowego).
Niestety jeśli byśmy chcieli oficjalny obraz wydany przez zweryfikowanego dostawcę to dla C++ na moment pisania tego artykułu mamy jedynie:
gdy jednak odznaczymy te dwie opcje rzuca się w oczy obraz przygotowany dla pewnego amerykańskiego uniwesrytetu, przy jego pomocy możemy skompilować dany kod w następujący sposób:



Podobnym sposobem możemy skorzystać z gotowego, oficjalnego obrazu Pythona, który wołamy w następujący sposób:

Volumeny - lepszy mechanizm od mapowania katalogów

Bardziej zalecanym mechanizmem od mapowania katalogów są volumeny, ich zalety nad mapowaniem katalogów są wymienione w oficjalnej dokumentacji, poniżej kilka przykładowych komend:
Powyższy volumen możemy podpiąć podając jego nazwę np.:

Mapowanie urządzeń

Zamontowany penrdive można zmapować z kontenerem, ale jest też inny sposób.

Mapowanie portów i konfiguracja sieci między kontenerami a gospodarzem

Pierwszym zagadnieniem w tym temacie jest konfiguracja sieci między instancją kontenera a systemem gospodarza, robimy ją przy pomocy . Przykładowo jeśli chcemy zmapować instancje kontenera tak jakby wszystkie usługi sieciowe były uruchomione na systemie gospodarzu to używamy opcji. Mamy też inne możliwości, ale zagadnienie jest na tyle rozległe i skomplikowane, że odsyłam do dokumentacji.

Bardzo często nasza aplikacja udostępnia pewne porty, część z nich chcemy wystawić na zewnątrz, część przekierować, a część aby była widoczna tylko dla komputera gospodarza lub dla wszystkich. Przykładowo jeśli napiszemy serwer www w WT możemy wystawić port w momencie uruchamiania () w taki spobów:

Sterowanie kontenerem przez zmienne środowiskowe

Jest to mechanizm stosowany do sterowania programem w C++ jako alternatywa do argumentów uruchomienia programu. Zmienne środowiskowe przekazujemy komendą  w następujący sposób:
Mając wiele zmiennych można je przekazać przez plik ze zmiennymi środowiskowymi stosując argument:

Przykładowy plik ze zmiennymi środowiskami wygląda tak:
ich czytanie można szybko sprawdzić:

Zmienne środowiskowe można przekazać chociażby dla oficjalnego obrazu Ubuntu umożliwiające wybór języka.

Dockerfile dla programisty C++

W poprzednich rozdziałach dowiedzieliśmy się coś o obrazach, o tworzeniu instancji kontenera z tychże obrazów, dowiedzieliśmy się również, że po wejściu do instancji kontenera możemy zainstalować potrzebne zależności. W ten sposób można przygotować własny obraz, który po wyeksportowaniu do pliku można udostępnić. Jednakże taki kontener w pliku zajmuje trochę miejsca. Istnieje dużo lepsza możliwość! Wystarczy przygotować plik Dockerfile z tekstowymi instrukcjami jak zbudować własny kontener od zera. Zawiera on instrukcje jak zbudować obraz dockera, jakie pliki przenieść, jakie komendy wywołać, czy w końcu jakie porty wystawia i jaka jest komenda uruchomionej instancji kontenera (tzw. entrypoint).

Jako, że niniejszy portal jest poświęcony językowi C++ skupię się na pisaniu prostych aplikacji w C++ i przygotowywaniu ich na dockerze, oraz tego co z funkcjonalności dockera jest nam potrzebne. Artykuł ten jest zainspirowany wystąpieniem na konferencji CppNow w roku 2018 (slajdy). Aby nie pisać tylko teoretycznie, dobrym przykładem programu w C++, który jest dobrze zdockeryzowany jest Hyperledger Iroha, który ponadto jest tak zrobiony, że można ją zbudować i uruchomić również bez dockera.

Napiszmy więc przykładowy plik  dla kompilatora g++:
Powyższy plik  pobiera obraz Ubuntu:21.04 (), na nim instaluje g++ (), następnie ustawia ścieżkę roboczą (), która jak nie istnieje zostanie utworzona. Ostatnim elementem  jest wystawienie tzw. entrypoint, czyli komendy uruchamianej w ramach dockera wraz z argumentami. Obraz z tego możemy utworzyć (komenda wołana w tym samym katalogu co ):
W ramach obrazu mamy już kompilator, więc aby skompilować plik wystarczy zawołać (dla skompilowania pliku , który znajduje się w aktualnym katalogu ):

Powyższe skompiluje w ramach instancji dockera plik źródłowy, natomiast jak chcemy uruchomić wynikowy plik już robimy to na komputerze gospodarza, aby móc uruchomić to również w ramach dockera musimy podmienić entrypoint:

Jak widzimy instancje kontenera są usuwane od razu po wykonaniu (flaga ), natomiast jakbyśmy chcieli usunąć obraz wołamy:


Teraz spróbujmy ciut bardziej zaawansowany , który będzie zawierał jeszcze cmake'a:
Powyższy plik  może posłużyć do wytworzenia obrazu:
Po skutecznym zbudowaniu obrazu możemy jednokrotnie uruchomić rezultat (uruchomienie  i uruchomienie aplikacji):
 - po uruchomieniu instancja kontenera zostanie usunięta (flaga ). A jakbyśmy chcieli usunąć obraz wołamy:



Powyższy Dockerfile jest dość skąpy, zwłaszcza w sytuacji gdy chcemy go lepiej skonfigurować, w tym celu możemy użyć komend , która jest zmienną w trakcie budowania obrazu, a w momencie uruchamiania instancji już jej nie ma, oraz , która jest dostępna zarówno w trakcie budowania jak i uruchamiania instancji, ale ustawić ją można bezpośrednio tylko w momencie uruchamiania. Aby to zobrazować zmodyfikujmy powyższy plik:
Aby zbudować obraz z wykorzystaniem opcji konfiguracyjnych przekazujemy parametry po fladze  przykładowo tak:
Natomiast w trakcie tworzenia instancji kontenera przekazujemy argumenty flagą:  lub  np. w taki sposób:


Z innych możliwości dockerfile (więcej w dokumentacji):
 - jest podobne do CMD, z tą różnicą, że domyślne polecenie nie może być wtedy nadpisane (chyba, że użyjemy flagi ).
 - Jest to opcja, która tak naprawdę jest tylko informacją na temat pliku portów wystawionych przez instancje kontenera, ale w praktyce należy uzyć jeszcze -p
 - pewna informacja, którą można pobrać przez docker image inspect --format='' myimage
 - sygnał stopujący kontener (nazwa, lub id) w razie niepodania SIGTERM
 - komenda przy pomocy której się sprawdza czy wszystko w porządku z kontenerem
 - zmiana powłoki od danego momentu
 - ustawia innego użytkownika i opcjonalnie grupę do wykonywania dalszych komend
 - opcja, w ramach której możemy dodać pewne dodatkowe komendy wykonane w momencie, gdyby nasz obraz poslużył do zbudowania innego obrazu
 - tworzy punkt montowania w obrazie, który w razie czego zostanie utworzony jako oddzielne volume??????

Jak sobie nie zaśmiecić dockerfile - czyli jeden obraz buduje drugi (tzw. multistage-build)

Multistage build to bardzo wygodny mechanizm pozwalający aby sobie nie zaśmiecić obrazu dodatkowymi pakietami, które potem będziemy chcieli usunąć. Mechanizm ten stosujemy przez użycie wielokrotnie klauzuli .
Przykładowo aby kompilować pliki w C++ w ramach jednej instancji dockera, a uruchamiać w ramach innej możemy utworzyć następujący plik:
Przykładowe zbudowanie obrazu i uruchomienie (dla pliku ):

Uruchamianie aplikacji okienkowej z dockera

Jest to jedno z odradzanych zastosowań dockera, niemniej jednak jest to możliwe. Niestety wiele zależy od systemu goszczącego i goszczonego, przykładowo dla Ubuntu na Ubuntu przez dockera można ten efekt osiągnąć tak:

Opis jak coś takiego zrobić na windowsie w oddzielnym artykule.

CppDock narzędzie tworzące obrazy dockera z zależnościami w konkratnych wersjach

Pod koniec  wystąpienia konferencyjnego, będącego inspiracją dla tego artykułu zostało przedstawione narzędzie CppDock, które w oparciu o plik konfiguracyjny w formacie JSON wygeneruje obraz dockera zawierający wszystkie zależności C++owe w konkretnych wersjach. Po przejrzeniu się temu rozwiązaniu przyznaje, że pomysł szczytny, przydatność jest, jednakże lista przepisów, jak zbudować daną bibliotekę, jest bardzo ograniczona, dlatego wg mnie lepiej użyć managera zależności cieszącego się większą społecznością np. vcpkg, który to jeszcze załatwia multiplatformowość.

Narzędzia wspierające zarządzanie aplikacjami na wielu dockerach równocześnie

Poznaliśmy podstawy ogólnego zastosowania. Jednakże pojawiają się pytania jak używać tego gdy m.in. chcemy zarządzać dużą ilością kontenerów. Poniżej popularne narzędzia, o których warto wiedzieć

Docker-compose

Nauczyliśmy się używać Dockera, widzimy tego zalety, ale pozostaje pytanie co jeśli chcemy aby wiele instancji ze sobą rozmawiało, przykładowo: aplikacja, baza danych, oraz command-line do aplikacji. Wtedy musieli byśmy mieć trzy obrazy i uruchamiać je w odpowiedniej kolejności pilnując aby wszystkie dane konfiguracyjne były jednolite. W takich sytuacjach przydaje się narzędzie , które to zarządza kilkoma instancjami równocześnie pilnując wszystkiego, a konfigurujemy przy pomocy plików YAML.

Zasadniczo narzędzie ma podobne możliwości jak Dockerfile, czyli konfigurowanie argumentów uruchomienia, zmiennych środowiskowych, sieci, a poza tym możliwość wskazania, który kontener wymaga którego innego do uruchomienia.

Przykładowy plik ocker-compose możemy zobaczyć w projekcie Hyperledger Iroha, którego treść znajduje się tutaj:
Jak widzimy w powyższym mamy tworzone volume, oprócz tego bazę danych, a następnie węzeł blockchain Hyperledger Iroha.

Mając powyższy plik  możemy zarządzać wszystkimi instancjami w następujący sposób:

Docker Swarn - zarządzanie dużą ilością konrenerów dockera

Docker Swarn jest to rozwiązanie klastrowe zarządzające dużą ilością kontenerów dostarczane wraz z Dockerem. Posiada własne api, dobrze jest zintegrowane z Dockerem i docker-compose. Niestety pewne funkcjonalności wymagają wersji Enterprice. Jest to narzędzie mniej popularne niż niżej opisany Kubernetes, mimo iż jest prostrze lecz posiada mniej możliwości. Osoby zainteresowane dowiedzeniem się więcej odsyłam do oddzielnego atykułu opisującego jak skonfigurować i uruchomić Docker Swarn na wielu serwerach.

Kubernetes

Kubernetes jest to platforma open-source do zarządzania kontenerami. Jest ona na tyle popularna, że wiele dostawców serwerów wirtualnych (ang. VPS) zawierają wsparcie i instrukcje jak uruchomić na ich serwerach klaster Kubernetes. W porównaniu z Docker Swarn narzędzie Kubernetes posiada znacznie więcej możliwości, bardziej szczegółowe porównanie tych dwóch narzędzi w artykule: Swarn vs Kubernetes.

Alternatywy dockera

Docker jest najpopularniejszym narzędziem do konteneryzacji.

Dla użytkowników istnieją alternatywy (lub lista oprogramowania na stronie Wikipedii) m.in.: OpenVz, LDC (Linux Containers), ZeroVM.

Spośród alternatyw na szczególną uwagę zasługuje podman, który jest na tyle kompatybilny z dockerem, że można go używać jako . Zaletą Podmana jest, że nie trzeba używać go jako użytkownik z uprawnieniami. Za wadę należy zuznać fakt, że niestety można go używać jedynie na Linuxie.

Przykładowo poniżej pokazano w jaki sposób pokstawić bazę danych postgres. Zwróć uwagę, że opcje polecenia są zgodne z tymi użytymi przy poleceniu docker.

Bibliografia + literatura uzupełniająca

• Dokumentacja ogólnie
• Dokumentacja argumentów dockera z command-line
• Dokumentacja sieciowa dockera
• Dokumentacja komendy
  docker run ...
• Strona poświęcona tajnikom zagłębienia Dockera, polecam po przeczytaniu mojego artykułu osobom zainteresowanym zgłębieniem tematu
• IBM w języku polskim opisuje przeglądowo Dockera, dlaczego jest super i w ogóle, jakie mechanizmy w jądzer Linuxa są używane, opisują jak ja ale bez przykładów
• Artykuł podobny do mojego, ale krótszy i dla Javy, powiązany link video
• Najlepsze praktyki dla dockerfile
• Słownik pojęć związnych z Dockerem
• Dokumentacja Dockerfile
• Prezentacja dla początkujących na temat Dockera
• 7 powodów aby nie używać Dockera, polecam jeszcze dyskusje na ten temat
• Dokumentacja jak usuwać niepotrzebne pozostałości Dockera
• Automatyczne buildy w ramach Dockera z Githuba
• Artykuł skupiony na szybkim postawieniu programu programu w C++ przy użyciu Dockera - bardziej skrótowo niż ja, ale bez wprowadzenia do dockera
• alternatywny do powyższego, rzucający przykładami ze skąpym opisem.
• Dyskusja na StackOverflow jak praktycznie podejść do zdockeryzowanego CI
• Kurs dockera video
• Kurs w formie artykułów: link1, link2, link3, link4

Autorzy artykułu

Autor	Zakres zmian	Afiliacja
Bazior Grzegorz	Utworzenie artykułu	Pracownik AGH w Krakowie
Paweł Król	Korekta	Pracownik Politechniki Krakowskiej