Udostępnij za pośrednictwem


Samouczek: wdrażanie aplikacji internetowej ASP.NET przy użyciu usługi Azure Cosmos DB for NoSQL, tożsamości zarządzanej i usługi AKS za pośrednictwem aplikacji Bicep

DOTYCZY: NoSQL

W tym samouczku wdrożysz odwołanie ASP.NET aplikacji internetowej w klastrze usługi Azure Kubernetes Service (AKS), który łączy się z usługą Azure Cosmos DB for NoSQL.

Usługa Azure Cosmos DB to w pełni zarządzana rozproszona platforma baz danych do tworzenia nowoczesnych aplikacji przy użyciu baz danych NoSQL lub relacyjnych baz danych.

Usługa AKS to zarządzana usługa Kubernetes, która ułatwia szybkie wdrażanie klastrów i zarządzanie nimi.

Ważne

  • Ten artykuł wymaga najnowszej wersji interfejsu wiersza polecenia platformy Azure. Aby uzyskać więcej informacji, zobacz Instalowanie interfejsu wiersza polecenia platformy Azure. Jeśli używasz usługi Azure Cloud Shell, najnowsza wersja jest już zainstalowana.
  • Ten artykuł wymaga również najnowszej wersji interfejsu wiersza polecenia Bicep w interfejsie wiersza polecenia platformy Azure. Aby uzyskać więcej informacji, zobacz Instalowanie narzędzi Bicep.
  • Jeśli uruchamiasz polecenia w tym samouczku lokalnie zamiast w usłudze Azure Cloud Shell, upewnij się, że używasz konta administratora.

Wymagania wstępne

Następujące narzędzia są wymagane do skompilowania ASP.NET aplikacji internetowej i utworzenia obrazu kontenera:

Omówienie

W tym samouczku do wdrażania zasobów na platformie Azure jest używana metoda infrastruktury jako kodu (IaC ). Używasz Bicep, czyli nowego języka deklaratywnego, który oferuje te same możliwości co szablony usługi Azure Resource Manager. Jednak Bicep zawiera składnię, która jest bardziej zwięzła i łatwiejsza w użyciu.

Moduły Bicep wdrażają następujące zasoby platformy Azure w zakresie subskrypcji docelowej:

W tym samouczku są używane następujące najlepsze rozwiązania dotyczące zabezpieczeń usługi Azure Cosmos DB:

Napiwek

Kroki opisane w tym samouczku korzystają z usługi Azure Cosmos DB for NoSQL. Można jednak zastosować te same pojęcia do usługi Azure Cosmos DB dla bazy danych MongoDB.

Pobieranie modułów Bicep

Pobierz lub sklonuj moduły Bicep z folderu Bicep repozytorium GitHub azure-samples/cosmos-aks-samples:

git clone https://github.com/Azure-Samples/cosmos-aks-samples.git

cd Bicep/

Nawiązywanie połączenia z subskrypcją platformy Azure

Użyj polecenia az sign in , aby nawiązać połączenie z domyślną subskrypcją platformy Azure:

az login

Opcjonalnie użyj polecenia az account set z nazwą lub identyfikatorem określonej subskrypcji, aby ustawić aktywną subskrypcję, jeśli masz wiele subskrypcji:

az account set \
  --subscription <subscription-id>

Inicjowanie parametrów wdrożenia

Utwórz plik param.json przy użyciu kodu JSON w poniższym przykładzie. Zastąp {resource group name}symbole zastępcze , {Azure Cosmos DB account name}i {Azure Container Registry instance name} własnymi wartościami.

Ważne

Wszystkie nazwy zasobów używane w poniższym kodzie powinny być zgodne z regułami i ograniczeniami nazewnictwa dla zasobów platformy Azure. Upewnij się również, że wartości symboli zastępczych są stale zastępowane i zgodne z wartościami w param.json.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "rgName": {
      "value": "{resource group name}"
    },    
    "cosmosName" :{
      "value": "{Azure Cosmos DB account name}"
    },
    "acrName" :{
      "value": "{Azure Container Registry instance name}"
    }
  }
}

Tworzenie wdrożenia Bicep

Ustaw zmienne powłoki przy użyciu następujących poleceń. {deployment name} Zastąp symbole zastępcze i {location} własnymi wartościami.

deploymentName='{deployment name}'  # Name of the deployment
location='{location}' # Location for deploying the resources

