A nosso pedido, Habr criou um hub e temos o prazer de colocar a primeira publicação nele. Se inscrever!
Kubernetes é fácil. Por que os bancos me pagam muito dinheiro para trabalhar nesta área, enquanto qualquer pessoa pode dominar esta tecnologia em apenas algumas horas?
Se você duvida que o Kubernetes possa ser aprendido tão rapidamente, sugiro que tente fazer isso sozinho. Ou seja, tendo dominado este material, você será capaz de executar uma aplicação baseada em microsserviços em um cluster Kubernetes. Posso garantir isso, pois é na mesma metodologia que utilizo aqui que ensino nossos clientes a trabalhar com Kubernetes. O que torna este guia diferente dos outros? Na verdade, muitas coisas. Portanto, a maioria desses materiais começa com uma explicação de coisas simples - os conceitos do Kubernetes e os recursos do comando kubectl. Os autores desses artigos presumem que o leitor esteja familiarizado com desenvolvimento de aplicativos, microsserviços e contêineres Docker. Iremos por outro caminho. Primeiro, vamos falar sobre como executar um aplicativo baseado em microsserviços em um computador. Em seguida, veremos a construção de imagens de contêiner para cada microsserviço. E em seguida conheceremos o Kubernetes e analisaremos a implantação de uma aplicação baseada em microsserviços em um cluster gerenciado pelo Kubernetes.
Essa abordagem, com uma abordagem gradual ao Kubernetes, dará a profundidade de compreensão do que está acontecendo que a pessoa média precisa para entender como tudo é organizado de forma simples no Kubernetes. Kubernetes é certamente uma tecnologia simples, desde que quem queira dominá-la saiba onde e como é utilizada.
Agora, sem mais delongas, vamos trabalhar e falar sobre o aplicativo com o qual trabalharemos.
Aplicativo experimental
Nosso aplicativo executará apenas uma função. Toma como entrada uma frase, após a qual, utilizando ferramentas de análise de texto, realiza uma análise de sentimento dessa frase, obtendo uma avaliação da atitude emocional do autor da frase em relação a determinado objeto.
Esta é a aparência da janela principal deste aplicativo.
Aplicativo Web de análise de sentimento
Do ponto de vista técnico, a aplicação é composta por três microsserviços, cada um dos quais resolve um determinado conjunto de tarefas:
- SA-Frontend é um servidor web Nginx que serve arquivos estáticos React.
- SA-WebApp é uma aplicação web escrita em Java que trata de solicitações do frontend.
- SA-Logic é um aplicativo Python que realiza análise de sentimento de texto.
É importante observar que os microsserviços não existem isoladamente. Eles implementam a ideia de “separação de funções”, mas, ao mesmo tempo, precisam interagir entre si.
Fluxos de dados no aplicativo
No diagrama acima, você pode ver os estágios numerados do sistema, ilustrando os fluxos de dados na aplicação. Vamos decompô-los:
- O navegador solicita um arquivo do servidor
index.html(que por sua vez carrega o pacote do aplicativo React). - O usuário interage com a aplicação, isso provoca uma chamada para uma aplicação web baseada em Spring.
- A aplicação web encaminha a solicitação para analisar o texto para a aplicação Python.
- O aplicativo Python analisa o sentimento do texto e retorna o resultado como resposta à solicitação.
- A aplicação Spring envia uma resposta para a aplicação React (que, por sua vez, mostra o resultado do texto analisado ao usuário).
O código para todos esses aplicativos pode ser encontrado . Eu recomendo que você copie este repositório para si mesmo agora, pois há muitos experimentos interessantes com ele pela frente.
Executando um aplicativo baseado em microsserviços na máquina local
Para que o aplicativo funcione, precisamos iniciar todos os três microsserviços. Vamos começar com o mais bonito deles – o aplicativo front-end.
▍Configurando o React para o desenvolvimento local
Para executar um aplicativo React, você precisa instalar a estrutura Node.js e o NPM em seu computador. Depois de instalar tudo isso, vá usando o terminal para a pasta do projeto sa-frontend e execute o seguinte comando:
npm install
Ao executar este comando na pasta node_modules serão carregadas as dependências da aplicação React, cujos registros estão no arquivo package.json. Após baixar as dependências na mesma pasta, execute o seguinte comando:
npm start
Isso é tudo. O aplicativo React agora está em execução e pode ser acessado navegando até o endereço do navegador localhost:3000. Você pode mudar algo no código dele. Você verá imediatamente o efeito dessas alterações no navegador. Isso é possível graças à chamada substituição "a quente" de módulos. Graças a isso, o desenvolvimento front-end se transforma em uma experiência simples e divertida.
▍Preparando um aplicativo React para produção
Para realmente usar um aplicativo React, precisamos convertê-lo em um conjunto de arquivos estáticos e servi-los aos clientes usando um servidor web.
Para construir o aplicativo React, novamente usando o terminal, navegue até a pasta sa-frontend e execute o seguinte comando:
npm run build
Isso criará um diretório na pasta do projeto build. Ele conterá todos os arquivos estáticos necessários para o funcionamento do aplicativo React.
▍ Servindo arquivos estáticos com Nginx
Primeiro você precisa instalar e executar o servidor web Nginx. você pode baixá-lo e encontrar instruções para instalá-lo e executá-lo. Então você precisa copiar o conteúdo da pasta sa-frontend/build para a pasta [your_nginx_installation_dir]/html.
Com esta abordagem, o arquivo gerado durante a montagem da aplicação React index.html estará disponível em [your_nginx_installation_dir]/html/index.html. Este é o arquivo que, por padrão, o servidor Nginx emite ao acessá-lo. O servidor está configurado para escutar em uma porta 80, mas você pode personalizá-lo da maneira que desejar editando o arquivo [your_nginx_installation_dir]/conf/nginx.conf.
Agora abra seu navegador e vá para localhost:80. Você verá a página do aplicativo React.
Aplicativo React servido pelo servidor Nginx
Se você inserir algo agora no campo Type your sentence e pressione o botão Send - nada vai acontecer. Mas, se você olhar para o console, poderá ver mensagens de erro lá. Para entender exatamente onde ocorrem esses erros, vamos analisar o código da aplicação.
▍Análise do código da aplicação front-end
Olhando o código do arquivo App.js, podemos ver que clicando no botão Send chama um método analyzeSentence(). O código para este método é mostrado abaixo. Ao mesmo tempo, preste atenção ao fato de que para cada linha onde há um comentário do formulário # Номер, há uma explicação dada abaixo do código. Da mesma forma, analisaremos outros fragmentos de código.
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. A URL para a qual a solicitação POST é feita. Presume-se que esse endereço seja um aplicativo aguardando tais solicitações.
2.O corpo da solicitação enviado ao aplicativo. Aqui está um exemplo de corpo de solicitação:
{
sentence: "I like yogobella!"
}
3.Quando uma resposta a uma solicitação é recebida, o estado do componente é atualizado. Isso faz com que o componente seja renderizado novamente. Se recebermos dados (ou seja, um objeto JSON contendo os dados inseridos e a pontuação do texto calculada), geraremos o componente Polaritydesde que as condições sejam satisfeitas. Aqui está como descrevemos o componente:
const polarityComponent = this.state.polarity !== undefined ?
<Polarity sentence={this.state.sentence}
polarity={this.state.polarity}/> :
null;
O código parece funcionar muito bem. O que há de errado aqui, afinal? Se você presumir que no endereço para o qual o aplicativo está tentando enviar uma solicitação POST ainda não há nada que possa aceitar e processar essa solicitação, você estará absolutamente certo. Ou seja, para processar solicitações que chegam ao endereço http://localhost:8080/sentiment, precisamos executar uma aplicação web baseada em Spring.
Precisamos de um aplicativo Spring que possa aceitar uma solicitação POST
▍Configurando um aplicativo web baseado em Spring
Para implantar um aplicativo Spring, você precisa de JDK8 e Maven e de variáveis de ambiente configuradas corretamente. Depois de instalar tudo isso, você pode continuar trabalhando em nosso projeto.
▍Empacotar o aplicativo em um arquivo jar
Navegue, usando o terminal, até a pasta sa-webapp e digite o seguinte comando:
mvn install
Depois de executar este comando na pasta sa-webapp diretório será criado target. É aqui que ficará localizada a aplicação Java, empacotada em um arquivo jar, representado pelo arquivo sentiment-analysis-web-0.0.1-SNAPSHOT.jar.
▍Iniciando um aplicativo Java
Vá para a pasta target e execute o aplicativo com o seguinte comando:
java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jarOcorrerá um erro ao executar este comando. Para começar a corrigi-lo, podemos analisar os detalhes da exceção nos dados de rastreamento de pilha:
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}"
Para nós, o mais importante aqui é a menção à impossibilidade de esclarecer o significado sa.logic.api.url. Vamos analisar o código onde ocorre o erro.
▍Análise de código de aplicativo Java
Aqui está o trecho de código onde ocorre o erro.
@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();
}
}- Em S
entimentControllerhá um camposaLogicApiUrl. Seu valor é definido pela propriedadesa.logic.api.url. - Linha
saLogicApiUrlconcatena com valor/analyse/sentiment. Juntos eles formam um endereço para fazer uma chamada ao microsserviço que realiza a análise de texto.
▍Definir um valor de propriedade
No Spring, a fonte padrão de valores de propriedade é um arquivo application.properties, que pode ser encontrado em sa-webapp/src/main/resources. Mas usá-lo não é a única maneira de definir valores de propriedades. Você também pode fazer isso com o seguinte comando:
java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=WHAT.IS.THE.SA.LOGIC.API.URLO valor desta propriedade deve apontar para o endereço da nossa aplicação Python.
Ao configurá-lo, informamos ao aplicativo da web Spring onde ele precisa ir para executar solicitações de análise de texto.
Para não complicar nossas vidas, decidiremos que o aplicativo Python estará disponível em localhost:5000 e tente não esquecer disso. Como resultado, o comando para iniciar o aplicativo Spring ficará assim:
java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=http://localhost:5000
Nosso sistema está faltando um aplicativo Python
Agora só precisamos executar a aplicação Python e o sistema funcionará conforme o esperado.
▍Configurando um aplicativo Python
Para executar um aplicativo Python, você deve ter o Python 3 e o Pip instalados e as variáveis de ambiente apropriadas definidas corretamente.
▍Instalar dependências
Vá para a pasta do projeto sa-logic/sa e execute os seguintes comandos:
python -m pip install -r requirements.txt
python -m textblob.download_corpora▍ Lançamento do aplicativo
Com as dependências instaladas, estamos prontos para executar a aplicação:
python sentiment_analysis.pyDepois de executar este comando, seremos informados do seguinte:
* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
Isso significa que o aplicativo está em execução e aguardando solicitações em localhost:5000/
▍Pesquisa de código
Vejamos o código do aplicativo Python para entender como ele responde às solicitações:
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- Inicialização de objeto
Flask. - Especificando o endereço para fazer solicitações POST.
- Recuperando uma propriedade
sentencedo corpo da solicitação. - Inicialização de objeto anônimo
TextBlobe obtendo o valorpolaritypara a primeira proposta recebida no corpo da solicitação (no nosso caso, esta é a única proposta submetida para análise). - Retornando uma resposta cujo corpo contém o texto da oferta e o indicador calculado para ela
polarity. - Lançando o aplicativo Flask, que estará disponível em
0.0.0.0:5000(você também pode acessá-lo usando uma construção do formuláriolocalhost:5000).
Agora os microsserviços que compõem o aplicativo estão em execução. Eles estão configurados para interagir uns com os outros. Esta é a aparência do diagrama do aplicativo nesta fase do trabalho.
Todos os microsserviços que compõem o aplicativo são colocados em um estado íntegro
Agora, antes de continuarmos, abra o aplicativo React em um navegador e tente analisar alguma frase com ele. Se tudo for feito corretamente - após pressionar o botão Send você verá os resultados da análise abaixo da caixa de texto.
Na próxima seção, falaremos sobre como executar nossos microsserviços em contêineres Docker. Isso é necessário para preparar o aplicativo para execução no cluster Kubernetes.
Contêineres Docker
é um sistema para automatizar a implantação, dimensionamento e gerenciamento de aplicativos em contêineres. Também é chamado de "orquestrador de contêineres". Se o Kubernetes funciona com contêineres, antes de usar este sistema, primeiro precisamos adquirir esses contêineres. Mas primeiro, vamos falar sobre o que são contêineres. Talvez a melhor resposta para a questão do que é possa ser encontrada em para Docker:
Uma imagem de contêiner é um pacote executável leve e independente que contém um aplicativo, que inclui tudo o que é necessário para executá-lo: código do aplicativo, ambiente de tempo de execução, ferramentas e bibliotecas do sistema, configurações. Os programas em contêineres podem ser usados em ambientes Linux e Windows e sempre funcionarão da mesma forma, independentemente da infraestrutura.
Isso significa que os containers podem ser executados em qualquer computador, inclusive servidores de produção, e em qualquer ambiente, as aplicações neles contidas funcionarão da mesma forma.
Para explorar os recursos dos contêineres e compará-los com outras maneiras de executar aplicativos, vejamos o exemplo de servir um aplicativo React usando uma máquina virtual e um contêiner.
▍ Servindo arquivos estáticos de um aplicativo React usando uma máquina virtual
Tentando organizar a manutenção de arquivos estáticos utilizando máquinas virtuais, encontraremos as seguintes desvantagens:
- Uso ineficiente de recursos, pois cada máquina virtual é um sistema operacional completo.
- Dependência de plataforma. O que funciona em algum computador local pode não funcionar em um servidor de produção.
- Dimensionamento lento e intensivo de recursos de uma solução de máquina virtual.
Servidor web Nginx servindo arquivos estáticos em execução em uma máquina virtual
Se contêineres forem usados para resolver um problema semelhante, então, em comparação com máquinas virtuais, os seguintes pontos fortes podem ser observados:
- Uso eficiente de recursos: trabalhe com o sistema operacional usando Docker.
- Independência de plataforma. Um contêiner que um desenvolvedor pode executar em seu próprio computador será executado em qualquer lugar.
- Implantação leve por meio do uso de camadas de imagem.
Servidor web Nginx servindo arquivos estáticos em execução em um contêiner
Comparamos máquinas virtuais e contêineres apenas em alguns pontos, mas mesmo isso é o suficiente para ter uma ideia dos pontos fortes dos contêineres. Você pode encontrar detalhes sobre contêineres Docker.
▍Construindo uma imagem de contêiner para um aplicativo React
O bloco de construção básico de um contêiner Docker é o arquivo Dockerfile. No início deste arquivo é gravada uma imagem base do container, em seguida é incluída uma sequência de instruções indicando como criar um container que atenda às necessidades de uma aplicação.
Antes de começarmos a trabalhar com o arquivo Dockerfile, lembre-se do que fizemos para preparar os arquivos do aplicativo React para upload no servidor Nginx:
- Construindo um pacote de aplicativo React (
npm run build). - Iniciando o servidor Nginx.
- Copiando o conteúdo de um diretório
buildda pasta do projetosa-frontendpara a pasta do servidornginx/html.
Abaixo você pode ver os paralelos entre a criação de um contêiner e as ações acima executadas no computador local.
▍Preparando um Dockerfile para o aplicativo SA-Fronend
Instruções a serem incluídas em Dockerfile para aplicação SA-Frontend, consistem em apenas duas equipes. O fato é que a equipe de desenvolvimento do Nginx preparou um básico para Nginx, que usaremos para construir nossa imagem. Aqui estão as duas etapas que precisamos descrever:
- Você precisa fazer da imagem Nginx a base da imagem.
- Conteúdo da pasta
sa-frontend/buildprecisa copiar para a pasta de imagensnginx/html.
Se passarmos desta descrição para o arquivo Dockerfile, então ficará assim:
FROM nginx
COPY build /usr/share/nginx/html
Como você pode ver, tudo aqui é muito simples, enquanto o conteúdo do arquivo acaba sendo bastante legível e compreensível. Este arquivo diz ao sistema para tirar a imagem nginx com tudo o que já possui e copie o conteúdo do diretório build para o diretório nginx/html.
Aqui você pode ter uma dúvida sobre como saber exatamente onde copiar os arquivos da pasta build, ou seja, de onde veio o caminho /usr/share/nginx/html. Na verdade, também não há nada complicado aqui. O fato é que as informações relevantes podem ser encontradas em imagem.
▍Montando a imagem e enviando-a para o repositório
Antes de podermos trabalhar com uma imagem completa, precisamos enviá-la ao repositório de imagens. Para fazer isso, usaremos a plataforma gratuita de hospedagem de imagens baseada em nuvem Docker Hub. Nesta fase do trabalho, você precisa fazer o seguinte:
- Instalar .
- Registre-se no site Docker Hub.
- Faça login em sua conta executando o seguinte comando no terminal:
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
Agora você precisa, usando o terminal, ir até o diretório sa-frontend e execute o seguinte comando lá:
docker build -f Dockerfile -t $DOCKER_USER_ID/sentiment-analysis-frontend .
Aqui e abaixo em comandos semelhantes $DOCKER_USER_ID deve ser substituído pelo seu nome de usuário no Docker Hub. Por exemplo, esta parte do comando pode ser assim: rinormaloku/sentiment-analysis-frontend.
Neste caso, este comando pode ser abreviado removendo dele -f Dockerfile, pois a pasta onde executamos este comando já possui este arquivo.
Para enviar a imagem finalizada para o repositório, precisamos do seguinte comando:
docker push $DOCKER_USER_ID/sentiment-analysis-frontendApós concluí-lo, verifique sua lista de repositórios no Docker Hub para ver se a imagem foi enviada com sucesso para o armazenamento em nuvem.
▍Iniciando um contêiner
Agora qualquer pessoa pode baixar e executar a imagem conhecida como $DOCKER_USER_ID/sentiment-analysis-frontend. Para fazer isso, você precisa executar a seguinte sequência de comandos:
docker pull $DOCKER_USER_ID/sentiment-analysis-frontend
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend
Agora o contêiner está em execução e podemos continuar trabalhando criando outras imagens de que precisamos. Mas antes de continuarmos, vamos entender o design 80:80, que se encontra no comando para executar a imagem e pode parecer confuso.
- Primeiro numero
80é o número da porta do host (ou seja, o computador local). - Segundo número
80é a porta do contêiner para a qual a solicitação deve ser redirecionada.
Considere a seguinte ilustração.
Encaminhamento de porta
O sistema encaminha solicitações da porta <hostPort> para o porto <containerPort>. Ou seja, acessando a porta 80 computador é redirecionado para uma porta 80 recipiente.
Desde o porto 80 aberto no computador local, você pode acessar o aplicativo deste computador em localhost:80. Se o seu sistema não suportar Docker, você poderá executar o aplicativo em uma máquina virtual Docker, cujo endereço será semelhante a <docker-machine ip>:80. Para descobrir o endereço IP da máquina virtual Docker, você pode usar o comando docker-machine ip.
Neste ponto, depois que o contêiner do aplicativo front-end for iniciado com êxito, você poderá abrir sua página em um navegador.
▍.dockerignore arquivo
Construindo a imagem do aplicativo SA-Frontend, pudemos notar que esse processo é extremamente lento. Isso ocorre porque o contexto de construção da imagem deve ser enviado ao daemon do Docker. O diretório que representa o contexto de construção é fornecido como último argumento do comando docker build. No nosso caso, há um ponto no final deste comando. Isso resulta na inclusão da seguinte estrutura no contexto da montagem:
sa-frontend:
| .dockerignore
| Dockerfile
| package.json
| README.md
+---build
+---node_modules
+---public
---src
Mas de todas as pastas aqui presentes, só precisamos de uma pasta build. Baixar qualquer outra coisa é uma perda de tempo. Você pode acelerar a construção informando ao Docker quais diretórios ignorar. Para fazer isso, precisamos de um arquivo .dockerignore. Você, se estiver familiarizado com o arquivo .gitignore, a estrutura deste arquivo provavelmente parecerá familiar. Ele lista os diretórios que o sistema de construção de imagens pode ignorar. No nosso caso, o conteúdo deste arquivo é assim:
node_modules
src
public
arquivo .dockerignore deve estar na mesma pasta do arquivo Dockerfile. Agora a montagem da imagem demorará alguns segundos.
Vamos agora lidar com a imagem de um aplicativo Java.
▍Construindo uma imagem de contêiner para um aplicativo Java
Você sabe de uma coisa e já aprendeu tudo o que precisa para criar imagens de contêiner. É por isso que esta seção será muito curta.
Abra o arquivo Dockerfile, que está localizado na pasta do projeto sa-webapp. Se você ler o texto deste arquivo, nele encontrará apenas duas novas construções que começam com palavras-chave ENV и EXPOSE:
ENV SA_LOGIC_API_URL http://localhost:5000
…
EXPOSE 8080
Palavra-chave ENV permite declarar variáveis de ambiente dentro de contêineres Docker. Em particular, no nosso caso, permite definir uma URL para acessar a API da aplicação que realiza a análise de texto.
Palavra-chave EXPOSE permite que você diga ao Docker para abrir uma porta. Usaremos esta porta enquanto trabalhamos com o aplicativo. Aqui você pode ver isso em Dockerfile para aplicação SA-Frontend não existe tal comando. Isto é apenas para fins de documentação, ou seja, esta construção é para o leitor Dockerfile.
Construir a imagem e enviá-la para o repositório é exatamente igual ao exemplo anterior. Se você ainda não está muito confiante em suas habilidades, os comandos correspondentes podem ser encontrados no arquivo README.md na pasta sa-webapp.
▍Construindo uma imagem de contêiner para um aplicativo Python
Se você der uma olhada no conteúdo do arquivo Dockerfile na pasta sa-logicvocê não encontrará nada de novo lá. Os comandos para construir a imagem e enviá-la para o repositório já devem ser familiares para você, mas, como no caso de nossos outros aplicativos, eles podem ser encontrados no arquivo README.md na pasta sa-logic.
▍Testando aplicativos em contêineres
Você pode confiar em algo que não testou? Eu também não posso. Vamos testar nossos contêineres.
- Vamos iniciar o contêiner do aplicativo
sa-logice configure-o para escutar em uma porta5050:docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic - Vamos iniciar o contêiner do aplicativo
sa-webappe configure-o para escutar em uma porta8080. Além disso, precisamos definir a porta na qual o aplicativo Python escutará as solicitações do aplicativo Java reatribuindo a variável de ambienteSA_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
Para saber como descobrir o endereço IP de um contêiner ou Docker VM, consulte o arquivo .
Vamos iniciar o contêiner do aplicativo sa-frontend:
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend
Agora está tudo pronto para navegar no navegador até o endereço localhost:80 e teste o aplicativo.
Observe que se você alterar a porta para sa-webapp, ou se estiver executando uma VM Docker, você precisará editar o arquivo App.js da pasta sa-frontendalterando o endereço IP ou número da porta no método analyzeSentence()substituindo informações atuais em vez de dados obsoletos. Depois disso, você precisa remontar a imagem e utilizá-la.
Esta é a aparência do nosso diagrama de aplicação agora.
Microsserviços executados em contêineres
Resumo: por que precisamos de um cluster Kubernetes?
Acabamos de revisar os arquivos Dockerfile, falou sobre como construir imagens e enviá-las para um repositório Docker. Além disso, aprendemos como agilizar a montagem de imagens utilizando o arquivo .dockerignore. Como resultado, nossos microsserviços agora estão sendo executados em contêineres Docker. Aqui você pode ter uma pergunta completamente justificada sobre por que precisamos do Kubernetes. A resposta a esta pergunta será dedicada à segunda parte deste material. Enquanto isso, considere a seguinte questão:
Vamos supor que nosso aplicativo web de análise de texto tenha se tornado popular em todo o mundo. Milhões de pedidos chegam a ele a cada minuto. Isso significa que microsserviços sa-webapp и sa-logic estará sob enorme estresse. Como dimensionar contêineres que executam microsserviços?
Fonte: habr.com