1. Podstawy

1.1. Hello World w świecie Dockera

1. docker run hello-world

   • docker - komenda uruchamiająca klienta dockerowego
   • run - komenda dla klienta dockerowego oznaczająca uruchomienie kontenera
   • hello-world nazwa obrazu, z którego ma być stworzony kontener

2. A teraz bardziej interaktywnie:
   docker run -it busybox sh
   Wykonaj jakieś polecenia, np. cat /etc/resolv.conf. Z kontenera możesz wyjść wpisując komendę exit.

3. W końcu przejdźmy na ciemną stronę mocy:
   docker run -d busybox sh -c "while true; do echo hello world; sleep 1; done"

   • Sprawdźmy co się dzieje komendą docker ps. Jeżeli chcesz zobaczyć wszystkie kontenery, a nie tylko działające, użyj opcji -a.
   • Podejrzyj standardowe wyjście z kontenera po wydaniu polecenia docker logs <id_kontenera/nazwa_kontenera>.
   • Zatrzymaj kontener komendą docker stop <id_kontenera/nazwa_kontenera> i sprawdź odpowiednią komendą, czy na pewno już nie działa.

1.2. Znajdźmy "winowajcę"

1. W głównym repozytorium dockera znajdź obraz whalesay (docker/whalesay).
2. Przeczytaj opis obrazu i wykonaj przykładową komendę uruchomieniową zawartą w opisie.
3. Następnie spróbuj podać własne słowo w dymku. Czy można podać więcej słów?

1.3. Jakie mamy teraz pobrane obrazy?

W celu odpowiedzi na to pytanie wykonaj polecenie docker images. Ile widzisz obrazów?

1.4. Weźmy sprawy w swoje ręce

1. Stwórz plik Dockerfile z następującą zawartością

   # Obrazem bazowym niech będzie gadający wieloryb
   FROM docker/whalesay
   # Instalujemy program fortune
   RUN apt-get -y update && apt-get install -y fortunes
   # Podczas uruchomienia kontenera złota myśl z fortune zostanie wypowiedziana przez wieloryba
   CMD /usr/games/fortune -a | cowsay
   

2. Zbuduj nowy obraz komendą docker build -t fortune-whale .

3. Sprawdź, czy nowy obraz istnieje na liście obrazów komendą... no właśnie - jaką?
4. Uruchom ten obraz w nowym konterze (znowu sam musisz pogłówkować). Spróbuj to zrobić kilkukrotnie. Czy za każdym razem dostajesz to samo? Dlaczego tak się dzieje?

1.5. Zaczyna się robić poważnie

1. Stwórz swoje konto w głównym repozytorium dockera.
2. Kliknij Create repository w celu utworzenia nowego repozytorium na obrazy i nazwij fortune-whale (albo jakkolwiek inaczej). Wprowadź opis.
3. Wyświetl listę swoich obrazów i znajdź ID dopiero co stworzonego obrazu.
4. Oznacz ten obraz jako <nazwa_użytkownika>/<nazwa_repozytorium> wydjąc komendę docker tag <id_obrazu> <nazwa_użytkownika>/<nazwa_repozytorium>.
5. Sprawdź, czy na liście obrazów widnieje twoja nowa nazwa <nazwa_użytkownika>/<nazwa_repozytorium>.
6. Zaloguj się do swojego konta poleceniem docker login --username=<nazwa_użytkownika> --email=<adres_email>. W razie problemów sprawdź zgłoszenie.
7. Wypchnij swój nowy obraz do repozytorium wydając komendę docker push <nazwa_użytkownika>/<nazwa_repozytorium>
8. Obejrzyj obraz na swoim profilu w głównym repozytorium dockera.
9. Usuń swój obraz z lokalnego dysku poleceniem docker rmi <id_obrazu>. Jeżeli dostaniesz komunikat o niemożliwości skasowania obrazu ze względu na istniejące kontenery, które z niego korzystają, to możesz najpierw skasować te kontenery, albo użyć opcji -f, która pozwala na wymuszenie skasowania obrazu.
10. Sprawdź ponownie listę obrazów i czy rzeczywiście nie widznieje już na niej dopiero co stworzony obraz.
11. Pobierz obraz z repozytorium za pomocą komendy docker pull <nazwa_użytkownika>/<nazwa_repozytorium>.
12. Prawda, że proste?

2. Rozwinięcie skrzydeł

2.1 Aplikacja

1. Stwórz katalog hello i wejdź do niego.

