Číst v angličtině

Hostování nové databáze pomocí služby Azure Cosmos DB

Dokončeno

Teď, když jsme si prostudovali základní koncepty externích států a jak s nimi pracovat pomocí Kubernetes, vytvoříme prostředky, které budou podporovat aplikaci vaší přepravní společnosti, a pak vytvoříme samotnou aplikaci.

Vytvoření skupiny prostředků

Důležité

Ke spuštění tohoto cvičení potřebujete vlastní předplatné Azure a můžou se vám účtovat poplatky. Pokud ještě nemáte předplatné Azure, vytvořte si bezplatný účet, než začnete.

  1. Přihlaste se do portálu Azure pomocí vlastního předplatného.

  2. Otevřete Cloud Shell a vyberte Bash.

  3. Pomocí příkazu az group create vytvořte skupinu prostředků Azure a zadejte oblast. Tento příklad vytvoří skupinu prostředků s názvem rg-ship-manager v oblasti eastus:

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

    Dokončení procesu vytváření může chvíli trvat.

Vytvořte stav

Jak jsme již dříve uvedli, je sice možné spravovat stav v Kubernetes, ale nedoporučuje se to. Správa stavu aplikace s vysokou dostupností může být příliš obtížná, když potřebujete spravovat stav sami.

Abychom tento problém vyřešili, externalizujeme stav do aplikace, která se specializuje na práci s externím stavem: Azure Cosmos DB.

Poznámka

I když vytváříme instanci Azure Cosmos DB jako součást požadovaných prostředků pro spuštění aplikace, služba Azure Kubernetes Service (AKS) a Azure Cosmos DB se nejsou vzájemně související.

  1. Vytvořte proměnné Bash pro uložení názvu účtu služby Azure Cosmos DB a názvu skupiny prostředků pro použití během zbytku modulu.

    export RESOURCE_GROUP=rg-ship-manager
    export COSMOSDB_ACCOUNT_NAME=contoso-ship-manager-$RANDOM
    
  2. Pomocí příkazu az cosmosdb create vytvořte nový účet služby Azure Cosmos DB.

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

    Dokončení procesu vytváření může chvíli trvat.

  3. Vytvořte novou databázi pomocí příkazu az cosmosdb mongodb database create. V tomto příkladu se databáze jmenuje contoso-ship-manager.

    az cosmosdb mongodb database create --account-name $COSMOSDB_ACCOUNT_NAME --resource-group $RESOURCE_GROUP --name contoso-ship-manager
    
  4. Pomocí příkazu az cosmosdb mongodb database list ověřte, že se databáze úspěšně vytvořila.

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

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

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

Teď, když jste vytvořili externí úložiště dat pro uložení všech dat z aplikace správce lodí, pojďme vytvořit prostředek AKS pro uložení samotné aplikace.

Vytvoření clusteru AKS

  1. Vytvořte proměnnou Bash pro uložení názvu clusteru pro použití ve zbytku modulu.

    AKS_CLUSTER_NAME=ship-manager-cluster
    
  2. Vytvořte cluster AKS pomocí příkazu 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
    

    Dokončení procesu vytváření může chvíli trvat.

    Poznámka

    Všechny služby Azure nastavují výchozí limity a kvóty pro prostředky a funkce, včetně omezení využití pro určité skladové položky virtuálního počítače. Pokud narazíte na chybu naznačující, že požadovaná SKU virtuálního počítače není dostupná ve vámi vybrané oblasti, pravděpodobně budete muset tuto kvótu zvýšit prostřednictvím žádosti o podporu Azure (pro typ problému vyberte Kvóta).

  3. Pomocí příkazu az aks get-credentials stáhněte konfiguraci kubectl.

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

    Pokud dostanete nějaké zprávy o existujících clusterech, například:

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

    Zadejte y k přepsání.

  4. Otestujte konfiguraci pomocí příkazu kubectl get nodes.

    kubectl get nodes
    

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

    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
    

Nasazení aplikace

Pokud chcete vytvořit aplikaci, musíte vytvořit soubory YAML pro nasazení do Kubernetes.

