Development – Szkoła Dockera https://szkoladockera.pl Najlepsze miejsce dla entuzjastów konteneryzacji i Dockera Fri, 03 Jul 2020 08:51:00 +0000 pl-PL hourly 1 https://wordpress.org/?v=5.7.21 https://szkoladockera.pl/wp-content/uploads/2019/07/cropped-Shelftons-5-32x32.png Development – Szkoła Dockera https://szkoladockera.pl 32 32 MySQL & phpMyAdmin z poziomu Dockera https://szkoladockera.pl/mysql-phpmyadmin-z-poziomu-dockera/ https://szkoladockera.pl/mysql-phpmyadmin-z-poziomu-dockera/#respond Fri, 03 Jul 2020 07:18:23 +0000 https://szkoladockera.pl/?p=1970 Baza Danych w Dockerze 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 Dowiedz się więcej

Artykuł MySQL & phpMyAdmin z poziomu Dockera pochodzi z serwisu Szkoła Dockera.

]]>
Baza Danych w Dockerze

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.


Jak do tego podejść?

Pierwsza sprawa.

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! ; )

Druga sprawa

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.


Krok pierwszy: stworzenie nowej sieci

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.


Krok drugi: uruchomienie kontenera MySQL

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

Szybki komentarz do przekazanych w docker container run argumentów:

  • --name mysql określa nazwę kontenera
  • restart=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.


Krok trzeci: Uruchomienie phpMyAdmin

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.


MySQL & phpMyAdmin w docker-compose

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.

MySQL docker

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)

phpmyadmin docker

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 docker mysql

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


Połączenie z phpMyAdmin do zewnętrznej bazy danych

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.

Podsumowanie

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.

]]>
https://szkoladockera.pl/mysql-phpmyadmin-z-poziomu-dockera/feed/ 0
Docker i Ngrok – publikacja kontenera w internecie https://szkoladockera.pl/docker-ngrok-publikacja-kontenera-w-internecie/ https://szkoladockera.pl/docker-ngrok-publikacja-kontenera-w-internecie/#comments Fri, 26 Jun 2020 05:55:02 +0000 https://szkoladockera.pl/?p=1933 Docker i Ngrok 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. Wyzwanie Naniosłeś jakieś zmiany w Dowiedz się więcej

Artykuł Docker i Ngrok – publikacja kontenera w internecie pochodzi z serwisu Szkoła Dockera.

]]>
Docker i Ngrok

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.

Wyzwanie

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.

Jeszcze lepszy przykład

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

Ngrok – co to jest?

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!

Docker i Ngrok – pierwsze kroki

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.

Lokalny development aplikacji

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:

  • Tworzenie własnych obrazów
  • narzędzia wspomagające pracę z Dockerem
  • bezpieczeństwo,
  • orkiestracja
  • zagadnienia DevOps
  • …i wiele, wiele więcej

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 = appRouter

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

Spróbuj samodzielnie

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.

]]>
https://szkoladockera.pl/docker-ngrok-publikacja-kontenera-w-internecie/feed/ 2
Komunikacja kontenerów – sieć typu bridge https://szkoladockera.pl/komunikacja-kontenerow-siec-typu-bridge/ https://szkoladockera.pl/komunikacja-kontenerow-siec-typu-bridge/#respond Wed, 24 Jun 2020 08:12:18 +0000 https://szkoladockera.pl/?p=1921 Komunikacja kontenerów 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 Dowiedz się więcej

Artykuł Komunikacja kontenerów – sieć typu bridge pochodzi z serwisu Szkoła Dockera.

]]>
Komunikacja kontenerów

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.

Czego się dowiem?


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.

]]>
https://szkoladockera.pl/komunikacja-kontenerow-siec-typu-bridge/feed/ 0
Tworzenie lekkich i optymalnych obrazów dockerowych https://szkoladockera.pl/tworzenie-lekkich-i-optymalnych-obrazow-dockerowych/ https://szkoladockera.pl/tworzenie-lekkich-i-optymalnych-obrazow-dockerowych/#respond Wed, 17 Jun 2020 08:24:12 +0000 https://szkoladockera.pl/?p=1869 Tworzenie obrazów dockerowych 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 Dowiedz się więcej

Artykuł Tworzenie lekkich i optymalnych obrazów dockerowych pochodzi z serwisu Szkoła Dockera.

]]>
Tworzenie obrazów dockerowych

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

Zacznij od ustalenia konkretnej wersji obrazu bazowego

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.

Poszukaj minimalnego obrazu bazowego

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.

Korzystaj z pliku .dockerignore

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

