🥇Przewodnik po Kubernetes, część 1: aplikacje, mikroserwisy i kontenery

Na naszą prośbę Habr stworzył hub Kubernetes i cieszymy się, że możemy opublikować pierwszą publikację w nim. Subskrybujcie!

Kubernetes to prosta rzecz. Dlaczego banki płacą mi wysokie pieniądze za pracę w tej dziedzinie, podczas gdy każdy może opanować tę technologię zaledwie w kilka godzin?

Jeśli masz wątpliwości, że Kubernetes można tak szybko nauczyć się — zachęcam cię do spróbowania samodzielnie. Opanowując ten materiał, będziesz mógł uruchomić aplikację opartą na mikrousługach w klastrze Kubernetes. Mogę to zagwarantować, ponieważ właśnie w ten sposób, który jest tu zastosowany, uczę naszych klientów obsługi Kubernetes. Co wyróżnia ten przewodnik spośród innych? Tak naprawdę — jest wiele rzeczy. Większość podobnych materiałów zaczyna się od wyjaśnienia prostych rzeczy — koncepcji Kubernetes i funkcji komendy kubectl. Autorzy tych materiałów zakładają, że ich czytelnik zna się na rozwijaniu aplikacji, mikrousługach i kontenerach Docker. My jednak pójdziemy inną drogą. Najpierw opowiemy, jak uruchomić aplikację opartą na mikrousługach na komputerze. Następnie zajmiemy się budowaniem obrazów kontenerów dla każdej mikrousługi. A dopiero potem zapoznamy się z Kubernetes i przeanalizujemy wdrażanie aplikacji opartej na mikrousługach w klastrze zarządzanym przez Kubernetes.

Takie podejście, z stopniowym zbliżaniem się do Kubernetes, zapewni głębię zrozumienia tego, co się dzieje, niezbędną zwykłemu człowiekowi, aby pojąć, jak prosto wszystko działa w Kubernetes. Kubernetes to bez wątpienia prosta technologia, pod warunkiem, że osoba chcąca ją opanować wie, gdzie i jak jest używana.

Teraz, bez zbędnych słów, przejdźmy do pracy i porozmawiajmy o aplikacji, z którą będziemy pracować.

Aplikacja eksperymentalna

Nasza aplikacja będzie pełnić jedną funkcję. Przyjmuje jako dane wejściowe jedno zdanie, a następnie, wykorzystując narzędzia analizy tekstu, przeprowadza analizę sentymentu (sentiment analysis) tego zdania, uzyskując ocenę emocjonalnego nastawienia autora zdania do pewnego obiektu.

Tak wygląda główne okno tej aplikacji.

Aplikacja webowa do analizy sentymentu tekstów

Z technicznego punktu widzenia aplikacja składa się z trzech mikroserwisów, z których każdy rozwiązuje określony zestaw zadań:

SA-Frontend — serwer www Nginx, który obsługuje statyczne pliki React.
SA-WebApp — aplikacja internetowa napisana w Javie, która przetwarza zapytania z frontend.
SA-Logic — aplikacja Python, która przeprowadza analizę sentymentu tekstu.

Warto zauważyć, że mikroserwisy nie istnieją w izolacji. Realizują ideę „podziału obowiązków”, ale muszą ze sobą współpracować.

Przepływy danych w aplikacji

Na powyższym schemacie można zobaczyć ponumerowane etapy działania systemu, ilustrujące przepływy danych w aplikacji. Przyjrzyjmy się im:

Przeglądarka wysyła zapytanie do serwera o plik index.html (który z kolei ładuje pakiet aplikacji React).
Użytkownik wchodzi w interakcję z aplikacją, co powoduje zapytanie do aplikacji webowej opartej na Spring.
Aplikacja internetowa przekazuje zapytanie do aplikacji Python w celu przeprowadzenia analizy tekstu.
Aplikacja Python przeprowadza analizę sentymentu tekstu i zwraca wynik w odpowiedzi na zapytanie.
Aplikacja Spring wysyła odpowiedź do aplikacji React (która z kolei wyświetla wynik analizy tekstu użytkownikowi).

Kod dla wszystkich tych aplikacji można znaleźć tutaj. Polecam, by teraz skopiować ten repozytorium, ponieważ czekają nas ciekawe eksperymenty z nim.

