ProHoster > Blog > administracja > Samouczek Kubernetes, część 1: Aplikacje, mikrousługi i kontenery

Samouczek Kubernetes, część 1: Aplikacje, mikrousługi i kontenery

Na naszą prośbę Habr stworzył hub Kubernetes i mamy przyjemność umieścić w nim pierwszą publikację. Subskrybuj!

Kubernetes jest łatwy. Dlaczego banki płacą mi dużo pieniędzy za pracę w tej dziedzinie, podczas gdy każdy może opanować tę technologię w zaledwie kilka godzin?

Samouczek Kubernetes, część 1: Aplikacje, mikrousługi i kontenery

Jeśli wątpisz w to, że Kubernetesa można się tak szybko nauczyć, proponuję spróbować zrobić to samemu. Mianowicie po opanowaniu tego materiału będziesz w stanie uruchomić aplikację opartą o mikroserwisy w klastrze Kubernetes. Mogę to zagwarantować, ponieważ w tej samej metodyce, którą tu stosuję, uczę naszych klientów pracy z Kubernetes. Czym ten poradnik różni się od innych? Właściwie wiele rzeczy. Tak więc większość tych materiałów zaczyna się od wyjaśnienia prostych rzeczy - koncepcji Kubernetesa i cech polecenia kubectl. Autorzy tych artykułów zakładają, że ich czytelnik jest zaznajomiony z tworzeniem aplikacji, mikroserwisami i kontenerami Dockera. Pójdziemy w drugą stronę. Najpierw porozmawiajmy o tym, jak uruchomić aplikację opartą na mikroserwisach na komputerze. Następnie przyjrzymy się tworzeniu obrazów kontenerów dla każdej mikrousługi. A potem zapoznamy się z Kubernetes i przeanalizujemy wdrożenie aplikacji opartej o mikroserwisy w klastrze zarządzanym przez Kubernetes.

Takie podejście, ze stopniowym podejściem do Kubernetes, zapewni głębię zrozumienia tego, co się dzieje, czego potrzebuje przeciętny człowiek, aby zrozumieć, jak prosto wszystko jest zorganizowane w Kubernetes. Kubernetes to z pewnością prosta technologia, pod warunkiem, że każdy, kto chce ją opanować, wie, gdzie i jak jest używany.

Teraz, bez zbędnych ceregieli, zabierzmy się do pracy i porozmawiajmy o aplikacji, z którą będziemy pracować.

Aplikacja eksperymentalna

Nasza aplikacja będzie wykonywać tylko jedną funkcję. Jako dane wejściowe przyjmuje jedno zdanie, po czym za pomocą narzędzi analizy tekstu przeprowadza analizę sentymentalną tego zdania, uzyskując ocenę emocjonalnego stosunku autora zdania do określonego obiektu.

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

Samouczek Kubernetes, część 1: Aplikacje, mikrousługi i kontenery
Aplikacja internetowa do analizy nastrojó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 to serwer sieciowy Nginx obsługujący statyczne pliki React.
  • SA-WebApp to aplikacja internetowa napisana w Javie, która obsługuje żądania z frontendu.
  • SA-Logic to aplikacja w języku Python, która przeprowadza analizę tonacji tekstu.

Należy zauważyć, że mikrousługi nie istnieją w izolacji. Realizują ideę „rozdzielenia obowiązków”, ale jednocześnie muszą ze sobą współdziałać.

Samouczek Kubernetes, część 1: Aplikacje, mikrousługi i kontenery
Przepływy danych w aplikacji

Na powyższym diagramie można zobaczyć ponumerowane etapy systemu, ilustrujące przepływy danych w aplikacji. Podzielmy je:

  1. Przeglądarka żąda pliku z serwera index.html (co z kolei ładuje pakiet aplikacji React).
  2. Użytkownik wchodzi w interakcję z aplikacją, co powoduje wywołanie aplikacji internetowej opartej na Springu.
  3. Aplikacja internetowa przekazuje żądanie przeanalizowania tekstu do aplikacji w języku Python.
  4. Aplikacja Pythona analizuje tonację tekstu i zwraca wynik jako odpowiedź na żądanie.
  5. Aplikacja Spring wysyła odpowiedź do aplikacji React (która z kolei pokazuje użytkownikowi wynik przeanalizowanego tekstu).

Kod dla wszystkich tych aplikacji można znaleźć tutaj. Polecam skopiować to repozytorium do siebie już teraz, ponieważ czeka nas wiele ciekawych eksperymentów z nim.

