Hospedar um novo banco de dados usando o Azure Cosmos DB

  • 15 minutos

Agora que revisamos os conceitos básicos de estados externos e como lidar com eles usando o Kubernetes, vamos criar os recursos que darão suporte ao aplicativo da sua empresa de frete e, em seguida, criar o próprio aplicativo.

Criar um grupo de recursos

Importante

É preciso ter uma assinatura do Azure para fazer esse exercício, e isso pode gerar encargos. Caso ainda não tenha uma assinatura do Azure, crie uma conta gratuita antes de começar.

  1. Entre no portal do Azure com a sua própria assinatura.

  2. Abra o Cloud Shell e selecione Bash.

  3. Crie um grupo de recursos do Azure usando o comando az group create e especifique uma região. Este exemplo cria um grupo de recursos chamado rg-ship-manager na região eastus:

    az group create --name rg-ship-manager --location eastus

    A conclusão do processo de criação pode levar alguns minutos.

Criar o estado

Como descrevemos anteriormente, é possível, mas não recomendado, lidar com o estado no Kubernetes. O gerenciamento do estado de um aplicativo altamente disponível pode se tornar muito difícil quando você mesmo precisa gerenciar o estado.

Para resolver esse problema, vamos externalizar o estado para um aplicativo especializado em lidar com estado externo: Azure Cosmos DB.

Observação

Embora estejamos criando uma instância do Azure Cosmos DB como parte dos recursos necessários para executar o aplicativo, o AKS (Serviço de Kubernetes do Azure) e o Azure Cosmos DB não estão relacionados entre si.

  1. Crie variáveis do Bash para armazenar o nome da conta do Azure Cosmos DB e o nome do grupo de recursos para uso no restante do módulo.

    export RESOURCE_GROUP=rg-ship-manager
export COSMOSDB_ACCOUNT_NAME=contoso-ship-manager-$RANDOM

  2. Crie uma nova conta do Azure Cosmos DB usando o comando az cosmosdb create.

    az cosmosdb create --name $COSMOSDB_ACCOUNT_NAME --resource-group $RESOURCE_GROUP --kind MongoDB

    A conclusão do processo de criação pode levar alguns minutos.

  3. Crie um novo banco de dados usando o comando az cosmosdb mongodb database create. Neste exemplo, o banco de dados é denominado contoso-ship-manager.

    az cosmosdb mongodb database create --account-name $COSMOSDB_ACCOUNT_NAME --resource-group $RESOURCE_GROUP --name contoso-ship-manager

  4. Verifique se o banco de dados foi criado com êxito usando o comando az cosmosdb mongodb database list.

    az cosmosdb mongodb database list --account-name $COSMOSDB_ACCOUNT_NAME --resource-group $RESOURCE_GROUP -o table

    Seu resultado deve ser semelhante ao seguinte exemplo de saída:

    Name                  ResourceGroup
--------------------  ---------------
contoso-ship-manager  rg-ship-manager

Agora que você criou um estado externo para armazenar todos os dados do aplicativo gerenciador de navios, vamos criar o recurso do AKS para armazenar o aplicativo propriamente dito.

Criar o cluster do AKS

  1. Crie uma variável Bash para armazenar o nome do cluster para uso no restante do módulo.

    AKS_CLUSTER_NAME=ship-manager-cluster

  2. Crie um cluster do AKS usando o comando az aks create.

    az aks create --resource-group $RESOURCE_GROUP \
    --name $AKS_CLUSTER_NAME  \
    --node-count 3 \
    --generate-ssh-keys \
    --node-vm-size Standard_B2s \
    --enable-addons http_application_routing

    A conclusão do processo de criação pode levar alguns minutos.

    Observação

    Todos os serviços do Azure definem limites e cotas padrão para recursos e funcionalidades, incluindo restrições de uso para determinados SKUs de VM (máquina virtual). Se você encontrar um erro sugerindo que a SKU de VM desejada não está disponível na região selecionada, provavelmente precisará aumentar essa cota por meio de uma solicitação de suporte do Azure (para o tipo de problema, selecione Cota).

  3. Faça o download da configuração do kubectl usando o comando az aks get-credentials.

    az aks get-credentials --name $AKS_CLUSTER_NAME --resource-group $RESOURCE_GROUP

    Se você receber mensagens sobre clusters existentes, por exemplo:

    A different object named ship-manager-cluster already exists in your kubeconfig file.
