Hospedar um novo banco de dados usando o Azure Cosmos DB

Concluído

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.