Artykuł MySQL & phpMyAdmin z poziomu Dockera pochodzi z serwisu Szkoła Dockera.
]]>Jak uruchomić popularne silniki bazy danych za pomocą Dockera? Ktoś powie, że to nic trudnego – z tym się absolutnie zgadzam. Wystarczy wejść na Docker Hub i w wyszukiwarce wpisać nazwę interesującej nas bazy danych.
W większości przypadków dostajemy tam gotowe polecenie docker container run.
Wklejamy i DZIAŁA 
A gdyby tak iść o krok dalej i chcieć na szybko uruchomić bazę danych wraz z jakimś UI? (narzędziami graficznymi do zarządzania bazą)
Przykład: MySQL i phpMyAdmin.
Do czego potrzebujesz tej bazy danych?
Chcesz ją wykorzystać tylko do celów developerskich, a może powiedziano Ci, że jak wrzucisz bazę w Dockera, to cała Twoja aplikacja będzie szybsza? (tak jak z samochodami koloru czerwonego)
Prowadząc webinary, szkolenia i ogólnie rzecz biorąc „udzielając się w społecznośći” – jest to najcześciej pojawiające się pytanie:
Czy baza danych w Dockerze to dobry pomysł ?
Zajrzyj koniecznie do tego posta, gdzie mam nadzieję – znajdziesz odpowiedź. Odsyłam do niego wszystkich zadających podobne pytania.
A potem wróć tutaj i zacznij czytać dalej! ; )
Wszystkie omawiane w tym poście przykłady zostały przygotowane z myślą o zastosowaniach DEVELOPERSKICH.
W wielkim skrócie chcę ułatwić Ci życie i pokazać jak odpalić poszczególne silniki bazodanowe na potrzeby developmentu.
Nawet jeśli Twoja aplikacja nie jest skonteneryzowana – zamiast instalować bazę danych, możesz ją szybko uruchomić z poziomu Dockera (i nie zaśmiecać swojego komputera).
Potrzebujemy obrazu dla konkretnego silnika bazy danych. Jak wspominałem, wchodzimy więc na Docker Huba i szukamy tego, co nas interesuje.
Zanim jeszcze wkleisz kod odpowiadający za uruchomienia kontenera z MySQL – zatrzymaj się na chwilę. Jeżeli Twoim celem jest uruchomienie również phpMyAdmin – zacznij od stworzenia nowej sieci.
docker network create -d bridge mysql-net
Dlaczego?
Więcej na temat sieci i komunikacji pomiędzy kontenerami możesz znaleźć w darmowej lekcji DEMO pochodzącej z kursu Docker Maestro.
Mając utworzoną sieć, przystępujemy do uruchomienia kontenera MySQL.
Uwaga: Jeśli korzystasz z Windowsa to usuń wszystkie „\” i wklej całość w jednej linii.
docker container run --name mysql --restart=always \
-e MYSQL_ROOT_PASSWORD=password123 -p 3307:3306 \
-v mysql-db-vol:/var/lib/mysql \
--network mysql-net \
mysql:5.7Szybki komentarz do przekazanych w docker container run argumentów:
--name mysql określa nazwę kontenerarestart=always zapewni automatyczne uruchomienie kontenera przy każdym restarcie komputera-e MY_SQL_ROOT_PASSWORD ustawia hasło dla roota-p 3307:3306 baza danych będzie dostępna lokalnie na porcie 3307-v mysql-db-vol:/var/lib/mysql tworzy nowy volumen mysql-db-vol i podmontowywuje go do katalogu /var/lib/mysql w kontenerze--network mysql-net podłącza kontener do wcześniej utworzonej sieci Od tej pory baza działa i możemy wykorzystać ją do naszych celów developerskich – wskazując w konfiguracji połączenia (connection string) aplikacji localhost:3307.
Czas na uruchomienie kontenera phpMyAdmin.
docker container run --name phpmyadmin --restart=always \
-p 8081:80 --network mysql-net \
phpmyadmin/phpmyadmin:latest
Podobnie jak w przypadku kontenera MySQL, dodajemy parametr –restart=always oraz podłączamy kontener do sieci mysql-net.
Dzięki parametrowi-p 8081:80 phpMyAdmin będzie działać na https://localhost:8081
UWAGA: Pomimo tego, że baza danych działa lokalnie na porcie 3307, to phpMyAdmin będzie się komunikował z MySQL na porcie 3306. Wszystko dzięki temu, że obydwa kontenery są podłączone do tej samej sieci – mysql-net.
Aby uruchomić bazę danych z pomocą docker-compose, przykładowy plik docker-compose.yml może wyglądać następująco:
Jeszcze raz podkreślam, że to wersja DEVELOPERSKA ; )
Montujemy volumen o nazwie db-vol tak, by mieć persystencję danych – inaczej mówiąc nie stracić danych, nawet po zabiciu kontenera czy ponownym uruchomieniu komputera.

Teraz wystarczy wykonać polecenie docker-compose up -d. Baza danych powinna uruchomić się (w tle) i być dostępna na porcie 3307.
Czas na dodanie phpMyAdmin.
W wersji podstawowej chcemy, by phpMyAdmin mógł rozmawiać TYLKO z lokalnym MySQL i był dostępny lokalnie na porcie 8081 – http://localhost:8081
Warto wspomnieć o jeszcze jednej rzeczy:
Używanie tagu „latest” w rozwiązaniach produkcyjnych to spore ryzyko.
W pełni się z tym zgadzam. Ba, tłumaczę, dlaczego tak jest i jakie to niesie ryzyko TUTAJ.
Chcę jednak przypomnieć, że prezentowany przykład ma służyć do rozwiązań testowych / developerskich. Jak wyjdzie nowa wersja phpMyAdmin, to zwyczajnie z niej skorzystasz. Może będzie miała ciekawsze funkcje.
W związku z tym phpmyadmin/phpmyadmin:latest w tym KONKRETNYM przypadku jest OK.
Jednocześnie zachęcam, by obraz MySQL był w KONKRETNEJ wersji, nawet na potrzeby developmentu. (na prezentowanym przykładzie jest to wersja 5.7)

A tutaj całość (w wersji kopiowalnej)
Odpalamy całość za pomocą docker-compose up -d i przechodzimy na http://localhost:8081. Przypominam, że hasło do roota jest takie, jak podaliśmy w pliku docker-compose.yml – password123

PhpMyAdmin podłączył się domyślnie do lokalnego serwera bazy danych (działającego w kontenerze).

Chcąc mieć możliwość podłączania się również do innych serwerów – należy dodać zmienną środowiskową PMA_ARBITRARY=1, tak jak zostało to opisane TUTAJ.

Po zmodyfikowaniu całości i ponownym uruchomieniu ukazuje się nam pole Server. Dzięki temu mamy możliwość podłączania się zarówno do lokalnego jak i do zewnętrznych serwerów MySQL.
Aby podłączyć się do lokalnego serwera, należy wpisać db. Wynika to z pliku docker-compose.yml, w którym tak właśnie nazwaliśmy serwis bazodanowy.