Overwrite? (y/n):

    Insira y para substituir.

  4. Teste a configuração usando o comando kubectl get nodes.

    kubectl get nodes

    Seu resultado deve ser semelhante ao seguinte exemplo de saída:

    NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-12345678-vmss000000   Ready    agent   3m19s   v1.27.7
aks-nodepool1-12345678-vmss000001   Ready    agent   3m25s   v1.27.7
aks-nodepool1-12345678-vmss000002   Ready    agent   3m20s   v1.27.7

Implantar o aplicativo

Para criar o aplicativo, você precisa criar os arquivos YAML para implantar no Kubernetes.

Implantar a API de back-end

  1. Obtenha a cadeia de conexão do banco de dados do Azure Cosmos DB usando o comando az cosmosdb keys list.

    az cosmosdb keys list --type connection-strings -g $RESOURCE_GROUP -n $COSMOSDB_ACCOUNT_NAME --query "connectionStrings[0].connectionString" -o tsv

    Seu resultado deve ser semelhante ao seguinte exemplo de saída:

    mongodb://contoso-ship-manager-12345678.documents.azure.com:10255/?ssl=true&replicaSet=globaldb

  2. Crie um novo arquivo chamado backend-deploy.yml e cole na seguinte especificação de implementação:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: ship-manager-backend
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ship-manager-backend
  template:
    metadata:
      labels:
        app: ship-manager-backend
    spec:
      containers:
        - image: mcr.microsoft.com/mslearn/samples/contoso-ship-manager:backend
          name: ship-manager-backend
          resources:
            requests:
              cpu: 100m
              memory: 128Mi
            limits:
              cpu: 250m
              memory: 256Mi
          ports:
            - containerPort: 3000
              name: http
          env:
            - name: DATABASE_MONGODB_URI
              value: "{your database connection string}"
            - name: DATABASE_MONGODB_DBNAME
              value: contoso-ship-manager

  3. Substitua o espaço reservado {your database connection string} pela cadeia de conexão do banco de dados que você recuperou na etapa anterior.

    Observação

    Não se esqueça de adicionar aspas " às variáveis de ambiente, pois a cadeia de conexão às vezes apresenta caracteres YAML inválidos. Você pode considerar o uso de segredos como uma forma segura de armazenar e recuperar a cadeia de conexão no AKS.

  4. Salve e feche o arquivo.

  5. Aplique a implementação da API de back-end usando o comando kubectl apply.

    kubectl apply -f backend-deploy.yml

    Você deverá ver uma mensagem semelhante ao exemplo de saída a seguir:

    deployment.apps/ship-manager-backend created

Para tornar esse aplicativo disponível para todos, você precisa criar um serviço e uma entrada para cuidar do tráfego.

  1. Obtenha o endereço do servidor de API do cluster usando o comando az aks show.

    az aks show -g $RESOURCE_GROUP -n $AKS_CLUSTER_NAME -o tsv --query fqdn

    Seu resultado deve ser semelhante ao seguinte exemplo de saída:

    ship-manag-rg-ship-manager-a1bcd2-efghij56.hcp.eastus.azmk8s.io

  2. Crie um novo arquivo chamado backend-network.yml e cole a seguinte especificação de rede:

    apiVersion: v1
kind: Service
metadata:
  name: ship-manager-backend
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 3000
  selector:
    app: ship-manager-backend
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ship-manager-backend
spec:
  ingressClassName: webapprouting.kubernetes.azure.com
  rules:
  - host: <host-name>
    http:
      paths:
      - backend:
          service:
            name: ship-manager-backend
            port:
              number: 80
        path: /
        pathType: Prefix

  3. Substitua o espaço reservado <host-name> pela cadeia de conexão que você recuperou na etapa anterior.

  4. Salve e feche o arquivo.

  5. Aplique a implementação de rede de back-end usando o comando kubectl apply.

    kubectl apply -f backend-network.yml

    Seu resultado deve ser semelhante ao seguinte exemplo de saída:

    service/ship-manager-backend created