Już to wiem, ale jak ogarnąć resztę?

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.

]]>
https://szkoladockera.pl/tworzenie-lekkich-i-optymalnych-obrazow-dockerowych/feed/ 0
Inicjalizacja kontenera za pomocą drugiego kontenera na przykładzie HashiCorp Vault https://szkoladockera.pl/inicjalizacja-kontenera-za-pomoca-drugiego-kontenera-na-przykladzie-hashicorp-vault/ https://szkoladockera.pl/inicjalizacja-kontenera-za-pomoca-drugiego-kontenera-na-przykladzie-hashicorp-vault/#comments Thu, 30 Apr 2020 06:04:38 +0000 https://szkoladockera.pl/?p=1806 Inicjalizacja danych kontenera to zagwozdka, z którą spotyka się wiele osób. Przeglądając pytania na forach i grupach tematycznych, jak i otrzymując wiadomości na priv, zauważyłem, że jest to dość powszechny problem. Postanowiłem więc odpowiedzieć na to w formie blog posta, abyś i Ty mógł/mogła z tego skorzystać. Dzisiejszy wpis dotyczyć Dowiedz się więcej

Artykuł Inicjalizacja kontenera za pomocą drugiego kontenera na przykładzie HashiCorp Vault pochodzi z serwisu Szkoła Dockera.

]]>
Inicjalizacja danych kontenera to zagwozdka, z którą spotyka się wiele osób. Przeglądając pytania na forach i grupach tematycznych, jak i otrzymując wiadomości na priv, zauważyłem, że jest to dość powszechny problem. Postanowiłem więc odpowiedzieć na to w formie blog posta, abyś i Ty mógł/mogła z tego skorzystać. Dzisiejszy wpis dotyczyć będzie inicjalizacji danych kontenera za pomocą innego kontenera. Całość zostanie omówiona na przykładzie popularnego obecnie narzędzia — jakim jest HashiCorp Vault.

Wprowadzenie

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.

Opis problemu

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.

Inicjalizacja kontenera
Źródło https://unsplash.com

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.

HashiCorp Vault z poziomu Dockera

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.

Kontener pomocniczy

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.

Inicjalizacja kontenera – rozwiązanie

Na ten moment w głównym katalogu projektu znajdują się trzy pliki. 

Docker

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-dev

Na 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 kontenerami

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.

Podsumowanie

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.

]]>
https://szkoladockera.pl/inicjalizacja-kontenera-za-pomoca-drugiego-kontenera-na-przykladzie-hashicorp-vault/feed/ 2
LazyDocker – czyli Docker NIE tylko dla leniwych https://szkoladockera.pl/lazydocker-czyli-docker-nie-tylko-dla-leniwych/ https://szkoladockera.pl/lazydocker-czyli-docker-nie-tylko-dla-leniwych/#respond Thu, 23 Apr 2020 06:40:21 +0000 https://szkoladockera.pl/?p=1770 Docker kojarzony jest głównie z terminalem, a co za tym idzie — wpisywaniem poleceń służących do uruchamiania kontenerów i zarządzania nimi. Czy można tego uniknąć i nie wpisywać tych wszystkich poleceń manualnie? Odpowiedź brzmi: TAK. Istnieje wiele narzędzi pozwalających zarządzanie Dockerem z poziomu GUI. Dzisiaj chciałbym pokazać narzędzie, które może Dowiedz się więcej

Artykuł LazyDocker – czyli Docker NIE tylko dla leniwych pochodzi z serwisu Szkoła Dockera.

]]>
Docker kojarzony jest głównie z terminalem, a co za tym idzie — wpisywaniem poleceń służących do uruchamiania kontenerów i zarządzania nimi. Czy można tego uniknąć i nie wpisywać tych wszystkich poleceń manualnie? Odpowiedź brzmi: TAK. Istnieje wiele narzędzi pozwalających zarządzanie Dockerem z poziomu GUI. Dzisiaj chciałbym pokazać narzędzie, które może być ciekawą alternatywą lub po prostu dodatkiem dla terminala. Mowa tutaj o narzędziu — LazyDocker.

Czym jest Lazy Docker?

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.

Instalacja Lazy Docker

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.

Instalacja na Windows 

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.  

Instalacja na Linuxie

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. 


Jak używać Lazy Docker?

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.

Podgląd stanu kontenerów

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:


Przeglądanie warstw obrazów

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.

Podgląd volumenó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ć.

Wsparcie dla docker-compose

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:

docker-compose

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.