Dzisiejszy post to kolejny przykład tego, jak Docker ułatwia życie w codziennej pracy. Za pomocą kilku prostych kroków jesteśmy w stanie uruchomić bazę danych i zarządzać nią z poziomu przeglądarki.
W razie czego usuwamy tylko kontenery (i volumeny) i komputer zostaje CZYSTY.
PS. Chcesz więcej takich TUTORIALOWYCH przykładów? Napisz w komentarzu 
Artykuł MySQL & phpMyAdmin z poziomu Dockera pochodzi z serwisu Szkoła Dockera.
]]>Artykuł Docker i Ngrok – publikacja kontenera w internecie pochodzi z serwisu Szkoła Dockera.
]]>Jeżeli znasz już Dockera na poziomie przynajmniej podstawowym – czyli potrafisz uruchamiać kontenery oraz wiesz jak z nich korzystać na swoim komputerze – ten post jest dla Ciebie.
Pokażę Ci jak za pomocą Dockera oraz narzędzia Ngrok – opublikować aplikację w internecie.
Naniosłeś jakieś zmiany w aplikacji (np. w UI) i chciałbyś je na szybko zaprezentować koledze z zespołu. Na przykład, żeby ocenił czy to, co robisz, ma sens. Standardowy proces to quick call i udostępnianie ekranu na komunikatorze, który używacie w firmie.
Jeżeli jednak kolega z zespołu, chciałby to samodzielnie przeklikać albo podglądnąć jak zachowuje się aplikacja u siebie – raczej nie pozostaje nic innego jak zrobienie commita i wdrożenie naniesionych zmian na jakieś środowisko testowe.
Tutaj już zależy, jak sprawny jest wasz proces CI/CD i jak szybko jesteście w stanie wdrożyć zmiany.
Środowisko testowe nie jest udostępnione do internetu (działa tylko w sieci firmowej).
Twoja aplikacja (webowa) ma działać „dobrze”, niezależnie od rozdzielczości ekranu. Chciałbyś więc podglądnąć zmiany z Twojego smartfona (bo przecież masz go cały czas przy sobie).
BOOM.
Znowu trzeba kombinować. Konfigurować VPN-y albo inne cuda.
W bardzo dużym skrócie – ngrok jest narzędziem (i usługą), które umożliwia przekierowanie ruchu z publicznego adresu IP (domena ngrok.io) do usługi uruchomionej na Twoim komputerze.
Nie będę się tutaj rozwodził, jak to dokładnie działa „pod spodem”, ponieważ zostało to dość obszernie opisane w dokumentacji.
Posłużymy się tą usługą/narzędziem do opublikowania aplikacji uruchomionej z poziomu Dockera. Co ciekawe, nie będziemy nic instalować. Na Docker Hubie znajduje się obraz, który wystarczy użyć.
I LOVE IT.
Za to właśnie uwielbiam Dockera. Chcesz skorzystać z jakiegoś fajnego narzędzia/rozwiązania i najczęściej jest do tego gotowy obraz. Bierzesz, uruchamiasz – działa!
Na początku potrzebujemy stworzyć sieć dockerową. Będzie to sieć typu bridge. Więcej informacji na ten temat możesz znaleźć w jednej z lekcji DEMO mojego kursu online Docker Maestro.
docker network create -d bridge ngrok-network
Uruchom kontener o nazwie mynginx, na podstawie oficjalnego obrazu nginxa.
WAŻNE: podłącz go do nowo utworzonej sieci ngrok-network. Jeżeli jesteś ciekawy, dlaczego jest to kluczowe – zaglądnij tutaj.
docker container run -d -p 8080:80 --network ngrok-network --name mynginx nginx:1.17.1
Kontener będzie dostępny na http://localhost:8080/

Uruchom kontener o nazwie ngrok, bazując na obrazie wernight/ngrok. Musi on być podłączony do wcześniej utworzonej sieci ngrok-network, do której w poprzednim kroku podłączony został kontener mynginx.
Dzięki temu, ngrok będzie mógł komunikować się z kontenerem mynginx za pomocą DNS – (na przykład http://mynginx).
Otwórz ruch z portu 4040 – dzięki czemu będziesz mieć dostęp do UI ngroka. Na koniec przekaż nazwę kontenera mynginx oraz port, na którym działa.
UWAGA: przekazujemy tutaj port 80. Wynika to z tego, że jest to domyślny port, na którym działa nginx w kontenerze.
docker container run -d -p 4040:4040 --network ngrok-network \ --name ngrok wernight/ngrok ngrok http mynginx:80
Możesz teraz przejść do przeglądarki i użyć adresu http://localhost:4040.
Twoim oczom ukaże się interfejs, gdzie podglądniesz twój publiczny adres URL stworzony przez ngroka.

W moim przypadku jest to http://352dd73fe4bf.ngrok.io/
U Ciebie będzie to inny adres, ponieważ ngrok generuje adresy dynamicznie.
Teraz każdy, kto ma powyższy adres URL, może podglądnąć naszego nginxa.

OK – wiemy już, jak to wszystko działa. Czas na przykład z życia wzięty, czyli lokalny development aplikacji.
Docker Maestro – najbardziej obszerny kurs online Dockera po polsku

Poruszana tematyka:
Sprawdź na http://dockermaestro.pl
Posłużę się tutaj przykładową aplikacją NodeJS, ale może to być aplikacji w dowolnej technologii.
Aplikacja ma dwa zwracające dane endpointy.
Pierwszy to /services/projects zwracający listę projektów, a drugi zwracający ich szczegóły /services/projects/:id
const express = require( 'express' )
const appRouter = express.Router()
const projects = require( './data' )
appRouter.get( '/services/projects', function( req, res ) {
res.json({ code: 'success', payload: projects })
})
appRouter.get( '/services/projects/:id', function( req, res ) {
const project = projects.find( p => p.projectId === parseInt( req.params.id ) )
res.json({ code: 'success', payload: project })
})
module.exports = appRouterDla tej aplikacji przygotowałem następujący Dockerfile
FROM node:14.4.0-buster-slim ARG NODE_ENV=production ENV NODE_ENV $NODE_ENV WORKDIR /app ARG PORT=8080 ENV PORT $PORT COPY package.json package-lock.json ./ RUN npm ci COPY . /app USER node CMD [ "node", "src/server.js" ]
Teraz całość zwieńczymy plikiem docker-compose.yml z pomocą, którego zbudujemy obraz oraz uruchomimy całość (już z wykorzystaniem Ngroka)
Plik docker-compose.yml prezentuje się następująco
version: "3.7"
services:
backend:
image: nodejs-app
build:
context: ./backend
args:
NODE_ENV: production
PORT: "8080"
ports:
- "8080:8080"
ngrok:
image: wernight/ngrok
ports:
- "4040:4040"
command: ["ngrok", "http", "backend:8080"]Teraz nie pozostaje nic innego jak wykonanie polecenia docker-compose build (aby zbudować obraz), a następnie docker-compose up
Dzięki temu na http://localhost:4040/inspect/http będziemy mieć dostępny UI ngroka – w tym publiczny adres URL, pod którym możemy odpytać API.
Nasza przykładowa aplikacja lokalnie działać będzie na http://localhost:8080/services/projects
Po odczytaniu publicznego adresu URL (w moim przypadku http://4f09a1a0acea.ngrok.io/) wygląda to następująco

Każde przychodzące żądanie jest zapisywane w panelu ngroka.

Omawianą aplikację, wraz z instrukcją jak to uruchomić znajdziesz na moim GitHubie https://github.com/dnaprawa/nodejs-docker-ngrok
Wystarczy sklonować repozytorium i uruchomić
docker-compose build docker-compose up -d
Życzę miłej zabawy 
PS. Jeżeli artykuł był dla Ciebie przydatny, będę wdzięczny za podzielenie się nim z przynajmniej jedną osobą! Dziękuję!
Artykuł Docker i Ngrok – publikacja kontenera w internecie pochodzi z serwisu Szkoła Dockera.
]]>Artykuł Komunikacja kontenerów – sieć typu bridge pochodzi z serwisu Szkoła Dockera.
]]>Podstawowa rzecz, z jaką prędzej czy później musimy się zmierzyć, to komunikacja między kontenerami. Najprostszy przykład, jaki nasuwa mi się na myśl, to komunikacji kontenera zawierającego frontend z kontenerem zawierającym backend aplikacji.
Kolejny przykład – komunikacja backendu z usługami typu Redis czy Elasticsearch. Takich przykładów może być zdecydowanie więcej. Wszystko zależy od naszych potrzeb i rodzaju wykorzystywanych w projekcie technologii.
Żeby dokładnie zrozumieć, w jaki sposób Docker na to zezwala, trzeba zacząć od podstaw, czyli od tego jak działa sieć typu bridge.
Można śmiało powiedzieć, że jest to najczęściej stosowany sterownik sieciowy — bridge.
Wynika to z tego, że można go wykorzystywać zarówno do celów developerskich, jak również uruchamiając projekt na środowiskach testowych czy produkcyjnych.
Po pierwsze, poznasz różnicę pomiędzy DOMYŚLNĄ siecią typu bridge (tworzoną przez Dockera po zainstalowaniu) oraz manualnie tworzonymi sieciami.
Po drugie, zobaczysz w praktyce jak tworzyć własne sieci i podpinać do nich kontenery
Po trzecie, zrozumiesz działanie sieci typu bridge
Jest to jedna z lekcji mojego kursu online Docker Maestro.
Łącznie cały kurs to blisko 13 godzin materiału.
Sprawdź agendę i listę wszystkich lekcji na http://dockermaestro.pl
Artykuł Komunikacja kontenerów – sieć typu bridge pochodzi z serwisu Szkoła Dockera.
]]>Artykuł Tworzenie lekkich i optymalnych obrazów dockerowych pochodzi z serwisu Szkoła Dockera.
]]>Tworzenie obrazów dockerowych to temat rzeka. Dla każdej technologii obraz będzie wyglądał nieco inaczej. Są jednak pewne „wspólne” dobre praktyki, które możemy stosować niezależnie od technologii, w której stworzona została aplikacja.
Przypomnijmy, że to obraz to działająca instancja kontenera. Jeżeli chcesz, by Twoje kontenery po uruchomieniu były lekkie i bezpieczne — koniecznie stosuj dobre praktyki podczas tworzenia obrazów
Może to się wydawać oczywiste, ale wiele osób zapomina o ustaleniu konkretnej wersji obrazu bazowego. Dlaczego jest to takie ważne?
Ten kod:
FROM node
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
CMD ["node", "server.js"]
Zastąp tym:
FROM node:14.4
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
CMD ["node", "server.js"]
Jeżeli nie podasz konkretnej wersji, to domyślną wersją obrazu będzie latest, która każdej chwili może zostać zaktualizowana na Docker Hubie.
W chwili przeprowadzania testów wszystko działało, a nagle po upływie kilku miesięcy…
NIE DZIAŁA.
Zastanawiasz się, co może być przyczyną. Spędzasz masę czasu na znalezienie problemu. Okazuje się, że obraz z tagiem :latest został w tym czasie kilkukrotnie zaktualizowany (w obrazie wprowadzono zmiany), co spowodowało, że Twoja aplikacja zachowuje się teraz inaczej.
Ten kod:
FROM node:14.4.0
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
CMD ["node", "server.js"]
Zastąp tym:
FROM node:14.4.0-buster-slim
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
CMD ["node", "server.js"]
Dzięki temu otrzymujemy oszczędność około ~250MB na rozmiarze obrazu, co oznacza szybszy czas budowania, pobierania i pushowania do Docker Registry.
.git
node_modules
build
Na pewno kojarzysz i wiesz do czego służy plik .gitignore w przypadku systemu kontroli wersji Git. Aby wykluczyć niepotrzebne pliki z procesu budowania obrazu (bez konieczności zmian twojego katalogu), użyj pliku .dockeringore. Docker tworząc to rozwiązanie, wzorował się na .gitignore (które to podejście zapewne doskonale znasz). Przykładem mogą być zbudowane paczki lub pliki wykonywalne (.dll, .exe, katalog node_modules itp), utworzone lokalnie podczas developmentu aplikacji.
Przygotowując kontener, nie chcemy ich kopiować. Chcemy, by zostały one zbudowane na nowo wewnątrz kontenera.
Są dwie drogi.
Pierwsza z nich to dołączenie do programu Docker Maestro, czyli najbardziej obszernego kursu online z Docker po polsku. Budowanie własnych obrazów to tylko mały fragment tego co znajduje się w całym kursie. Łącznie znajdziesz tam:

12 modułów
89 lekcji
Wiedza w pigułce
Praktyka & teoria
Od podstaw aż po zaawansowane tematy.
Jeżeli jednak z jakichś powodów nie możesz dołączyć do Docker Maestro, to zachęcam do obejrzenia poniższego wideo, gdzie na przykładzie dwóch aplikacji — ReactJS oraz NodeJS pokazuję jak optymalizować swoje obrazy.
Jest to tylko przykład i nawet jeśli na co dzień używasz innych technologii, poprzez analogię możesz przenieść te dobre praktyki do siebie.
1. Co robić by po zbudowaniu nie ważyły setek megabajtów?
2. Jak zadbać o ich bezpieczeńśtwo?
3. A co z obrazami bazującymi na Alpine Linux?
4. Jakich narzędzi używać, by ciągle pilnować ich jakości?
Zapraszam do oglądania!
Jak już obejrzysz, to wpadnij na stronę Docker Maestro i sprawdź TRZY darmowe lekcje DEMO.
Dzięki i do usłyszenia!
Artykuł Tworzenie lekkich i optymalnych obrazów dockerowych pochodzi z serwisu Szkoła Dockera.
]]>Artykuł Inicjalizacja kontenera za pomocą drugiego kontenera na przykładzie HashiCorp Vault pochodzi z serwisu Szkoła Dockera.
]]>Skoro to czytasz, to doskonale wiesz jak, Docker może ułatwić życie. Szczególnie mowa tutaj o środowiskach developerskich — i na nich głównie się skupimy.
Docker świetnie radzi sobie z uruchamianiem różnego rodzaju usług na potrzeby developerskie (i nie tylko). Mam tutaj na myśli usługi takie jak bazy danych (MySQL), serwery WWW (Nginx), brokery wiadomości (RabbitMq) czy narzędzia do przechowywania sekretów (HashiCorp Vault).
Często na potrzeby developerskie istnieje potrzeba inicjalizacji tychże usług zaraz po starcie. Przykładowo może to być inicjalizacja poprzez wczytanie danych, czy inicjalizacja konfiguracji danej usługi.
W niektórych przypadkach problem ten można rozwiązać za pomocą volumenów, czyli podmontowania danych lub plików konfiguracyjnych z hosta do kontenera. Nie zawsze jest jednak taka możliwość. Czasami musimy zainicjalizować usługę działającą w kontenerze danymi, ale dopiero po jego starcie. Tym tematem dzisiaj się zajmiemy.
W jednym z projektów, nad którym ostatnio pracowałem, do przechowywania sekretów wykorzystaliśmy narzędzie HashiCorp Vault. Architektura i specyfika projektu wymagała pobrania sekretów z Vaulta przez kilka mikroserwisów — podczas ich startupu. Może się to wydawać oczywiste, ale warto dodać, że wspomniane mikroserwisy również były uruchamiane z poziomu Dockera.
Aby ułatwić sobie proces developmentu i mieć możliwość uruchomienia całego ekosystemu, potrzebowaliśmy automatyczną inicjalizację Vaulta testowymi danymi. Nad projektem pracowało kilka osób i naszym celem było stworzenie przenośnego środowiska.
Idealnym rozwiązaniem było uruchomienie wszystkich komponentów za pomocą tylko jednego polecenia. Dzięki temu każda nowa osoba w zespole mogła uruchomić cały projekt — pobierając kod źródłowy z repozytorium i wpisując jedno polecenie. Jedyne wymaganie to zainstalowany wcześniej Docker. Tak też się stało.
Moim celem było uruchomienie całego projektu za pomocą jednego polecenie. Pierwszym pomysłem, który przychodzi w takiej sytuacji do głowy, jest skorzystanie z docker-compose. Aby uruchomić Vaulta jednym poleceniem, przygotowany został następujący plik docker-compose.yml.
version: "3.6"
services:
vault:
image: vault:1.3.2
container_name: vault
ports:
- "8200:8200"
cap_add:
- IPC_LOCK
environment:
- VAULT_ADDR=http://127.0.0.1:8200
- VAULT_DEV_ROOT_TOKEN_ID=21ebe9d7-a536-4b32-ae16-99b56352122b
networks:
- network-dev
volumes:
- vaultdata:/vault
restart: unless-stopped
networks:
network-dev:
volumes:
vaultdata:
Dzięki temu, już na tym etapie możemy uruchomić Vaulta za pomocą jednego polecenia: docker-compose up -d.
Vault posiada wbudowaną opcję zarządzania zdalnymi instancjami. Dzieje się to za pomocą Vault CLI, które może komunikować się z innymi instancjami poprzez HTTP API. Wystarczy adres URL zdalnej instancji Vaulta oraz token do autoryzacji.
W tym celu wystarczy użyć polecenia:
vault login -address="REMOTE_ADDRES" <ACCESS_TOKEN>
Oznacza to, że z poziomu CLI, możemy skomunikować się z inną instancją Vaulta, znając tylko jego adres i token. To otwiera możliwość na stworzenie pomocniczego kontenera, który posłuży do inicjalizacji głównej instancji.
W tym celu stworzony został plik o nazwie Dockerfile.vaultinit. Jego zawartość znajduje się poniżej:
FROM vault:1.3.2
COPY ./vault_init.sh /usr/local/bin/
RUN chmod +x /usr/local/bin/vault_init.sh \
&& ln -s /usr/local/bin/vault_init.sh /
ENTRYPOINT ["vault_init.sh"]Wewnątrz powyższego Dockerfile dodawany jest plik vault_init.sh, który zawiera zbiór poleceń służących do inicjalizacji głównej instancji Vaulta. Stanie się on głównym procesem pomocniczego kontenera. Dzieje się tak z powodu wskazania go w instrukcji ENTRYPOINT.
Plik inicjalizacyjny to nic innego jak zbiór poleceń specyficznych dla Vault CLI. Przykładowa zawartość pliku vault_init.sh znajduje się poniżej.
#!/bin/sh while ! nc -z vault 8200; do sleep 3; done vault login 21ebe9d7-a536-4b32-ae16-99b56352122b vault secrets enable -version=2 -path=MyEngine kv vault kv put MyEngine/MyFirstSecret Url=http://test.com/ vault kv put MyEngine/MySecondSecret Url=http://test221.com/ exit 0
Co tutaj się dzieje?
Po pierwsze w pętli while sprawdzamy połączenie z głównym kontenerem. Wykorzystujemy do tego narzędzie nc, którego zadaniem jest upewnienie się, że usługa w głównym kontenerze może przyjąć połączenie. Następnie logujemy się do głównej instancji. Na pierwszy rzut oka we wszystkich poleceniach brakuje tutaj parametru: -address="REMOTE_ADDRES" Parametr ten będzie dodawany automatycznie „w tle” dzięki dodatkowej zmiennej środowiskowej VAULT_ADDR, którą przekażemy do kontenera.
Pozostałe polecenia służą do dodania nowego engine’a oraz przykładowych sekretów.
Na ten moment w głównym katalogu projektu znajdują się trzy pliki.
Ostatnim krokiem jest dodanie kontenera pomocniczego do pliku docker-compose.yml. Zauważ, że za pomocą składni build wskazujemy plik Dockerfile.vaultinit. Dzięki temu osoba uruchamiająca skrypty po raz pierwszy nadal będzie mogła użyć tylko jednego polecenia: docker-compose up.
vault-initializer:
build:
context: .
dockerfile: Dockerfile.vaultinit
container_name: vault-initializer
cap_add:
- IPC_LOCK
environment:
- VAULT_ADDR=http://vault:8200
depends_on:
- "vault"
networks:
- network-devNa działanie tego rozwiązania mają wpływ również dwa inne czynniki.
Po pierwsze, przekazanie zmiennej środowiskowej VAULT_ADDR=http://vault:8200 oraz instrukcja depends_on: "vault".
Dzięki tym wpisom kontener pomocniczy otrzymuje adres głównej instancji Vaulta, który będzie domyślnym adresem podczas komunikacji za pomocą Vault CLI. Dodatkowo instrukcja depends_on sprawi, że kontener pomocniczy zostanie stworzony dopiero po stworzeniu głównego kontenera.
Oznacza to, że wszystkie instrukcje znajdujące się w pliku vault_init.sh zostaną wykonane, tak jakby za każdym razem dodawana był parametr -address "http://vault:8200". Przykład poniżej.
vault login -address="http://vault:8200" 21ebe9d7-a536-4b32-ae16-99b56352122b vault secrets enable -address="http://vault:8200" -version=2 -path=MyEngine kv
Komunikacja między kontenerem pomocniczym a kontenerem głównym jest możliwa, ponieważ oba kontenery po uruchomieniu zostaną podpięte do tej samej sieci —network-dev.
Sieć ta zdefiniowana jest w pliku docker-compose.yml i zostanie automatycznie utworzona. Komunikacja z kontenera pomocniczego do kontenera głównego odbywa się po nazwie usługi —vault.
Finalnie plik docker-compose.yml może wyglądać następująco:
version: "3.6"
services:
vault:
image: vault:1.3.2
container_name: vault
ports:
- "8200:8200"
cap_add:
- IPC_LOCK
environment:
- VAULT_ADDR=http://127.0.0.1:8200
- VAULT_DEV_ROOT_TOKEN_ID=21ebe9d7-a536-4b32-ae16-99b56352122b
networks:
- network-dev
volumes:
- vaultdata:/vault
restart: unless-stopped
vault-initializer:
build:
context: .
dockerfile: Dockerfile.vaultinit
container_name: vault-initializer
cap_add:
- IPC_LOCK
environment:
- VAULT_ADDR=http://vault:8200
depends_on:
- "vault"
networks:
- network-dev
networks:
network-dev:
volumes:
vaultdata:Jedyne co pozostaje, to wpisanie polecenia docker-compose up, które spowoduje uruchomienie Vaulta, a następnie jego inicjalizację przez kontener pomocniczy. Warto jeszcze zaznaczyć, że po zakończeniu procesu inicjalizacji, kontener pomocniczy kończy swoje działanie. Odpowiedzialne za to jest znajdujące się w pliku vault_init.sh polecenie exit 0, które wysyła sygnał zatrzymania kontenera.
Omawiany przykład pokazuje tylko jeden ze sposobów na zainicjalizowanie kontenera (danych) z wykorzystaniem kontenera pomocniczego. Należy podkreślić, że rozwiązanie jest przeznaczone wyłącznie do zastosowań developerskich. Produkcyjna konfiguracja Vaulta znacznie się różni i należy mieć tego świadomość.
W niektórych przypadkach twórcy obrazu przewidzieli możliwość inicjalizacji i jest na to gotowa metoda. Bardzo dobrym przykładem jest PostgreSQL, gdzie skrypty inicjalizujące wystarczy dodać do katalogu /docker-entrypoint-initdb.d/. Mogą to być zarówno skrypty .sql jak i .sh, które wykonają się bezpośrednio po starcie kontenera.
Artykuł Inicjalizacja kontenera za pomocą drugiego kontenera na przykładzie HashiCorp Vault pochodzi z serwisu Szkoła Dockera.
]]>Artykuł LazyDocker – czyli Docker NIE tylko dla leniwych pochodzi z serwisu Szkoła Dockera.
]]>Jak sama nazwa wskazuje, Lazy Docker to narzędzie stworzone dla osób, których męczy ciągłe wpisywanie różnych poleceń w terminalu. Zamiast ręcznie wpisywać polecenia, możemy uruchomić Lazy Docker, jednocześnie nie wychodząc z terminala. Po jego uruchomieniu otrzymujemy “klikalną” aplikację pozwalająca na podgląd i zarządzanie: lokalnych kontenerów, obrazów oraz volumenów. Dodatkowo posiada również wsparcie dla docker-compose.
Nie można by nie wspomnieć, że LazyDocker jest projektem open-source, dostępnym na GitHubie.
Narzędzie posiada wsparcie dla różnych systemów operacyjnych. Oznacza, że jesteśmy w stanie uruchomić go zarówno na Linuxie, jak i na Windowsie czy Macu. Osobiście przetestowałem działanie LazyDocker na dwóch systemach: Windows 10 Pro oraz Ubuntu 18.04. W obu przypadkach instalacja przebiegła błyskawicznie, a narzędzia działa bez żadnych problemów.
Najprostszym sposobem na zainstalowanie LazyDocker na systemach Windows, jest pobranie gotowego execa. Możemy go pobrać z oficjalnego repozytorium LazyDocker na GitHubie. W moim przypadku był to plik lazydocker_0.8_Windows_x86_64.zip
Wystarczy rozpakować pobrane archiwum .zip i umieścić lazydocker.exe w wybranym przez siebie katalogu.
UWAGA: Aby móc uruchomić LazyDocker w terminalu z dowolnel lokalizacji, polecam dodać katalog, w którym znajduje się lazydocker.exe do zmiennej środowiskowej $PATH.
Gdy już to zrobimy, wystarczy w CMD lub w Powershellu wpisać lazydocker.
W przypadku Linuxa, instalacja jest jeszcze prostsza. Wystarczy użyć następującego polecenia:
curl https://raw.githubusercontent.com/jesseduffield/lazydocker/master/scripts/install_update_linux.sh | bash
Spowoduje to pobranie oraz dodanie binarki LazyDocker do katalogu /usr/local/bin, dzięki czemu otrzymamy również możliwość uruchomienia narzędzia z dowolnej lokalizacji.
Jeżeli instalacja zakończy się pomyślnie, wystarczy w terminalu wpisać polecenie lazydocker.
Pozostaje nam tylko wpisanie polecenia lazydocker w dowolnym momencie, w którym chcemy z niego z skorzystać.
Po uruchomieniu narzędzia możemy posługiwać się zarówno myszką jak klawiaturą (jak komu będzie wygodniej). Na samym dole okienka znajduje się opis klawiszy, służących do nawigacji po programie.
Lazy Docker pozwala na podgląd zarówna działających, jak i zatrzymanych kontenerów. Oznacza to, że jesteśmy w stanie przeglądać logi, sprawdzać konfigurację, czy wyświetlić wszystkie procesy działające w kontenerze.