2. Stwórz plik app.py z następującą zawartością

   import os
   
   from flask import Flask
   
   app = Flask(__name__)
   
   @app.route('/')
   def hello():
       provider = str(os.environ.get('PROVIDER', 'world'))
       return 'Hello '+provider+'!'
   
   if __name__ == '__main__':
       # Nasluchuj na porcie PORT jezeli zdefiniowano, inaczej na 5000.
       port = int(os.environ.get('PORT', 5000))
       app.run(host='0.0.0.0', port=port, debug=True)
   

3. Stwórz plik źródłowy obrazu z zawartością

   FROM python:2.7
   MAINTAINER Alojzy Kleks <kleks@bajka.org>
   RUN pip install flask
   ADD ./app.py /webapp/
   WORKDIR /webapp
   EXPOSE 5000
   CMD ["python", "app.py"]
   

4. Zbuduj obraz i nazwij go hello.

2.2. Sieć

1. Uruchom obraz w tle z opcją -p 5000.
2. Wyświetl działające kontenery. Co widzisz w kolumnie PORTS?
3. Aktualnie przypisany port możesz też odczytać używając komendy docker port <id_kontenera/nazwa_kontenera> 5000.
4. Uruchom komendę docker logs -f <id_kontenera/nazwa_kontenera> i wejdź na adres http://localhost:<aktualnie_przypisany_port>.
5. Możesz wymusić własne mapowanie portu za pomocą opcji -p, np. docker run -d -p 8080:5000 hello podmontuje aplikację na lokalnym porcie 8080.

2.3. Zarządzanie

1. Przekaż zmienną PROVIDER do kontenera za pomocą komendy docker run -d -p 8080:5000 -e "PROVIDER=Kleks" hello i zobacz tekst na stronie.
2. Zobacz szczegóły kontenera komendą docker inspect <id_kontenera/nazwa_kontnera>.
3. Kontener możesz zatrzymać podkomendą stop i ponownie uruchomić podkomendą start.
4. Kasowanie kontenera odbywa się przy pomocy podkomendy rm.

2.4. Wolumeny

1. Zamontuj wolumen z opcją -v: docker run -d -p 8080:5000 -v /webapp hello.
2. Wykorzystując komendę docker inspect zobacz, gdzie fizycznie leży ten wolumen.
3. Podmontuj lokalny katalog jako /webapp w kontenerze. W tym celu sprawdź położenie bieżącego katalogu komendą pwd i zapamiętaj pełną ścieżkę. Potem uruchom kontener komendą docker run -d -p 8080:5000 -v <pełna_ścieżka_do_bieżącego_katalogu>:/webapp hello.
4. Zmień wyświetlany tekst w pliku app.py, zatrzymaj i ponownie uruchom kontener. Zobacz zmiany na stronie. Dlaczego tak się dzieje?

3. Kompozycja

3.1. Aplikacja

1. Stwórz katalog counter i wejdź do niego.

2. Stwórz plik app.py z następującą zawartością

   from flask import Flask
   from redis import Redis
   
   app = Flask(__name__)
   redis = Redis(host='redis', port=6379)
   
   @app.route('/')
   def hello():
       redis.incr('hits')
       return 'Siemka! Strona zostala wyswietlona %s razy.' % redis.get('hits')
   
   if __name__ == "__main__":
       app.run(host="0.0.0.0", debug=True)
   

3. Stwórz plik requirements.txt z zawartością

   flask
   redis
   

3.2. Obraz

1. Stwórz plik obrazu z zawartością

   FROM python:2.7
   ADD . /code
   WORKDIR /code
   RUN pip install -r requirements.txt
   CMD python app.py
   

2. Zbuduj obraz i nazwij go web.

3.3. Serwisy

1. Stwórz plik docker-compose.yml z zawartością

   web:
     build: .
     ports:
       - "5000:5000"
     volumes:
       - .:/code
     links:
       - redis
   redis:
     image: redis
   

3.4. Do dzieła!

1. Uruchom aplikację poleceniem docker-compose up.
2. Wejdź na adres http://localhost:5000/.
3. Odśwież stronę.
4. Wciśnij Ctrl-C.
5. Uruchom aplikację poleceniem docker-compose up -d.
6. Podejrzyj uruchomione kontenery poleceniem docker-compose ps.
7. Podejrzyj zmienne środowiskowe w kontenerze web poleceniem docker-compose run web env.
8. Zatrzymaj aplikację poleceniem docker-compose stop.

3.5. Czas na zabawę

1. Zmodyfikuj plik app.py.
2. Uruchom aplikację.
3. Czy obraz był ponownie budowany? Czy zmiany zostały odzwierciedlone? Jak to się stało?