Exercício – Implantar um contêiner de microsserviço no Kubernetes

7 minutos

O Kubernetes executa contêineres para você. Você descreve o que deseja que o Kubernetes faça por meio de um arquivo YAML. Este exercício orienta você na criação do arquivo para que você possa implantar e executar o serviço de back-end no Kubernetes.

Importante

Antes de continuar, você deve ter certeza de que tem uma implementação do Kubernetes instalada. Usaremos a implementação k3d em execução no codespace. Iniciaremos o laboratório instalando essa implementação.

Instalar ferramentas e implementação do Kubernetes

Precisamos instalar a ferramenta kubectl e a implementação k3d do Kubernetes:

No codespace, alterne para a guia TERMINAL e execute estes comandos para instalar os pré-requisitos:
```
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl
```
Em seguida, para baixar a chave de assinatura para os repositórios de pacote do Kubernetes, execute estes comandos:
```
sudo mkdir /etc/apt/keyrings
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.28/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
```
Se você receber um erro de que o diretório já existe, execute o curl comando separadamente.

Adicione o repositório kubernetes à configuração do apt :

echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.28/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

Agora, você pode instalar a ferramenta kubectl :

sudo apt-get update
sudo apt-get install -y kubectl

Por fim, instale a implementação k3D do Kubernetes e crie um cluster:

curl -s https://raw.githubusercontent.com/k3d-io/k3d/main/install.sh | bash
k3d cluster create devcluster --config k3d.yml

Criar um arquivo de implantação para o serviço de back-end

Você pode criar uma implantação de contêiner de gerenciamento de arquivos no Kubernetes com um arquivo YAML. Vamos criar um arquivo para implantar o serviço de back-end.

Crie um novo arquivo na pasta donet-kubernetes do codespace denominado backend-deploy.yml.

Copie o texto a seguir no arquivo e salve-o.

---
apiVersion: apps/v1
kind: Deployment
metadata:
    name: productsbackend
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: productsbackend
    spec:
      containers:
      - name: productsbackend
        image: [YOUR DOCKER USER NAME]/productservice:latest
        ports:
        - containerPort: 80
        env:
        - name: ASPNETCORE_URLS
          value: http://*:80
  selector:
    matchLabels:
      app: productsbackend
---
apiVersion: v1
kind: Service
metadata:
  name: productsbackend
spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
    nodePort: 32001
  selector:
    app: productsbackend

Substitua o espaço reservado [YOUR DOCKER USER NAME] pelo nome de usuário real do Docker.

Este arquivo faz algumas coisas.

A primeira parte define uma especificação de implantação para o contêiner a ser implantado no Kubernetes. Ele especifica uma réplica, onde encontrar a imagem do contêiner, quais portas abrir no contêiner e define algumas variáveis de ambiente. Essa primeira parte também define rótulos e nomes que podem ser usados para fazer referência ao contêiner e à especificação.

Em seguida, a segunda parte define que o contêiner é executado como um serviço NodePort do Kubernetes. Para este módulo, você não precisa entender todas as especificidades do NodePorts. No entanto, você deve saber que esse tipo de serviço expõe um endereço IP externo para que você possa testar o serviço de fora do cluster.

Implantar e executar o microsserviço de back-end

Em seguida, vamos implantar e executar o microsserviço.

Na guia TERMINAL , execute o seguinte comando:
```
kubectl apply -f backend-deploy.yml
```
Esse comando está solicitando que o Kubernetes execute o arquivo que criamos. Ele baixa a imagem do Hub do Docker e cria o contêiner.
O kubectl apply comando retorna rapidamente. Mas a criação do contêiner pode demorar um pouco. Para exibir o progresso, use o código a seguir.
```
kubectl get pods
```
Na saída resultante, você tem uma linha com productsbackend seguida por uma cadeia de caracteres aleatórios na coluna NAME . Quando tudo estiver pronto, haverá um 1/1 na coluna READY e em execução na coluna STATUS .
Para testar o serviço, alterne para a guia PORTAS, próximo ao endereço local da porta Back End, selecione o ícone de globo. O navegador abre uma nova guia nesse endereço.

Para consultar alguns produtos, acrescente o endereço com /api/product e pressione Enter. Você deve ver algumas informações do produto listadas no formato JSON.

[
    {
        "id": 1,
        "name": "Solar Powered Flashlight",
        "description": "A fantastic product for outdoor enthusiasts",
        "price": 19.99,
        "imageUrl": "product1.png"
    },
    {
        "id": 2,
        "name": "Hiking Poles",
        "description": "Ideal for camping and hiking trips",
        "price": 24.99,
        "imageUrl": "product2.png"
    },
    {
        "id": 3,
        "name": "Outdoor Rain Jacket",
        "description": "This product will keep you warm and dry in all weathers",
        "price": 49.99,
        "imageUrl": "product3.png"
    },
    ...

Criar um arquivo de implantação e executar o serviço de front-end

Assim como o serviço de back-end, também precisamos de um arquivo de implantação para o front-end.

Criar um novo arquivo na pasta donet-kubernetes chamada frontend-deploy.yml

Cole o seguinte código no arquivo:

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: storefrontend
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: storefrontend
    spec:
      containers:
      - name: storefrontend
        image: [YOUR DOCKER USER NAME]/storeimage:latest
        ports:
        - containerPort: 80
        env:
        - name: ASPNETCORE_URLS
          value: http://*:80
        - name: ProductEndpoint
          value: http://productsbackend
  selector:
    matchLabels:
      app: storefrontend
---
apiVersion: v1
kind: Service
metadata:
  name: storefrontend
spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
    nodePort: 32000
  selector:
    app: storefrontend

Substitua o espaço reservado [YOUR DOCKER USERNAME] pelo nome de usuário real do Docker.

Observe que esse arquivo é semelhante ao que criamos para o microsserviço de back-end. Há duas diferenças:
- Estamos especificando um contêiner diferente para ser executado no valor spec.template.spec.containers.image da implantação.
- Há uma nova variável de ambiente na spec.template.spec.containers.env seção. O código no aplicativo storefrontend chama o back-end, mas como não especificamos um nome de domínio totalmente qualificado (FQDN), não sabemos o endereço IP do microsserviço de back-end, usamos o nome especificado no nó metadata.name do Deployment. O Kubernetes cuida do resto.
Implante o contêiner no Kubernetes com o seguinte comando:
```
kubectl apply -f frontend-deploy.yml
```
Novamente, você pode usar kubectl get pods para ver o status da implantação. Depois que a linha do storefrontend exibir Em execução na coluna STATUS, tudo estará pronto.
Para testar o serviço front-end, alterne para a guia PORTAS e, em seguida, à direita do endereço local da porta Front-End , selecione o ícone de globo. O navegador exibirá a página inicial.
Selecione Produtos. O catálogo mostra os produtos da Contoso.

Neste exercício, você criou um arquivo de implantação que descreveu exatamente como deseja que os contêineres sejam executados no Kubernetes. Em seguida, você fez o Kubernetes baixar a imagem do Hub do Docker e iniciar os contêineres.

Comentários

Esta página foi útil?