Uruchomienie aplikacji opartej o mikroserwisy na lokalnej maszynie

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

▍Konfiguracja React dla rozwoju lokalnego

Aby uruchomić aplikację React, musisz zainstalować na swoim komputerze framework Node.js i NPM. Po zainstalowaniu tego wszystkiego przejdź za pomocą terminala do folderu projektu sa-frontend i uruchom następujące polecenie:

npm install

Wykonując to polecenie w folderze node_modules zostaną załadowane zależności aplikacji React, których zapisy znajdują się w pliku package.json. Po pobraniu zależności w tym samym folderze uruchom następujące polecenie:

npm start

To wszystko. Aplikacja React jest teraz uruchomiona i można uzyskać do niej dostęp, przechodząc do adresu przeglądarki localhost:3000. Możesz coś zmienić w jego kodzie. Od razu zobaczysz efekt tych zmian w przeglądarce. Jest to możliwe dzięki tzw. „gorącej” wymianie modułów. Dzięki temu tworzenie frontendu staje się prostym i przyjemnym doświadczeniem.

▍Przygotowanie aplikacji React do produkcji

Aby faktycznie korzystać z aplikacji React, musimy ją przekonwertować na zestaw plików statycznych i udostępnić klientom korzystającym z serwera WWW.

Aby zbudować aplikację React, ponownie korzystając z terminala, przejdź do folderu sa-frontend i uruchom następujące polecenie:

npm run build

Spowoduje to utworzenie katalogu w folderze projektu build. Będzie zawierał wszystkie pliki statyczne wymagane do działania aplikacji React.

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

Najpierw musisz zainstalować i uruchomić serwer WWW Nginx. Tutaj możesz go pobrać i znaleźć instrukcje dotyczące jego instalacji i uruchamiania. Następnie musisz skopiować zawartość folderu sa-frontend/build do folderu [your_nginx_installation_dir]/html.

Dzięki takiemu podejściu plik generowany podczas montażu aplikacji React index.html dostępny będzie o godz [your_nginx_installation_dir]/html/index.html. Jest to plik, który domyślnie serwer Nginx wydaje podczas uzyskiwania do niego dostępu. Serwer jest skonfigurowany do nasłuchiwania na porcie 80, ale możesz dostosować go tak, jak chcesz, edytując plik [your_nginx_installation_dir]/conf/nginx.conf.

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

Samouczek Kubernetes, część 1: Aplikacje, mikrousługi i kontenery
Aplikacja React obsługiwana przez serwer Nginx

Jeśli teraz wpiszesz coś w polu Type your sentence i naciśnij przycisk Send - nic się nie stanie. Ale jeśli spojrzysz na konsolę, zobaczysz tam komunikaty o błędach. Aby dokładnie zrozumieć, gdzie występują te błędy, przeanalizujmy kod aplikacji.

▍Analiza kodu aplikacji frontendowej

Patrząc na kod pliku App.js, widzimy, że klikając na przycisk Send wywołuje metodę analyzeSentence(). Kod tej metody pokazano poniżej. Jednocześnie zwróć uwagę na fakt, że dla każdej linii, do której znajduje się komentarz formularza # Номер, pod kodem znajduje się wyjaśnienie. 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, do którego kierowane jest żądanie POST. Zakłada się, że ten adres jest aplikacją oczekującą na takie żądania.

2.Treść żądania wysłana do aplikacji. Oto przykładowa treść żądania:

{
    sentence: "I like yogobella!"
}

3.Po otrzymaniu odpowiedzi na żądanie stan komponentu jest aktualizowany. Spowoduje to ponowne renderowanie komponentu. Jeśli otrzymamy dane (czyli obiekt JSON zawierający wprowadzone dane i obliczony wynik tekstowy), wyślemy komponent Polarityo ile spełnione są warunki. Oto jak opisujemy komponent:

const polarityComponent = this.state.polarity !== undefined ?
    <Polarity sentence={this.state.sentence} 
              polarity={this.state.polarity}/> :
    null;

Kod wydaje się działać całkiem dobrze. Co tu jest nie tak? Jeśli założysz, że pod adresem, na który aplikacja próbuje wysłać żądanie POST, nie ma jeszcze nic, co mogłoby przyjąć i przetworzyć to żądanie, to będziesz miał absolutną rację. Mianowicie w celu przetwarzania żądań przychodzących na adres http://localhost:8080/sentiment, musimy uruchomić aplikację internetową opartą na Springu.