Nasazení back-endového rozhraní API

  1. Pomocí příkazu az cosmosdb keys list získejte připojovací řetězec databáze Azure Cosmos DB.

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

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

    mongodb://contoso-ship-manager-12345678.documents.azure.com:10255/?ssl=true&replicaSet=globaldb
    
  2. Vytvořte nový soubor s názvem backend-deploy.yml a vložte následující specifikaci nasazení:

    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. Zástupný symbol {your database connection string} vyměňte za připojovací řetězec databáze, který jste získali v předchozím kroku.

    Poznámka

    Nezapomeňte do proměnných prostředí přidat uvozovky ", protože připojovací řetězec někdy představuje neplatné znaky YAML. Můžete zvážit použití tajných kódů jako bezpečný způsob ukládání a načítání připojovacího řetězce v AKS.

  4. Uložte a zavřete soubor.

  5. Použijte nasazení back-endového rozhraní API pomocí příkazu kubectl apply.

    kubectl apply -f backend-deploy.yml
    

    Měla by se zobrazit zpráva podobná následujícímu příkladu výstupu:

    deployment.apps/ship-manager-backend created
    

Pokud chcete tuto aplikaci zpřístupnit všem, musíte vytvořit službu a ingress, aby se o provoz postaral.

  1. Pomocí příkazu az aks show získejte adresu serveru rozhraní API clusteru.

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

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

    ship-manag-rg-ship-manager-a1bcd2-efghij56.hcp.eastus.azmk8s.io
    
  2. Vytvořte nový soubor s názvem backend-network.yml a vložte následující specifikaci sítě:

    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. Zástupný symbol <host-name> nahraďte připojovacím řetězcem, který jste získali v předchozím kroku.

  4. Uložte a zavřete soubor.

  5. Aplikujte back-endové síťové nasazení pomocí příkazu kubectl apply.

    kubectl apply -f backend-network.yml
    

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

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

    K rozhraní API můžete přistupovat prostřednictvím názvu hostitele, který jste vložili do prostředku příchozího přenosu dat. Dokončení detekce DNS může trvat až pět minut. Pokud nemáte přístup k rozhraní API hned, počkejte několik minut a zkuste to znovu.

  6. Pomocí příkazu kubectl get ingress zkontrolujte stav příchozího přenosu dat dotazováním Kubernetes na dostupné příchozí přenosy dat.

    kubectl get ingress
    

    Jakmile je pole ADDRESS ve výstupu vyplněno, znamená to, že ingress byl nasazen a je připraven k použití, jak je znázorněno v následujícím příkladu výstupu.

    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
    

Nasazení front-endového rozhraní

  1. Vytvořte nový soubor s názvem frontend-deploy.yml a vložte následující specifikaci nasazení:

    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. Zástupný symbol {YOUR_BACKEND_URL} nahraďte adresou URL názvu hostitele back-endového rozhraní API, které jste získali v předchozí části.

  3. Uložte a zavřete soubor.

  4. Použijte nasazení front-endu pomocí příkazu kubectl apply

    kubectl apply -f frontend-deploy.yml
    

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

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

Dále můžete vytvořit síťové prostředky, které tato aplikace potřebuje, aby byla dostupná na webu.

  1. Vytvořte nový soubor s názvem frontend-network.yml a vložte následující specifikaci sítě:

    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. Zástupný symbol <host-name> nahraďte připojovacím řetězcem, který jste získali v předchozí části.

  3. Uložte a zavřete soubor.

  4. Aplikujte front-endové síťové nasazení pomocí příkazu kubectl apply.

    kubectl apply -f frontend-network.yml
    

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

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

    K rozhraní API můžete přistupovat prostřednictvím názvu hostitele, který jste vložili do prostředku příchozího přenosu dat. Zdroj oblasti Azure DNS může dokončení detekce DNS trvat až pět minut. Pokud nemáte přístup k rozhraní API hned, počkejte několik minut a zkuste to znovu.

  5. Pomocí příkazu kubectl get ingress zkontrolujte stav příchozího přenosu dat dotazováním Kubernetes na dostupné příchozí přenosy dat.

    kubectl get ingress
    

    Jakmile se ve výstupu vyplní pole ADDRESS, znamená to, že ingress byl nasazen a je připraven k přístupu, jak je zobrazeno v následujícím příkladu výstupu:

    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
    

Nyní můžete získat přístup k adrese URL z názvu hostitele prostředku vstupu a vstoupit do aplikace pro správu lodí.