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

7 minutos

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

Importante

Antes de continuar, você precisa 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 comando curl separadamente.

Adicione o repositório do 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 back-end-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 do usuário do Docker.

Esse arquivo faz algumas coisas.

A primeira parte define uma especificação de implantação para o contêiner a ser implantado no Kubernetes. Ela especifica uma réplica, onde encontrar a imagem do contêiner e quais portas abrir no contêiner, e define algumas variáveis de ambiente. Esta 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 este 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á informando o Kubernetes para executar o arquivo que criamos. Ele baixa a imagem do Docker Hub e cria o contêiner.
O comando kubectl apply 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.

Crie um novo arquivo na pasta donet-kubernetes chamado 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 do usuário 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 seção spec.template.spec.containers.env. 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
```
Use 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 a mercadoria da Contoso.

Neste exercício, você criou um arquivo de implantação descrevendo exatamente como queria que os contêineres fossem executados no Kubernetes. Você fez com que o Kubernetes baixasse a imagem do Docker Hub e inicializasse os contêineres.

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

Instalar ferramentas e implementação do Kubernetes

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

Implantar e executar o microsserviço de back-end

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

Comentários