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żny

Potrzebujesz własnej subskrypcji platformy Azure, aby uruchomić to ćwiczenie i możesz ponieść opłaty. Jeśli nie masz jeszcze subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto .

  1. Zaloguj się w portalu Azure przy użyciu własnej subskrypcji.

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

  3. Utwórz grupę zasobów platformy Azure przy użyciu polecenia az group create 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.

Utwórz stan

Jak opisano wcześniej, możliwe jest zarządzanie stanem w Kubernetes, ale nie jest to zalecane. 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, przeniesiemy stan na zewnątrz do aplikacji, która specjalizuje się w obsłudze stanu zewnętrznego: Azure Cosmos DB.

Notatka

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

  1. ** Utwórz zmienne Bash, aby przechowywać nazwę konta Azure Cosmos DB i nazwę grupy zasobów do używania w reszcie 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 polecenia az cosmosdb create.

    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 polecenia az cosmosdb mongodb database create. 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 polecenia az cosmosdb mongodb database list.

    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

Teraz, gdy utworzyłeś zewnętrzny stan do przechowywania wszystkich danych z aplikacji do zarządzania statkami, stwórzmy zasób AKS do przechowywania samej aplikacji.

Utwórz klaster AKS

  1. Utwórz zmienną shell Bash, aby przechować nazwę klastra dla 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 polecenia 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

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

    Notatka

    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 pomocy technicznej platformy Azure (w przypadku typ problemu wybierz pozycję Limit przydziału).

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

    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ź y, aby nadpisać.

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

    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.

Wdróż interfejs API zaplecza

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

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

    Notatka

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

  4. Zapisz i zamknij plik.

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

    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 ingress, aby zarządzać ruchem.

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

    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 symbol zastępczy <host-name> parametrami połączenia pobranymi w poprzednim kroku.

  4. Zapisz i zamknij plik.

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

    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

    Możesz uzyskać dostęp do interfejsu API za pomocą nazwy hosta, którą wkleiłeś w zasobie wejściowym. Ukończenie wykrywania DNS przez zasób strefy usługi Azure DNS może potrwać do pięciu minut. Jeśli nie możesz od razu uzyskać dostępu do interfejsu API, poczekaj kilka minut i spróbuj ponownie.

  6. Sprawdź status ingressu, wysyłając zapytanie do Kubernetes pod kątem dostępnych zasobów przy użyciu polecenia kubectl get ingress.

    kubectl get ingress

    Po wypełnieniu pola ADRESU 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

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

  3. Zapisz i zamknij plik.

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

    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 potrzebuje, aby móc się otworzyć 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. Zastąp symbol zastępczy <host-name> parametrami połączenia pobranymi w poprzedniej sekcji.

  3. Zapisz i zamknij plik.

  4. Zastosuj front-endowe wdrożenie sieci przy użyciu polecenia kubectl apply.

    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, który wkleiłeś w swoim zasobie wejściowym. Ukończenie wykrywania DNS przez zasób strefy usługi Azure DNS może potrwać do pięciu minut. Jeśli nie możesz od razu uzyskać dostępu do interfejsu API, poczekaj kilka minut i spróbuj ponownie.

  5. Sprawdź stan ingress, zapytując Kubernetes o dostępne ingresses za pomocą polecenia kubectl get ingress.

    kubectl get ingress

    Po wypełnieniu pola ADRESU w danych wyjściowych oznacza to, że zasób 'ingress' został wdrożony i jest gotowy do użycia, co pokazano w poniższym przykładowym wyniku.

    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 za pomocą nazwy hosta zasobu wejściowego, aby wejść do aplikacji zarządzania statkiem.