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

Concluído

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 Kubernetes k3d:

  1. No ambiente de código, alterne para a guia TERMINAL e, em seguida, execute estes comandos para instalar os pré-requisitos:

    sudo apt-get update
    sudo apt-get install -y apt-transport-https ca-certificates curl
    
  2. 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.

  3. Adicione o repositório Kubernetes ao seu apt configuração:

    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
    
  4. Agora, você pode instalar a ferramenta kubectl:

    sudo apt-get update
    sudo apt-get install -y kubectl
    
  5. Finalmente, instale o k3d implementação 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.

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

  2. 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
    
  3. 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.

  1. No separador 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.

  2. 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 sob a coluna READY e Running na coluna STATUS.

  3. Para testar o serviço, alterne para a guia PORTS, perto do endereço local da porta de back-end, selecione o ícone de globo. O navegador abre um novo separador nesse endereço.

  4. 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.

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

  2. 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
    
  3. Substitua o espaço reservado [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 completamente qualificado (FQDN), desconhecemos o endereço IP do microsserviço de back-end. Assim, usamos o nome que especificámos no nó metadata.name do Deployment. O Kubernetes cuida do resto.
  4. 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 de vitrine for exibida em execução sob a coluna STATUS, tudo estará pronto.

  5. Para testar o serviço Front End, alterne para o separador PORTAS e, depois, à direita do endereço local para a porta Front End, selecione o ícone de globo. O navegador exibe a página inicial.

  6. Selecione Produtos. O catálogo mostra os produtos da Contoso.

    Uma captura de tela da página de produtos eSHopLite.

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.