Podsumowanie

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.

]]>
https://szkoladockera.pl/lazydocker-czyli-docker-nie-tylko-dla-leniwych/feed/ 0
Jak skonfigurować Docker CI/CD w mniej niż 10 minut? https://szkoladockera.pl/jak-skonfigurowac-docker-ci-cd-w-mniej-niz-10-minut/ https://szkoladockera.pl/jak-skonfigurowac-docker-ci-cd-w-mniej-niz-10-minut/#comments Thu, 16 Apr 2020 05:40:19 +0000 https://szkoladockera.pl/?p=1711 Dzisiejszy wpis porusza kwestie automatyzacji, a dokładniej skonfigurowanie procesu budowania obrazów dockerowych (Docker CI/CD) przy wykorzystaniu nowo wprowadzonej funkcjonalności — Docker Github Action. Dodatkowo dowiesz się o planach rozwoju Dockera na rok 2020. Road Mapa Dockera na rok 2020 Jeśli zaglądasz regularnie na tego bloga (jeśli nie to czas to zmienić :P), to już pewnie wiesz, że kilka Dowiedz się więcej

Artykuł Jak skonfigurować Docker CI/CD w mniej niż 10 minut? pochodzi z serwisu Szkoła Dockera.

]]>
Dzisiejszy wpis porusza kwestie automatyzacji, a dokładniej skonfigurowanie procesu budowania obrazów dockerowych (Docker CI/CD) przy wykorzystaniu nowo wprowadzonej funkcjonalności — Docker Github Action. Dodatkowo dowiesz się o planach rozwoju Dockera na rok 2020.


Road Mapa Dockera na rok 2020

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


Dlaczego CI/CD na Githubie?

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


Jak działa Docker Github Action?

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:

  • Nadawanie obrazom tagów na podstawie referencji gitowych (pull requesty, branche, tagi)
  • Nadawanie obrazom tagów na podstawie commitów (SHA) mogących przydać się w bardziej złożonych procesach CI/CD.
  • Przekazywanie argumentów do Dockerfile (--build-arg)
  • Uwierzytelnianie do prywatnych Docker Registry
  • Warunkowe wypychanie obrazów do Docker Registry.
    Przykładowo, chcemy by obraz został wypchnięty do Docker Registry tylko po dodaniu nowego taga w repozytorium gita.


Docker CI/CD na Githubie – Przykład

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 ; )


1. Sekrety do prywatnego Docker Registry

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.

Tworzenie sekretów dla Docker Regsitry na Githubie

Analogicznie dodajemy DOCKER_PASSWORD

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

Tworzenie sekretów dla Docker Regsitry na Githubie

2. Dodanie akcji

Przechodzimy następnie do repozytorium do sekcji Actions.

Dodanie Docker Github Action

Następnie wybieram „Set up a workflow yourself”

Docker CI/CD

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


3. Zatwierdzenie zmian

Przed zatwierdzeniem zmian, całość wyglądała następująco:

Docker CI/CD - konfiguracja

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

Docker CI/CD - konfiguracja

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

Docker CI/CD - budowanie obrazów

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

4. Weryfikacja Docker Registry

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.


Podsumowanie

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.

]]>
https://szkoladockera.pl/jak-skonfigurowac-docker-ci-cd-w-mniej-niz-10-minut/feed/ 2
Jak tworzyć testy jednostkowe dla obrazów dockerowych? https://szkoladockera.pl/jak-tworzyc-testy-jednostkowe-dla-obrazow-dockerowych/ https://szkoladockera.pl/jak-tworzyc-testy-jednostkowe-dla-obrazow-dockerowych/#respond Thu, 09 Apr 2020 05:51:35 +0000 https://szkoladockera.pl/?p=1674 Dzisiaj dla odmiany, zamiast formy tekstowej mam dla Ciebie wideo. Temat dosyć niszowy, ale warty uwagi, czyli Docker i testy jednostkowe. Oglądając to wideo, dowiesz się, dlaczego warto tworzyć testy jednostkowe dla obrazów oraz przede wszystkim nauczysz się jak to robić! Film skupia się głównie na praktyce, czyli na pisaniu Dowiedz się więcej

Artykuł Jak tworzyć testy jednostkowe dla obrazów dockerowych? pochodzi z serwisu Szkoła Dockera.

]]>
Dzisiaj dla odmiany, zamiast formy tekstowej mam dla Ciebie wideo. Temat dosyć niszowy, ale warty uwagi, czyli Docker i testy jednostkowe. Oglądając to wideo, dowiesz się, dlaczego warto tworzyć testy jednostkowe dla obrazów oraz przede wszystkim nauczysz się jak to robić! Film skupia się głównie na praktyce, czyli na pisaniu testów i ich uruchamianiu.


Testy jednostkowe – po co to komu?

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.


Testy jednostkowe obrazó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ć:

  • istnienie i zawartość plików
  • wartości zmiennych środowiskowych
  • poprawność działania narzędzi
  • dystrybucję systemu operacyjnego


Najpierw testy – później kontener

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!