W zakładce „Config” możemy podejrzeć całą konfigurację kontenera, w tym też zmienne środowiskowe.
Po naciśnięciu na klawiaturze klawisza “b”, pojawia się menu, w którym mamy możliwość zatrzymania czy usunięcia wszystkich kontenerów.
Powyższy przykład jest tylko początkiem tego, co możemy zrobić za pomocą tego narzędzia. Wybierając klawisz “x” na klawiaturze pojawia nam się kolejne menu, które oferuje znacznie więcej możliwości.
Dzięki temu możemy już niemal w pełni kontrolować poszczególne kontenery, podobnie jak robimy to za pomocą poleceń w terminalu. Mianowicie: zatrzymać lub usunąć kontener, przejrzeć logi. W łatwy sposób możemy również “wejść do kontenera”. Wystarczy wybrać opcję “run predefined custom command”.
Spowoduje to wygenerowanie polecenia ‘docker exec’.
Po naciśnięciu Entera, wchodzimy do konsoli kontenera:
Chyba najlepsza opcja, jaką oferuje to narzędzie, czyli przeglądanie warstw obrazów. Oznacza to, że możemy podejrzeć z ilu i z jakich warstw składa się poszczególny obraz.

Po prawej stronie ekranu widzimy wszystkie warstwy obrazu, który zaznaczyliśmy. W większości przypadków finalny obraz korzysta z jakiegoś obrazu bazowego (instrukcja FROM). Możemy tutaj podejrzeć, jakie warstwy znajdują się w obrazie bazowym.
Jedną z kluczowych informacji, jakie tutaj możemy uzyskać, jest rozmiar poszczególnych warstw. Zwróć uwagę na instrukcję takie jak EXPOSE czy CMD. Pomimo że dla tych instrukcji tworzone są osobne warstwy, to nie wpływają one na finalny rozmiar obrazu, gdyż zajmują 0 bajtów.
Ostatnia z oferowanych przez narzędzie Lazy Docker opcja to podgląd informacji o wszystkich volumenach.