W folderze Bicep użyj polecenia az deployment sub create , aby wdrożyć szablon w bieżącym zakresie subskrypcji:

az deployment sub create \
  --name $deploymentName \
  --location $location \
  --template-file main.bicep \
  --parameters @param.json

Podczas wdrażania konsola generuje komunikat informujący, że wdrożenie jest nadal uruchomione:

 / Running ..

Wdrożenie może potrwać od 20 do 30 minut. Po zakończeniu aprowizacji konsola wyświetli kod JSON Succeeded jako stan aprowizacji:

      }
    ],
    "provisioningState": "Succeeded",
    "templateHash": "0000000000000000",
    "templateLink": null,
    "timestamp": "2022-01-01T00:00:00.000000+00:00",
    "validatedResources": null
  },
  "tags": null,
  "type": "Microsoft.Resources/deployments"
}

Stan wdrożenia można również wyświetlić w grupie zasobów:

Zrzut ekranu przedstawiający stan wdrożenia grupy zasobów w witrynie Azure Portal.

Uwaga

Podczas tworzenia klastra usługi AKS druga grupa zasobów jest tworzona automatycznie w celu przechowywania zasobów usługi AKS. Aby uzyskać więcej informacji, zobacz Dlaczego dwie grupy zasobów są tworzone za pomocą usługi AKS?.

Użyj następujących poleceń, aby połączyć wystąpienie usługi Azure Container Registry z usługą AKS. {Azure Container Registry instance name} Zastąp symbole zastępcze i {resource group name} własnymi wartościami.

acrName='{Azure Container Registry instance name}'
rgName='{resource group name}'
aksName=$rgName'aks'

Uruchom polecenie az aks update , aby dołączyć istniejący zasób usługi Azure Container Registry z klastrem usługi AKS:

az aks update \
  --resource-group $rgName \
  --name $aksName \
  --attach-acr $acrName

Nawiązywanie połączenia z klastrem usługi AKS

Aby zarządzać klastrem Kubernetes, należy użyć klienta wiersza polecenia usługi Kubernetes — narzędzia kubectl. Jeśli korzystasz z usługi Azure Cloud Shell, narzędzie kubectl jest już zainstalowane. Aby zainstalować kubectl lokalnie, użyj polecenia az aks install-cli:

az aks install-cli

Aby skonfigurować kubectl połączenie z klastrem Kubernetes, użyj polecenia az aks get-credentials. To polecenie powoduje pobranie poświadczeń i zastosowanie ich w konfiguracji interfejsu wiersza polecenia Kubernetes.

az aks get-credentials \
  --resource-group $rgName \
  --name $aksName

Łączenie zasobników usługi AKS z usługą Azure Key Vault

Tożsamości zarządzane przez pod firmy Microsoft używają elementów pierwotnych usługi AKS do kojarzenia tożsamości zarządzanych dla zasobów i tożsamości platformy Azure w usłudze Microsoft Entra ID z zasobnikami. Te tożsamości służą do udzielania dostępu do sterownika interfejsu CSI (Container Storage Interface) dostawcy usługi Azure Key Vault dla wpisów tajnych.

Użyj następującego polecenia, aby znaleźć wartości identyfikatora dzierżawy (homeTenantId):

az account show

Użyj następującego szablonu YAML, aby utworzyć plik secretproviderclass.yml . {Tenant Id} Zastąp symbole zastępcze i {resource group name} własnymi wartościami. Upewnij się również, że wartość parametru jest {resource group name} zgodna z wartością w param.json.

# This is a SecretProviderClass example that uses aad-pod-identity to access the key vault
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: azure-kvname-podid
spec:
  provider: azure
  parameters:
    usePodIdentity: "true"               
    keyvaultName: "{resource group name}kv"       # Replace resource group name. Bicep generates the key vault name.
    tenantId: "{Tenant Id}"              # The tenant ID of your account. Use the 'homeTenantId' attribute value from  the 'az account show' command output.

Stosowanie klasy SecretProviderClass do klastra usługi AKS

Użyj narzędzia kubectl apply , aby zainstalować sterownik CSI magazynu wpisów tajnych przy użyciu kodu YAML:

kubectl apply \
  --filename secretproviderclass.yml

Tworzenie aplikacji internetowej ASP.NET