Kiedy warto tworzyć testy jednostkowe dla obrazów?

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:

  • plik A powinien znajdować się w obrazie w katalogu X
  • plik A powinien mieć prawa dostępu 775
  • plik A powinien zawierać frazę o nazwie „ConnectionString”
  • framework niezbędny do działania naszej aplikacji powinien być w wersji X
  • w obrazie powinno znajdować się narzędzie curl
PS. Narzędzie, które wykorzystuję do tworzenia testów to Container Structure Test. Jest to kolejne narzędzie ze stajni Google’a.


Artykuł Jak tworzyć testy jednostkowe dla obrazów dockerowych? pochodzi z serwisu Szkoła Dockera.

]]>
https://szkoladockera.pl/jak-tworzyc-testy-jednostkowe-dla-obrazow-dockerowych/feed/ 0
Zmienne środowiskowe w Dockerze https://szkoladockera.pl/zmienne-srodowiskowe-w-dockerze/ https://szkoladockera.pl/zmienne-srodowiskowe-w-dockerze/#respond Thu, 19 Mar 2020 07:08:15 +0000 https://szkoladockera.pl/?p=1508 Przeglądając grupy tematyczne związane z Dockerem, zauważyłem, że wiele osób ma problem z zrozumieniem, w jaki sposób można przekazywać zmienne środowiskowe do obrazu i do kontenera. Zmotywowało mnie to do stworzenia tego artykułu. Z artykułu dowiesz się WSZYSTKO na temat zmiennych środowiskowych w Dockerze. Oczywiście wszystko na przykładach, tak by Dowiedz się więcej

Artykuł Zmienne środowiskowe w Dockerze pochodzi z serwisu Szkoła Dockera.

]]>
Przeglądając grupy tematyczne związane z Dockerem, zauważyłem, że wiele osób ma problem z zrozumieniem, w jaki sposób można przekazywać zmienne środowiskowe do obrazu i do kontenera. Zmotywowało mnie to do stworzenia tego artykułu.

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.


Zastosowania instrukcji ENV

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:

  • adres IP do bazy danych
  • adres IP do innych usług (Elasticsearch, Vault etc.)
  • zmienne związane z technologią (NODE_ENV, JAVA_VERSION etc)
  • zmienne związane z logiką biznesową


Sposoby na przekazywanie zmiennych środowiskowych

1. Uruchamianie kontenera z terminala

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 wordpress

2. Uruchamianie z pomocą docker-compose

Ten 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: exampledb

3. Bezpośrednio w Dockerfile

Istnieją 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//nodejs


Stosowanie plików .env

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

Gdzie takie podejście może mieć zastosowanie?

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.


Zmienne środowiskowe na hoście nadpisują wpisy w pliku .env

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)


Zmienne w terminalu nadpisują wszystko

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:

  • na hoście: C:\Program Files\Java\jdk1.8.0_221
  • w pliku .env:  D:\java
  • w terminalu: D:\shell_variable_path

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


Inne sposoby na przekazywanie zmiennych środowiskowych do kontenera

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.

1. Zmienne środowiskowe z hosta

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

2. Wartości z pliku (env_file)

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_file


Podsumowanie

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

]]>
https://szkoladockera.pl/zmienne-srodowiskowe-w-dockerze/feed/ 0
Docker Contexts – czyli jak ułatwić sobie życie https://szkoladockera.pl/docker-contexts-czyli-jak-ulatwic-sobie-zycie/ https://szkoladockera.pl/docker-contexts-czyli-jak-ulatwic-sobie-zycie/#respond Thu, 05 Mar 2020 07:06:59 +0000 https://szkoladockera.pl/?p=1320 Docker Contexts – czyli jak ułatwić sobie życie 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 Dowiedz się więcej

Artykuł Docker Contexts – czyli jak ułatwić sobie życie pochodzi z serwisu Szkoła Dockera.

]]>
Docker Contexts – czyli jak ułatwić sobie życie

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.

Opis Problemu

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:

  1. Loguję się za pomocą SSH do serwera docelowego
  2. Sprawdzam stan kontenerów / stan zużycia zasobów
  3. Wykonuję jakieś akcje
  4. Zamykam połączenie SSH
$ ssh user@destinationhost
$ docker ps -a
$ docker stats --no-stream
$ exit


Docker Contexts

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.

Docker Contexts - deploy na zdalnych hostach
Obrazowe przedstawienie Docker Contexts.

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


Jak tworzyć i używać contexty

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       


Zmiana domyślnego contextu

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       


Wsparcie dla docker-compose

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 🙂

Przykład użycia

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/tcp

Moż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.

]]>
https://szkoladockera.pl/docker-contexts-czyli-jak-ulatwic-sobie-zycie/feed/ 0