🥇Kubernetes Tutorial Parte 1: Applicazioni, microservizi e container

Su nostra richiesta, Habr ha creato un hub kubernetes e siamo lieti di collocarvi la prima pubblicazione. Sottoscrivi!

Kubernetes è facile. Perché le banche mi pagano un sacco di soldi per lavorare in quest'area, mentre chiunque può padroneggiare questa tecnologia in poche ore?

Se dubiti che Kubernetes possa essere appreso così rapidamente, ti suggerisco di provare a farlo da solo. Vale a dire, dopo aver padroneggiato questo materiale, sarai in grado di eseguire un'applicazione basata su microservizi in un cluster Kubernetes. Posso garantirlo, perché è nella stessa metodologia che utilizzo qui che insegno ai nostri clienti come lavorare con Kubernetes. Cosa rende questa guida diversa dalle altre? In realtà, molte cose. Quindi, la maggior parte di questi materiali inizia con una spiegazione di cose semplici: i concetti di Kubernetes e le caratteristiche del comando kubectl. Gli autori di questi articoli presumono che il loro lettore abbia familiarità con lo sviluppo di applicazioni, i microservizi e i contenitori Docker. Andremo dall'altra parte. Innanzitutto, parliamo di come eseguire un'applicazione basata su microservizi su un computer. Quindi esamineremo la creazione di immagini del contenitore per ogni microservizio. Successivamente, faremo conoscenza con Kubernetes e analizzeremo l'implementazione di un'applicazione basata su microservizi in un cluster gestito da Kubernetes.

Questo approccio, con un approccio graduale a Kubernetes, fornirà la profondità di comprensione di ciò che sta accadendo di cui la persona media ha bisogno per capire quanto semplicemente tutto è organizzato in Kubernetes. Kubernetes è sicuramente una tecnologia semplice, a patto che chi vuole padroneggiarla sappia dove e come viene utilizzata.

Ora, senza ulteriori indugi, mettiamoci al lavoro e parliamo dell'applicazione con cui lavoreremo.

Applicazione sperimentale

La nostra applicazione eseguirà solo una funzione. Prende, come input, una frase, dopodiché, utilizzando strumenti di analisi del testo, esegue un'analisi del sentimento di questa frase, ottenendo una valutazione dell'atteggiamento emotivo dell'autore della frase nei confronti di un determinato oggetto.

Ecco come appare la finestra principale di questa applicazione.

Applicazione Web per l'analisi del sentiment

Da un punto di vista tecnico, l'applicazione è composta da tre microservizi, ognuno dei quali risolve un certo 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 sentiment del testo.

È importante notare che i microservizi non esistono isolatamente. Attuano l'idea della "separazione dei compiti", ma allo stesso tempo hanno bisogno di interagire tra loro.

Flussi di dati nell'applicazione