Uruchomienie aplikacji opartej na mikroserwisach na lokalnym komputerze

Aby aplikacja działała, musimy uruchomić wszystkie trzy mikroserwisy. Zacznijmy od najładniejszego z nich — aplikacji frontendowej.

▍Konfiguracja React do lokalnego rozwoju

Aby uruchomić aplikację React, musisz zainstalować na swoim komputerze platformę Node.js i NPM. Po zainstalowaniu wszystkiego, przejdź w terminalu do folderu projektu sa-frontend i wykonaj następującą komendę:

npm install

Dzięki wykonaniu tego polecenia do folderu node_modules zostaną pobrane zależności aplikacji React, których zapisy znajdują się w pliku package.json. Po zakończeniu pobierania zależności w tym samym folderze wykonaj następujące polecenie:

npm start

I to wszystko. Teraz aplikacja React jest uruchomiona, a dostęp do niej można uzyskać, przechodząc w przeglądarce pod adres localhost:3000. Możesz zmienić coś w jego kodzie. Efekt tych zmian od razu zobaczysz w przeglądarce. Jest to możliwe dzięki tzw. «gorącej» wymianie modułów. Dzięki temu rozwój front-end staje się prostym i przyjemnym zajęciem.

▍Przygotowanie aplikacji React do produkcji

Aby używać aplikacji React w zastosowaniach rzeczywistych, musimy przekształcić ją w zestaw statycznych plików i udostępniać je klientom za pomocą serwera webowego.

Aby zbudować aplikację React, ponownie użyj terminala, przejdź do folderu sa-frontend i wykonaj następującą komendę:

npm run build

To spowoduje utworzenie w folderze projektu katalogu build. Będzie on zawierał wszystkie statyczne pliki potrzebne do działania aplikacji React.

▍Obsługa plików statycznych za pomocą Nginx

Na początek należy zainstalować i uruchomić serwer webowy Nginx. Tutaj można go pobrać i znaleźć instrukcje dotyczące instalacji i uruchamiania. Następnie trzeba skopiować zawartość folderu sa-frontend/build do folderu [your_nginx_installation_dir]/html.

Przy takim podejściu, wygenerowany podczas procesu budowania aplikacji React plik index.html będzie dostępny pod adresem [your_nginx_installation_dir]/html/index.html. To jest plik, który domyślnie serwer Nginx wydaje podczas żądania. Serwer jest skonfigurowany do nasłuchu na porcie 80, ale można go skonfigurować według własnych potrzeb, edytując plik [your_nginx_installation_dir]/conf/nginx.conf.

Teraz otwórz przeglądarkę i przejdź pod adres localhost:80. Zobaczysz stronę aplikacji React.

Aplikacja React obsługiwana przez serwer Nginx

Jeśli teraz coś wpiszesz w polu Type your sentence i naciśniesz przycisk Send — nic się nie wydarzy. Jednak, jeśli zajrzysz do konsoli, możesz zobaczyć wiadomości o błędach. Aby zrozumieć, gdzie dokładnie występują te błędy, przeanalizujmy kod aplikacji.

▍Analiza kodu aplikacji front-end

Patrząc na kod pliku App.js, możemy zobaczyć, że naciśnięcie przycisku Send wywołuje metodę analyzeSentence(). Kod tej metody znajduje się poniżej. Zauważ, że każda linia, do której zastosowano komentarz w formacie # Номер, ma wyjaśnienie podane poniżej kodu. W ten sam sposób będziemy analizować inne fragmenty kodu.

analyzeSentence() {
    fetch('http://localhost:8080/sentiment', {  // #1
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
                       sentence: this.textField.getValue()})// #2
    })
        .then(response => response.json())
        .then(data => this.setState(data));  // #3
}

1. Adres URL, pod który wysyłane jest zapytanie POST. Zakłada się, że w tym miejscu znajduje się aplikacja oczekująca na tego typu zapytania.

2.Treść zapytania wysyłana do aplikacji. Oto przykład treści zapytania:

{
    sentence: "I like yogobella!"
}

