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

Precisa da sua própria subscrição do Azure para executar este exercício e poderá incorrer em custos. Se ainda não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar.

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

  2. Abra o Cloud Shell e selecione Bash.

  3. Crie um grupo de recursos do Azure usando o az group create comando 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 demorar algum tempo a 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.

Nota

Apesar de estarmos a criar uma instância do Azure Cosmos DB como parte dos recursos necessários para executar a aplicação, o Azure Kubernetes (AKS) Service e o Azure Cosmos DB não estão relacionados.

  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 az cosmosdb create comando.

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

    O processo de criação pode demorar algum tempo a ser concluído.

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

    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 do 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 az aks create comando.

    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 demorar algum tempo a ser concluído.

    Nota

    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 problema , selecione Cota).

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

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

    Se você receber alguma mensagem sobre clusters existentes, por exemplo:

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

    Entre y para substituir.

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

    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

Implementar a aplicação

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

Implementar a API de back-end

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

    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 espaço reservado {your database connection string} pela cadeia de conexão de banco de dados recuperada na etapa anterior.

    Nota

    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 maneira segura de armazenar e recuperar a cadeia de conexão no AKS.

  4. Guarde e feche o ficheiro.

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

    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 az aks show comando.

    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 espaço reservado <host-name> pela cadeia de conexão recuperada na etapa anterior.

  4. Guarde e feche o ficheiro.

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

    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

    Pode aceder à API através do nome do anfitrião que colou no seu recurso de entrada. A deteção de DNS pode demorar até cinco minutos a ser concluída pelo recurso da zona DNS do Azure. Se não conseguir aceder imediatamente à API, aguarde uns minutos e tente novamente.

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

    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

Implementar a interface de 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 espaço reservado {YOUR_BACKEND_URL} pela URL do nome do host da API de back-end recuperada na seção anterior.

  3. Guarde e feche o ficheiro.

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

    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 cadeia de conexão recuperada na seção anterior.

  3. Guarde e feche o ficheiro.

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

    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

    Pode aceder à API através do nome do anfitrião que colou no seu recurso de entrada. A deteção de DNS pode demorar até cinco minutos a ser concluída pelo recurso da zona DNS do Azure. Se não conseguir aceder imediatamente à API, aguarde uns minutos e tente novamente.

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

    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 ao URL a partir do nome do anfitrião do recurso de entrada para introduzir a aplicação do gestor de envios.