Samouczek Kubernetes, część 1: Aplikacje, mikrousługi i kontenery
Potrzebujemy aplikacji Spring, która może zaakceptować żądanie POST

▍Konfiguracja aplikacji webowej opartej o Spring

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

▍Pakowanie aplikacji do pliku jar

Przejdź za pomocą terminala do folderu sa-webapp i wprowadź następujące polecenie:

mvn install

Po wykonaniu tego polecenia w folderze sa-webapp katalog zostanie utworzony target. Tutaj będzie zlokalizowana aplikacja Java, spakowana w pliku jar, reprezentowanym przez plik sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Uruchamianie aplikacji Java

Przejdź do folderu target i uruchom aplikację za pomocą następującego polecenia:

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

Podczas wykonywania tego polecenia wystąpi błąd. Aby zacząć to naprawiać, możemy przeanalizować szczegóły wyjątku w danych śledzenia stosu:

Error creating bean with name 'sentimentController': Injection of autowired dependencies failed; nested exception is java.lang.IllegalArgumentException: Could not resolve placeholder 'sa.logic.api.url' in value "${sa.logic.api.url}"

Dla nas najważniejsza jest tutaj wzmianka o niemożności doprecyzowania znaczenia sa.logic.api.url. Przeanalizujmy 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();
    }
}

  1. w SentimentController jest pole saLogicApiUrl. Jego wartość jest ustalana przez właściwość sa.logic.api.url.
  2. Linia saLogicApiUrl łączy się z wartością /analyse/sentiment. Razem tworzą adres do nawiązania połączenia z mikroserwisem przeprowadzającym analizę tekstu.

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

W Springu domyślnym ź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. Ale użycie go nie jest jedynym sposobem na ustawienie wartości właściwości. Możesz to również zrobić za pomocą następującego polecenia:

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ć adres naszej aplikacji w Pythonie.

Konfigurując go, informujemy aplikację internetową Springa, gdzie musi się udać, aby wykonać żądania analizy tekstu.

Aby nie komplikować sobie życia, zdecydujemy, że aplikacja w Pythonie będzie dostępna pod adresem localhost:5000 i postaraj się o tym nie zapomnieć. W rezultacie polecenie uruchomienia aplikacji Spring będzie wyglądać następująco:

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

Samouczek Kubernetes, część 1: Aplikacje, mikrousługi i kontenery
W naszym systemie brakuje aplikacji Python

Teraz pozostaje nam już tylko uruchomić aplikację Python i system będzie działał zgodnie z oczekiwaniami.

▍Konfigurowanie aplikacji Python

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

▍Zainstaluj zależności

Przejdź do folderu projektu sa-logic/sa i uruchom 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 tego polecenia otrzymamy następujące informacje:

* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)

Oznacza to, że aplikacja jest uruchomiona i oczekuje na żądania o godz localhost:5000/

▍Badanie kodu

Przyjrzyjmy się kodowi aplikacji w Pythonie, aby zrozumieć, w jaki sposób odpowiada ona na żądania:

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

  1. Inicjalizacja obiektu Flask.
  2. Określenie adresu do wysyłania do niego żądań POST.
  3. Odzyskanie własności sentence z treści żądania.
  4. Inicjalizacja obiektu anonimowego TextBlob i uzyskanie wartości polarity za pierwszą otrzymaną ofertę w treści zapytania (w naszym przypadku jest to jedyna propozycja przesłana do analizy).
  5. Zwrócenie odpowiedzi, której treść zawiera treść oferty oraz wyliczony dla niej wskaźnik polarity.
  6. Uruchomienie aplikacji Flask, która będzie dostępna pod adresem 0.0.0.0:5000 (możesz również uzyskać do niego dostęp za pomocą konstrukcji formularza localhost:5000).

Teraz działają mikroserwisy, z których składa się aplikacja. Są ustawione na interakcję ze sobą. Oto jak wygląda schemat aplikacji na tym etapie prac.

Samouczek Kubernetes, część 1: Aplikacje, mikrousługi i kontenery
Wszystkie mikrousługi, które składają się na aplikację, są przywracane do prawidłowego stanu

Teraz, zanim przejdziemy dalej, otwórz aplikację React w przeglądarce i spróbuj przeanalizować za jej pomocą jakieś zdanie. Jeśli wszystko jest wykonane poprawnie - po naciśnięciu przycisku Send zobaczysz wyniki analizy pod polem tekstowym.

