# Conectando um Frontend a um Backend usando Serviços
LLMS index: [llms.txt](/llms.txt)
---
Esta tarefa mostra como criar um microserviço *frontend* e um microserviço *backend*. O microserviço backend é um serviço que envia uma mensagem de saudação. O frontend expõe o backend usando o nginx e um objeto Service do Kubernetes.
## Objetivos
* Crie e execute um microserviço de backend de amostra chamado `hello` usando um objeto Deployment.
* Use um objeto de serviço (`Service`) para enviar tráfego para as várias réplicas do microserviço de backend.
* Crie e execute um microserviço de frontend chamado `nginx`, também usando um objeto `Deployment`.
* Configure o microserviço de frontend para enviar tráfego para o microserviço de backend.
* Use um objeto `Service` do tipo `LoadBalancer` para expor o microserviço de frontend fora do cluster.
## Antes de você começar
Você precisa ter um cluster do Kubernetes e a ferramenta de linha de comando kubectl deve estar configurada para se comunicar com seu cluster. É recomendado executar esse tutorial em um cluster com pelo menos dois nós que não estejam atuando como hosts de camada de gerenciamento. Se você ainda não possui um cluster, pode criar um usando o minikube ou pode usar um dos seguintes ambientes:
Para verificar a versão, digite kubectl version.
Esta tarefa utiliza [Serviços com balanceadores de carga externos](/docs/tasks/access-application-cluster/create-external-load-balancer/), que necessitam de um ambiente suportado. Se o seu ambiente não suportar isso, você pode substituir por um serviço do tipo [`NodePort`](/docs/concepts/services-networking/service/#type-nodeport).
## Criando o backend usando um Deployment.
O backend é um microserviço simples de saudação. Aqui está o arquivo de configuração para o Deployment do backend:
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: backend
spec:
selector:
matchLabels:
app: hello
tier: backend
track: stable
replicas: 3
template:
metadata:
labels:
app: hello
tier: backend
track: stable
spec:
containers:
- name: hello
image: "gcr.io/google-samples/hello-go-gke:1.0"
ports:
- name: http
containerPort: 80
...
Crie o `Deployment` do backend:
```shell
kubectl apply -f https://k8s.io/examples/service/access/backend-deployment.yaml
```
Veja informações sobre o `Deployment` do backend:
```shell
kubectl describe deployment backend
```
A saída é semelhante a esta:
```
Name: backend
Namespace: default
CreationTimestamp: Mon, 24 Oct 2016 14:21:02 -0700
Labels: app=hello
tier=backend
track=stable
Annotations: deployment.kubernetes.io/revision=1
Selector: app=hello,tier=backend,track=stable
Replicas: 3 desired | 3 updated | 3 total | 3 available | 0 unavailable
StrategyType: RollingUpdate
MinReadySeconds: 0
RollingUpdateStrategy: 1 max unavailable, 1 max surge
Pod Template:
Labels: app=hello
tier=backend
track=stable
Containers:
hello:
Image: "gcr.io/google-samples/hello-go-gke:1.0"
Port: 80/TCP
Environment:
Mounts:
Volumes:
Conditions:
Type Status Reason
---- ------ ------
Available True MinimumReplicasAvailable
Progressing True NewReplicaSetAvailable
OldReplicaSets:
NewReplicaSet: hello-3621623197 (3/3 replicas created)
Events:
...
```
## Criando o objeto Service `hello`
A chave para enviar solicitações do frontend para o backend é o `Service` do backend. Um `Service` cria um endereço IP persistente e uma entrada de nome DNS, para que o microserviço do backend possa ser sempre acessado. Um `Service` usa seletores para encontrar os `Pods` para os quais ele roteia o tráfego.
Primeiro, explore o arquivo de configuração do `Service`:
---
apiVersion: v1
kind: Service
metadata:
name: hello
spec:
selector:
app: hello
tier: backend
ports:
- protocol: TCP
port: 80
targetPort: http
...
No arquivo de configuração, você pode ver que o `Service`, chamado de `hello`, roteia o tráfego para Pods que possuem as labels `app: hello` e `tier: backend`.
Crie o `Service` para o backend:
```shell
kubectl apply -f https://k8s.io/examples/service/access/backend-service.yaml
```
Neste ponto, você possui um `Deployment` chamado `backend` executando três réplicas do seu aplicativo `hello` e possui um `Service` que pode rotear o tráfego para eles. No entanto, esse serviço ainda não pode ser acessado ou resolvido fora do cluster.
## Criando o frontend
Agora que o seu backend está em execução, você pode criar um frontend que seja acessível fora do cluster e se conecte ao backend por meio de solicitações de proxy.
O frontend envia solicitações para os worker Pods do backend usando o nome DNS fornecido ao Serviço do backend. O nome DNS é `hello`, que é o valor do campo `name` no arquivo de configuração `examples/service/access/backend-service.yaml`.
Os Pods no Deployment do frontend executam uma imagem nginx que é configurada para fazer proxy de solicitações para o Serviço de backend `hello`. Aqui está o arquivo de configuração nginx:
# The identifier Backend is internal to nginx, and used to name this specific upstream
upstream Backend {
# hello is the internal DNS name used by the backend Service inside Kubernetes
server hello;
}
server {
listen 80;
location / {
# The following statement will proxy traffic to the upstream named Backend
proxy_pass http://Backend;
}
}
Similarmente ao backend, o frontend possui um `Deployment` e um `Service`. Uma diferença importante a ser notada entre os serviços de backend e frontend é que a configuração do serviço de frontend tem o parâmetro `type: LoadBalancer`, o que significa que o serviço usa um balanceador de carga fornecido pelo provedor de nuvem e será acessível de fora do cluster.
---
apiVersion: v1
kind: Service
metadata:
name: frontend
spec:
selector:
app: hello
tier: frontend
ports:
- protocol: "TCP"
port: 80
targetPort: 80
type: LoadBalancer
...
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: frontend
spec:
selector:
matchLabels:
app: hello
tier: frontend
track: stable
replicas: 1
template:
metadata:
labels:
app: hello
tier: frontend
track: stable
spec:
containers:
- name: nginx
image: "gcr.io/google-samples/hello-frontend:1.0"
lifecycle:
preStop:
exec:
command: ["/usr/sbin/nginx","-s","quit"]
...
Crie o `Deployment` e o `Service` para o frontend:
```shell
kubectl apply -f https://k8s.io/examples/service/access/frontend-deployment.yaml
kubectl apply -f https://k8s.io/examples/service/access/frontend-service.yaml
```
A saída mostra que ambos os recursos foram criados:
```
deployment.apps/frontend created
service/frontend created
```
Nota
A configuração do nginx está incorporada à
imagem do contêiner. Uma maneira melhor de fazer isso seria usar um
ConfigMap, para que seja possível alterar a configuração com mais facilidade.