Nel diagramma sopra, puoi vedere le fasi numerate 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'app React).
L'utente interagisce con l'applicazione, questo provoca una chiamata a un'applicazione web basata su Spring.
L'applicazione web inoltra la richiesta di analizzare il testo all'applicazione Python.
L'applicazione Python analizza il sentimento del testo e restituisce il risultato come risposta alla richiesta.
L'applicazione Spring invia una risposta all'applicazione React (che, a sua volta, mostra all'utente il risultato del testo analizzato).

È possibile trovare il codice per tutte queste applicazioni qui. Ti consiglio di copiare questo repository su te stesso in questo momento, poiché ci sono molti esperimenti interessanti davanti a noi.

Esecuzione di un'applicazione basata su microservizi nel computer locale

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

▍Impostare React per lo sviluppo locale

Per eseguire un'applicazione React, devi installare il framework Node.js e NPM sul tuo computer. Dopo aver installato tutto questo, vai usando il terminale nella cartella del progetto sa-frontend ed esegui il seguente comando:

npm install

Eseguendo questo comando nella cartella node_modules verranno caricate le dipendenze dell'applicazione React, i cui record sono nel file package.json. Dopo aver scaricato le dipendenze nella stessa cartella, esegui il seguente comando:

npm start

È tutto. L'app React è ora in esecuzione ed è possibile accedervi accedendo all'indirizzo del browser localhost:3000. Puoi cambiare qualcosa nel suo codice. Vedrai immediatamente l'effetto di queste modifiche nel browser. Ciò è possibile grazie alla cosiddetta sostituzione "a caldo" dei moduli. Grazie a questo, lo sviluppo front-end si trasforma in un'esperienza semplice e divertente.

▍Preparazione di un'app React per la produzione

Ai fini dell'utilizzo effettivo di un'app React, dobbiamo convertirla in un insieme di file statici e servirli ai client utilizzando un server web.

Per creare l'app React, sempre utilizzando il terminale, vai alla cartella sa-frontend ed esegui il seguente comando:

npm run build

Questo creerà una directory nella cartella del progetto build. Conterrà tutti i file statici necessari per il funzionamento dell'applicazione React.

▍Servizio di file statici con Nginx

Per prima cosa devi installare ed eseguire il server web Nginx. Qui puoi scaricarlo e trovare le istruzioni per installarlo ed eseguirlo. Quindi è necessario copiare il contenuto della cartella sa-frontend/build nella cartella [your_nginx_installation_dir]/html.

Con questo approccio, il file generato durante l'assemblaggio dell'applicazione React index.html sarà disponibile a [your_nginx_installation_dir]/html/index.html. Questo è il file che, per impostazione predefinita, il server Nginx emette quando vi accede. Il server è configurato per l'ascolto su una porta 80, ma puoi personalizzarlo come preferisci modificando il file [your_nginx_installation_dir]/conf/nginx.conf.

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

App React servita dal server Nginx

Se ora inserisci qualcosa nel campo Type your sentence e premere il pulsante Send - non succederà nulla. Ma, se guardi la console, puoi vedere i messaggi di errore lì. Per capire esattamente dove si verificano questi errori, analizziamo il codice dell'applicazione.

▍Analisi del codice dell'applicazione front-end

Guardando il codice del file App.js, possiamo vedere che facendo clic sul pulsante Send chiama un metodo analyzeSentence(). Il codice per questo metodo è mostrato di seguito. Allo stesso tempo, presta attenzione al fatto che per ogni riga a cui è presente un commento del modulo # Номер, c'è una spiegazione fornita sotto il codice. Allo stesso modo, analizzeremo 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. L'URL a cui viene effettuata la richiesta POST. Si presume che questo indirizzo sia un'applicazione in attesa di tali richieste.

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

{
    sentence: "I like yogobella!"
}

3.Quando viene ricevuta una risposta a una richiesta, lo stato del componente viene aggiornato. Questo fa sì che il componente esegua nuovamente il rendering. Se riceviamo dati (ovvero un oggetto JSON contenente i dati immessi e il punteggio di testo calcolato), emetteremo il componente Polarityfintanto che le condizioni sono soddisfatte. Ecco come descriviamo il componente:

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

Il codice sembra funzionare abbastanza bene. Cosa c'è che non va qui, comunque? Se presumi che all'indirizzo a cui l'applicazione sta tentando di inviare una richiesta POST, non ci sia ancora nulla che possa accettare ed elaborare questa richiesta, allora avrai assolutamente ragione. Vale a dire, per elaborare le richieste che arrivano all'indirizzo http://localhost:8080/sentiment, dobbiamo eseguire un'applicazione Web basata su Spring.

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

▍Impostazione di un'applicazione web basata su Spring

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

▍Comprimere l'applicazione in un file jar

Passare, utilizzando il terminale, alla cartella sa-webapp e inserisci il seguente comando:

mvn install

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

▍Avvio di un'applicazione Java

Vai alla cartella target ed eseguire l'applicazione con il seguente comando:

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

Si verificherà un errore durante l'esecuzione di questo comando. Per iniziare a risolverlo, possiamo analizzare i dettagli dell'eccezione nei dati di traccia dello stack:

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}"

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

▍Analisi del codice dell'applicazione Java

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

A sentimentController c'è un campo saLogicApiUrl. Il suo valore è impostato dalla proprietà sa.logic.api.url.
fila saLogicApiUrl concatena con valore /analyse/sentiment. Insieme formano un indirizzo per effettuare una chiamata al microservizio che esegue l'analisi del testo.

▍Impostazione di un valore di proprietà

In Spring, l'origine predefinita dei valori delle proprietà è un file application.properties, che si trova su sa-webapp/src/main/resources. Ma usarlo non è l'unico modo per impostare i valori delle proprietà. Puoi anche farlo con il seguente comando:

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.

Configurandolo, diciamo all'applicazione Web Spring dove deve andare per eseguire le richieste di analisi del testo.

Per non complicarci la vita, decideremo che l'applicazione Python sarà disponibile su localhost:5000 e cerca di non dimenticartene. Di conseguenza, il comando per avviare l'applicazione Spring sarà simile al seguente:

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