W następnej sekcji porozmawiamy o tym, jak uruchamiać nasze mikroserwisy w kontenerach Docker. Jest to niezbędne do przygotowania aplikacji do działania w klastrze Kubernetes.

Kontenery Dockera

Kubernetes to system do automatyzacji wdrażania, skalowania i zarządzania konteneryzowanymi aplikacjami. Jest również nazywany „organizatorem kontenerów”. Jeśli Kubernetes współpracuje z kontenerami, to przed użyciem tego systemu musimy najpierw zdobyć te kontenery. Ale najpierw porozmawiajmy o tym, czym są kontenery. Być może najlepszą odpowiedź na pytanie, co to jest, można znaleźć w dokumentacja do Dockera:

Obraz kontenera to lekki, samodzielny, wykonywalny pakiet zawierający aplikację, która zawiera wszystko, co niezbędne do jej uruchomienia: kod aplikacji, środowisko wykonawcze, narzędzia i biblioteki systemowe, ustawienia. Konteneryzowane programy mogą być używane zarówno w środowiskach Linux, jak i Windows i zawsze będą działać tak samo niezależnie od infrastruktury.

Oznacza to, że kontenery można uruchomić na dowolnym komputerze, w tym na serwerach produkcyjnych, iw każdym środowisku zawarte w nich aplikacje będą działać tak samo.

Aby poznać możliwości kontenerów i porównać je z innymi sposobami uruchamiania aplikacji, spójrzmy na przykład serwowania aplikacji React przy użyciu maszyny wirtualnej i kontenera.

▍Obsługa statycznych plików aplikacji React przy użyciu maszyny wirtualnej

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

  1. Nieefektywne wykorzystanie zasobów, ponieważ każda maszyna wirtualna jest kompletnym systemem operacyjnym.
  2. Zależność od platformy. To, co działa na niektórych komputerach lokalnych, może nie działać na serwerze produkcyjnym.
  3. Powolne i wymagające dużych zasobów skalowanie rozwiązania maszyny wirtualnej.

Samouczek Kubernetes, część 1: Aplikacje, mikrousługi i kontenery
Serwer WWW Nginx obsługujący pliki statyczne działające na maszynie wirtualnej

Jeśli kontenery są używane do rozwiązania podobnego problemu, to w porównaniu z maszynami wirtualnymi można zauważyć następujące mocne strony:

  1. Efektywne wykorzystanie zasobów: praca z systemem operacyjnym przy użyciu Dockera.
  2. Niezależność platformy. Kontener, który programista może uruchomić na własnym komputerze, będzie działać w dowolnym miejscu.
  3. Lekkie wdrożenie dzięki zastosowaniu warstw obrazu.

Samouczek Kubernetes, część 1: Aplikacje, mikrousługi i kontenery
Serwer WWW Nginx obsługujący pliki statyczne działające w kontenerze

Porównaliśmy maszyny wirtualne i kontenery tylko w kilku punktach, ale nawet to wystarczy, aby poznać mocne strony kontenerów. Tutaj Możesz znaleźć szczegółowe informacje na temat kontenerów Docker.

▍Budowanie obrazu kontenera dla aplikacji React

Podstawowym elementem konstrukcyjnym kontenera Docker jest plik Dockerfile. Na początku tego pliku zapisywany jest podstawowy obraz kontenera, następnie dołączana jest sekwencja instrukcji wskazujących, jak stworzyć kontener, który będzie spełniał potrzeby aplikacji.

Zanim zaczniemy pracować z plikiem Dockerfile, pamiętaj co zrobiliśmy, aby przygotować pliki aplikacji React do wgrania na serwer Nginx:

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

Poniżej można zobaczyć podobieństwa pomiędzy tworzeniem kontenera a powyższymi czynnościami wykonywanymi na komputerze lokalnym.

▍Przygotowanie pliku Docker dla aplikacji SA-Frontend

Instrukcje, które należy uwzględnić Dockerfile do zastosowania SA-Frontend, składają się tylko z dwóch drużyn. Faktem jest, że zespół programistów Nginx przygotował podstawowy obraz dla Nginx, które wykorzystamy do zbudowania naszego wizerunku. Oto dwa kroki, które musimy opisać:

  1. Musisz ustawić obraz Nginx jako podstawę obrazu.
  2. Zawartość folderu sa-frontend/build należy skopiować do folderu obrazów nginx/html.

Jeśli przejdziemy od tego opisu do pliku Dockerfile, wtedy będzie wyglądać tak:

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

