Självstudie: Distribuera ett ASP.NET webbprogram med hjälp av Azure Cosmos DB för NoSQL, hanterad identitet och AKS via Bicep
GÄLLER FÖR: NoSQL
I den här självstudien distribuerar du en referens ASP.NET webbprogram i ett AKS-kluster (Azure Kubernetes Service) som ansluter till Azure Cosmos DB för NoSQL.
Azure Cosmos DB är en fullständigt hanterad distribuerad databasplattform för modern programutveckling med NoSQL eller relationsdatabaser.
AKS är en hanterad Kubernetes-tjänst som hjälper dig att snabbt distribuera och hantera kluster.
Viktigt!
- Den här artikeln kräver den senaste versionen av Azure CLI. Mer information finns i Installera Azure CLI. Om du använder Azure Cloud Shell är den senaste versionen redan installerad.
- Den här artikeln kräver också den senaste versionen av Bicep CLI i Azure CLI. Mer information finns i Installera Bicep-verktyg.
- Om du kör kommandona i den här självstudien lokalt i stället för i Azure Cloud Shell kontrollerar du att du använder ett administratörskonto.
Förutsättningar
Följande verktyg krävs för att kompilera ASP.NET webbappen och skapa dess containeravbildning:
- Docker Desktop
- Visual Studio Code
- C#-tillägg för Visual Studio Code
- Docker-tillägg för Visual Studio Code
- Azure-kontotillägg för Visual Studio Code
Översikt
I den här självstudien används en IaC-metod (infrastruktur som kod) för att distribuera resurserna till Azure. Du använder Bicep, som är ett nytt deklarativt språk som erbjuder samma funktioner som Azure Resource Manager-mallar. Bicep innehåller dock en syntax som är mer koncis och enklare att använda.
Bicep-modulerna distribuerar följande Azure-resurser inom det riktade prenumerationsomfånget:
- En resursgrupp för att organisera resurserna
- En hanterad identitet för autentisering
- Ett containerregister för lagring av containeravbildningar
- Ett AKS-kluster
- Ett virtuellt nätverk för att konfigurera AKS
- Ett Azure Cosmos DB för NoSQL-konto, tillsammans med en databas, en container och SQL-rollen
- Ett nyckelvalv för att lagra säkra nycklar
- (Valfritt) En Log Analytics-arbetsyta
I den här självstudien används följande metodtips för säkerhet med Azure Cosmos DB:
- Implementera åtkomstkontroll med hjälp av rollbaserad åtkomstkontroll (RBAC) och en hanterad identitet. Dessa funktioner eliminerar behovet av att utvecklare hanterar hemligheter, autentiseringsuppgifter, certifikat och nycklar för säker kommunikation mellan tjänster.
- Begränsa Azure Cosmos DB-åtkomsten till AKS-undernätet genom att konfigurera en tjänstslutpunkt för virtuellt nätverk.
- Ange
disableLocalAuth = true
i resursendatabaseAccount
för att framtvinga RBAC som den enda autentiseringsmetoden.
Dricks
Stegen i den här självstudien använder Azure Cosmos DB för NoSQL. Du kan dock använda samma begrepp för Azure Cosmos DB för MongoDB.
Ladda ned Bicep-modulerna
Ladda ned eller klona Bicep-modulerna från mappen Bicep på GitHub-lagringsplatsen azure-samples/cosmos-aks-samples :
git clone https://github.com/Azure-Samples/cosmos-aks-samples.git
cd Bicep/
Ansluta till din Azure-prenumeration
Använd az login för att ansluta till din azure-standardprenumeration:
az login
Du kan också använda az account set med namnet eller ID:t för en specifik prenumeration för att ange den aktiva prenumerationen om du har flera prenumerationer:
az account set \
--subscription <subscription-id>
Initiera distributionsparametrarna
Skapa en param.json fil med hjälp av JSON i följande exempel. {resource group name}
Ersätt platshållarna , {Azure Cosmos DB account name}
och {Azure Container Registry instance name}
med dina egna värden.
Viktigt!
Alla resursnamn som du använder i följande kod ska följa namngivningsreglerna och begränsningarna för Azure-resurser. Kontrollera också att platshållarvärdena ersätts konsekvent och matchar värdena i 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}"
}
}
}
Skapa en Bicep-distribution
Ange gränssnittsvariabler med hjälp av följande kommandon. {deployment name}
Ersätt platshållarna och {location}
med dina egna värden.
deploymentName='{deployment name}' # Name of the deployment
location='{location}' # Location for deploying the resources
I mappen Bicep använder du az deployment sub create för att distribuera mallen till det aktuella prenumerationsomfånget:
az deployment sub create \
--name $deploymentName \
--location $location \
--template-file main.bicep \
--parameters @param.json
Under distributionen skickar konsolen ett meddelande som anger att distributionen fortfarande körs:
/ Running ..
Distributionen kan ta mellan 20 och 30 minuter. När etableringen är klar matar konsolen ut JSON med Succeeded
etableringstillståndet:
}
],
"provisioningState": "Succeeded",
"templateHash": "0000000000000000",
"templateLink": null,
"timestamp": "2022-01-01T00:00:00.000000+00:00",
"validatedResources": null
},
"tags": null,
"type": "Microsoft.Resources/deployments"
}
Du kan också se distributionsstatusen i resursgruppen:
Kommentar
När du skapar ett AKS-kluster skapas en andra resursgrupp automatiskt för att lagra AKS-resurserna. Mer information finns i Varför skapas två resursgrupper med AKS?.
Länka Azure Container Registry med AKS
Använd följande kommandon för att länka din Azure Container Registry-instans med AKS. {Azure Container Registry instance name}
Ersätt platshållarna och {resource group name}
med dina egna värden.
acrName='{Azure Container Registry instance name}'
rgName='{resource group name}'
aksName=$rgName'aks'
Kör az aks update för att koppla den befintliga Azure Container Registry-resursen till AKS-klustret:
az aks update \
--resource-group $rgName \
--name $aksName \
--attach-acr $acrName
Ansluta till AKS-klustret
För att hantera Kubernetes-kluster använder du kubectl, Kubernetes kommandoradsklient. Om du använder Azure Cloud Shell är kubectl
redan installerat. Om du vill installera kubectl
lokalt använder du az aks install-cli:
az aks install-cli
Du konfigurerar kubectl
för anslutning till Kubernetes-klustret med kommandot az aks get-credentials. Det här kommandot laddar ned autentiseringsuppgifter och konfigurerar Kubernetes CLI för att använda dem.
az aks get-credentials \
--resource-group $rgName \
--name $aksName
Ansluta AKS-poddar till Azure Key Vault
Microsoft Entra-poddhanterade identiteter använder AKS-primitiver för att associera hanterade identiteter för Azure-resurser och identiteter i Microsoft Entra-ID med poddar. Du använder dessa identiteter för att ge åtkomst till Azure Key Vault-providern för Secrets Store CSI-drivrutinen.
Använd följande kommando för att hitta värdena för klientorganisations-ID :t (homeTenantId
):
az account show
Använd följande YAML-mall för att skapa en secretproviderclass.yml fil. {Tenant Id}
Ersätt platshållarna och {resource group name}
med dina egna värden. Kontrollera också att värdet för {resource group name}
matchar värdet i 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.
Tillämpa SecretProviderClass på AKS-klustret
Använd kubectl apply för att installera CSI-drivrutinen för Secrets Store med hjälp av YAML:
kubectl apply \
--filename secretproviderclass.yml
Skapa ASP.NET webbappen
Ladda ned eller klona webbprogrammets källkod från programmappen för GitHub-lagringsplatsen azure-samples/cosmos-aks-samples:
git clone https://github.com/Azure-Samples/cosmos-aks-samples.git
cd Application/
Öppna programmappen i Visual Studio Code. Kör programmet med hjälp av antingen F5-nyckeln eller kommandot Felsök: Starta felsökning .
Skicka Docker-containeravbildningen till Azure Container Registry
Om du vill skapa en containeravbildning från fliken Utforskaren i Visual Studio Code högerklickar du på Dockerfile och väljer sedan Skapa avbildning.
Ange namnet todo:latest i prompten som ber om att namnet och versionen ska tagga avbildningen.
Använd Docker-fönstret för att skicka den skapade avbildningen till Azure Container Registry. Du hittar den skapade avbildningen under noden Bilder . Öppna todo-noden, högerklicka på senaste och välj sedan Push.
I anvisningarna väljer du din Azure-prenumeration, Azure Container Registry-resurs och avbildningstaggar. Bildtaggformatet ska vara
{acrname}.azurecr.io/todo:latest
.Vänta tills Visual Studio Code skickar containeravbildningen till Azure Container Registry.
Förbereda distributionens YAML
Använd följande YAML-mall för att skapa en akstododeploy.yml fil. {ACR name}
Ersätt platshållarna , {Image name}
, {Version}
och {resource group name}
med dina egna värden.
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
Tillämpa distributionens YAML
Använd kubectl apply
igen för att distribuera programpoddar och exponera poddarna via en lastbalanserare:
kubectl apply \
--filename akstododeploy.yml \
--namespace 'my-app'
Testa programmet
När programmet körs exponerar en Kubernetes-tjänst programmets klientdel till Internet. Den här processen kan ta ett par minuter att slutföra.
Använd kubectl get för att visa den externa IP-adressen som lastbalanseraren exponerar:
kubectl get services \
--namespace "my-app"
Öppna DEN IP-adress som du fick som utdata i en webbläsare för att få åtkomst till programmet.
Rensa resurserna
Undvik Azure-avgifter genom att rensa onödiga resurser när du inte längre behöver klustret. Använd az group delete och az deployment sub delete för att ta bort resursgruppen respektive prenumerationsdistributionen:
az group delete \
--resource-group $rgName
--yes
az deployment sub delete \
--name $deploymentName
Nästa steg
- Lär dig hur du utvecklar ett webbprogram med Azure Cosmos DB.
- Lär dig hur du kör frågor mot Azure Cosmos DB för NoSQL.
- Lär dig hur du uppgraderar klustret.
- Lär dig hur du skalar klustret.
- Lär dig hur du aktiverar kontinuerlig distribution.