3.Po otrzymaniu odpowiedzi na zapytanie następuje aktualizacja stanu komponentu. To powoduje ponowne renderowanie komponentu. Jeśli otrzymamy dane (czyli obiekt JSON zawierający wprowadzone dane i obliczoną ocenę tekstu), wyświetlimy komponent Polaryzacja, ponieważ spełnione będą odpowiednie warunki. Oto jak opisujemy komponent:

const polarityComponent = this.state.polarity !== undefined ?
     :
    null;

Kod, jak się wydaje, wygląda na całkiem działający. Co więc jest nie tak? Jeśli założysz, że pod adresem, do którego aplikacja próbuje wysłać zapytanie POST, nie ma jeszcze nic, co mogłoby to zapytanie zaakceptować i przetworzyć, będziesz całkowicie w błędzie. Mianowicie, aby przetwarzać zapytania, które przychodzą pod adresem http://localhost:8080/sentiment, musimy uruchomić aplikację webową opartą na Spring.

Potrzebujemy aplikacji Spring, która będzie w stanie zaakceptować zapytanie POST

▍Konfiguracja aplikacji webowej opartej na Spring

Aby wdrożyć aplikację Spring, potrzebujesz JDK8 i Mavena oraz odpowiednio skonfigurowanych zmiennych środowiskowych. Po ich zainstalowaniu możesz kontynuować pracę nad naszym projektem.

▍Pakowanie aplikacji do pliku jar

Wejdź, za pomocą terminala, do folderu sa-webapp i wprowadź następującą komendę:

mvn install

Po wykonaniu tej komendy w folderze sa-webapp zostanie utworzony katalog target. Tutaj znajdziesz aplikację Java zapakowaną w plik jar, przedstawioną w pliku sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Uruchamianie aplikacji Java

Przejdź do folderu target i uruchom aplikację następującą komendą:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar

Podczas wykonywania tej komendy wystąpi błąd. Aby rozpocząć jego naprawę, możemy przeanalizować informacje o wyjątku w danych śladowych stosu:

Błąd podczas tworzenia beana o nazwie 'sentimentController': Wstrzykiwanie autowire'owanych zależności nie powiodło się; zagnieżdżony wyjątek to java.lang.IllegalArgumentException: Nie można rozwiązać symbolu zastępczego 'sa.logic.api.url' w wartości "${sa.logic.api.url}"

Dla nas najważniejsze jest wspomnienie o niemożności ustalenia wartości sa.logic.api.url. Przeanalizujemy kod, w którym występuje błąd.

▍Analiza kodu aplikacji Java

Oto fragment kodu, w którym występuje błąd.

@CrossOrigin(origins = "*")
@RestController
public class SentimentController {
    @Value("${sa.logic.api.url}")    // #1
    private String saLogicApiUrl;
    @PostMapping("/sentiment")
    public SentimentDto sentimentAnalysis(
        @RequestBody SentenceDto sentenceDto) 
    {
        RestTemplate restTemplate = new RestTemplate();
        return restTemplate.postForEntity(
                saLogicApiUrl + "/analyse/sentiment",    // #2
                sentenceDto, SentimentDto.class)
                .getBody();
    }
}

W SentimentController jest polem saLogicApiUrl. Jego wartość jest ustalana przez właściwość sa.logic.api.url.
Ciąg saLogicApiUrl konkatenuje się z wartością /analyse/sentiment. Razem tworzą adres do wykonania zapytania do mikroserwisu analizującego tekst.

▍Ustalanie wartości właściwości

W Springu standardowym źródłem wartości właściwości jest plik application.properties, który można znaleźć pod adresem sa-webapp/src/main/resources. Jednak jego użycie nie jest jedynym sposobem ustalania wartości właściwości. Można to zrobić również za pomocą polecenia o następującej postaci:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=WHAT.IS.THE.SA.LOGIC.API.URL

Wartość tej właściwości powinna wskazywać na adres naszej aplikacji w Pythonie.

Konfigurując go, informujemy aplikację webową Spring, dokąd ma się odwoływać, aby wykonywać zapytania do analizy tekstu.

Aby nie komplikować sobie życia, załóżmy, że aplikacja Python będzie dostępna pod adresem localhost:5000 i postaramy się o tym nie zapomnieć. W rezultacie polecenie do uruchomienia aplikacji Spring będzie wyglądać tak:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=http://localhost:5000