Jeżeli interesuje nas, gdzie fizycznie na dysku przechowywane są dane dla poszczególnych volumenów, to tutaj jesteśmy w stanie się tego dowiedzieć.
Oprócz wszystkich wymienionych funkcji, LazyDocker posiada również wsparcie dla docker-compose. Aby móc z niego skorzystać, należy uruchomić lazydocker z katalogu, w którym znajduje się plik docker-compose.yml
Poniżej przedstawiony został przykład WordPressa:

Potrzebujesz zrestartować którąś z usług? Wystarczy użyć „Shift + R”, a pojawi się menu z kilkoma opcjami do wyboru. Uwaga: sam klawisz „r” (bez Shift) spowoduje natychmiastowy restart kontenera.

Lazy Docker jest tylko jednym z wybranych narzędzi, które w sposób graficzny pozwalają na wyświetlanie informacji o Dockerze i zarządzanie poszczególnymi jego komponentami. Jednak jego główną zaletą jest fakt, że możemy uruchomić go bezpośrednio w terminalu. Może się to przydać szczególnie w przypadku, gdy łączymy się do zdalnego serwera po SSH i chcemy zbiorczo sprawdzić stan kontenerów czy też podglądnąć logi. Oczywiście, na zdalnym hoście również potrzebujemy go zainstalować, ale zdecydowanie nie jest wielkim problemem. Polecam! 
Artykuł LazyDocker – czyli Docker NIE tylko dla leniwych pochodzi z serwisu Szkoła Dockera.
]]>Artykuł Jak skonfigurować Docker CI/CD w mniej niż 10 minut? pochodzi z serwisu Szkoła Dockera.
]]>Jeśli zaglądasz regularnie na tego bloga (jeśli nie to czas to zmienić :P), to już pewnie wiesz, że kilka tygodni temu, Docker ogłosił roadmapę na rok 2020. Znajdziesz w niej całą masę usprawnień i feature’ów, które zostaną zaimplementowane w najbliższej przyszłości.
W 2019 roku Docker (jako firma) przeszedł dość sporą rewolucję. Kluczowym momentem była sprzedaż rozwiązania Docker Enterprise firmie Mirantis. Od tej pory Docker skupia się na rozwiązaniach dla developerów, co potwierdza wcześniej wymieniona roadmapa.
Jednym z nowych elementów było stworzenie Docker Github Action, która miała posłużyć do automatyzacji procesów CI/CD i finalnie przyjęła nazwę „build-push-action”.
Pojawia się pytanie. Dlaczego Github, a nie Gitlab, Bitbucket czy Jenkins?
Bez wątpienia Github jest najpopularniejszym miejscem w internecie dla projektów open source. Github posiada też opcję prywatnych repozytoriów, które przez dłuższy czas były dostępne tylko za odpowiednią opłatą.
Od niedawna ta opłata została zniesiona. Dzięki temu, jeżeli nie chcemy udostępniać kodu publicznie (przykładowo pracujemy nad swoim tajnym projektem / produktem) możemy skorzystać z GitHuba za darmo.
W dzisiejszych czasach stosowanie automatycznego budowania, czy automatycznego wdrażania aplikacji na różne środowiska jest standardem. Nawet dla własnych projektów, z czasem warto skonfigurować sobie taki proces.
Czas to najcenniejsze co mamy w życiu. Po co więc tracić go na rzeczy, które możemy zautomatyzować.
Do tej pory, chcąc skonfigurować automatycznie budowanie obrazu, taggowanie oraz wypchnięcie go do Docker Registry musieliśmy posługiwać się skryptami pomocniczymi, których na dodatek nie można było przetestować lokalnie. Problem ten został rozwiązany za pomocą przeznaczonej do tego akcji, którą możemy dodać jako krok w procesie ciągłej integracji (Docker CI/CD) bezpośrednio Github Marketplace.
Głównym założeniem tego rozwiązania jest po pierwsze zbudowanie obrazu, przypisanie mu odpowiedniego taga (np. nazwę branch’a czy też SHA danego commit’a), logowanie do prywatnego Docker Registry oraz wsparcie dla typowych poleceń Docker CLI takich jak określenie build context’u, czy nazwy Dockerfile’a.
Reasumując, nowo wprowadzoną akcja pozwala na:
--build-arg)Aby móc skorzystać z benefitów oferowanych przez tę akcję, potrzebujemy:
Po pierwsze: aplikacji dostępnej na Githubie, zawierającej w repozytorium plik Dockerfile.
Po drugie: Docker Registry, aby móc wypchnąć tam zbudowany obraz
Do skonfigurowania automatyzacji posłużę się jest prostym WebAPI, dostępnym na moim Githubie — oo TUTAJ.
Jako Docker Registry, skorzystam z rozwiązania oferowanego na platformie Microsoft Azure (Azure Container Registry). Utworzone Docker Registry dostępne jest pod adresem dnaprawa.azurecr.io
Niestety nie jest to darmowe rozwiązanie i wymaga to posiadania subskrypcji. Jeśli chodzi o darmowe Docker Registry, można skorzystać z TreeScale lub Canister. Ostatnio testowałem to ostanie (Canister) i póki co nie wykryłem żadnych problemów 
To tyle jeśli chodzi o wymagania wstępne. Zaczynamy ; )
Ideą prywatnych Docker Registry jest zabezpieczenie przed nieautoryzowanym dostępem do dodawania i pobierania obrazów.
Aby umożliwić komunikacje na lini Github-Registry, dodajemy sekrety DOCKER_USERNAME oraz DOCKER_PASSWORD zawierające dane do uwierzytelniania do Docker Registry.

