Docker część III: dockerfiles

W poprzednich dwóch postach poznaliśmy podstawy poruszania się w dockerowym świecie. Były to jednak dosyć proste przykłady, a my, przy własnych lub firmowych projektach, będziemy używali bardziej rozbudowanego kodu. Ale nie każdy jest w stanie albo chciałby, korzystać z nano lub vima przy pisaniu aplikacji ASP.Net Core. Jednak jak przenieść kod naszej aplikacji z naszego komputera do dockerowego kontenera? Oczywiście można pushować kod na repozytorium git(np github) oraz pobierać je w kontenerze. Jednakże istnieje dużo lepsze wyjście. Są to pliki Dockerfile, które w tym poście omówię.

Nieco teorii

Dockerfile jest to plik tekstowy zawierający komendy, dzięki którym docker przy pomocy

docker build [args] .

zbuduje nasz własny obraz, na podstawie którego będziemy mogli stworzyć kontener. Kropka na końcu komendy mówi nam, że mamy zbudować pliki z katalogu, w którym się znajdujemy. Jednym z argumentów, które możemy podać jest -t, który pozwala nam nadać tag dla naszego obrazu. Najlepiej zilustruje to przykład:
Załóżmy, że jako programista Pythona chcielibyśmy cały nasz napisany kod odpalić na dockerowym obrazie. Struktura naszego projektu wygląda następująco:

Screen Shot 2017-08-13 at 17.49.40

Dla uproszczenia chcielibyśmy tylko, aby cały kod z naszego folderu src znalazł się w folderze app naszego kontenera i był gotowy do odpalenia.
Pierwsze, co musimy zrobić to stworzenie pliku o nazwie “Dockerfile” w naszym katalogu głównym. Pliki dockerfile posiadają kilka komend, z których korzystamy, aby stworzyć nasz obraz. Oto najważniejsze z nich:

FROM [imageName]

Komenda, od której zaczyna się plik dockerfile. Pokazuje ona, na podstawie którego już istniejącego obrazu zostanie stworzony nasz.

RUN [command]

Komenda, która uruchamia komendy w naszym terminalu, najczęściej instalujące konkretne potrzebne nam rzeczy, jak np. pythona, pip.

EXPOSE [port]

Komenda, która wystawia port naszej aplikacji na zewnątrz.

ENV [variableName]=[variableValue]

Komenda, która pozwala nam na zdefiniowanie zmiennej środowiskowej.

ADD [codeSourceLocation] [codeDestinyLocation]

Komenda, która pozwala nam na skopiowanie plików z codeSourceLocation na naszym komputerze do codeDestinyLocation w kontenerze.

WORKDIR [location]

Komenda, która pozwala nam przejść w kontenerze do konkretnego folderu, w którym możemy odpalić komendy, np. dotnet restore.

ENTRYPOINT [commands]

Komenda, która pozwala nam ustawić zachowanie dla naszego kontenera po jego uruchomieniu.
To wszystko z podstawowych komend. Zachęcam do zapoznania się z resztą tutaj.
Teraz, kiedy znamy już komendy niezbędne do stworzenia naszego pliku, napiszmy go po prostu:

#wybranie bazowego obrazu
FROM ubuntu:14.04

#odpalenie komend odpowiedzialnych za instalację pythona
RUN apt-get update && apt-get install python -y

#skopiowanie plików z naszego folderu z kodem do folderu app 
#UWAGA gdybyśmy napisali app zamist app/ zostanie stworzony plik zamiast folderu
ADD src/. app/

#ustawienie app jako folderu, w którym znajdujemy się po odpaleniu kontenera
WORKDIR app/

Kod nie wymaga większego komentarza poza tym, który już mamy 😉
Teraz, po użyciu komendy:

docker build -t python-dev .

zostanie stworzony obraz o tagu python-dev, którego następnie odpalamy komendą:

docker run -it python-dev

Znajdziemy się od razu w folderze app, w którym wystarczy wpisać w terminal:

python app.py

Aby wyświetlił nam się piękny napis “Hello World!” 🙂

Aplikacja webowa

Załóżmy teraz, że jako programista ASP.Net Core chcielibyśmy, aby po uruchomieniu naszego kontenera można było od razu wejść na naszą stronę na localhoście. Struktura naszej aplikacji pozostaje taka sama, z tym wyjątkiem, że w folderze src będziemy mieć teraz kod aplikacji MVC. Tak więc nasz plik dockerfile będzie wyglądał następująco:

#wybieramy bazowy obraz:
FROM microsoft/dotnet

#kopiujemy kod naszej aplikacji:
ADD src/. app/

#definiujemy zmienną środowsikową:
ENV ASPNETCORE_URLS="http://+:5000"

#wystawiamy port naszej aplikacji:
EXPOSE 5000

#przechodzimy do folderu aplikacji:
WORKDIR app/

#uruchamiamy komendy dotnetowe:
RUN dotnet restore && dotnet build

#ustawiamy zachowanie dla kontenera po jego uruchomieniu:
ENTRYPOINT dotnet run

Teraz, po wykonaniu w folderze zawierającym nasz Dockerfile komendy:

docker build -t netcore .

stworzymy obraz o tagu netcore, którego możemy uruchomić następnie komendą:

docker run -d -p 5000:5000 netcore

Teraz, kiedy wpiszemy komendę:

docker ps

jesteśmy w stanie zobaczyć nasz działający kontener, który możemy zatrzymać komendami:

docker kill [containerId]
docker stop [containerId]

a po przejściu na stronę: http://localhost:5000/ zobaczymy piękną stronę naszej aplikacji.
To by było wszystko w zakresie podstaw tworzenia plików Dockerfile. Zachęcam do eksperymentowania, odkrywania co można za pomocą takich plików zrobić. Następne dwa posty będą małą odskocznią od Dockera – poruszymy w nich temat Azure Web Apps oraz Bitbucket Pipelines.

Do przeczytania niedługo 😉

Advertisements

One Reply to “Docker część III: dockerfiles”

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s