Docker część II: kill/stop oraz .Net Core

W poprzednim poście omówiliśmy podstawy używania Dockera na przykładzie prostego programu konsolowego w Pythonie. Wspomniałem w nim o różnicy pomiędzy komendami:

 docker kill [containerName/containerId]

oraz

 docker stop [containerName/containerId]

Teraz przedstawię tę różnicę na przykładzie prostego programu konsolowego napisanego w C#. Stworzy on wątek, który można przerwać poprzez wpisanie naszego (lub nie ;)) imienia, co skończy działanie aplikacji, lub naciśnięcia klawiszy ctrl+c.
Zaczynajmy.

Dotnet

Nasz program zostanie uruchomiony na kontenerze zbudowanym na obrazie microsoft/dotnet. Jest to stworzony przez Microsoft obraz linuxa zawierający wszystko czego potrzebujemy, aby uruchamiać aplikacje napisaną w języku C# na platformie .Net Core.
Jeśli wpiszemy w nasz terminal z uruchomionym dockerem komendę:

 docker search microsoft

naszym oczom ukaże się taki oto widok:

Screen Shot 2017-08-11 at 22.03.09.png
Nas na obecny moment interesuje jedynie obraz o nazwie microsoft/dotnet, więc to właśnie jego pobieramy i uruchamiamy:

docker pull microsoft/dotnet
docker run -it microsoft/dotnet

Pierwszą naszą czynnością będzie odpalenie komendy:

apt-get update && apt-get install nano

która zainstaluje nam edytor tekstowy nano, w którym będziemy edytować nasz kod.
Następnie tworzymy folder naszej aplikacji:

mkdir app

przechodzimy do tego folderu:

cd app

Teraz komendą

dotnet new console

tworzymy naszą konsolową aplikację.
Następnie poprzez komendę:

nano Program.cs

uruchamiamy nano, w którego wklejamy nastepujący kod:

using System;

namespace app
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("Say your name:");
            string userName = Console.ReadLine();
            Console.WriteLine("You're goddamn right "+userName);
        }
    }
}

Zapisujemy, a następnie komendami:

dotnet restore
dotnet build
dotnet run

uruchamiamy naszą aplikację konsolową:

Screen Shot 2017-08-11 at 22.16.14
Jak widać na załączonym obrazku, oczekuje ona od nas na wpisanie jakiegoś ciągu znaków. Zostawiamy tak uruchomioną aplikację i otwieramy nową konsolę/terminal, na której będziemy uruchamiać komendy dockerowe.
Po wpisaniu:

docker ps

naszym oczom ukaże się nasz działający kontener:

Screen Shot 2017-08-11 at 22.30.24
Wpisując komendę:

docker kill [containerId/containerName]

w której wstawiamy pierwsze 3 znaki z id kontenera lub jego nazwę kontener natychmiast przestanie pracować. Jednak jeśli ponownie uruchomimy w jednej konsoli/terminalu nasz kontener komendą:

docker start -i [containerId/containerName]

(w tym momencie nie musimy tworzyć nowego pseudo terminalu w naszym kontenerze, więc argument -t jest niepotrzebny), uruchomimy naszą aplikację konsolową ponownie oraz w drugiej konsoli/terminalu wpiszemy:

 docker stop [containerId/containerName]

Docker poczeka z wyłączeniem naszego kontenera do czasu, aż nasza aplikacja zakończy swoje działanie. Jest to bardzo prosty przykład różnicy pomiędzy kill a stop 😉

ASP.Net Core

Tym razem będzie krótko.
Aby uruchomić aplikację ASP.Net Core w naszym kontenerze, musimy zdefiniować zmienną środowiskową o nazwie ASPNETCORE_URLS, z której nasza aplikacja skorzysta, aby przypisać sobie port. Można to zrobić na dwa sposoby:
zdefiniować ją już w działającym kontenerze komendą

export ASPNETCORE_URLS="http://+:[portNumber]"

podać do docker run jako argument -e, który pozwala nam zdefiniować zmienne środowiskowe, np:

docker run -it -p [localHostPort]:[containerPort] -e "ASPNETCORE_URLS=http://+:[containerPort]"

To o czym musimy pamiętać to to, że numer portu, jaki podamy w zmiennej środowiskowej musi być taki sam, jak numer portu kontenera, który podajemy przy argumencie -p
Zróbmy to pierwszą metodą. W naszej konsoli/terminalu wpisujemy po kolei komendy:

docker run -it -p 5000:5000 microsoft/dotnet
export ASPNETCORE_URLS="http://+:5000"
mkdir app
cd app
dotnet new mvc
dotnet restore
dotnet build
dotnet run

W tym momencie jeśli odpalimy przeglądarkę i przejdziemy na adres http://localhost:5000/ naszym oczom ukaże się taki oto widok:

Screen Shot 2017-08-11 at 22.54.41.png

Tym oto sposobem stworzyliśmy naszą pierwszą aplikację webową .Net Core opalaną na dockerze. W następnym poście omówię czym są i jak napisać pliki dockerfile.

Do przeczytania niedługo 😉

Advertisements

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