W naszym systemie brakuje aplikacji Python

Teraz wystarczy, że uruchomimy aplikację Python i system zacznie działać tak, jak oczekiwano.

▍Konfiguracja aplikacji Python

Aby uruchomić aplikację Python, musisz mieć zainstalowane Python 3 oraz Pip, i musisz mieć poprawnie skonfigurowane odpowiednie zmienne środowiskowe.

▍Instalacja zależności

Przejdź do folderu projektu sa-logic/sa i wykonaj następujące polecenia:

python -m pip install -r requirements.txt
python -m textblob.download_corpora

▍Uruchomienie aplikacji

Po zainstalowaniu zależności jesteśmy gotowi do uruchomienia aplikacji:

python sentiment_analysis.py

Po wykonaniu tej komendy otrzymamy następujący komunikat:

* Running on http://0.0.0.0:5000/ (Naciśnij CTRL+C, aby zakończyć)

Oznacza to, że aplikacja została uruchomiona i oczekuje na zapytania pod adresem localhost:5000/

▍Analiza kodu

Przeanalizujmy kod aplikacji w Pythonie, aby zrozumieć, jak reaguje na zapytania:

from textblob import TextBlob
from flask import Flask, request, jsonify
app = Flask(__name__)                                   #1
@app.route("/analyse/sentiment", methods=['POST'])      #2
def analyse_sentiment():
    sentence = request.get_json()['sentence']           #3
    polarity = TextBlob(sentence).sentences[0].polarity #4
    return jsonify(                                     #5
        sentence=sentence,
        polarity=polarity
    )
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)                #6

Inicjalizacja obiektu Flask.
Ustalenie adresu do wykonywania na nim zapytań POST.
Ekstrakcja właściwości sentence z ciała zapytania.
Inicjalizacja anonimowego obiektu TextBlob i uzyskanie wartości polarity dla pierwszego zdania przekazanego w ciele zapytania (w naszym przypadku jest to jedno zdanie, które poddajemy analizie).
Zwrócenie odpowiedzi, w której zawarty jest tekst zdania oraz obliczona wartość polarity.
Uruchomienie aplikacji Flask, która będzie dostępna pod adresem 0.0.0.0:5000 (można się do niej odwołać także z konstrukcją localhost:5000).

Teraz mikroserwisy, które tworzą aplikację, zostały uruchomione. Są one skonfigurowane do wzajemnej współpracy. Oto jak wygląda schemat aplikacji na tym etapie.

Wszystkie mikroserwisy, które tworzą aplikację, są w stanie działać

Teraz, zanim przejdziesz dalej, otwórz aplikację React w przeglądarce i spróbuj przeanalizować jakieś zdanie. Jeśli wszystko zostało zrobione poprawnie — po naciśnięciu na przycisk Send zobaczysz wyniki analizy pod polem tekstowym.

W następnej sekcji omówimy, jak uruchomić nasze mikroserwisy w kontenerach Docker. Jest to potrzebne, aby przygotować aplikację do uruchomienia w klastrze Kubernetes.

Kontenery Docker

Kubernetes — to systema do automatyzacji wdrażania, skalowania i zarządzania aplikacjami kontenerowymi. Nazywa się je również „orkiestratorem kontenerów” (container orchestrator). Jeśli Kubernetes działa z kontenerami, zanim zaczniemy korzystać z tego systemu, musimy najpierw zaopatrzyć się w te kontenery. Ale najpierw porozmawiajmy o tym, czym są kontenery. Najlepsza odpowiedź na to pytanie można znaleźć w dokumentacji do Dockera:

Obraz kontenera to lekki, autonomiczny i wykonywalny pakiet zawierający pewną aplikację, która zawiera wszystko, co potrzebne do jej uruchomienia: kod aplikacji, środowisko wykonawcze, narzędzia systemowe oraz biblioteki i ustawienia. Aplikacje kontenerowe można używać w środowiskach Linux i Windows, a one zawsze będą działać tak samo, niezależnie od infrastruktury.

Oznacza to, że kontenery można uruchamiać na dowolnych komputerach, w tym na serwerach produkcyjnych, i w dowolnych środowiskach zawarte w nich aplikacje będą działać identycznie.