ingress.networking.k8s.io/ship-manager-backend created

    Acesse a API por meio do nome do host que você colou no recurso de entrada. O recurso de zona DNS do Azure pode levar até cinco minutos para concluir a detecção de DNS. Se você não conseguir acessar a API imediatamente, aguarde alguns minutos e tente novamente.

  6. Verifique o status da entrada consultando o Kubernetes sobre as entradas disponíveis usando o comando kubectl get ingress.

    kubectl get ingress

    Quando o campo ENDEREÇO na saída estiver preenchido, isso significa que a entrada foi implantada e está pronta para ser acessada, conforme mostrado no exemplo de saída a seguir:

    NAME                   CLASS                                HOSTS                                                               ADDRESS        PORTS   AGE
ship-manager-backend   webapprouting.kubernetes.azure.com   ship-manag-rg-ship-manager-a1bcd2-efghij56.hcp.eastus.azmk8s.io     xx.xx.xx.xx    80      2m40s

Implantar a interface de front-end

  1. Crie um novo arquivo chamado frontend-deploy.yml e cole a seguinte especificação de implementação:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: ship-manager-frontend
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ship-manager-frontend
  template:
    metadata:
      labels:
        app: ship-manager-frontend
    spec:
      containers:
        - image: mcr.microsoft.com/mslearn/samples/contoso-ship-manager:frontend
          name: ship-manager-frontend
          imagePullPolicy: Always
          resources:
            requests:
              cpu: 100m
              memory: 128Mi
            limits:
              cpu: 250m
              memory: 256Mi
          ports:
            - containerPort: 80
          volumeMounts:
            - name: config
              mountPath: /usr/src/app/dist/config.js
              subPath: config.js
      volumes:
        - name: config
          configMap:
            name: frontend-config
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: frontend-config
data:
  config.js: |
    const config = (() => {
      return {
        'VUE_APP_BACKEND_BASE_URL': 'http://{YOUR_BACKEND_URL}',
      }
    })()

  2. Substitua o espaço reservado {YOUR_BACKEND_URL} pela URL do nome do host da API de back-end que você recuperou na seção anterior.

  3. Salve e feche o arquivo.

  4. Aplique a implantação de front-end usando o comando kubectl apply.

    kubectl apply -f frontend-deploy.yml

    Seu resultado deve ser semelhante ao seguinte exemplo de saída:

    deployment.apps/ship-manager-frontend created
configmap/frontend-config created

Em seguida, você pode criar os recursos de rede de que esse aplicativo precisa para ser aberto na Web.

  1. Crie um novo arquivo chamado frontend-network.yml e cole a seguinte especificação de rede:

    apiVersion: v1
kind: Service
metadata:
  name: ship-manager-frontend
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 80
  selector:
    app: ship-manager-frontend
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ship-manager-frontend
spec:
  ingressClassName: webapprouting.kubernetes.azure.com
  rules:
  - host: <host-name>
    http:
      paths:
      - backend:
          service:
            name: ship-manager-frontend
            port:
              number: 80
        path: /
        pathType: Prefix

  2. Substitua o espaço reservado <host-name> pela cadeia de conexão recuperada na seção anterior.

  3. Salve e feche o arquivo.

  4. Aplique a implantação de rede de front-end usando o comando kubectl apply.

    kubectl apply -f frontend-network.yml

    Seu resultado deve ser semelhante ao seguinte exemplo de saída:

    service/ship-manager-frontend created
ingress.networking.k8s.io/ship-manager-frontend created

    Acesse a API por meio do nome do host que você colou no recurso de entrada. O recurso de zona DNS do Azure pode levar até cinco minutos para concluir a detecção de DNS. Se você não conseguir acessar a API imediatamente, aguarde alguns minutos e tente novamente.

  5. Verifique o status da entrada consultando o Kubernetes sobre as entradas disponíveis usando o comando kubectl get ingress.

    kubectl get ingress

    Quando o campo ENDEREÇO na saída estiver preenchido, isso significa que a entrada foi implantada e está pronta para ser acessada, conforme mostrado no exemplo de saída a seguir:

    NAME                   CLASS                                HOSTS                                                               ADDRESS        PORTS   AGE
ship-manager-backend   webapprouting.kubernetes.azure.com   ship-manag-rg-ship-manager-a1bcd2-efghij56.hcp.eastus.azmk8s.io     xx.xx.xx.xx    80      2m40s
ship-manager-frontend  webapprouting.kubernetes.azure.com   ship-manag-rg-ship-manager-a1bcd2-efghij56.hcp.eastus.azmk8s.io     xx.xx.xx.xx    80      100s

Agora, você pode acessar a URL por meio do nome do host do recurso de entrada para entrar no aplicativo gerenciador de navios.