Jak widać, wszystko tutaj jest bardzo proste, a nawet zawartość pliku okazuje się całkiem czytelna i zrozumiała. Ten plik nakazuje systemowi zrobienie obrazu nginx ze wszystkim, co już ma, i skopiuj zawartość katalogu build do katalogu nginx/html.

Tutaj możesz mieć pytanie dotyczące tego, skąd wiem, gdzie dokładnie skopiować pliki z folderu build, czyli skąd się wzięła ścieżka /usr/share/nginx/html. W rzeczywistości nie ma tu też nic skomplikowanego. Faktem jest, że odpowiednie informacje można znaleźć w opis wizerunek.

▍Składanie obrazu i przesyłanie go do repozytorium

Zanim będziemy mogli pracować z gotowym obrazem, musimy przesłać go do repozytorium obrazów. W tym celu wykorzystamy bezpłatną platformę do hostingu obrazów w chmurze Docker Hub. Na tym etapie pracy musisz wykonać następujące czynności:

  1. Zainstaluj Doker.
  2. Zarejestruj się w witrynie Docker Hub.
  3. Zaloguj się na swoje konto, uruchamiając następującą komendę w terminalu: 
    docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"

Teraz musisz za pomocą terminala przejść do katalogu sa-frontend i uruchom tam następujące polecenie:

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

Tutaj i poniżej w podobnych poleceniach $DOCKER_USER_ID należy zastąpić nazwą użytkownika w Docker Hub. Na przykład ta część polecenia może wyglądać tak: rinormaloku/sentiment-analysis-frontend.

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

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

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Po jej zakończeniu sprawdź swoją listę repozytoriów w Docker Hub, aby zobaczyć, czy obraz został pomyślnie wypchnięty do magazynu w chmurze.

▍Uruchomienie kontenera

Teraz każdy może pobrać i uruchomić obraz znany jako $DOCKER_USER_ID/sentiment-analysis-frontend. Aby to zrobić, musisz uruchomić 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, zrozummy projekt 80:80, który znajduje się w poleceniu uruchomienia obrazu i może wydawać się mylący.

  • Pierwsza liczba 80 to numer portu hosta (czyli komputera lokalnego).
  • Druga liczba 80 to port kontenera, do którego ma zostać przekierowane żądanie.

Rozważ następującą ilustrację.

Samouczek Kubernetes, część 1: Aplikacje, mikrousługi i kontenery
Przekierowanie portów

System przekazuje żądania z portu <hostPort> na port <containerPort>. To znaczy dostęp do portu 80 komputer jest przekierowywany do portu 80 pojemnik.

Od portu 80 otwarte na komputerze lokalnym, możesz uzyskać dostęp do aplikacji z tego komputera pod adresem localhost:80. Jeśli Twój system nie obsługuje Dockera, możesz uruchomić aplikację na maszynie wirtualnej Docker, której adres będzie wyglądał jak <docker-machine ip>:80. Aby znaleźć adres IP maszyny wirtualnej Docker, możesz użyć polecenia docker-machine ip.

W tym momencie, po pomyślnym uruchomieniu kontenera aplikacji front-end, powinno być możliwe otwarcie jego strony w przeglądarce.

▍ plik .dockerignore

Budowanie obrazu aplikacji SA-Frontend, mogliśmy zauważyć, że proces ten jest niezwykle powolny. Wynika to z faktu, że kontekst budowania obrazu musi zostać wysłany do demona Dockera. Katalog reprezentujący kontekst kompilacji jest podawany jako ostatni argument polecenia docker build. W naszym przypadku na końcu tego polecenia znajduje się kropka. Powoduje to uwzględnienie następującej struktury w kontekście zespołu:

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

Ale ze wszystkich obecnych tutaj folderów potrzebujemy tylko folderu build. Pobieranie czegokolwiek innego to strata czasu. Możesz przyspieszyć kompilację, mówiąc Dockerowi, które katalogi mają ignorować. W tym celu potrzebujemy pliku .dockerignore. Ty, jeśli znasz plik .gitignore, struktura tego pliku prawdopodobnie będzie wyglądać znajomo. Zawiera listę katalogów, które system budowania obrazu może zignorować. W naszym przypadku zawartość tego pliku wygląda następująco:

node_modules
src
public

plik .dockerignore musi znajdować się w tym samym folderze co plik Dockerfile. Teraz montaż obrazu zajmie kilka sekund.

Zajmijmy się teraz obrazem aplikacji Java.

▍Budowanie obrazu kontenera dla aplikacji Java