Aby zbadać cechy kontenerów i porównać je z innymi metodami uruchamiania aplikacji, rozważmy przykład obsługi aplikacji React przy użyciu maszyny wirtualnej i kontenera.

▍Obsługa statycznych plików aplikacji React za pomocą maszyny wirtualnej

Próbując zorganizować obsługę statycznych plików za pomocą maszyn wirtualnych, napotkamy następujące wady:

Nieefektywne wykorzystanie zasobów, ponieważ każda maszyna wirtualna to pełnoprawny system operacyjny.
Zależność od platformy. To, co działa na pewnym lokalnym komputerze, może nie działać na serwerze produkcyjnym.
Wolne i wymagające zasobów skalowanie rozwiązań opartych na maszynach wirtualnych.

Serwer WWW Nginx, obsługujący statyczne pliki, uruchomiony na maszynie wirtualnej

Jeśli jednak do rozwiązania podobnego zadania zastosujemy kontenery, możemy zauważyć następujące ich mocne strony w porównaniu do maszyn wirtualnych:

Efektywne wykorzystanie zasobów: praca z systemem operacyjnym przy użyciu Dockera.
Niezależność od platformy. Kontener, który programista będzie mógł uruchomić na swoim komputerze, będzie działać wszędzie.
Lekka implementacja dzięki wykorzystaniu warstw obrazów.

Serwer WWW Nginx obsługujący statyczne pliki uruchomiony w kontenerze.

Porównaliśmy maszyny wirtualne i kontenery jedynie pod kilkoma względami, ale nawet to wystarczy, aby dostrzec mocne strony kontenerów. Tutaj Szczegóły dotyczące kontenerów Docker można znaleźć tutaj.

▍Budowanie obrazu kontenera dla aplikacji React.

Podstawowym elementem kontenera Docker jest plik. DockerfileNa początku tego pliku zapisuje się podstawowy obraz kontenera, a następnie zawiera sekwencję instrukcji wskazującą kolejność tworzenia kontenera, który odpowiada potrzebom konkretnej aplikacji.

Zanim zaczniemy pracować z plikiem Dockerfile, przypomnijmy sobie, co robiliśmy, aby przygotować pliki aplikacji React do wdrożenia na serwerze Nginx:

Budowanie pakietu aplikacji React (npm run build).
Uruchomienie serwera Nginx.
Kopiowanie zawartości katalogu build z folderu projektu sa-frontend do folderu serwera nginx/html..

Poniżej zobaczysz analogie między tworzeniem kontenera a wcześniej opisanymi działaniami wykonywanymi na lokalnym komputerze.

▍Przygotowanie pliku Dockerfile dla aplikacji SA-Frontend.

Instrukcje, które będą zawarte w Dockerfile dla aplikacji SA-Frontend, składają się tylko z dwóch poleceń. Faktem jest, że zespół programistów Nginx przygotował podstawowy obraz dla Nginx, którego użyjemy do stworzenia naszego obrazu. Oto dwa kroki, które musimy opisać:

Obraz bazowy musi być obrazem Nginx.
Zawartość katalogu sa-frontend/build musi być skopiowana do katalogu obrazu. nginx/html..

Przechodząc od tego opisu do pliku Dockerfile, będzie on wyglądał tak:

FROM nginx
COPY build /usr/share/nginx/html

Jak widzisz, wszystko jest bardzo proste, a zawartość pliku jest całkiem czytelna i zrozumiała. Ten plik mówi systemowi, że trzeba wziąć obraz nginx ze wszystkim, co już w nim jest, i skopiować zawartość katalogu. build do katalogu. nginx/html..

Tutaj może pojawić się pytanie, skąd wiem, dokąd dokładnie należy kopiować pliki z katalogu build, zatem skąd wzięła się ścieżka /usr/share/nginx/html. W rzeczywistości nie ma tutaj nic skomplikowanego. Odpowiednie informacje można znaleźć w opisie obrazu.

▍Tworzenie obrazu i przesyłanie go do repozytorium

Zanim będziemy mogli pracować z gotowym obrazem, musimy wysłać go do repozytorium obrazów. W tym celu skorzystamy z darmowej chmurowej platformy do hostingu obrazów Docker Hub. Na tym etapie pracy należy wykonać następujące kroki:

Zainstalować Docker.
Zarejestrować się na stronie Docker Hub.
Zalogować się na konto, wykonując w terminalu polecenie o następującym wyglądzie:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Teraz musisz, za pomocą terminala, przejść do katalogu sa-frontend i wykonać tam polecenie o następującym wyglądzie:

docker build -f Dockerfile -t $DOCKER_USER_ID/sentiment-analysis-frontend .

W dalszej części tego typu poleceń $DOCKER_USER_ID należy zastąpić swoją nazwą użytkownika na Docker Hub. Na przykład, ta część polecenia może wyglądać tak: rinormaloku/sentiment-analysis-frontend.

W tym przypadku to polecenie można skrócić, usuwając z niego -f Dockerfile, ponieważ w folderze, w którym wykonujemy to polecenie, ten plik już istnieje.

Aby wysłać gotowy obraz do repozytorium, potrzebujemy takiego polecenia:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Po jego wykonaniu sprawdź listę swoich repozytoriów na Docker Hub, aby upewnić się, że wysyłka obrazu do chmurowego magazynu zakończyła się sukcesem.

▍Uruchamianie kontenera

Teraz każdy może pobrać i uruchomić obraz znany jako $DOCKER_USER_ID/sentiment-analysis-frontend. Aby to zrobić, trzeba wykonać następującą sekwencję poleceń:

docker pull $DOCKER_USER_ID/sentiment-analysis-frontend
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend

Teraz kontener jest uruchomiony i możemy kontynuować pracę, tworząc inne potrzebne nam obrazy. Ale zanim przejdziemy dalej, przyjrzyjmy się konstrukcji 80:80, która występuje w poleceniu uruchomienia obrazu i może wydawać się niejasna.

Pierwsza liczba 80 to numer portu hosta (czyli lokalnego komputera).
Druga liczba 80 to port kontenera, na który powinien być przekierowany request.

Rozważmy następującą ilustrację.

Przekierowanie portów

System przekierowuje żądania z portu <hostPort> na port <containerPort>. Oznacza to, że odwołanie do portu 80 komputera jest przekierowywane na port 80 kontenera.

Ponieważ port 80 jest otwarty na lokalnym komputerze, można uzyskać dostęp do aplikacji z tego komputera pod adresem localhost:80. Jeśli jednak twoja система nie obsługuje Dockera, aplikację można uruchomić na maszynie wirtualnej Docker, której adres będzie wyglądał jak :80. Aby ustalić adres IP maszyny wirtualnej Docker, można skorzystać z polecenia docker-machine ip.

Na tym etapie, po pomyślnym uruchomieniu kontenera aplikacji frontendowej, powinieneś mieć możliwość otwarcia jego strony w przeglądarce.

▍Plik .dockerignore

Tworząc obraz aplikacji SA-Frontend, mogliśmy zauważyć, że proces ten jest niezwykle wolny. Dzieje się tak, ponieważ demon Docker musi otrzymać kontekst budowy obrazu. Katalog, który stanowi kontekst budowy, jest określany jako ostatni argument polecenia docker build. W naszym przypadku na końcu tego polecenia znajduje się kropka. Prowadzi to do tego, że w kontekst budowy włączona jest następująca struktura:

sa-frontend:
|   .dockerignore
|   Dockerfile
|   package.json
|   README.md
+---build
+---node_modules
+---public
---src

Ale potrzebujemy tylko folderu build. Ładowanie czegokolwiek innego to strata czasu. Można przyspieszyć budowę, wskazując Dockerowi, które katalogi można zignorować. Właśnie do tego potrzebny jest nam plik .dockerignore. Jeśli znasz plik .gitignore, struktura tego pliku będzie dla ciebie zapewne znajoma. W nim wymienione są katalogi, które system budowy obrazu może zignorować. W naszym przypadku zawartość tego pliku wygląda tak:

node_modules
src
public

Plik .dockerignore musi znajdować się w tym samym folderze co plik Dockerfile. Teraz budowa obrazu zajmie zaledwie sekundy.

Zajmijmy się teraz obrazem dla aplikacji Java.

▍Budowa obrazu kontenera dla aplikacji Java

Wiesz co, już poznałeś wszystko, co potrzebne do tworzenia obrazów kontenerów. Dlatego ten rozdział będzie bardzo krótki.

