🥇Kubernetes Tutorial Part 1: Applicazioni, Microservizi, è Containers

À a nostra dumanda, Habr hà creatu un hub Kubernetes è avemu piacè di mette a prima publicazione in questu. Abbonate!

Kubernetes hè faciule. Perchè i banche mi paganu assai soldi per travaglià in questa zona, mentre chì qualcunu pò ammaistrà sta tecnulugia in pocu ore?

Se dubbite chì Kubernetes pò esse imparatu cusì rapidamente, vi cunsigliu di pruvà à fà da sè stessu. Vale à dì, dopu avè ammaistratu stu materiale, puderà eseguisce una applicazione basata nantu à i microservizi in un cluster Kubernetes. Puderaghju guarantisce questu, perchè hè in a stessa metodulugia chì aghju utilizatu quì chì insegnu à i nostri clienti cumu travaglià cù Kubernetes. Chì face sta guida diversa da l'altri? In fatti, assai cose. Allora, a maiò parte di sti materiali cumincianu cù una spiegazione di e cose simplici - i cuncetti di Kubernetes è e caratteristiche di u cumandamentu kubectl. L'autori di sti articuli assumenu chì u so lettore hè familiarizatu cù u sviluppu di l'applicazioni, i microservizii è i cuntenituri Docker. Andemu da l'altra strada. Prima, parlemu di cumu eseguisce una applicazione basata nantu à i microservizi in un computer. Allora guardemu à custruisce l'imaghjini di u containeru per ogni microserviziu. E dopu, avemu da cunnosce Kubernetes è analizà a implementazione di una applicazione basata nantu à i microservizi in un cluster gestitu da Kubernetes.

Stu approcciu, cù un accostu graduale à Kubernetes, darà a prufundità di capiscenu di ciò chì succede chì a persona media hà bisognu per capisce cumu simpliciamente tuttu hè dispostu in Kubernetes. Kubernetes hè certamente una tecnulugia simplice, basta chì quellu chì vole ammaistrà sà induve è cumu si usa.

Avà, senza più, andemu à travaglià è parlemu di l'applicazione chì avemu da travaglià.

App sperimentale

A nostra applicazione farà una sola funzione. Piglia, cum'è input, una frase, dopu à quale, utilizendu strumenti di analisi di testu, eseguisce un analisi di sentimentu di sta frase, ottene una valutazione di l'attitudine emotiva di l'autore di a frase à un certu ughjettu.

Questu hè ciò chì a finestra principale di sta applicazione pare.

Applicazione Web per l'analisi di sentimenti

Da un puntu di vista tecnicu, l'applicazione hè custituita da trè microservizi, ognunu di i quali risolve un certu settore di compiti:

SA-Frontend hè un servitore web Nginx chì serve i schedarii statichi React.
SA-WebApp hè una applicazione web scritta in Java chì gestisce e richieste da u frontend.
SA-Logic hè una applicazione Python chì esegue l'analisi di sentimenti di testu.

Hè impurtante di nutà chì i microservizi ùn esistenu micca isolati. Implementanu l'idea di "separazione di funzioni", ma, à u stessu tempu, anu bisognu di interagisce cù l'altri.

I flussi di dati in l'applicazione

In u diagramma sopra, pudete vede e tappe numerate di u sistema, illustrandu i flussi di dati in l'applicazione. Scupritemu:

U navigatore dumanda un schedariu da u servitore index.html (chì à u turnu carica u pacchettu di l'app React).
L'utilizatore interagisce cù l'applicazione, questu provoca una chjama à una applicazione web basatu in Spring.
L'applicazione web trasmette a dumanda di analizà u testu à l'applicazione Python.
L'applicazione Python analizà u sentimentu di u testu è torna u risultatu cum'è una risposta à a dumanda.
L'applicazione Spring manda una risposta à l'applicazione React (chì, à u turnu, mostra u risultatu di u testu parsed à l'utilizatore).

U codice per tutte queste applicazioni pò esse truvatu ccà. Vi ricumandemu di copià stu repository à voi stessu avà, postu chì ci sò assai esperimenti interessanti cun ellu davanti à noi.

Eseguisce una applicazione basata nantu à i microservizi nantu à a macchina locale

Per chì l'applicazione funziona, avemu bisognu di inizià tutti i trè microservizi. Cuminciamu cù u più bellu di elli - l'applicazione front-end.

▍Installà React per u sviluppu lucale

Per eseguisce una applicazione React, avete bisognu di stallà u framework Node.js è NPM in u vostru urdinatore. Dopu à stallà tuttu chistu, vai cù u terminal à u cartulare prughjettu sa-frontend è eseguite u cumandimu seguitu:

npm install

Eseguendu stu cumandamentu in u cartulare node_modules i dependenzii di l'applicazione React seranu caricati, chì i registri sò in u schedariu package.json. Dopu avè scaricatu e dipendenze in u stessu cartulare, eseguite u cumandimu seguente:

npm start

Eccu tuttu. L'app React hè avà in esecuzione è si pò accede navigendu à l'indirizzu di u navigatore localhost:3000. Pudete cambià qualcosa in u so codice. Vi vede subitu l'effettu di sti cambiamenti in u navigatore. Questu hè pussibule grazia à u chjamatu "caldo" di rimpiazzamentu di moduli. Grazie à questu, u sviluppu front-end si trasforma in una sperienza simplice è piacevule.

▍Preparazione di una app React per a produzzione

Per u scopu di aduprà veramente una app React, avemu bisognu di cunvertisce in un inseme di fugliali statichi è serve à i clienti chì utilizanu un servitore web.

Per custruisce l'app React, torna cù u terminal, navigate à u cartulare sa-frontend è eseguite u cumandimu seguitu:

npm run build

Questu hà da creà un cartulare in u cartulare di u prughjettu build. Contenerà tutti i fugliali statici necessarii per u travagliu di l'applicazione React.

▍Servendu i fugliali statichi cù Nginx

Prima avete bisognu di stallà è eseguisce u servitore web Nginx. hè pudete scaricà è truvà struzzioni per stallà è eseguisce. Allora vi tocca à cupià u cuntenutu di u cartulare sa-frontend/build à u cartulare [your_nginx_installation_dir]/html.

Cù questu approcciu, u schedariu generatu durante l'assemblea di l'applicazione React index.html serà dispunibule à [your_nginx_installation_dir]/html/index.html. Questu hè u schedariu chì, per difettu, u servitore Nginx emette quandu accede à ellu. U servitore hè cunfiguratu per sente in un portu 80, ma pudete persunalizà a manera chì vulete editendu u schedariu [your_nginx_installation_dir]/conf/nginx.conf.

Avà apre u vostru navigatore è andate à localhost:80. Puderete vede a pagina di l'app React.

App React servuta da u servitore Nginx

Sè vo avà entre qualcosa in u campu Type your sentence è appughjà u buttone Send - ùn succede nunda. Ma, s'è vo fighjate à a cunsola, vi ponu vede missaghji errore ci. Per capisce esattamente induve sò questi errori, analizzemu u codice di l'applicazione.

▍Analisi di u codice di l'applicazione front-end

Fighjendu u codice di u schedariu App.js, pudemu vede chì clicchendu nant'à u buttone Send chjama un metudu analyzeSentence(). U codice per stu metudu hè mostratu quì sottu. À u listessu tempu, fate attenzione à u fattu chì per ogni linea à quale ci hè un cumentu di a forma # Номер, Ci hè una spiegazione datu sottu u codice. In u listessu modu, avemu da analizà 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 à quale hè fatta a dumanda POST. Questu indirizzu hè presumitu esse una applicazione chì aspetta tali richieste.

2.U corpu di dumanda mandatu à l'applicazione. Eccu un esempiu di corpu di dumanda:

{
    sentence: "I like yogobella!"
}

3.Quandu una risposta à una dumanda hè ricevutu, u statu di u cumpunente hè aghjurnatu. Questu face chì u cumpunente torna à rende. Se ricevemu dati (vale à dì, un ughjettu JSON chì cuntene i dati inseriti è u puntuatu di testu calculatu), avemu da pruduce u cumpunente. Polaritysempre chì e cundizioni sò scontri. Eccu cumu discrimu u cumpunente:

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

U codice pare di travaglià bè. Chì ci hè sbagliatu quì, in ogni modu? Se supponete chì à l'indirizzu à quale l'applicazione prova di mandà una dumanda POST, ùn ci hè nunda chì pò accettà è processà sta dumanda, allora sarete assolutamente ghjustu. Vale à dì, per processà e dumande chì venenu à l'indirizzu http://localhost:8080/sentiment, avemu bisognu di eseguisce una applicazione web basatu in Spring.

Avemu bisognu di una applicazione Spring chì pò accettà una dumanda POST

▍Setting up a web application based on Spring

Per implementà una applicazione Spring, avete bisognu di JDK8 è Maven è variabili d'ambiente cunfigurati bè. Dopu à stallà tuttu chistu, vi ponu cuntinuà à travaglià nant'à u nostru prughjettu.

▍Packing l'applicazione in un schedariu jar

Navigate, usendu u terminal, à u cartulare sa-webapp è entre u cumandimu seguente:

mvn install

Dopu à esecutà stu cumandamentu in u cartulare sa-webapp u cartulare serà creatu target. Hè quì chì l'applicazione Java serà situata, imballata in un schedariu jar, rapprisintatu da u schedariu sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Lanciare una Applicazione Java

Andà à u cartulare target è eseguite l'applicazione cù u cumandimu seguitu:

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

Un errore accade durante l'esecuzione di stu cumandamentu. Per cumincià à riparà, pudemu analizà i dettagli di l'eccezzioni in i dati di traccia di 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, u più impurtante quì hè a menzione di l'impossibilità di clarificà u significatu sa.logic.api.url. Analizemu u codice induve si trova l'errore.

▍Analisi di codice di l'applicazione Java

Eccu u snippet di codice induve si trova 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 ci hè un campu saLogicApiUrl. U so valore hè stabilitu da a pruprietà sa.logic.api.url.
Linea saLogicApiUrl cuncatena cù u valore /analyse/sentiment. Inseme formanu un indirizzu per fà una chjama à u microserviziu chì realiza l'analisi di testu.

▍Settà un valore di pruprietà

In primavera, a fonte predeterminata di i valori di pruprietà hè un schedariu application.properties, chì si pò truvà à sa-webapp/src/main/resources. Ma l'usu ùn hè micca l'unicu modu per stabilisce valori di pruprietà. Pudete ancu fà questu cù u cumandimu seguitu:

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

U valore di sta pruprietà deve indicà l'indirizzu di a nostra applicazione Python.

Per cunfigurà, dicemu à l'applicazione web Spring induve deve andà per fà e dumande di analisi di testu.

Per ùn cumplicà a nostra vita, decideremu chì l'applicazione Python serà dispunibule à localhost:5000 è pruvate micca di scurdà di questu. In u risultatu, u cumandimu per inizià l'applicazione Spring serà cusì:

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

U nostru sistema manca una applicazione Python

Avà solu avemu da eseguisce l'applicazione Python è u sistema funziona cum'è previstu.

▍ Configurazione di una applicazione Python

Per eseguisce una applicazione Python, duvete avè installatu Python 3 è Pip, è avete bisognu di e variabili di l'ambiente appropritate stabilite currettamente.

▍Installa dipendenze

Andà à u cartulare di prughjettu sa-logic/sa è eseguite i seguenti cumandamenti:

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

▍Lanciamentu di l'app

Cù e dipendenze installate, simu pronti per eseguisce l'applicazione:

python sentiment_analysis.py

Dopu avè eseguitu stu cumandamentu, ci sarà dettu u seguente:

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

Questu significa chì l'applicazione hè in esecuzione è aspittendu richieste à localhost:5000/

▍ Ricerca di codice

Fighjemu u codice di l'applicazione Python per capisce cumu risponde à e dumande:

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

Inizializazione di l'ughjettu Flask.
Specificà l'indirizzu per fà e dumande POST.
Ritruvà una pruprietà sentence da u corpu di dumanda.
Inizializazione di l'ughjettu anonimu TextBlob è ottene u valore polarity per a prima pruposta ricevuta in u corpu di a dumanda (in u nostru casu, questa hè l'unica pruposta sottumessa per l'analisi).
Riturnà una risposta, u corpu di quale cuntene u testu di l'offerta è l'indicatore calculatu per questu polarity.
Lanciamentu di l'applicazione Flask, chì serà dispunibule à 0.0.0.0:5000 (pudete ancu accede cù una custruzzione di a forma localhost:5000).

Avà i microservizi chì custituiscenu l'applicazione sò in esecuzione. Sò disposti per interagisce cù l'altri. Eccu ciò chì u diagramma di l'applicazione pare in questa fase di u travagliu.

Tutti i microservizi chì custituiscenu l'applicazione sò purtati à un statu sanu

Avà, prima di cuntinuà, apre l'app React in un navigatore è pruvate à analizà una frase cun ella. Sè tuttu hè fattu bè - dopu à appughjà u buttone Send vi vede i risultati di analisi sottu à a casella di testu.

In a sezione dopu, parlemu di cumu fà eseguisce i nostri microservizi in cuntenituri Docker. Questu hè necessariu per preparà l'applicazione per eseguisce in u cluster Kubernetes.

Contenitori Docker

Kubernetes hè un sistema per automatizà l'implementazione, a scala è a gestione di l'applicazioni containerizzate. Hè ancu chjamatu "orchestratore di cuntainer". Se Kubernetes travaglia cù cuntenituri, allora prima di utilizà stu sistema, avemu bisognu di acquistà sti cuntenituri. Ma prima, parlemu di ciò chì i cuntenituri sò. Forsi a megliu risposta à a quistione di ciò chì hè pò esse truvata ducumentazione à Docker:

Una maghjina di cuntainer hè un pacchettu liggeru, autocontenutu, eseguibile chì cuntene una applicazione, chì include tuttu ciò chì hè necessariu per eseguisce: codice di l'applicazione, ambiente di runtime, arnesi di sistema è biblioteche, paràmetri. I prugrammi cuntainerizzati ponu esse aduprati in l'ambienti Linux è Windows è sempre travaglià u listessu, indipendentemente da l'infrastruttura.

Questu significa chì i cuntenituri ponu esse eseguiti nantu à qualsiasi computer, cumpresi i servitori di pruduzzione, è in ogni ambiente, l'applicazioni cuntenute in elli funzionanu a stessa manera.

Per scopre e caratteristiche di i cuntenituri è paragunà cù altre manere di eseguisce l'applicazioni, fighjemu l'esempiu di serve una applicazione React utilizendu una macchina virtuale è un containeru.

▍Servendu i fugliali statichi di una applicazione React utilizendu una macchina virtuale

Pruvate d'urganizà u mantenimentu di i fugliali statichi cù e macchine virtuali, scontru i seguenti svantaghji:

Usu inefficace di risorse, postu chì ogni macchina virtuale hè un sistema operatore cumpletu.
Dipendenza di a piattaforma. Ciò chì funziona nantu à qualchì computer locale pò esse micca travagliatu in un servitore di produzzione.
Scala lenta è intensiva di risorse di una soluzione di macchina virtuale.

Servitore web Nginx chì serve file statici in esecuzione in una macchina virtuale

Se i cuntenituri sò usati per risolve un prublema simili, allora, in paragone cù e macchine virtuali, ponu esse nutati i seguenti punti di forza:

Usu efficiente di risorse: travaglià cù u sistema operatore cù Docker.
L'indipendenza di a piattaforma. Un cuntinuu chì un sviluppatore pò eseguisce nantu à u so propiu computer correrà in ogni locu.
Impiegazione ligera attraversu l'usu di strati d'imaghjini.

Servitore web Nginx chì serve file statici in esecuzione in un containeru

Avemu paragunatu solu e macchine virtuali è i cuntenituri in uni pochi di punti, ma ancu questu hè abbastanza per avè una sensazione di i punti di forza di i cuntenituri. hè Pudete truvà dettagli nantu à i cuntenituri Docker.

▍Custruisce una maghjina di cuntainer per una app React

U bloccu di basi di un containeru Docker hè u schedariu Dockerfile. À u principiu di stu schedariu, una maghjina di basa di u cuntinuu hè registrata, dopu una sequenza d'istruzzioni hè inclusa chì indica cumu creà un cuntinuu chì risponde à i bisogni di una applicazione.

Prima di principià à travaglià cù u schedariu Dockerfile, ricordate ciò chì avemu fattu per preparà i schedarii di l'applicazione React per uploading à u servitore Nginx:

Custruì un pacchettu di app React (npm run build).
Cumincià u servitore Nginx.
Copia u cuntenutu di un annuariu build da u cartulare di u prughjettu sa-frontend à u cartulare di u servitore nginx/html.

Quì sottu pudete vede i paralleli trà a creazione di un cuntinuu è l'azzioni sopra realizate nantu à l'urdinatore lucale.

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

Istruzzioni per esse incluse in Dockerfile per applicazione SA-Frontend, custituitu di solu dui squadre. U fattu hè chì a squadra di sviluppu Nginx hà preparatu una basa imagine per Nginx, chì avemu aduprà per custruisce a nostra imagina. Eccu i dui passi chì avemu bisognu di discrive:

Avete bisognu di fà l'imagine Nginx a basa di l'imaghjini.
U cuntenutu di u cartulare sa-frontend/build bisognu di cupià à u cartulare imagine nginx/html.

Se andemu da sta descrizzione à u schedariu Dockerfile, allora sarà cusì:

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

Comu pudete vede, tuttu quì hè assai simplice, mentre chì u cuntenutu di u schedariu hè ancu abbastanza leggibile è comprensibile. Stu schedariu dice à u sistema di piglià l'imaghjini nginx cù tuttu ciò chì hà digià, è copià u cuntenutu di u cartulare build à u repertoriu nginx/html.

Quì pudete avè una quistione in quantu à sapè induve esattamente copià i schedari da u cartulare build, vale à dì da induve vene a strada /usr/share/nginx/html. In fatti, ùn ci hè nunda complicatu ancu quì. U fattu hè chì l'infurmazioni pertinenti ponu esse truvati in descrizzione imagine.

▍Assembla l'imaghjina è caricala in u repository

Prima di pudè travaglià cù una maghjina cumpleta, avemu bisognu di mandà à u repositoriu di l'imaghjini. Per fà questu, useremu a piattaforma di hosting d'imaghjini gratuitu basata in nuvola Docker Hub. In questa fase di u travagliu, avete bisognu di fà i seguenti:

Installà Docker.
Registratevi nantu à u situ Docker Hub.
Entra in u vostru contu eseguendu u cumandimu seguitu in u terminal:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Avà avete bisognu, cù u terminal, andate à u cartulare sa-frontend è eseguite u cumandimu seguitu quì:

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

Quì è quì sottu in cumandamenti simili $DOCKER_USER_ID deve esse rimpiazzatu cù u vostru nome d'utilizatore in Docker Hub. Per esempiu, sta parte di u cumandamentu puderia vede cusì: rinormaloku/sentiment-analysis-frontend.

In questu casu, stu cumandamentu pò esse scurciatu sguassendu da ellu -f Dockerfile, postu chì u cartulare in quale eseguimu stu cumandimu hà digià stu schedariu.

Per mandà l'imagine finita à u repository, avemu bisognu di u cumandimu seguente:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Dopu avè finitu, verificate a vostra lista di repositori in Docker Hub per vede s'ellu l'imaghjini hè stata imbuttata bè in u cloud storage.

▍Starting un containeru

Avà qualchissia pò scaricà è eseguisce l'imaghjini cunnisciuti cum'è $DOCKER_USER_ID/sentiment-analysis-frontend. Per fà questu, avete bisognu di eseguisce a seguente sequenza di cumandamenti:

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

Avà u cuntinuu hè in esecuzione, è pudemu cuntinuà à travaglià creendu altre imagine chì avemu bisognu. Ma prima di cuntinuà, capiscemu u disignu 80:80, chì si trova in u cumandamentu per eseguisce l'imaghjini è pò esse cunfusu.

Primu numeru 80 hè u numeru di portu di l'ospite (vale à dì, l'urdinatore lucale).
Secondu numeru 80 hè u portu di u containeru à quale a dumanda deve esse ridiretta.

Cunsiderate l'illustrazione seguente.

Port Forwarding

U sistema trasmette e dumande da u portu <hostPort> à u portu <containerPort>. Questu hè, accede à u portu 80 l'urdinatore hè ridirettu à un portu 80 cuntainer.

Dapoi u portu 80 apertu nantu à l'urdinatore lucale, pudete accede à l'applicazione da questu computer à localhost:80. Se u vostru sistema ùn sustene micca Docker, pudete eseguisce l'applicazione nantu à una macchina virtuale Docker, l'indirizzu di quale sarà cum'è <docker-machine ip>:80. Per sapè l'indirizzu IP di a macchina virtuale Docker, pudete aduprà u cumandimu docker-machine ip.

À questu puntu, una volta chì u cuntinuu di l'app front-end hà lanciatu cù successu, duvete esse capace di apre a so pagina in un navigatore.

▍.dockerignore file

Custruisce l'imaghjini di l'applicazione SA-Frontend, Pudemu nutà chì stu prucessu hè estremamente lento. Questu hè chì u cuntestu di creazione di l'imaghjini deve esse mandatu à u demone Docker. U cartulare chì rapprisenta u cuntestu di custruzzione hè datu cum'è l'ultimu argumentu à u cumandamentu docker build. In u nostru casu, ci hè un puntu à a fine di stu cumandamentu. Questu risulta chì a seguente struttura hè inclusa in u cuntestu di l'assemblea:

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

Ma di tutti i cartulare prisenti quì, avemu solu bisognu di un cartulare build. Scaricamentu di qualcosa altru hè una perdita di tempu. Pudete accelerà a custruzzione dicendu à Docker quali cartulari ignurà. Per fà questu, avemu bisognu di un schedariu .dockerignore. Tu, s'è tù sai pràticu cù u schedariu .gitignore, a struttura di stu schedariu prubabilmente parerà familiar. Elenca i cartulari chì u sistema di creazione di l'imaghjini pò ignurà. In u nostru casu, u cuntenutu di stu schedariu s'assumiglia cusì:

node_modules
src
public

u schedariu .dockerignore deve esse in u listessu cartulare cum'è u schedariu Dockerfile. Avà l'assemblea di l'imaghjini duverà uni pochi seconde.

Trattemu avà di l'imaghjini per una applicazione Java.

▍Custruisce una maghjina di cuntainer per una applicazione Java

Sapete chì, è avete digià amparatu tuttu ciò chì avete bisognu per creà l'imaghjini di u containeru. Hè per quessa chì sta sezione serà assai corta.

Apertura u fugliale Dockerfile, chì si trova in u cartulare di u prughjettu sa-webapp. Se leghjite u testu di stu schedariu, allora in questu scuntrà solu dui novi custruzzioni chì cumincianu cù e parolle chjave ENV и EXPOSE:

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

Parolla chjave ENV permette di dichjarà variabili di l'ambiente in i cuntenituri Docker. In particulare, in u nostru casu, vi permette di stabilisce un URL per accede à l'API di l'applicazione chì realiza l'analisi di testu.

Parolla chjave EXPOSE permette di dì à Docker per apre un portu. Avemu da aduprà stu portu mentre travaglia cù l'applicazione. Quì pudete vede chì in Dockerfile per applicazione SA-Frontend ùn ci hè un tali cumandamentu. Questu hè solu per scopi di documentazione, in altre parolle, sta custruzzione hè per u lettore Dockerfile.

Custruì l'imaghjini è spinghjela à u repositoriu s'assumiglia esattamente à l'esempiu precedente. Se ùn site micca assai cunfidenza in e vostre capacità, i cumandamenti currispondenti ponu esse truvati in u schedariu README.md in cartulare sa-webapp.

▍Custruisce una maghjina di cuntainer per una applicazione Python

Se fate un ochju à u cuntenutu di u schedariu Dockerfile in cartulare sa-logicùn truverete nunda di novu quì. I cumandamenti per a custruzzione di l'imaghjini è di spinghje à u repositoriu deve esse digià familiarizatu per voi, ma, cum'è in u casu di e nostre altre applicazioni, ponu esse truvati in u schedariu. README.md in cartulare sa-logic.

▍Test d'applicazioni containerizzate

Pudete fidà di qualcosa chì ùn avete micca pruvatu? Ùn possu micca ancu. Testemu i nostri cuntenituri.

Cuminciamu u containeru di l'applicazione sa-logic è cunfigurà per sente in un portu 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Cuminciamu u containeru di l'applicazione sa-webapp è cunfigurà per sente in un portu 8080. Inoltre, avemu bisognu di stabilisce u portu nantu à quale l'applicazione Python ascolterà e dumande da l'applicazione Java riassignendu a variabile di l'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 sapè cumu truvà l'indirizzu IP di un containeru o Docker VM, riferite à u schedariu README.

Cuminciamu u containeru di l'applicazione sa-frontend:

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

Avà tuttu hè prontu per navigà in u navigatore à l'indirizzu localhost:80 è pruvà l'app.

Per piacè nutate chì si cambia u portu per sa-webapp, o se eseguite una VM Docker, avete bisognu di edità u schedariu App.js da u cartulare sa-frontendcambiendu l'indirizzu IP o u numeru di portu in u metudu analyzeSentence()sustituendu l'infurmazioni attuali invece di dati obsoleti. Dopu questu, avete bisognu di riunificà l'imaghjini è l'utilizanu.

Eccu ciò chì u nostru diagramma di l'applicazione pare avà.

I microservizi funzionanu in cuntenituri

Riassuntu: perchè avemu bisognu di un cluster Kubernetes?

Avemu ghjustu rivista i schedari Dockerfile, hà parlatu di cumu custruisce l'imaghjini è spinghje à un repository Docker. Inoltre, avemu amparatu cumu accelerà l'assemblea di l'imaghjini cù u schedariu .dockerignore. In u risultatu, i nostri microservizi sò avà in esecuzione in cuntenituri Docker. Quì pudete avè una quistione cumpletamente ghjustificata nantu à perchè avemu bisognu di Kubernetes. A risposta à sta quistione serà cunsacratu à a seconda parte di stu materiale. Intantu, cunsiderà a seguente quistione:
Assumimu chì a nostra applicazione web di analisi di testu hè diventata populari in u mondu sanu. Milioni di richieste venenu à ellu ogni minutu. Questu significa chì i microservizi sa-webapp и sa-logic sarà sottu à un stress enormu. Cumu scala i cuntenituri chì gestiscenu microservizi?

Source: www.habr.com

Kubernetes Tutorial Part 1: Applicazioni, Microservizi, è Containers