Analogicznie dodajemy DOCKER_PASSWORD
Po dodaniu obu sekretów, powinniśmy otrzymać zbliżony efekt.

Przechodzimy następnie do repozytorium do sekcji Actions.

Następnie wybieram „Set up a workflow yourself”

W tym miejscu dodaję akcję, jako osobny krok w definicji procesu. W moim przypadku wygląda to następująco:
- name: Build and push Docker images
uses: docker/[email protected]
with:
username: ${{ secrets.DOCKER_USERNAME }}
password: ${{ secrets.DOCKER_PASSWORD }}
registry: dnaprawa.azurecr.io
repository: currency-viewer
tags: v1
# Set build context as current (root) directory
path: .Krótko mówiąc, wystarczy wskazać dane do uwierzytelniania na podstawie sekretów zdefiniowanych w poprzednim kroku oraz dodać nazwę Docker Registry i repozytorium, do którego ma trafić zbudowany obraz. Oczywiście, potrzebujemy również tag, który u mnie testowo przybrał nazwę v1. Na koniec, określamy build context. Jako że plik Dockerfile znajduje się w głównym katalogu wewnątrz repozytorium gita, ustawiam build context na bieżący katalog za pomocą path: .
Przed zatwierdzeniem zmian, całość wyglądała następująco:

Wystarczy teraz zatwierdzić zmiany (Start commit), co spowoduje utworzenie nowego pliku w katalogu ~/.github/workflows, a następnie uruchomi procesu budowania.

Proces budowania przeszedł poprawnie. Oznacza to, że obraz został zbudowany i wypchnięty do Docker Registry

Cała definicja, której użyłem wygląda następująco:
# This is a basic workflow to help you get started with Actions
name: CI
# Controls when the action will run. Triggers the workflow on push or pull request
# events but only for the master branch
on:
push:
branches: [ master ]
pull_request:
branches: [ master ]
# A workflow run is made up of one or more jobs that can run sequentially or in parallel
jobs:
# This workflow contains a single job called "build"
build:
# The type of runner that the job will run on
runs-on: ubuntu-latest
# Steps represent a sequence of tasks that will be executed as part of the job
steps:
# Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
- uses: actions/checkout@v2
- name: Build and push Docker images
uses: docker/[email protected]
with:
username: ${{ secrets.DOCKER_USERNAME }}
password: ${{ secrets.DOCKER_PASSWORD }}
registry: dnaprawa.azurecr.io
repository: currency-viewer
tags: v1
# Set build context as current (root) directory
path: .Chcąc upewnić się, że obraz został przesłany do repozytorium, należy przejść do portalu Azure:

Widzimy, że zostało stworzone repozytorium o nazwie currency-viewer (tak jak podaliśmy w definicji) oraz został dodany obraz z tagiem v1

