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

Você precisa de sua própria assinatura do Azure para executar este exercício e pode incorrer em cobranças. Se você ainda não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.

  1. Entre no portal do Azure usando 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

    O processo de criação pode levar alguns minutos para ser concluído.

Criar o estado

Como descrevemos anteriormente, é possível, mas não recomendado, lidar com o estado no Kubernetes. Gerenciar um estado de aplicativo altamente disponível pode se tornar muito difícil quando você precisa gerenciar o estado por conta própria.

Para resolver esse problema, externalizaremos o estado para um aplicativo especializado em lidar com o estado externo: o 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 Serviço Kubernetes do Azure (AKS) e o Azure Cosmos DB não estão relacionados um ao outro.

  1. Crie variáveis 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

    O processo de criação pode levar alguns minutos para ser concluído.

  3. Crie um novo banco de dados usando o comando az cosmosdb mongodb database create. Neste exemplo, o banco de dados é chamado 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

    Sua saída deve ser semelhante à saída de exemplo a seguir:

    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 AKS para armazenar o próprio aplicativo.

Criar o cluster AKS

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

    AKS_CLUSTER_NAME=ship-manager-cluster

  2. Crie um cluster 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

    O processo de criação pode levar alguns minutos para ser concluído.

    Observação

    Todos os serviços do Azure definem limites e cotas padrão para recursos e recursos, incluindo restrições de uso para determinadas SKUs de máquina virtual (VM). Se você encontrar um erro sugerindo que sua 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 tipo de de Problema, selecione de Cota).

  3. Baixe a configuração kubectl usando o comando az aks get-credentials.

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

    Se receber alguma mensagem sobre grupos 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

    Sua saída deve ser semelhante à saída de exemplo a seguir:

    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 sua cadeia de ligaçã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

    Sua saída deve ser semelhante à saída de exemplo a seguir:

    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 implantaçã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 marcador {your database connection string} pela cadeia de conexão de banco de dados recuperada 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 usar segredos como uma maneira segura de armazenar e recuperar a cadeia de conexão no AKS.

  4. Salve e feche o arquivo.

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

    kubectl apply -f backend-deploy.yml

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

    deployment.apps/ship-manager-backend created

Para tornar este 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 da API do cluster usando o comando az aks show.

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

    Sua saída deve ser semelhante à saída de exemplo a seguir:

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

  2. Crie um novo arquivo chamado backend-network.yml e cole na 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 marcador de posição <host-name> pela cadeia de conexão recuperada na etapa anterior.

  4. Salve e feche o arquivo.

  5. Aplique a configuração de rede do back-end utilizando o comando kubectl apply.

    kubectl apply -f backend-network.yml

    Sua saída deve ser semelhante à saída de exemplo a seguir:

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

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

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

    kubectl get ingress

    Uma vez que o campo ADDRESS na saída é 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 front-end

  1. Crie um novo arquivo chamado frontend-deploy.yml e cole na seguinte especificação de implantaçã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 marcador de posição {YOUR_BACKEND_URL} pela URL do nome de anfitrião da API de back-end que você recuperou na seção anterior.

  3. Salve e feche o arquivo.

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

    kubectl apply -f frontend-deploy.yml

    Sua saída deve ser semelhante à saída de exemplo a seguir:

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

Em seguida, você pode criar os recursos de rede que este aplicativo precisa para estar aberto para a Web.

  1. Crie um novo arquivo chamado frontend-network.yml e cole na 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 sequência de ligação que recuperou na secção anterior.

  3. Salve e feche o arquivo.

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

    kubectl apply -f frontend-network.yml

    Sua saída deve ser semelhante à saída de exemplo a seguir:

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

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

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

    kubectl get ingress

    Uma vez que o campo ADDRESS na saída é 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 pode aceder à URL a partir do nome de host do recurso de ingresso para entrar na aplicação gestora de navios.