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-te na criação do ficheiro, para que possas implantar e executar o serviço de back-end no Kubernetes.

Importante

Antes de prosseguir, você deve ter certeza de que tem uma implementação do Kubernetes instalada. Usaremos a implementação k3d em execução no espaço de código. Iniciaremos o laboratório instalando esta implementação.

Instalar ferramentas e implementação do Kubernetes

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

No espaço de código, 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 pacotes 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 informando que o diretório já existe, execute o comando curl separadamente.

Adicione o repositório Kubernetes à sua configuração 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

Finalmente, 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 chamado backend-deploy.yml.

Copie o seguinte texto para o ficheiro e, em seguida, guarde-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 marcador [YOUR DOCKER USER NAME] pelo seu nome de utilizador 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. Esta primeira parte também define rótulos e nomes que podem ser usados para fazer referência ao contêiner e à especificação.

A segunda parte define que o contêiner é executado como um serviço Kubernetes NodePort. Para este módulo, você não precisa entender todas as especificidades de 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
```
Este comando está instruindo o Kubernetes para executar o arquivo que criámos. Ele baixa a imagem do Docker Hub e cria o contêiner.
O comando kubectl apply retorna rapidamente. Mas a criação de contêineres 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 sob a coluna NAME . Quando tudo estiver pronto, há um 1/1 na coluna READY e Running na coluna STATUS .
Para testar o serviço, alterne para o separador PORTAS, perto do endereço local para a porta Back End, selecione o ícone de globo. O navegador abre um novo separador 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 frontend.

Crie 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 marcador [YOUR DOCKER USERNAME] pelo seu nome de utilizador real do Docker.

Observe que esse arquivo é semelhante ao que criamos para o microsserviço de back-end. Existem duas diferenças:
- Estamos especificando um contêiner diferente para ser executado sob o valor de 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 na aplicação storefrontend chama o back-end, mas como não especificámos um nome de domínio totalmente qualificado (FQDN), não sabemos qual o endereço IP do microsserviço de back-end, usamos o nome que especificámos sob o 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. Assim que a linha do storefrontend exibir Em execução na coluna STATUS, tudo estará pronto para ser usado.
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 exibe 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 descrevia exatamente como você queria que os contêineres fossem executados no Kubernetes. Em seguida, o Kubernetes baixou a imagem do Docker Hub e iniciou os contêineres.

Comentários

Esta página foi útil?