Hostowanie nowej bazy danych przy użyciu usługi Azure Cosmos DB

  • 15 min

Teraz, gdy zapoznaliśmy się z podstawowymi pojęciami dotyczącymi stanów zewnętrznych i sposobu radzenia sobie z nimi przy użyciu platformy Kubernetes, utwórzmy zasoby, które będą obsługiwać aplikację firmy frachtowej, a następnie utworzymy samą aplikację.

Tworzenie grupy zasobów

Ważne

Do wykonania tego ćwiczenia potrzebna jest własna subskrypcja platformy Azure. Ponadto mogą zostać naliczone opłaty. Jeśli nie masz jeszcze subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.

  1. Zaloguj się do witryny Azure Portal przy użyciu własnej subskrypcji.

  2. Otwórz usługę Cloud Shell i wybierz pozycję Bash.

  3. Utwórz grupę zasobów platformy Azure przy użyciu az group create polecenia i określ region. W tym przykładzie tworzona jest grupa zasobów o nazwie rg-ship-manager w regionie eastus :

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

    Ukończenie procesu tworzenia może potrwać kilka minut.

Tworzenie stanu

Jak opisano wcześniej, możliwe jest, ale nie zaleca się obsługi stanu na platformie Kubernetes. Zarządzanie stanem aplikacji o wysokiej dostępności może stać się zbyt trudne, gdy musisz samodzielnie zarządzać stanem.

Aby rozwiązać ten problem, przejmiemy stan do aplikacji specjalizującej się w radzeniu sobie ze stanem zewnętrznym: Azure Cosmos DB.

Uwaga

Mimo że tworzymy wystąpienie usługi Azure Cosmos DB w ramach wymaganych zasobów do uruchomienia aplikacji, usługi Azure Kubernetes Service (AKS) i Azure Cosmos DB nie są ze sobą powiązane.

  1. Utwórz zmienne powłoki Bash, aby przechowywać nazwę konta usługi Azure Cosmos DB i nazwę grupy zasobów do użycia w pozostałej części modułu.

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

  2. Utwórz nowe konto usługi Azure Cosmos DB przy użyciu az cosmosdb create polecenia .

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

    Ukończenie procesu tworzenia może potrwać kilka minut.

  3. Utwórz nową bazę danych przy użyciu az cosmosdb mongodb database create polecenia . W tym przykładzie baza danych nosi nazwę contoso-ship-manager.

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

  4. Sprawdź, czy baza danych została pomyślnie utworzona przy użyciu az cosmosdb mongodb database list polecenia .

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

    Dane wyjściowe powinny wyglądać podobnie do następujących przykładowych danych wyjściowych:

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

Po utworzeniu stanu zewnętrznego do przechowywania wszystkich danych z aplikacji menedżera wysyłki utwórzmy zasób usługi AKS do przechowywania samej aplikacji.

Tworzenie klastra AKS

  1. Utwórz zmienną powłoki Bash do przechowywania nazwy klastra do użycia w pozostałej części modułu.

    AKS_CLUSTER_NAME=ship-manager-cluster

  2. Utwórz klaster usługi AKS przy użyciu az aks create polecenia .

    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

    Ukończenie procesu tworzenia może potrwać kilka minut.

    Uwaga

    Wszystkie usługi platformy Azure ustawiają domyślne limity i limity przydziału dla zasobów i funkcji, w tym ograniczenia użycia dla niektórych jednostek SKU maszyny wirtualnej. Jeśli wystąpi błąd sugerujący, że żądana jednostka SKU maszyny wirtualnej nie jest dostępna w wybranym regionie, najprawdopodobniej musisz zwiększyć ten limit przydziału za pośrednictwem żądania pomoc techniczna platformy Azure (w polu Typ problemu wybierz pozycję Limit przydziału).

  3. Pobierz konfigurację narzędzia kubectl przy użyciu az aks get-credentials polecenia .

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

    Jeśli otrzymasz jakiekolwiek komunikaty dotyczące istniejących klastrów, na przykład:

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

    Wprowadź polecenie y , aby zastąpić.

  4. Przetestuj kubectl get nodes konfigurację przy użyciu polecenia .

    kubectl get nodes

    Dane wyjściowe powinny wyglądać podobnie do następujących przykładowych danych wyjściowych:

    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

Wdrażanie aplikacji

Aby utworzyć aplikację, należy utworzyć pliki YAML w celu wdrożenia na platformie Kubernetes.

