🥇Guida a Kubernetes, parte 1: applicazioni, microservizi e contenitori

Su nostra richiesta, Habr ha creato un hub Kubernetes ed è un piacere per noi pubblicare il primo articolo in esso. Iscriviti!

Kubernetes è semplice. Perché allora le banche mi pagano così tanto per lavorare in questo campo, mentre chiunque può imparare questa tecnologia in poche ore?

Se hai dei dubbi sul fatto che Kubernetes si possa apprendere così rapidamente, ti invito a provare tu stesso. In particolare, acquisendo questo materiale, potrai avviare un'applicazione basata su microservizi in un cluster Kubernetes. Posso garantirlo, poiché proprio con questo metodo, che è utilizzato qui, insegno ai nostri clienti a utilizzare Kubernetes. Cosa distingue questa guida dalle altre? In realtà, molte cose. La maggior parte di questi materiali inizia con la spiegazione di concetti semplici — i concetti di Kubernetes e le caratteristiche del comando kubectl. Gli autori di questi materiali presume che i lettori siano familiari con lo sviluppo di applicazioni, i microservizi e i contenitori Docker. Noi, invece, procederemo in un modo diverso. Inizieremo raccontando come avviare un'applicazione basata su microservizi sul computer. Poi esamineremo la creazione di immagini dei contenitori per ogni microservizio. E solo dopo ci familiarizzeremo con Kubernetes e analizzeremo il deployment di un'applicazione basata su microservizi in un cluster gestito da Kubernetes.

Questo approccio, avvicinandosi gradualmente a Kubernetes, darà la profondità di comprensione necessaria a una persona comune per capire quanto sia semplice tutto ciò che riguarda Kubernetes. Kubernetes è senza dubbio una tecnologia semplice, a condizione che colui che desidera impararla sappia dove e come viene utilizzata.

Ora, senza ulteriori indugi, iniziamo a lavorare e parliamo dell'applicazione con cui lavoreremo.

Applicazione sperimentale

La nostra applicazione avrà una sola funzione. Riceve come input una frase e, utilizzando strumenti di analisi del testo, esegue un'analisi del sentiment di quella frase, ottenendo una valutazione dell'atteggiamento emotivo dell'autore della frase nei confronti di un certo oggetto.

Ecco come appare la finestra principale di questa applicazione.

Web app per l'analisi del sentiment dei testi

Dal punto di vista tecnico, l'applicazione è composta da tre microservizi, ognuno dei quali affronta un determinato insieme di compiti:

SA-Frontend è un server web Nginx che serve file statici React.
SA-WebApp è un'applicazione web scritta in Java che gestisce le richieste dal frontend.
SA-Logic è un'applicazione Python che esegue l'analisi del sentimento del testo.

È importante notare che i microservizi non esistono in isolamento. Realizzano l'idea di "divisione dei compiti", ma devono interagire tra loro.

Flussi di dati nell'applicazione

Nello schema sopra riportato è possibile vedere i passaggi numerati del funzionamento del sistema, che illustrano i flussi di dati nell'applicazione. Analizziamoli:

Il browser richiede un file dal server index.html (che, a sua volta, carica il pacchetto dell'applicazione React).
L'utente interagisce con l'applicazione, il che provoca una chiamata all'applicazione web basata su Spring.
L'applicazione web inoltra la richiesta per l'analisi del testo all'applicazione Python.
L'applicazione Python esegue l'analisi del sentimento del testo e restituisce il risultato come risposta alla richiesta.
L'applicazione Spring invia la risposta all'applicazione React (che, a sua volta, mostra il risultato dell'analisi del testo all'utente).

Il codice per tutte queste applicazioni può essere trovato qui. Ti consiglio di copiare subito questo repository, poiché ci aspettano molti interessanti esperimenti con esso.

Esecuzione dell'applicazione basata su microservizi su un computer locale

Per fare funzionare l'applicazione, dobbiamo avviare tutti e tre i microservizi. Iniziamo con il più carino di essi: l'applicazione frontend.

▍Configurazione di React per lo sviluppo locale

Per avviare l'applicazione React, devi installare sul tuo computer la piattaforma Node.js e NPM. Dopo aver installato tutto questo, utilizza il terminale per andare nella cartella del progetto sa-frontend ed eseguire il seguente comando:

npm install

Grazie all'esecuzione di questo comando, nella cartella node_modules verranno scaricate le dipendenze dell'applicazione React, di cui sono registrate nel file package.json. Dopo aver completato il download delle dipendenze, nella stessa cartella esegui il seguente comando:

npm start

Ecco fatto. Ora l'applicazione React è in esecuzione, e puoi accedervi aprendo il browser all'indirizzo localhost:3000. Puoi modificare qualcosa nel suo codice. Gli effetti di queste modifiche li vedrai immediatamente nel browser. Questo è possibile grazie alla cosiddetta sostituzione "hot" dei moduli. Grazie a ciò, lo sviluppo front-end diventa un'attività semplice e piacevole.

▍Preparazione dell'app React per la produzione

Per l'uso reale dell'app React, dobbiamo convertirla in un insieme di file statici e fornirli ai client utilizzando un server web.

Per costruire l'app React, di nuovo, usando il terminale, vai nella cartella sa-frontend ed eseguire il seguente comando:

npm run build

Questo porterà alla creazione all'interno della cartella del progetto di una directory build. Essa conterrà tutti i file statici necessari per il funzionamento dell'app React.

▍Servire file statici con Nginx

Per iniziare, bisogna installare e avviare il server web Nginx. Qui puoi scaricarlo e trovare le istruzioni per l'installazione e l'avvio. Quindi, è necessario copiare il contenuto della cartella sa-frontend/build nella cartella [your_nginx_installation_dir]/html.

Con questo approccio, il file generato durante la build dell'app React index.html sarà disponibile all'indirizzo [your_nginx_installation_dir]/html/index.html. Questo è il file che il server Nginx restituisce per impostazione predefinita quando vi si accede. Il server è configurato per ascoltare la porta 80, ma può essere configurato come desideri modificando il file [your_nginx_installation_dir]/conf/nginx.conf.

Ora apri il browser e vai all'indirizzo localhost:80. Vedrai la pagina dell'app React.

App React servita da un server Nginx

Se adesso digiti qualcosa nel campo Type your sentence e premi il pulsante Send — non succederà niente. Ma se guardi nella console, puoi vedere messaggi di errore. Per comprendere dove avvengono questi errori, analizziamo il codice dell'app.

▍Analisi del codice dell'app front-end

Dando un'occhiata al codice del file App.js, possiamo vedere che il clic sul pulsante Send chiama il metodo analyzeSentence(). Il codice di questo metodo è riportato di seguito. Notate che ogni riga che ha un commento del tipo # Номер, ha una spiegazione riportata sotto il codice. Allo stesso modo, analizzeremo anche altri frammenti di codice.

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. URL a cui viene effettuata la richiesta POST. Si presume che a questo indirizzo ci sia un'applicazione in attesa di richieste di questo tipo.

2.Il corpo della richiesta inviato all'applicazione. Ecco un esempio del corpo della richiesta:

{
    sentence: "Mi piace yogobella!"
}

3.Quando si riceve una risposta alla richiesta, lo stato del componente viene aggiornato. Questo provoca un nuovo rendering del componente. Se riceviamo dati (cioè un oggetto JSON contenente i dati inseriti e la valutazione calcolata del testo), visualizzeremo il componente Polarità, poiché saranno rispettate le condizioni appropriate. Ecco come descriviamo il componente:

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

Il codice sembra essere del tutto funzionante. Qual è quindi il problema? Se ipotizzi che all'indirizzo a cui l'applicazione tenta di inviare la richiesta POST non ci sia nulla che possa ricevere e elaborare questa richiesta, avrai ragione. In particolare, per gestire le richieste inviate all'indirizzo http://localhost:8080/sentiment, dobbiamo avviare un'applicazione web basata su Spring.

Abbiamo bisogno di un'applicazione Spring in grado di ricevere una richiesta POST

▍Configurazione dell'applicazione web basata su Spring

Per distribuire l'applicazione Spring, avrai bisogno di JDK8 e Maven e di variabili d'ambiente configurate correttamente. Dopo aver installato tutto questo, puoi continuare a lavorare al nostro progetto.

▍Imballaggio dell'applicazione in un file jar

Accedi alla cartella sa-webapp e immetti il seguente comando:

mvn install

Dopo aver eseguito questo comando, nella cartella sa-webapp verrà creata una directory target. Qui si troverà l'applicazione Java imballata in un file jar, rappresentata dal file sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Avvio dell'applicazione Java

Vai alla cartella target e avvia l'applicazione con il seguente comando:

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

Durante l'esecuzione di questo comando si verificherà un errore. Per iniziare a risolverlo, possiamo analizzare le informazioni sull'eccezione nei dati dello stack trace:

Errore nella creazione del bean con nome 'sentimentController': fallita l'iniezione delle dipendenze autowire; eccezione nidificata è java.lang.IllegalArgumentException: impossibile risolvere il segnaposto 'sa.logic.api.url' nel valore "${sa.logic.api.url}"

Per noi qui la cosa più importante è la menzione dell'impossibilità di determinare il valore sa.logic.api.url. Analizziamo il codice in cui si verifica l'errore.

▍Analisi del codice Java dell'applicazione

Ecco un frammento di codice in cui si verifica l'errore.

@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();
    }
}

