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

Su nostra richiesta, Habr ha creato un hub Kubernetes e siamo lieti di pubblicare il primo articolo qui. Iscrivetevi!

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

Se hai dei dubbi su quanto velocemente si possa apprendere Kubernetes, ti invito a provare tu stesso. Infatti, studiando questo materiale, sarai in grado di avviare un'applicazione basata su microservizi all'interno di un cluster Kubernetes. Te lo posso garantire, poiché è proprio seguendo questo metodo che insegno ai nostri clienti a lavorare con Kubernetes. Cosa rende questa guida diversa dalle altre? In realtà, molte cose. La maggior parte di questi materiali inizia spiegando concetti basilari di Kubernetes e le peculiarità del comando kubectl. Gli autori di tali materiali presuppongono che i lettori abbiano già familiarità con lo sviluppo di applicazioni, con i microservizi e con i container Docker. Noi seguiremo un approccio diverso. Prima parleremo di come avviare sul computer un'applicazione basata su microservizi. Poi esamineremo la creazione delle immagini dei container per ciascun microservizio. Solo dopo ci familiarizzeremo con Kubernetes e analizzeremo il deployment di un'applicazione basata su microservizi in un cluster gestito da Kubernetes.

Questo approccio, con un graduale avvicinamento a Kubernetes, fornirà una comprensione profonda di ciò che accade, necessaria a una persona comune per comprendere quanto sia semplice tutto ciò che riguarda Kubernetes. Kubernetes è, senza dubbio, una tecnologia semplice, a patto che chi 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à un'unica funzione. Essa accetta, come input, una sola frase e, utilizzando strumenti di analisi testuale, esegue un'analisi del sentiment di quella frase, ottenendo una valutazione dell'atteggiamento emotivo dell'autore verso un dato oggetto.

Ecco come appare la finestra principale di questa applicazione.

Web app per l'analisi del sentiment nei testi

Dal punto di vista tecnico, l'applicazione è composta da tre microservizi, ciascuno dei quali risolve un insieme specifico di compiti:

SA-Frontend — server web Nginx che serve file statici di 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 sentiment 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, si possono vedere le fasi numerate del funzionamento del sistema, che illustrano i flussi di dati nell'applicazione. Analizziamoli:

Il browser richiede al server il file index.html (che, a sua volta, carica il pacchetto dell'applicazione React).
L'utente interagisce con l'applicazione, questo provoca una chiamata all'applicazione web basata su Spring.
L'applicazione web reindirizza la richiesta all'applicazione Python per eseguire l'analisi del testo.
L'applicazione Python esegue l'analisi del sentiment 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 è disponibile qui. Ti consiglio di copiare subito questo repository, poiché ci aspettano molti esperimenti interessanti con esso.

Avvio di un'applicazione basata su microservizi sul computer locale

Affinché l'applicazione funzioni, dobbiamo avviare tutti e tre i microservizi. Cominciamo con il più carino di tutti: l'applicazione frontend.

▍Configurazione di React per lo sviluppo locale

Per avviare un'applicazione React, devi installare Node.js e NPM sul tuo computer. Dopo aver effettuato queste installazioni, apri il terminale e vai nella cartella del progetto sa-frontend e digita il seguente comando:

npm install

Eseguendo questo comando, le dipendenze dell'applicazione React verranno scaricate nella cartella node_modules di cui sono registrate nel file package.json. Al termine del download delle dipendenze, nella stessa cartella esegui questo comando:

npm start

Ecco fatto. Ora l'applicazione React è in esecuzione e puoi accedervi aprendo il browser all'indirizzo localhost:3000. Puoi modificare il suo codice. Gli effetti di queste modifiche appariranno immediatamente nel browser. Questo è possibile grazie alla cosiddetta «sostituzione a caldo» dei moduli. Questo rende lo sviluppo front-end un'attività semplice e piacevole.

▍Preparazione dell'applicazione React per il deployment in produzione

Per l'uso reale dell'applicazione React, dobbiamo trasformarla in un insieme di file statici e servirli ai clienti utilizzando un server web.

Per costruire l'applicazione React, di nuovo, utilizzando il terminale, vai nella cartella sa-frontend e digita il seguente comando:

npm run build

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

▍Servire file statici con Nginx

Prima di tutto, è necessario installare e avviare il server web Nginx. Qui Puoi scaricarlo e trovare le istruzioni per l'installazione e l'avvio. Quindi, copia il contenuto della cartella sa-frontend/build nella cartella [your_nginx_installation_dir]/html.

Con questo approccio, il file generato durante il processo di build dell'applicazione React index.html sarà accessibile all'indirizzo [your_nginx_installation_dir]/html/index.html. Questo è il file che, per impostazione predefinita, il server Nginx restituisce quando viene richiamato. 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 dal server Nginx

Se adesso scrivi qualcosa nel campo Type your sentence e premi il pulsante Send non succederà nulla. Ma, se guardi nella console, puoi vedere i messaggi di errore. Per capire dove si verificano questi errori, analizziamo il codice dell'applicazione.

▍Analisi del codice dell'applicazione frontend

Dando un'occhiata al codice del file App.js, possiamo vedere che premere il pulsante Send invoca il metodo analyzeSentence(). Il codice di questo metodo è riportato di seguito. Tieni presente che ogni riga con un commento del tipo # Номер, ha una spiegazione fornita di seguito al codice. In questo 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. Presuppone 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 che contiene i dati inseriti e la valutazione calcolata del testo), visualizziamo il componente Polarità, poiché le condizioni appropriate saranno soddisfatte. Ecco come descriviamo il componente:

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

Il codice sembra essere funzionante. Qual è quindi il problema? Se si suppone che all'indirizzo a cui l'applicazione sta tentando di inviare la richiesta POST non ci sia nulla in grado di accettare e gestire questa richiesta, si avrebbe assolutamente ragione. Infatti, per gestire le richieste che arrivano all'indirizzo http://localhost:8080/sentiment, è necessario avviare un'applicazione web basata su Spring.

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

▍Impostazione dell'applicazione web basata su Spring

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

▍Imballaggio dell'applicazione in un file jar

Naviga, tramite il terminale, nella cartella sa-webapp e digita 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 impacchettata in un file jar, rappresentato dal file sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Esecuzione dell'applicazione Java

Naviga nella 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 durante la creazione del bean con nome 'sentimentController': l'iniezione delle dipendenze autowirate è fallita; eccezione annidata: java.lang.IllegalArgumentException: Impossibile risolvere il segnaposto 'sa.logic.api.url' nel valore "${sa.logic.api.url}"

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

▍Analisi del codice dell'applicazione Java

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

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

▍Assegnazione del valore della proprietà

In Spring, la fonte standard dei valori delle proprietà è il file application.properties, che si può trovare nel seguente percorso sa-webapp/src/main/resources. Tuttavia, il suo utilizzo non è l'unico modo per definire i valori delle proprietà. È possibile farlo anche mediante 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à deve indicare l'indirizzo della nostra applicazione Python.

Configurandolo, informiamo l'applicazione web Spring su dove deve inviare le richieste per l'analisi del testo.

Per semplificare le cose, 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

Nel nostro 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, è necessario avere Python 3 e Pip installati e le rispettive variabili d'ambiente correttamente configurate.

▍Installazione delle dipendenze

Accedi alla cartella del progetto sa-logic/sa e 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, ci verrà comunicato quanto segue:

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

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

▍Esplorazione del codice

Esaminiamo 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 effettuare richieste POST.
Estrazione della proprietà sentence dal corpo della richiesta.
Inizializzazione dell'oggetto anonimo TextBlob e ottenimento del valore polarity per la prima frase ricevuta nel corpo della richiesta (in questo caso, si tratta dell'unica frase inviata per l'analisi).
Restituzione della risposta, il cui corpo contiene il testo della frase e il punteggio calcolato per essa. polarity.
Avvio dell'applicazione Flask, accessibile all'indirizzo 0.0.0.0:5000 (si può accedervi anche utilizzando una costruzione del tipo localhost:5000).

Ora i microservizi che compongono l'applicazione sono stati avviati. Sono configurati per interagire tra loro. Ecco come appare lo schema dell'applicazione in questa fase di lavoro.

Tutti i microservizi che compongono l'applicazione sono stati portati in uno stato funzionante.

Ora, prima di continuare, apri l'applicazione React nel browser e prova ad analizzare qualche frase con essa. Se tutto è stato fatto correttamente, dopo aver cliccato sul 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 all'esecuzione nel cluster Kubernetes.

Contenitori Docker

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

Un'immagine di container è un pacchetto leggero, autonomo ed eseguibile che contiene un'applicazione, comprensivo di tutto il necessario per farla funzionare: 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 allo stesso modo indipendentemente dall'infrastruttura.

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

Per esplorare le caratteristiche dei container e confrontarle con altri metodi di esecuzione delle applicazioni, consideriamo l'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 tramite macchine virtuali, ci imbatteremo nei seguenti svantaggi:

Utilizzo 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 su un server di produzione.
Scalabilità lenta e che richiede molte risorse per una soluzione basata su macchine virtuali.

Web server Nginx che serve file statici, eseguito su una macchina virtuale

Se per risolvere un compito simile si applicano i container, rispetto alle macchine virtuali, si possono notare i seguenti punti di forza:

Utilizzo efficiente delle risorse: operare con il sistema operativo tramite Docker.
Indipendenza dalla piattaforma. Un container che uno sviluppatore può eseguire sul proprio computer funzionerà ovunque.
Distribuzione leggera grazie all'uso di layer delle immagini.

Server web Nginx che gestisce file statici, eseguito all'interno di un container.

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

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

Il componente principale di un container Docker è il file Dockerfile. All'inizio di questo file si registra l'immagine di base del container, quindi viene inclusa una sequenza di istruzioni che indica l'ordine di creazione del container in base alle esigenze di un'applicazione.

Prima di iniziare a lavorare con il file Dockerfile, ricordiamo cosa abbiamo fatto per preparare i file dell'applicazione React per la distribuzione 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 le parallele tra la creazione di un contenitore e le azioni sopra descritte eseguite su un computer locale.

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

Le istruzioni che saranno contenute in Dockerfile per l'applicazione SA-Frontend, consistono in sole due comandi. La questione è che un gruppo di sviluppatori Nginx ha preparato un immagine di base per Nginx che utilizzeremo per creare la nostra immagine. Ecco i due passaggi che dobbiamo descrivere:

La base dell'immagine deve essere l'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, esso apparirà così:

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

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

Qui potrebbe sorgere una domanda su come so dove esattamente copiare i file dalla cartella build, cioè — da dove proviene il percorso /usr/share/nginx/html. In realtà, non c'è nulla di complicato qui. Il fatto è che le informazioni pertinenti possono essere trovate in descrizione l'immagine.

▍Creazione dell'immagine e caricamento nel repository

Prima di poter lavorare con l'immagine pronta, dobbiamo inviarla al repository delle immagini. Per questo, utilizzeremo la piattaforma cloud gratuita per l'hosting delle immagini Docker Hub. A questo punto, devi fare quanto segue:

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

Ora dobbiamo, utilizzando il terminale, passare alla directory sa-frontend ed eseguire lì il comando del seguente tipo:

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

Qui e nelle successive 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.

In questo caso, possiamo abbreviare questo comando rimuovendo -f Dockerfile, poiché nella cartella in cui eseguiamo questo comando, quel file è già presente.

Per inviare l'immagine pronta al repository, abbiamo bisogno del seguente comando:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Dopo aver completato questa operazione, verifica l'elenco dei tuoi repository su Docker Hub per capire se l'immagine è stata inviata correttamente nel cloud storage.

▍Avvio del contenitore

Ora chiunque può scaricare e avviare l'immagine conosciuta come $DOCKER_USER_ID/sentiment-analysis-frontend. Per farlo, è 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 contenitore è in esecuzione e possiamo continuare a lavorare creando altre immagini di cui abbiamo bisogno. Ma prima di procedere, vediamo la struttura 80:80, che appare nel comando di avvio dell'immagine e potrebbe sembrare poco chiara.

Il primo numero 80 è il numero di porto dell'host (cioè del computer locale).
Il secondo numero 80 è il porto del contenitore, sul quale deve essere reindirizzata la richiesta.

Consideriamo la seguente illustrazione.

Reindirizzamento delle porte

Il sistema esegue il reindirizzamento delle richieste dal porto <hostPort> al porto <containerPort>. Cioè, la richiesta al porto 80 del computer viene reindirizzata al porto 80 del contenitore.

Poiché il porto 80 se è aperto su un computer locale, è possibile accedere all'applicazione da questo computer all'indirizzo localhost:80. Se il tuo sistema non supporta Docker, l'applicazione può essere eseguita 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 aver avviato con successo il contenitore dell'applicazione frontend, dovresti essere in grado di aprire la sua pagina nel browser.

▍File .dockerignore

Durante la creazione dell'immagine dell'applicazione SA-Frontend, potremmo notare che questo processo risulta estremamente lento. Ciò accade perché il demone Docker deve ricevere 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 struttura del contesto di costruzione quanto segue:

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

Ma di tutte le cartelle presenti qui, abbiamo bisogno solo della cartella build. Caricare qualsiasi altra cosa sarebbe una perdita di tempo. La costruzione può essere accelerata indicando a Docker quali directory ignorare. È proprio per questo che abbiamo bisogno del file .dockerignore. Per voi, se conoscete il file .gitignore, la struttura di questo file vi sembrerà familiare. Esso elenca le directory che il sistema di costruzione dell'immagine può ignorare. Nel nostro caso, il contenuto di questo file è così composto:

node_modules
src
public

File .dockerignore deve trovarsi nella stessa cartella del 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 un'applicazione Java

Sapete una cosa? Avete già appreso tutto il necessario per creare immagini dei contenitori. È per questo che questa sezione sarà piuttosto breve.

Aprite il file Dockerfile, che si trova nella cartella del progetto sa-webapp. Se leggete il testo di questo file, troverete 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 consente di dichiarare variabili ambientali all'interno dei contenitori Docker. In particolare, nel nostro caso, permette 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 è necessario aprire una porta. Utilizzeremo questa porta durante il lavoro con l'applicazione. Qui si può notare che nella Dockerfile per l'applicazione SA-Frontend di tale comando non è presente. Questo è necessario solo a fini documentativi, in altre parole, questa costruzione è destinata a coloro che leggeranno. Dockerfile.

La costruzione dell'immagine e l'invio della stessa nel repository avviene esattamente come nell'esempio precedente. Se non sei ancora molto sicuro delle tue capacità, puoi trovare i comandi corrispondenti nel file README.md nella cartella sa-webapp.

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

Se guardi il contenuto del file Dockerfile nella cartella sa-logic, non troverai nulla di nuovo per te. I comandi per costruire l'immagine e inviarla nel repository dovrebbero già esserti familiari, ma come nel caso delle nostre altre applicazioni, puoi trovarli nel file README.md nella cartella sa-logic.

▍Test di applicazioni containerizzate

Puoi fidarti di qualcosa che non hai testato? Anche io non posso. Proviamo i nostri container.

Avviamo il container dell'applicazione sa-logic e configuriamolo per ascoltare la porta 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Avviamo il container dell'applicazione sa-webapp e configuriamolo per ascoltare la porta 8080. Inoltre, dobbiamo configurare la porta su cui l'app Python attenderà richieste dall'app Java, rinominando la variabile d'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 scoprire come determinare l'indirizzo IP del container o della macchina virtuale Docker, consulta il file README.

Avviamo il container dell'applicazione sa-frontend:

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

Ora tutto è pronto per accedere nel browser all'indirizzo localhost:80 e testare l'applicazione.

Nota che se hai cambiato la porta per sa-webapp, o se stai lavorando con una macchina virtuale Docker, dovrai 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 le informazioni attuali. Dopo questo, dovrai ricompilare l'immagine e utilizzarla.

Ecco come appare ora lo schema della nostra applicazione.

I microservizi vengono eseguiti nei container

Conclusioni: perché abbiamo bisogno di un cluster Kubernetes?

Abbiamo appena esaminato i file Dockerfile, abbiamo parlato di come costruire le immagini e inviarle al repository Docker. Inoltre, abbiamo imparato a velocizzare la costruzione delle immagini utilizzando il file .dockerignore. Ora i nostri microservizi vengono eseguiti in contenitori Docker. Qui potrebbe sorgere una domanda legittima su perché abbiamo bisogno di Kubernetes. La risposta a questa domanda sarà trattata nel secondo parte di questo materiale. Nel frattempo, pensate alla seguente domanda:
Supponiamo che la nostra applicazione web per l'analisi dei testi sia diventata popolare in tutto il mondo. Ogni minuto riceve milioni di richieste. Ciò significa che i microservizi sa-webapp e sa-logic saranno sottoposti a un enorme carico. Come scalare i contenitori in cui vengono eseguiti i microservizi?

Fonte: habr.com