Wdrażanie interfejsu API zaplecza

  1. Pobierz bazę danych usługi Azure Cosmos DB parametry połączenia przy użyciu az cosmosdb keys list polecenia .

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

    Dane wyjściowe powinny wyglądać podobnie do następujących przykładowych danych wyjściowych:

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

  2. Utwórz nowy plik o nazwie backend-deploy.yml i wklej następującą specyfikację wdrożenia:

    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. Zastąp {your database connection string} symbol zastępczy parametry połączenia bazy danych pobranymi w poprzednim kroku.

    Uwaga

    Nie zapomnij dodać cudzysłowów " do zmiennych środowiskowych, ponieważ parametry połączenia czasami przedstawia nieprawidłowe znaki YAML. Możesz rozważyć użycie wpisów tajnych jako bezpiecznego sposobu przechowywania i pobierania parametry połączenia w usłudze AKS.

  4. Zapisz i zamknij plik.

  5. Zastosuj wdrożenie interfejsu API zaplecza kubectl apply przy użyciu polecenia .

    kubectl apply -f backend-deploy.yml

    Powinien zostać wyświetlony komunikat podobny do następujących przykładowych danych wyjściowych:

    deployment.apps/ship-manager-backend created

Aby udostępnić tę aplikację wszystkim, musisz utworzyć usługę i ruch przychodzący, aby zadbać o ruch.

  1. Pobierz adres serwera interfejsu API klastra az aks show przy użyciu polecenia .

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

    Dane wyjściowe powinny wyglądać podobnie do następujących przykładowych danych wyjściowych:

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

  2. Utwórz nowy plik o nazwie backend-network.yml i wklej następującą specyfikację sieci:

    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. Zastąp <host-name> symbol zastępczy parametry połączenia pobranym w poprzednim kroku.

  4. Zapisz i zamknij plik.

  5. Zastosuj wdrożenie sieci zaplecza kubectl apply przy użyciu polecenia .

    kubectl apply -f backend-network.yml

    Dane wyjściowe powinny wyglądać podobnie do następujących przykładowych danych wyjściowych:

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

    Dostęp do interfejsu API można uzyskać za pomocą nazwy hosta wklejonej w zasobie ruchu przychodzącego. Wykrycie usługi DNS przez zasób usługi Azure DNS może potrwać do pięciu minut. Jeśli nie jesteś w stanie uzyskać natychmiastowego dostępu do interfejsu API, poczekaj kilka minut i spróbuj ponownie.

  6. Sprawdź stan ruchu przychodzącego, wysyłając zapytanie o platformę Kubernetes pod kątem dostępnych ruchu przychodzącego kubectl get ingress przy użyciu polecenia .

    kubectl get ingress

    Po wypełnieniu pola ADRES w danych wyjściowych oznacza to, że ruch przychodzący został wdrożony i jest gotowy do uzyskania dostępu, jak pokazano w poniższych przykładowych danych wyjściowych:

    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

Wdrożenie interfejsu frontonu

  1. Utwórz nowy plik o nazwie frontend-deploy.yml i wklej następującą specyfikację wdrożenia:

    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. {YOUR_BACKEND_URL} Zastąp symbol zastępczy adresem URL nazwy hosta interfejsu API zaplecza pobranego w poprzedniej sekcji.

  3. Zapisz i zamknij plik.

  4. Zastosuj wdrożenie frontonu kubectl apply przy użyciu polecenia .

    kubectl apply -f frontend-deploy.yml

    Dane wyjściowe powinny wyglądać podobnie do następujących przykładowych danych wyjściowych:

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

Następnie możesz utworzyć zasoby sieciowe, które ta aplikacja musi być otwarta w Internecie.

  1. Utwórz nowy plik o nazwie frontend-network.yml i wklej następującą specyfikację sieci:

    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. <host-name> Zastąp symbol zastępczy parametry połączenia pobranym w poprzedniej sekcji.

  3. Zapisz i zamknij plik.

  4. Zastosuj wdrożenie sieci frontonu kubectl apply przy użyciu polecenia .

    kubectl apply -f frontend-network.yml

    Dane wyjściowe powinny wyglądać podobnie do następujących przykładowych danych wyjściowych:

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

    Dostęp do interfejsu API można uzyskać za pomocą nazwy hosta wklejonej w zasobie ruchu przychodzącego. Wykrycie usługi DNS przez zasób usługi Azure DNS może potrwać do pięciu minut. Jeśli nie jesteś w stanie uzyskać natychmiastowego dostępu do interfejsu API, poczekaj kilka minut i spróbuj ponownie.

  5. Sprawdź stan ruchu przychodzącego, wysyłając zapytanie o platformę Kubernetes pod kątem dostępnych ruchu przychodzącego kubectl get ingress przy użyciu polecenia .

    kubectl get ingress

    Po wypełnieniu pola ADRES w danych wyjściowych oznacza to, że ruch przychodzący został wdrożony i jest gotowy do uzyskania dostępu, jak pokazano w poniższych przykładowych danych wyjściowych:

    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

Teraz możesz uzyskać dostęp do adresu URL z nazwy hosta zasobu ruchu przychodzącego, aby wejść do aplikacji menedżera wysyłki.