Wiesz co i nauczyłeś się już wszystkiego, czego potrzebujesz 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 tekst tego pliku, to spotkasz w nim tylko dwie nowe konstrukcje, które zaczynają się od słów kluczowych ENV и EXPOSE:

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

Słowo kluczowe ENV pozwala deklarować zmienne środowiskowe wewnątrz kontenerów Dockera. W szczególności w naszym przypadku umożliwia ustawienie adresu URL umożliwiającego dostęp do API aplikacji, która przeprowadza analizę tekstu.

Słowo kluczowe EXPOSE pozwala nakazać Dockerowi otwarcie portu. Będziemy używać tego portu podczas pracy z aplikacją. Tutaj możesz to zobaczyć w Dockerfile do zastosowania SA-Frontend nie ma takiego polecenia. Służy to wyłącznie celom dokumentacyjnym, innymi słowy, ta konstrukcja jest przeznaczona dla czytelnika Dockerfile.

Budowanie obrazu i umieszczanie go w repozytorium wygląda dokładnie tak, jak w poprzednim przykładzie. Jeśli nie jesteś jeszcze pewien swoich umiejętności, odpowiednie polecenia znajdziesz w pliku README.md w folderze sa-webapp.

▍Budowanie obrazu kontenera dla aplikacji w Pythonie

Jeśli spojrzysz na zawartość pliku Dockerfile w folderze sa-logicnie znajdziesz tam nic nowego. Polecenia służące do budowania obrazu i wypychania go do repozytorium również powinny być Ci znane, ale podobnie jak w przypadku innych naszych aplikacji można je znaleźć w pliku README.md w folderze sa-logic.

▍Testowanie aplikacji kontenerowych

Czy możesz zaufać czemuś, czego nie testowałeś? ja też nie mogę. Przetestujmy nasze pojemniki.

  1. Uruchommy kontener aplikacji sa-logic i skonfiguruj go do nasłuchiwania na porcie 5050: 
    docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
  2. Uruchommy kontener aplikacji sa-webapp i skonfiguruj go do nasłuchiwania na porcie 8080. Dodatkowo musimy ustawić port, na którym aplikacja Python będzie nasłuchiwać żądań z aplikacji Java poprzez ponowne przypisanie zmiennej środowiskowej SA_LOGIC_API_URL: 
    $ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://<container_ip or docker machine ip>:5000' $DOCKER_USER_ID/sentiment-analysis-web-app

Aby dowiedzieć się, jak znaleźć adres IP kontenera lub maszyny wirtualnej Docker, zapoznaj się z plikiem README.

Uruchommy kontener aplikacji sa-frontend:

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

Teraz wszystko jest gotowe do nawigacji w przeglądarce pod wskazany adres localhost:80 i przetestuj aplikację.

Pamiętaj, że jeśli zmienisz port dla sa-webapp, lub jeśli używasz maszyny wirtualnej Docker, musisz edytować plik App.js z folderu sa-frontendpoprzez zmianę adresu IP lub numeru portu w metodzie analyzeSentence()poprzez zastąpienie aktualnych informacji zamiast przestarzałych danych. Następnie musisz ponownie złożyć obraz i użyć go.

Tak wygląda teraz nasz schemat aplikacji.

Samouczek Kubernetes, część 1: Aplikacje, mikrousługi i kontenery
Mikrousługi działają w kontenerach

Podsumowanie: po co nam klaster Kubernetes?

Właśnie przejrzeliśmy pliki Dockerfile, mówił o tym, jak tworzyć obrazy i przekazywać je do repozytorium Dockera. Ponadto dowiedzieliśmy się, jak przyspieszyć montaż obrazów za pomocą pliku .dockerignore. W rezultacie nasze mikroserwisy działają teraz w kontenerach Docker. Tutaj możesz mieć całkowicie uzasadnione pytanie, dlaczego potrzebujemy Kubernetes. Odpowiedzi na to pytanie poświęcę drugą część tego materiału. W międzyczasie rozważ następujące pytanie:
Załóżmy, że nasza aplikacja internetowa do analizy tekstu stała się popularna na całym świecie. Co minutę napływają do niego miliony próśb. Oznacza to, że mikroserwisy sa-webapp и sa-logic będzie w ogromnym stresie. Jak skalować kontenery obsługujące mikroserwisy?

Samouczek Kubernetes, część 1: Aplikacje, mikrousługi i kontenery

Źródło: www.habr.com

Dodaj komentarz