Otwórz plik Dockerfile, który znajduje się w folderze projektu sa-webapp. Jeśli przeczytasz treść tego pliku, napotkasz tylko dwie nowe konstrukcje, które zaczynają się od słów kluczowych ENV i EXPOSE:

ENV SA_LOGIC_API_URL http://localhost:5000
…
EXPOSE 8080

Słowo kluczowe ENV pozwala na deklarowanie zmiennych środowiskowych wewnątrz kontenerów Docker. W szczególności w naszym przypadku pozwala określić URL do dostępu do API aplikacji, która wykonuje analizę tekstu.

Słowo kluczowe EXPOSE pozwala wskazać Docker, że port powinien być otwarty. Będziemy korzystać z tego portu podczas pracy z aplikacją. Można zauważyć, że w Dockerfile dla aplikacji SA-Frontend takiej komendy nie ma. To potrzebne jest tylko do celów dokumentacji, innymi słowy, ta konstrukcja jest przeznaczona dla kogoś, kto będzie czytał Dockerfile.

Zbudowanie obrazu i wysłanie go do repozytorium wygląda dokładnie tak samo, jak w poprzednim przykładzie. Jeśli jednak nie jesteś jeszcze pewny siebie — odpowiednie komendy można znaleźć w pliku README.md w folderze sa-webapp.

▍Budowa obrazu kontenera dla aplikacji Python

Jeśli spojrzysz na zawartość pliku Dockerfile w folderze sa-logic, to nie znajdziesz tam nic nowego. Komendy do budowy obrazu i wysyłania go do repozytorium również powinny być ci już znane, ale można je, jak w przypadku innych naszych aplikacji, znaleźć w pliku README.md w folderze sa-logic.

▍Testowanie aplikacji konteneryzowanych

Czy możesz zaufać czemuś, czego nie przetestowałeś? Ja też nie mogę. Przetestujmy nasze kontenery.

Uruchomimy kontener aplikacji sa-logic i skonfigurujemy go do nasłuchiwania na porcie 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Uruchomimy kontener aplikacji sa-webapp i skonfigurujemy go do nasłuchiwania na porcie 8080. Ponadto musimy skonfigurować port, na którym aplikacja Python będzie czekała na zapytania od aplikacji Java, przedefiniowując zmienną środowiskową SA_LOGIC_API_URL:
```
$ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://:5000' $DOCKER_USER_ID/sentiment-analysis-web-app
```

Aby dowiedzieć się, jak ustalić adres IP kontenera lub maszyny wirtualnej Docker — zajrzyj do pliku README.

Uruchomimy kontener aplikacji sa-frontend:

docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend

Teraz wszystko jest gotowe, aby przejść do przeglądarki pod adresem localhost:80 i przetestować aplikację.

Zauważ, że jeśli zmieniałeś port dla sa-webapp, lub jeśli pracujesz z maszyną wirtualną Docker, będziesz musiał edytować plik App.js z folderu sa-frontend, zmieniając adres IP lub numer portu w metodzie analyzeSentence(), podstawiając aktualne dane zamiast nieaktualnych. Następnie należy ponownie zbudować obraz i skorzystać z niego.

Oto jak wygląda schemat naszej aplikacji teraz.

Mikroserwisy działają w kontenerach

Podsumowanie: po co nam klaster Kubernetes?

Właśnie omówiliśmy pliki Dockerfile, porozmawialiśmy o tym, jak budować obrazy i wysyłać je do repozytorium Docker. Ponadto nauczyliśmy się przyspieszać budowę obrazów, korzystając z pliku .dockerignoreW rezultacie nasze mikroserwisy są teraz uruchamiane w kontenerach Docker. Możecie się zastanawiać, po co nam Kubernetes. Drugiej części tego materiału poświęcimy odpowiedzi na to pytanie. A na razie przemyślcie następujące pytanie:
Załóżmy, że nasza aplikacja internetowa do analizy tekstów stała się globalnie popularna. Co minutę przychodzi do niej miliony zapytań. To oznacza, że mikroserwisy sa-webapp i sa-logic będą poddawane ogromnemu obciążeniu. Jak skalować kontenery, w których działają mikroserwisy?

Źródło: habr.com