Na potrzeby testów, tag v1 został przypisany na stałe. Jak już wcześniej wspominałem, jako tag możemy użyć numeru commit’a czy też nazwę brancha, na podstawie którego budujemy obraz.
Jak widzimy, wystarczy tylko chwila czasu (i chęci), by zautomatyzować proces budowania obrazów dockerowych. Jeżeli pracujesz nad swoim projektem „po godzinach” to koniecznie rozważ skonfigurowanie takiego procesu. Wybranie któregoś z darmowych Docker Registry sprawi, że nie będzie to Cię nic kosztować. Mając zbudowany obraz aplikacji, możesz łatwo go udostępnić — komukolwiek zechcesz. Wystarczy, by ta osoba miała zainstalowanego Dockera.
Często firmy w swoich zadaniach rekrutacyjnych proszą, aby udostępnić kod na GitHubie. Zaskocz ich pozytywnie i powiedz, że oprócz zadania, dodałeś integrację z Dockerem i skonfigurowałeś automatyczne budowania obrazów.
Artykuł Jak skonfigurować Docker CI/CD w mniej niż 10 minut? pochodzi z serwisu Szkoła Dockera.
]]>Artykuł Jak tworzyć testy jednostkowe dla obrazów dockerowych? pochodzi z serwisu Szkoła Dockera.
]]>Tak samo jak tworzymy testy jednostkowe podczas programowania aplikacji, podobnie też, możemy tworzyć testy jednostkowe dla obrazów Dockera.
W przypadku pisania testów jednostkowych dla aplikacji, ich ideą jest sprawdzenie, czy pojedyncza funkcja większego systemu działa tak, jak sobie założyliśmy. Może to być zachowanie pojedynczej metody, czy też klasy. W momencie gdy dana funkcjonalność jest rozbudowana, testy pilnują tego czy całość działa poprawnie.
To tyle tytułem wstępu. Przechodzimy do konkretów.
W przypadku obrazów dockerowych, skupiamy się na testowaniu pojedynczych plików lub funkcjonalności znajdujących się w obrazie.
Dla przykładu możemy testować:
W przypadku „standardowych” testów jednostkowych (dla aplikacji), zasadą TDD (Test Driven Development) w bardzo ogólnym skrócie brzmi: „Najpierw testy – później kod”.
W naszym przypadku (Docker), możemy przełożyć to na następujące stwierdzenie: „Najpierw testy – później kontener”. Rozwijając ten skrót – najpierw tworzymy testy dla obrazu by upewnić się, że działa tak jak to sobie założyliśmy, a dopiero poźniej tworzymy kontener na podstawie tego obrazu.
Wydaje się proste? Zachęcam do oglądania oraz zasubskrybowania kanału!
Szczególnie poleciłbym tworzenie testów jednostkowych podczas pracy w zespole. Ze swojego doświadczenia wiem, że w większym zespole takie testy często weryfikują przypadkowe błędy. Przede wszystkim mam tutaj na myśli wszelkiego rodzaju literówki oraz błędy spowodowane nieznajomością wiedzy na temat tworzenia plików Dockerfile… 
Innym powodem dla którego warto to robić, jest auto-dokumentacja naszych założeń. Przeglądając takie testy, możemy szybko przypomnieć sobie jakie były początkowe zamiary co do obrazu naszej aplikacji.
Przykładowo:
775curlArtykuł Jak tworzyć testy jednostkowe dla obrazów dockerowych? pochodzi z serwisu Szkoła Dockera.
]]>Artykuł Zmienne środowiskowe w Dockerze pochodzi z serwisu Szkoła Dockera.
]]>Z artykułu dowiesz się WSZYSTKO na temat zmiennych środowiskowych w Dockerze. Oczywiście wszystko na przykładach, tak by łatwiej było zrozumieć, a następnie móc zastosować u siebie.
Post ten jest kontynuacją serii, w której opisują poszczególne instrukcje Dockerfile. Jeżeli jeszcze nie widziałeś, koniecznie sprawdź COPY vs ADD oraz CMD vs ENTRYPOINT.
Wewnątrz pliku Dockerfile, instrukcja ENV służy do tworzenia zmiennych środowiskowych. Podczas uruchamiania kontenera na podstawie obrazu, możemy nadpisać ich wartość. Taka praktyka jest bardzo często stosowana.
Do czego mogą służyć zmienne środowiskowe? Niemal każda aplikacja ma jakąś konfigurację.
Przykłady:
Jeżeli tworzysz kontener korzystając z terminala, do nadpisania lub ustawienia zmiennej środowiskowej służy argument -e KLUCZ=WARTOŚĆ. Poniżej tworzymy kontener WordPressa, przekazując w zmiennych środowiskowych połączenie do bazy danych.
docker run -e WORDPRESS_DB_HOST=10.1.2.3:3306 \
-e WORDPRESS_DB_USER=user \
-e WORDPRESS_DB_PASSWORD=somepassword \
-d wordpressTen sam efekt możesz uzyskać wewnątrz pliku docker-compose.yml
version: '3.1'
services:
wordpress:
image: wordpress
environment:
- WORDPRESS_DB_HOST: 10.1.2.3:3306
- WORDPRESS_DB_USER: user
- WORDPRESS_DB_PASSWORD: somepassword
- WORDPRESS_DB_NAME: exampledbIstnieją pewne przypadki, dla których na stałe chcemy ustawić zmienną środowiskową. Jak już wyżej wspominałem, może dotyczyć to technologii, w której tworzymy aplikację. Przykładowo, chcemy na stałe ustawić zmienną środowiskową NODE_VERSION. Przykład poniżej.
FROM scratch
# set up node
ENV NODE_VERSION 8.9.4
ENV NODE_DOWNLOAD_SHA 21fb4690e349f82d708ae766def01d7fec1b085ce1f5ab30d9bda8ee126ca8fc
RUN curl -SL "https://nodejs.org/dist/v${NODE_VERSION}/node-v${NODE_VERSION}-linux-x64.tar.gz" --output nodejs.tar.gz \
&& echo "$NODE_DOWNLOAD_SHA nodejs.tar.gz" | sha256sum -c - \
&& tar -xzf "nodejs.tar.gz" -C /usr/local --strip-components=1 \
&& rm nodejs.tar.gz \
&& ln -s /usr/local/bin/node /usr/local//nodejsIstnieje możliwość stworzenia pliku o nazwie .env. Zawartość tego pliku może posłużyć do nadpisania wartości znajdujących się w pliku docker-compose.yml. Warto zaznaczyć, że oba pliki muszą znajdować się w tym samym katalogu.
Zawartość pliku .env defniujemy za pomocą schematu klucz=wartość
DB_PORT=5434 DB_USER=myuser
Przykład pliku docker-compose, gdzie to zadziała. Zwróć uwagę w jaki sposób określamy, że zmienna ma zostać podstawiona. Jest to składnia ${DB_PORT} oraz ${DB_USER}
version: '3.2'
services:
postgres:
image: postgres:9.6
ports:
- ${DB_PORT}:5432
environment:
POSTGRES_PASSWORD: secretpassword
POSTGRES_USER: ${DB_USER}Aby upewnić się, że wartości są podstawiane prawidłowo wystarczy użyć komendy docker-compose config
$ docker-compose config
services:
postgres:
environment:
POSTGRES_PASSWORD: secretpassword
POSTGRES_USER: myuser
image: postgres:9.6
ports:
- published: 5434
target: 5432
version: '3.2'
W miejsce ${DB_USER} została podstawiona wartość myuser, a w miejsce ${DB_PORT} wartość 5434. Wartości te pochodzą z pliku .env. Warto podkreślić, że oba pliki muszą znajdować się w tym samym katalogu.
Plik docker-compose.yml jest dodawany do kontroli wersji, natomiast plik .env już nie. Dzięki temu, każdy z członków zespołu może mieć inną zawartość pliku .env według własnych potrzeb, co nie będzie powodować żadnych zmian w repozytorium.
Jeżeli na hoście istnieje zmienna o takiej samej nazwie jak wewnątrz pliku .env, wartość zostanie pobrana z zmiennej środowiskowej hosta! Sprawdźmy to na przykładzie. Na hoście ustawiłem wartość zmiennej środowiskowej JAVA_HOME na C:\Program Files\Java\jdk1.8.0_221
Mamy następujące plik docker-compose.yml, w którym odwołujemy się do ${JAVA_HOME}
version: '3.2'
services:
myapp:
image: openjdk:7
environment:
JAVA_DIRECTORY: ${JAVA_HOME}W tym samym katalogu znajduje się również plik .env zawierający zmienną JAVA_HOME=D:/java
JAVA_HOME=D:/java
Teraz pozostaje sprawdzić całość za pomocą polecenia docker-compose config
$ docker-compose config
services:
myapp:
environment:
JAVA_DIRECTORY: C:\Program Files\Java\jdk1.8.0_221
image: openjdk:7
version: '3.2'Rezulat? Zamiast wartości zdefiniowanej w pliku .env, została podstawiona wartość zmiennej środowiskowej z hosta! (C:\Program Files\Java\jdk1.8.0_221)
Nie można było o tym nie wspomnieć. Definiując zmienną środowiskową wewnątrz terminala, ma ona najwyższy priorytet.
Ustawiamy zmienną środowiskową (system Windows):
$ set JAVA_HOME=D:\shell_variable_path
Obecny stan zmiennych o nazwie JAVA_HOME:
Tradycyjnie sprawdzamy rezultat poleceniem docker-compose config
$ docker-compose config
services:
myapp:
environment:
JAVA_DIRECTORY: D:\shell_variable_path
image: openjdk:7
version: '3.2'Tym sposobem mamy potwierdzenie, iż zmienne środowiskowe zdefiniowane w terminalu mają najwyższy priorytet!
UWAGA: Plik .env nie ma nic wspólnego z instrukcjami ENV wewnątrz Dockerfile oraz argumentem `-e` w terminalu! Oznacza to, że wartości zdefiniowane w pliku .env, NIE trafią bezpośrednio do kontenera, a służą tylko do podstawiania wartości w pliku docker-compose.yml
Po zbudowaniu obrazu, możemy uruchamiać kontenery i przekazywać do nich zmienne środowiskowe na kilka sposobów. W każdym przypadku, spowoduje to nadpisanie domyślnych wartości zdefiniowanych w Dockerfile.
Jak to działa? Standardowo korzystamy z argumentu -e, ale z małą różnicą. Podajemy tylko nazwę zmiennej, bez wartości. W ten sposób docker pobiera zmienną środowiskową zdefiniowaną w terminalu (jeżeli istnieje) lub w systemie hosta.
Obecnie w terminalu wartość zmiennej JAVA_HOME=D:\shell_variable_path
Uruchamiamy kontener w trybie interaktywnym z konsolą, wskazując -e JAVA_HOME. Następnie wewnątrz kontenera, wyświetlamy zawartość zmiennej.
$ docker run -it -e JAVA_HOME alpine sh / # $JAVA_HOME sh: D:\shell_variable_path
Widzimy, że wewnątrz kontenera została podstawiona wartość z hosta (a dokładnie z terminala hosta).
Tworzymy plik o dowolnej nazwie, a jego zawartość powinna opierać się o wpisach typu klucz=wartość. Dla przykładu, plik ten będzie miał nazwę my_env_file (bez żadnego rozszerzenia), a jego zawartość będzie następująca:
VARIABLE_NAME=variable_value
Uruchamiamy kontener z parametrem env (spowoduje wyświetlenie wszystkich zmiennych środowiskowych) wskazując na plik my_env_file:
$ docker run --env-file=my_env_file alpine env PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin HOSTNAME=77929624bad0 VARIABLE_NAME=variable_value HOME=/root
Możemy również wykorzystać to samo podejście w pliku docker-compose.yml, dodając wpis env_file: <ścieżka_do_pliku>
version: '3.2'
services:
alpine:
image: alpine
env_file: my_env_fileStosowanie zmiennych środowiskowych w Dockerze jest czymś naturalnym i często wykorzystywanym. Na przykładzie WordPressa widzimy, że nawet oficjalne obrazy, które możemy znaleźć na Docker Hubie stosują ten mechanizm. Warto go zatem znać i rozumieć jak działa.
Mam nadzieję, że nieco pomogłem zrozumieć Ci jak działają zmienne środowiskowe w Dockerze, lub bynajmniej post ten spowodował odświeżenie Twojej dotychczasowej wiedzy. Ważne, że w razie wątpliwości można tutaj wrócić i rozwiać swoje wątpliwości, do czego gorąco zachęcam!
Artykuł Zmienne środowiskowe w Dockerze pochodzi z serwisu Szkoła Dockera.
]]>Artykuł Docker Contexts – czyli jak ułatwić sobie życie pochodzi z serwisu Szkoła Dockera.
]]>Jeżeli zdarzyło Ci się uruchamiać skonteneryzowaną aplikację w innym miejscu niż tylko na Twoim komputerze, to ten post jest zdecydowania dla Ciebie!
Wykorzystując Docker Contexts, pokażę Ci jak ułatwić sobie życie i nie musieć za każdym razem łączyć się do serwera docelowego gdzie działa Docker i Twoja aplikacja.
Często istnieje potrzeba, aby podejrzeć co dzieje się w danym momencie na serwerze, na którym wdrożyliśmy aplikację przy wykorzystaniu Dockera. Szczególnie w początkowej fazie projektu, gdzie nie mamy jeszcze w pełni skonfigurowanego monitoringu, zasadnym jest sprawdzanie przynajmniej stanu zużycia zasobów (docker stats). Jeśli chcesz wiedzieć więcej na temat monitoringu, zajrzyj TUTAJ.
W momencie, gdy mamy kilka środowisk (dev, staging, prod) – za każdym razem musimy przełączać się pomiędzy serwerami.
Standardowa procedura jest następująca:
$ ssh user@destinationhost $ docker ps -a $ docker stats --no-stream $ exit
Mechanizm, który jest głównym powodem tego posta — Docker Contexts. Dzięki niemu, z lokalnej maszyny (np. Twojego laptopa) możesz zarządzać Dockerem na zdalnych hostach. Co ważne, może to być zwykły Docker, klaster Docker Swarm oraz klaster Kubernetes (!).
Najważniejszą zaletą tego rozwiązania jest możliwość definiowania wielu contextów i ich odpowiedniego nazywania.