NentimentController c'è un campo saLogicApiUrl. Il suo valore è impostato dalla proprietà sa.logic.api.url.
Riga saLogicApiUrl è concatenato con il valore /analyse/sentiment. Insieme formano l'indirizzo per effettuare la chiamata al microservizio che esegue l'analisi del testo.

▍Impostazione del valore della proprietà

In Spring, la fonte standard dei valori di proprietà è il file application.properties, che può essere trovato all'indirizzo sa-webapp/src/main/resources. Ma il suo utilizzo non è l'unico modo per impostare i valori delle proprietà. Questo può essere fatto anche tramite un comando del tipo:

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

Il valore di questa proprietà dovrebbe puntare all'indirizzo della nostra applicazione Python.

Impostandolo, comunichiamo all'applicazione web Spring dove deve andare per eseguire le richieste di analisi del testo.

Per non complicarci la vita, decidiamo che l'applicazione Python sarà accessibile all'indirizzo localhost:5000 e cerchiamo di non dimenticarlo. Di conseguenza, il comando per avviare l'applicazione Spring sarà così:

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

Nella nostra sistema manca l'applicazione Python.

Ora non ci resta che avviare l'applicazione Python e il sistema funzionerà come previsto.

▍Configurazione dell'applicazione Python

Per avviare l'applicazione Python, devi avere installato Python 3 e Pip, e le rispettive variabili d'ambiente devono essere correttamente configurate.

▍Installazione delle dipendenze

Vai nella cartella del progetto sa-logic/sa ed esegui i seguenti comandi:

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

▍Avvio dell'applicazione

Dopo aver installato le dipendenze, siamo pronti per avviare l'applicazione:

python sentiment_analysis.py

Dopo aver eseguito questo comando, riceveremo il seguente messaggio:

* Running on http://0.0.0.0:5000/ (Premere CTRL+C per uscire)

Questo significa che l'applicazione è in esecuzione e sta aspettando richieste all'indirizzo localhost:5000/

▍Esplorazione del codice

Analizziamo il codice dell'applicazione Python per capire come risponde alle richieste:

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