Nel nostro sistema manca un'applicazione Python

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

▍Impostazione di un'applicazione Python

Per eseguire un'applicazione Python, è necessario che Python 3 e Pip siano installati e che le variabili di ambiente appropriate siano impostate correttamente.

▍Installare le dipendenze

Vai alla cartella del progetto sa-logic/sa ed eseguire i seguenti comandi:

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

▍Avvio dell'app

Con le dipendenze installate, siamo pronti per eseguire l'applicazione:

python sentiment_analysis.py

Dopo aver eseguito questo comando, ci verrà detto quanto segue:

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

Ciò significa che l'applicazione è in esecuzione e in attesa di richieste a localhost:5000/

▍Ricerca del codice

Diamo un'occhiata al 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.
Specificando l'indirizzo per effettuare richieste POST.
Recupero di una proprietà sentence dal corpo della richiesta.
Inizializzazione oggetto anonimo TextBlob e ottenere il valore polarity per la prima proposta ricevuta nel corpo della richiesta (nel nostro caso si tratta dell'unica proposta sottoposta ad analisi).
Restituendo una risposta, il cui corpo contiene il testo dell'offerta e l'indicatore calcolato per essa polarity.
Avvio dell'applicazione Flask, che sarà disponibile all'indirizzo 0.0.0.0:5000 (puoi accedervi anche utilizzando una costruzione del form localhost:5000).

Ora i microservizi che compongono l'applicazione sono in esecuzione. Sono impostati per interagire tra loro. Ecco come appare il diagramma dell'applicazione in questa fase del lavoro.

Tutti i microservizi che compongono l'applicazione vengono portati in uno stato integro

Ora, prima di continuare, apri l'app React in un browser e prova ad analizzare qualche frase con essa. Se tutto è stato eseguito correttamente, dopo aver premuto il pulsante Send vedrai i risultati dell'analisi sotto la casella di testo.

Nella prossima sezione parleremo di come eseguire i nostri microservizi nei container Docker. Ciò è necessario per preparare l'applicazione per l'esecuzione nel cluster Kubernetes.

Contenitori Docker

kubernetes è un sistema per automatizzare la distribuzione, il ridimensionamento e la gestione delle applicazioni containerizzate. È anche chiamato "orchestratore di contenitori". Se Kubernetes funziona con i container, prima di utilizzare questo sistema, dobbiamo prima acquisire questi container. Ma prima, parliamo di cosa sono i container. Forse la migliore risposta alla domanda su cosa sia può essere trovata in documentazione a Docker:

Un'immagine contenitore è un pacchetto leggero, autonomo ed eseguibile che contiene un'applicazione, che include tutto il necessario per eseguirla: codice dell'applicazione, ambiente di runtime, strumenti e librerie di sistema, impostazioni. I programmi containerizzati possono essere utilizzati sia in ambienti Linux che Windows e funzioneranno sempre allo stesso modo indipendentemente dall'infrastruttura.

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

Per esplorare le funzionalità dei contenitori e confrontarle con altri modi per eseguire le applicazioni, diamo un'occhiata all'esempio di servire un'applicazione React utilizzando una macchina virtuale e un contenitore.

▍Servizio di file statici di un'applicazione React utilizzando una macchina virtuale

Cercando di organizzare la manutenzione dei file statici utilizzando macchine virtuali, incontreremo i seguenti svantaggi:

Uso inefficiente delle risorse, poiché ogni macchina virtuale è un sistema operativo completo.
Dipendenza dalla piattaforma. Ciò che funziona su un computer locale potrebbe non funzionare su un server di produzione.
Ridimensionamento lento e ad alta intensità di risorse di una soluzione di macchina virtuale.

Server Web Nginx che serve file statici in esecuzione in una macchina virtuale

Se i container vengono utilizzati per risolvere un problema simile, allora, rispetto alle macchine virtuali, si possono notare i seguenti punti di forza:

Uso efficiente delle risorse: lavorare con il sistema operativo utilizzando Docker.
Indipendenza dalla piattaforma. Un contenitore che uno sviluppatore può eseguire sul proprio computer verrà eseguito ovunque.
Distribuzione leggera attraverso l'uso di livelli di immagine.

Server Web Nginx che serve file statici in esecuzione in un contenitore

Abbiamo confrontato macchine virtuali e container solo su pochi punti, ma anche questo è sufficiente per avere un'idea dei punti di forza dei container. Qui Puoi trovare dettagli sui contenitori Docker.

▍Creazione di un'immagine contenitore per un'app React

L'elemento costitutivo di base di un contenitore Docker è il file Dockerfile. All'inizio di questo file viene registrata un'immagine di base del contenitore, quindi viene inclusa una sequenza di istruzioni che indicano come creare un contenitore che soddisfi le esigenze di un'applicazione.

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

Creazione del pacchetto dell'app React (npm run build).
Avvio del server Nginx.
Copiare il contenuto di una directory build dalla cartella del progetto sa-frontend alla cartella del server nginx/html.

Di seguito puoi vedere i parallelismi tra la creazione di un contenitore e le azioni precedenti eseguite sul computer locale.

▍Preparazione di un Dockerfile per l'applicazione SA-Frontend

Istruzioni da inserire Dockerfile per l'applicazione SA-Frontend, consistono di soli due comandi. Il fatto è che il team di sviluppo di Nginx ha preparato una base immagine per Nginx, che useremo per costruire la nostra immagine. Ecco i due passaggi che dobbiamo descrivere:

Devi rendere l'immagine Nginx la base dell'immagine.
Contenuto della cartella sa-frontend/build è necessario copiare nella cartella dell'immagine nginx/html.

Se andiamo da questa descrizione al file Dockerfile, quindi sarà simile a questo:

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

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

Qui potresti avere una domanda su come so dove copiare esattamente i file dalla cartella build, cioè da dove viene il percorso /usr/share/nginx/html. In effetti, anche qui non c'è niente di complicato. Il fatto è che le informazioni pertinenti possono essere trovate in descrizione Immagine.

▍Assemblare l'immagine e caricarla nel repository

Prima di poter lavorare con un'immagine completa, dobbiamo inviarla al repository di immagini. Per fare ciò, utilizzeremo la piattaforma di hosting di immagini gratuita basata su cloud Docker Hub. In questa fase del lavoro, è necessario eseguire le seguenti operazioni:

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

Ora hai bisogno, usando il terminale, vai alla directory sa-frontend ed eseguire il seguente comando lì:

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

Qui e sotto in comandi simili $DOCKER_USER_ID dovrebbe essere sostituito con il tuo nome utente su Docker Hub. Ad esempio, questa parte del comando potrebbe essere simile a questa: rinormaloku/sentiment-analysis-frontend.

In questo caso, questo comando può essere abbreviato rimuovendolo da esso -f Dockerfile, poiché la cartella in cui eseguiamo questo comando ha già questo file.

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

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Dopo averlo completato, controlla l'elenco dei repository su Docker Hub per vedere se l'immagine è stata inviata correttamente all'archivio cloud.

▍Avvio di un contenitore

Ora chiunque può scaricare ed eseguire 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 contenitore è in esecuzione e possiamo continuare a lavorare creando altre immagini di cui abbiamo bisogno. Ma prima di continuare, capiamo il design 80:80, che si trova nel comando per eseguire l'immagine e può creare confusione.

Primo numero 80 è il numero di porta dell'host (ovvero il computer locale).
Secondo numero 80 è la porta del contenitore a cui deve essere reindirizzata la richiesta.

Considera la seguente illustrazione.

Port forwarding

Il sistema inoltra le richieste dalla porta <hostPort> al porto <containerPort>. Cioè, accedere al porto 80 computer viene reindirizzato a una porta 80 contenitore.

Dal porto 80 aperto sul computer locale, è possibile accedere all'applicazione da questo computer all'indirizzo localhost:80. Se il tuo sistema non supporta Docker, puoi eseguire l'applicazione su una macchina virtuale Docker, il cui indirizzo sarà simile <docker-machine ip>:80. Per scoprire l'indirizzo IP della macchina virtuale Docker, puoi utilizzare il comando docker-machine ip.

A questo punto, una volta avviato correttamente il contenitore dell'app front-end, dovresti essere in grado di aprire la sua pagina in un browser.

▍.dockerignore file

Creazione dell'immagine dell'applicazione SA-Frontend, potremmo notare che questo processo è estremamente lento. Questo perché il contesto di creazione dell'immagine deve essere inviato al daemon Docker. La directory che rappresenta il contesto di compilazione viene fornita come ultimo argomento del comando docker build. Nel nostro caso, c'è un punto alla fine di questo comando. In questo modo la seguente struttura viene inclusa nel contesto dell'assieme:

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

Ma di tutte le cartelle qui presenti, ci serve solo una cartella build. Scaricare qualsiasi altra cosa è una perdita di tempo. Puoi velocizzare la compilazione indicando a Docker quali directory ignorare. Per fare questo, abbiamo bisogno di un file .dockerignore. Tu, se hai familiarità con il file .gitignore, la struttura di questo file avrà probabilmente un aspetto familiare. Elenca le directory che il sistema di generazione dell'immagine può ignorare. Nel nostro caso, il contenuto di questo file è simile a questo:

node_modules
src
public

file .dockerignore deve trovarsi nella stessa cartella del file Dockerfile. Ora l'assemblaggio dell'immagine richiederà alcuni secondi.

Occupiamoci ora dell'immagine per un'applicazione Java.

▍Creazione di un'immagine contenitore per un'applicazione Java

Sai cosa e hai già imparato tutto il necessario per creare immagini contenitore. Ecco perché 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, in esso incontrerai solo due nuove costruzioni che iniziano con parole chiave ENV и EXPOSE:

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

Ключевое слово ENV consente di dichiarare le variabili di ambiente all'interno dei contenitori Docker. In particolare, nel nostro caso, consente di impostare un URL per accedere all'API dell'applicazione che esegue l'analisi del testo.

Ключевое слово EXPOSE consente di dire a Docker di aprire una porta. Utilizzeremo questa porta mentre lavoriamo con l'applicazione. Qui puoi vederlo dentro Dockerfile per l'applicazione SA-Frontend non esiste tale comando. Questo è solo a scopo di documentazione, in altre parole, questo costrutto è per il lettore Dockerfile.

Costruire l'immagine e inviarla al repository sembra esattamente come nell'esempio precedente. Se non sei ancora molto sicuro delle tue capacità, i comandi corrispondenti possono essere trovati nel file README.md nella cartella sa-webapp.

▍Creazione di un'immagine contenitore per un'applicazione Python

Se dai un'occhiata al contenuto del file Dockerfile nella cartella sa-logicnon troverai niente di nuovo lì. Anche i comandi per costruire l'immagine e inviarla al repository dovrebbero esserti familiari, ma, come nel caso delle altre nostre applicazioni, possono essere trovati nel file README.md nella cartella sa-logic.

▍Test di applicazioni containerizzate

Puoi fidarti di qualcosa che non hai testato? anch'io non posso. Testiamo i nostri contenitori.

Avviamo il contenitore dell'applicazione sa-logic e configurarlo per l'ascolto su una porta 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Avviamo il contenitore dell'applicazione sa-webapp e configurarlo per l'ascolto su una porta 8080. Inoltre, dobbiamo impostare la porta su cui l'applicazione Python ascolterà le richieste dall'applicazione Java riassegnando la variabile d'ambiente 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
```

Per informazioni su come trovare l'indirizzo IP di un container o di una macchina virtuale Docker, fare riferimento al file README.

Avviamo il contenitore dell'applicazione sa-frontend:

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

Ora tutto è pronto per navigare nel browser all'indirizzo localhost:80 e prova l'app.

Tieni presente che se cambi la porta per sa-webappo se stai eseguendo una Docker VM, dovrai modificare il file App.js dalla cartella sa-frontendmodificando l'indirizzo IP o il numero di porta nel metodo analyzeSentence()sostituendo le informazioni correnti invece dei dati obsoleti. Successivamente, è necessario riassemblare l'immagine e utilizzarla.

Ecco come appare ora il nostro diagramma dell'applicazione.

I microservizi vengono eseguiti in contenitori

Riepilogo: perché abbiamo bisogno di un cluster Kubernetes?

Abbiamo appena esaminato i file Dockerfile, ha parlato di come creare immagini e inviarle a un repository Docker. Inoltre, abbiamo imparato come velocizzare l'assemblaggio delle immagini utilizzando il file .dockerignore. Di conseguenza, i nostri microservizi sono ora in esecuzione nei container Docker. Qui potresti avere una domanda completamente giustificata sul motivo per cui abbiamo bisogno di Kubernetes. La risposta a questa domanda sarà dedicata alla seconda parte di questo materiale. Nel frattempo, considera la seguente domanda:
Supponiamo che la nostra applicazione web di analisi del testo sia diventata popolare in tutto il mondo. Gli arrivano milioni di richieste ogni minuto. Ciò significa che i microservizi sa-webapp и sa-logic sarà sottoposto a uno stress enorme. Come ridimensionare i contenitori che eseguono microservizi?

Fonte: habr.com

Kubernetes Tutorial Parte 1: Applicazioni, microservizi e container