Załóżmy, że masz dostęp do serwera developerskiego i do stagingowego. Wystarczy zdefiniować dwa contexty: dev i staging — oczywiście za pomocą Docker CLI (coś, co znasz i używasz na co dzień).
Sprawdźmy zatem jak to działa 
$ docker context --help Usage: docker context COMMAND Manage contexts Commands: create Create a context export Export a context to a tar or kubeconfig file import Import a context from a tar or zip file inspect Display detailed information on one or more contexts ls List contexts rm Remove one or more contexts update Update a context use Set the current docker context
Jeżeli nigdy wcześniej nie definiowałeś nowych contextów, domyślnie posiadasz jeden:
$ docker context ls NAME DESCRIPTION DOCKER ENDPOINT ORCHESTRATOR default * Current DOCKER_HOST based configuration npipe:////./pipe/docker_engine swarm
Należy wspomnieć, że Docker Contexts do komunikacji pomiędzy lokalną maszyną a zdalnym hostem wykorzystuje połączenie SSH. Zanim zaczniesz zabawę z Docker Contexts, potrzebujesz skonfigurować połączenie z Twoim lokalnym komputerem, a hostem docelowym za pomocą SSH z wykorzystaniem kluczy. Jeżeli nie wiesz jak to zrobić, możesz spojrzeć na ten artykuł.
UWAGA: Od jakiegoś czasu SSH jest dostępne również na Windowsie – sam z tego korzystam na co dzień 
Tworzymy nowy Docker Context, o nazwie dev-context
$ docker context create dev-context --docker "host=ssh://user@remote_host" dev-context Successfully created context "dev-context" $ docker context ls NAME DESCRIPTION DOCKER ENDPOINT ORCHESTRATOR default * Current DOCKER_HOST based configuration npipe:////./pipe/docker_engine swarm dev-context ssh://user@remote_host
OK, mamy to. Możemy zacząć korzystać z dev-context.
Przykładowo, chciałbym wyświetlić aktualny stan zużycia zasobów na zdalnym hoście.
$ docker --context dev-context stats --no-stream CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O f12209c30718 caddy 0.00% 2.52MiB / 1.861GiB 0.13% 2.1kB / 0B 10.8MB / 0B a6059f35f030 cadvisor 18.40% 67.84MiB / 1.861GiB 3.56% 1.4MB / 63.8MB 22MB / 0B 671da3a620d3 alertmanager 0.05% 16.56MiB / 1.861GiB 0.87% 270kB / 103kB 19.4MB / 24.6kB ea0d74500b38 grafana 0.01% 28.07MiB / 1.861GiB 1.47% 145kB / 39.1kB 38.5MB / 242kB 5b951fe4f274 nodeexporter 0.00% 13.75MiB / 1.861GiB 0.72% 582kB / 11.3MB 11.1MB / 0B 78a69302bb2c prometheus 2.17% 85.43MiB / 1.861GiB 4.48% 76.1MB / 2.31MB 223MB / 48.7MB 9591d2576885 pushgateway 0.00% 12.3MiB / 1.861GiB 0.65% 217kB / 978kB 12MB / 0B
Idąc krok dalej, możemy ustawić dev-context jako domyślny. To pozwoli na uruchamianie wszystkich komend CLI bezpośrednio na zdalnym hoście, bez konieczności wskazywania na dev-context
Aby to zrobić wystarczy użyć następującej komendy:
$ docker context use dev-context dev-context Current context is now "dev-context" $ docker stats --no-stream CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O f12209c30718 caddy 0.00% 2.52MiB / 1.861GiB 0.13% 2.1kB / 0B 10.8MB / 0B a6059f35f030 cadvisor 18.40% 67.84MiB / 1.861GiB 3.56% 1.4MB / 63.8MB 22MB / 0B 671da3a620d3 alertmanager 0.05% 16.56MiB / 1.861GiB 0.87% 270kB / 103kB 19.4MB / 24.6kB ea0d74500b38 grafana 0.01% 28.07MiB / 1.861GiB 1.47% 145kB / 39.1kB 38.5MB / 242kB 5b951fe4f274 nodeexporter 0.00% 13.75MiB / 1.861GiB 0.72% 582kB / 11.3MB 11.1MB / 0B 78a69302bb2c prometheus 2.17% 85.43MiB / 1.861GiB 4.48% 76.1MB / 2.31MB 223MB / 48.7MB 9591d2576885 pushgateway 0.00% 12.3MiB / 1.861GiB 0.65% 217kB / 978kB 12MB / 0B
Najnowsza wersja (1.26.0-rc2) docker-compose otrzymała wsparcie dla Docker Contexts. Dzięki temu możemy zdalnie uruchamiać polecenia specyficzne dla docker-compose na wielu maszynach.
Najnowszą wersję możesz pobrać TUTAJ. Wystarczy podmienić aktualny plik wykonywalny, na ten, który pobierzemy.
Przykładowo, na Windowsie plik wykonywalny docker-compose.exe znajduje się w C:\Program Files\Docker\Docker\resources\bin
Wystarczy zatem pobrać i podmienić plik .exe
Do celów testowych wykorzystamy WordPressa i MySQL. Stwórz lokalnie plik docker-compose.yml na podstawie tego linku.
Wykonaj lokalnie poniższe polecenie.
$ docker context use dev-context dev-context Current context is now "dev-context" $ docker-compose up -d Creating network "wp_default" with the default driver Creating volume "wp_db_data" with default driver Creating wp_db_1 ... done Creating wp_wordpress_1 ... Done
Tym sposobem wdrożyliśmy Wordpressa na zdalnym hoście, wykorzystując Docker Contexts oraz docker-compose.
$ docker-compose ps
Name Command State Ports
-------------------------------------------------------------------------------
wp_db_1 docker-entrypoint.sh mysqld Up 3306/tcp, 33060/tcp
wp_wordpress_1 docker-entrypoint.sh apach ... Up 0.0.0.0:8000->80/tcpMożemy to powtórzyć na innych środowiskach. Wystarczy zdefiniować nowy context, następnie ustawić go jako domyślny i wykonać polecenie docker-compose up -d
Artykuł Docker Contexts – czyli jak ułatwić sobie życie pochodzi z serwisu Szkoła Dockera.
]]>