Pobierz lub sklonuj kod źródłowy aplikacji internetowej z folderu Application repozytorium GitHub azure-samples/cosmos-aks-samples:

git clone https://github.com/Azure-Samples/cosmos-aks-samples.git

cd Application/

Otwórz folder Aplikacja w programie Visual Studio Code. Uruchom aplikację przy użyciu F5 lub debugowania: Uruchom debugowanie .

Wypychanie obrazu kontenera platformy Docker do usługi Azure Container Registry

  1. Aby utworzyć obraz kontenera na karcie Eksplorator w programie Visual Studio Code, kliknij prawym przyciskiem myszy plik Dockerfile, a następnie wybierz polecenie Kompiluj obraz.

    Zrzut ekranu przedstawiający menu kontekstowe w programie Visual Studio Code z wybraną opcją Kompiluj obraz.

  2. W wierszu monitu z prośbą o nazwę i wersję, aby oznaczyć obraz, wprowadź nazwę todo:latest.

  3. Użyj okienka Platformy Docker , aby wypchnąć utworzony obraz do usługi Azure Container Registry. Skompilowany obraz można znaleźć w węźle Obrazy . Otwórz węzeł zadań do wykonania, kliknij prawym przyciskiem myszy pozycję Najnowszy, a następnie wybierz polecenie Wypchnij.

    Zrzut ekranu przedstawiający menu kontekstowe w programie Visual Studio Code z wybraną opcją Wypychanie.

  4. W monitach wybierz subskrypcję platformy Azure, zasób usługi Azure Container Registry i tagi obrazów. Format tagu obrazu powinien mieć wartość {acrname}.azurecr.io/todo:latest.

  5. Poczekaj, aż program Visual Studio Code wypchnie obraz kontenera do usługi Azure Container Registry.

Przygotowywanie wdrożenia YAML

Użyj następującego szablonu YAML, aby utworzyć plik akstododeploy.yml . Zastąp {ACR name}symbole zastępcze , {Image name}, {Version}i {resource group name} własnymi wartościami.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: todo
  labels:
    aadpodidbinding: "cosmostodo-apppodidentity"
    app: todo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: todo
  template:
    metadata:
      labels:
        app: todo
        aadpodidbinding: "cosmostodo-apppodidentity"
    spec:
      containers:
      - name: mycontainer
        image: "{ACR name}/{Image name}:{Version}"   # Update per your environment; for example, myacrname.azurecr.io/todo:latest. Do not add https:// in ACR Name.
        ports:
        - containerPort: 80
        env:
        - name: KeyVaultName
          value: "{resource group name}kv"       # Replace resource group name. Key Vault name is generated by Bicep.
      nodeSelector:
        kubernetes.io/os: linux
      volumes:
        - name: secrets-store01-inline
          csi:
            driver: secrets-store.csi.k8s.io
            readOnly: true
            volumeAttributes:
              secretProviderClass: "azure-kvname-podid"       
---
    
kind: Service
apiVersion: v1
metadata:
  name: todo
spec:
  selector:
    app: todo
    aadpodidbinding: "cosmostodo-apppodidentity"    
  type: LoadBalancer
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80

Stosowanie wdrożenia YAML

Ponownie użyj kubectl apply polecenia , aby wdrożyć zasobniki aplikacji i uwidocznić zasobniki za pośrednictwem modułu równoważenia obciążenia:

kubectl apply \
  --filename akstododeploy.yml \
  --namespace 'my-app'

Testowanie aplikacji

Po uruchomieniu aplikacji usługa Kubernetes uwidacznia fronton aplikacji w Internecie. Ten proces może potrwać kilka minut.

Użyj polecenia kubectl get , aby wyświetlić zewnętrzny adres IP uwidaczniany przez moduł równoważenia obciążenia:

kubectl get services \
  --namespace "my-app"

Aby uzyskać dostęp do aplikacji, otwórz adres IP otrzymany jako dane wyjściowe w przeglądarce.

Oczyszczanie zasobów

Aby uniknąć opłat za platformę Azure, wyczyść niepotrzebne zasoby, gdy nie potrzebujesz już klastra. Użyj polecenia az group delete i az deployment sub delete, aby usunąć odpowiednio grupę zasobów i wdrożenie subskrypcji:

az group delete \
  --resource-group $rgName 
  --yes

az deployment sub delete \
  --name $deploymentName