Inizializzazione dell'oggetto Flask.
Impostazione dell'indirizzo per le richieste POST.
Estrazione della proprietà sentence dal corpo della richiesta.
Inizializzazione di un oggetto anonimo TextBlob e ottenimento del valore polarity per la prima frase ricevuta nel corpo della richiesta (nel nostro caso, si tratta di una sola frase inviata per l'analisi).
Restituzione della risposta, il cui corpo contiene il testo della frase e il valore calcolato per essa polarity.
Avvio dell'applicazione Flask, che sarà accessibile all'indirizzo 0.0.0.0:5000 (può essere raggiunta anche usando una costruzione come localhost:5000).

Ora i microservizi che compongono l'applicazione sono avviati. Sono configurati per interagire tra loro. Ecco come appare lo schema dell'applicazione a questo punto.

Tutti i microservizi che compongono l'applicazione sono stati messi in uno stato operativo

Ora, prima di continuare, apri l'applicazione React nel browser e prova ad analizzare una frase con essa. Se tutto è stato fatto correttamente, dopo aver premuto il pulsante Send vedrai i risultati dell'analisi sotto il campo di testo.

Nella prossima sezione parleremo di come avviare i nostri microservizi all'interno di contenitori Docker. Questo è necessario per preparare l'applicazione per l'esecuzione in un cluster Kubernetes.

Contenitori Docker

Kubernetes — è un sistema per automatizzare il dispiegamento, la scalabilità e la gestione delle applicazioni containerizzate. Viene anche chiamato "orchestratore di container" (container orchestrator). Se Kubernetes lavora con i container, prima di utilizzare questo sistema, dobbiamo prima acquisire questi container. Ma prima parliamo di cosa sono i container. Probabilmente la migliore risposta alla domanda su cosa siano si può trovare in documentazione Docker:

Un'immagine di container è un pacchetto autonomo e leggero che contiene un'applicazione e include tutto il necessario per eseguirla: il codice dell'applicazione, l'ambiente di esecuzione, gli strumenti di sistema e le librerie, le configurazioni. Le applicazioni containerizzate possono essere utilizzate in ambienti Linux e Windows e funzioneranno sempre in modo identico, indipendentemente dall'infrastruttura.

Ciò significa che i container possono essere eseguiti su qualsiasi computer, compresi i server di produzione, e in qualsiasi ambiente le applicazioni racchiuse in essi funzioneranno allo stesso modo.

Per esplorare le peculiarità dei container e confrontarle con altri modi di esecuzione delle applicazioni, consideriamo un esempio di gestione di un'applicazione React utilizzando una macchina virtuale e un container.

▍Gestione dei file statici di un'applicazione React tramite una macchina virtuale

Cercando di organizzare la gestione dei file statici utilizzando macchine virtuali, ci imbatteremo nei seguenti svantaggi:

Uso inefficiente delle risorse, poiché ogni macchina virtuale rappresenta un sistema operativo completo.
Dipendenza dalla piattaforma. Ciò che funziona su un certo computer locale potrebbe non funzionare affatto su un server di produzione.
Scalabilità lenta e che richiede molte risorse di una soluzione basata su macchine virtuali.

Il web server Nginx che gestisce i file statici, eseguito su una macchina virtuale.

Se invece utilizziamo i container per risolvere un compito simile, rispetto alle macchine virtuali, possiamo notare i seguenti punti di forza:

Uso efficiente delle risorse: lavorare con il sistema operativo tramite Docker.
Indipendenza dalla piattaforma. Un contenitore che lo sviluppatore può avviare sul proprio computer funzionerà ovunque.
Distribuzione leggera grazie all'uso di livelli di immagine.

Server web Nginx che serve file statici, eseguito all'interno di un contenitore

Abbiamo confrontato macchine virtuali e contenitori solo su alcuni punti, ma anche questo è sufficiente per percepire i punti di forza dei contenitori. Qui puoi trovare dettagli sui contenitori Docker.

▍Costruzione dell'immagine del contenitore per un'applicazione React

Il principale mattoncino del contenitore Docker è il file Dockerfile. All'inizio di questo file viene registrata l'immagine di base del contenitore, quindi include una sequenza di istruzioni che indica l'ordine di creazione del contenitore, che soddisferà le esigenze di una certa applicazione.

Prima di iniziare a lavorare con il file Dockerfile, ricordiamo cosa abbiamo fatto per preparare i file dell'applicazione React per il caricamento sul server Nginx:

Costruzione del pacchetto dell'applicazione React (npm run build).
Avvio del server Nginx.
Copia del contenuto della directory build dalla cartella del progetto sa-frontend nella cartella del server nginx/html.

Di seguito puoi vedere i paralleli tra la creazione di un contenitore e le azioni descritte sopra, eseguite su un computer locale.

▍Preparazione del file Dockerfile per l'applicazione SA-Frontend

Le istruzioni che conterrà Dockerfile per l'applicazione SA-Frontend, consistono in sole due comandi. Il fatto è che un gruppo di sviluppatori Nginx ha preparato un'immagine di base immagine per Nginx, che useremo per creare la nostra immagine. Ecco i due passaggi che dobbiamo descrivere:

L'immagine di base deve essere un'immagine Nginx.
Il contenuto della cartella sa-frontend/build deve essere copiato nella cartella dell'immagine nginx/html.

Se passiamo da questa descrizione al file Dockerfile, apparirà così:

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

Come puoi vedere, tutto qui è molto semplice, e il contenuto del file risulta anche abbastanza leggibile e comprensibile. Questo file dice al sistema di prendere l'immagine nginx con tutto ciò che ha già, e copiare il contenuto della directory build nella directory nginx/html.

Qui potresti avere una domanda riguardo a come so esattamente dove copiare i file dalla cartella build, cioè — da dove proviene il percorso /usr/share/nginx/html. In realtà, non c'è nulla di difficile. Il fatto è che le informazioni pertinenti possono essere trovate in descrizione dell'immagine.

▍Creazione dell'immagine e caricamento nel repository

Prima di poter lavorare con l'immagine pronta, dobbiamo caricarla nel repository delle immagini. A questo scopo, utilizzeremo la piattaforma cloud gratuita per l'hosting delle immagini Docker Hub. In questa fase del lavoro, è necessario fare quanto segue:

Installare Docker.
Registrati sul sito Docker Hub.
Accedi al tuo account eseguendo nel terminale il comando del seguente tipo:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Ora, è necessario, tramite il terminale, spostarsi nella directory sa-frontend ed eseguire lì il comando del seguente tipo:

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

Da qui in avanti in comandi simili $DOCKER_USER_ID deve essere sostituito con il tuo nome utente su Docker Hub. Ad esempio, questa parte del comando potrebbe apparire così: rinormaloku/sentiment-analysis-frontend.

A questo punto, questo comando può essere abbreviato rimuovendo -f Dockerfile, poiché nella cartella in cui eseguiamo questo comando, quel file è già presente.

Per caricare l'immagine pronta nel repository, abbiamo bisogno del seguente comando:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Dopo averlo eseguito, controlla l'elenco dei tuoi repository su Docker Hub per verificare se il caricamento dell'immagine nel cloud storage è avvenuto con successo.

▍Avvio del container

Ora chiunque può scaricare e avviare l'immagine, nota come $DOCKER_USER_ID/sentiment-analysis-frontend. Per fare ciò, è necessario eseguire la seguente sequenza di comandi:

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

Ora il container è in esecuzione e possiamo continuare a lavorare, creando altre immagini di cui abbiamo bisogno. Ma prima di proseguire, diamo un'occhiata alla costruzione 80:80, che appare nel comando di avvio dell'immagine e potrebbe sembrare poco chiara.

Il primo numero 80 è il numero di porta dell'host (cioè del computer locale).
Il secondo numero 80 è la porta del container, su cui la richiesta deve essere reindirizzata.

Esaminiamo la seguente illustrazione.

Reindirizzamento delle porte

Il sistema reindirizza le richieste dalla porta <hostPort> alla porta <containerPort>. Vale a dire, la richiesta alla porta 80 del computer viene reindirizzata alla porta 80 del container.

Poiché la porta 80 è aperta sul computer locale, è possibile accedere all'applicazione da questo computer all'indirizzo localhost:80. Se il tuo sistema non supporta Docker, puoi avviare l'applicazione su una macchina virtuale Docker, il cui indirizzo apparirà come :80. Per scoprire l'indirizzo IP della macchina virtuale Docker, puoi utilizzare il comando docker-machine ip.

A questo punto, dopo l'avvio riuscito del contenitore dell'applicazione frontend, dovresti avere la possibilità di aprire la sua pagina nel browser.

▍File .dockerignore

Mentre creavamo l'immagine dell'applicazione SA-Frontend, abbiamo notato che questo processo è estremamente lento. Questo accade perché deve essere inviato al demone Docker il contesto di costruzione dell'immagine. La directory che rappresenta il contesto di costruzione è specificata come ultimo argomento del comando docker build. Nel nostro caso, alla fine di questo comando c'è un punto. Questo porta a includere nella costruzione del contesto la seguente struttura:

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

Ma di tutte le cartelle presenti qui, ci serve solo la cartella build. Caricare qualcos'altro sarebbe solo una perdita di tempo. È possibile accelerare la costruzione indicando a Docker quali directory possono essere ignorate. È proprio per fare questo che abbiamo bisogno del file .dockerignore. Se sei familiare con il file .gitignore, la struttura di questo file ti sembrerà sicuramente familiare. In esso sono elencate le directory che il sistema di costruzione dell'immagine può ignorare. Nel nostro caso, il contenuto di questo file appare così:

node_modules
src
public

all'interno di ogni container per impostazione predefinita apparirà così: .dockerignore deve trovarsi nella stessa cartella in cui si trova il file Dockerfile. Ora la costruzione dell'immagine richiederà solo pochi secondi.

Passiamo ora all'immagine per l'applicazione Java.

▍Costruzione dell'immagine del contenitore per l'applicazione Java

Sai una cosa? Hai già studiato tutto il necessario per creare immagini dei contenitori. È per questo che questa sezione sarà molto breve.

Apri il file Dockerfile, che si trova nella cartella del progetto sa-webapp. Se leggi il testo di questo file, ti imbatterai in solo due nuove costruzioni, che iniziano con le parole chiave ENV e EXPOSE:

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

La parola chiave ENV permette di dichiarare variabili di ambiente all'interno dei contenitori Docker. In particolare, nel nostro caso, consente di specificare l'URL per accedere all'API dell'applicazione che esegue l'analisi del testo.

La parola chiave EXPOSE consente di indicare a Docker che la porta deve essere aperta. Intendiamo utilizzare questa porta durante il lavoro con l'applicazione. Qui si può notare che in Dockerfile per l'applicazione SA-Frontend non esiste un comando di questo tipo. Questo è necessario solo a scopo di documentazione, in altre parole, questa costruzione è destinata a chi dovrà leggere Dockerfile.

La creazione dell'immagine e l'invio nel repository appare esattamente come nell'esempio precedente. Se non sei ancora sicuro delle tue capacità, i comandi corrispondenti possono essere trovati nel file README.md nella cartella sa-webapp.

▍Creazione dell'immagine del contenitore per l'applicazione Python

Se dai un'occhiata al contenuto del file Dockerfile nella cartella sa-logic, non troverai nulla di nuovo. I comandi per la creazione dell'immagine e l'invio nel repository dovrebbero già esserti familiari, ma, come nel caso delle nostre altre applicazioni, possono essere trovati nel file README.md nella cartella sa-logic.

▍Testare le applicazioni containerizzate

Puoi fidarti di qualcosa che non hai testato? Anch'io non posso. Mettiamo alla prova i nostri contenitori.

Avviamo il contenitore dell'applicazione sa-logic e configurarlo per ascoltare sulla porta 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Avviamo il contenitore dell'applicazione sa-webapp e configurarlo per ascoltare sulla porta 8080. Inoltre, dobbiamo configurare la porta su cui l'applicazione Python attenderà richieste dall'applicazione Java, rinominando la variabile di ambiente SA_LOGIC_API_URL:
```
$ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://:5000' $DOCKER_USER_ID/sentiment-analysis-web-app
```

Per sapere come determinare l'indirizzo IP del contenitore o della macchina virtuale Docker, consultare il file README.

Avviamo il contenitore dell'applicazione sa-frontend:

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

Ora sei pronto per aprire il browser all'indirizzo localhost:80 e provare l'applicazione.

Si prega di notare che se hai modificato la porta per sa-webapp, o se stai lavorando con una macchina virtuale Docker, sarà necessario modificare il file App.js dalla cartella sa-frontend, cambiando l'indirizzo IP o il numero di porta nel metodo analyzeSentence(), sostituendo i dati obsoleti con informazioni aggiornate. Dopo questo, sarà necessario ricompilare l'immagine e utilizzarla.

Ecco come appare ora lo schema della nostra applicazione.

I microservizi vengono eseguiti all'interno dei contenitori

Conclusioni: perché abbiamo bisogno di un cluster Kubernetes?

Abbiamo appena esaminato i file Dockerfile, parlato su come costruire immagini e inviarle nel repository Docker. Inoltre, abbiamo imparato a velocizzare la creazione delle immagini utilizzando un file .dockerignore. Alla fine, i nostri microservizi ora vengono eseguiti in contenitori Docker. Qui potrebbe sorgere una domanda del tutto legittima su perché abbiamo bisogno di Kubernetes. La risposta a questa domanda sarà dedicata alla seconda parte di questo materiale. Nel frattempo, pensate alla seguente questione:
Supponiamo che la nostra applicazione web per l'analisi dei testi sia diventata famosa in tutto il mondo. Ogni minuto riceve milioni di richieste. Questo significa che i microservizi sa-webapp e sa-logic saranno sotto un'enorme pressione. Come possiamo scalare i contenitori in cui sono eseguiti i microservizi?

Fonte: habr.com