Skapa Bicep-filer med Visual Studio Code

2025-10-30

Den här artikeln visar hur du använder Visual Studio Code för att skapa Bicep-filer.

Installera Visual Studio Code

Information om hur du konfigurerar din miljö för Bicep-utveckling finns i Installera Bicep-verktyg. När du har slutfört de här stegen har du Visual Studio Code och Bicep-tillägget installerat. Du har också antingen den senaste Azure CLI-modulen eller den senaste Azure PowerShell-modulen.

Bicep-kommandon

Visual Studio Code levereras med flera Bicep-kommandon.

Öppna eller skapa en Bicep-fil i Visual Studio Code och välj menyn Visa och sedan Kommandopalett. Du kan också trycka på F1 eller tangentkombinationen Ctrl+Skift+P för att visa kommandopaletten. Ange Bicep för att visa Bicep-kommandona.

Skärmbild av Visual Studio Code Bicep-kommandon i kommandopaletten.

Dessa kommandon omfattar:

Skapa en Azure Resource Manager (ARM)-mall
Skapa parameterfil
Skapa Bicep-konfigurationsfilen
Dekompilera till Bicep
Distribuera Bicepfil
Generera parametrarfil
Importera Azure Kubernetes Manifest (EXPERIMENTELL)
Infoga resurs
Öppna Bicep Visualizer
Öppna Bicep Visualizer åt sidan
Klistra in JSON som Bicep
Återställa Bicep-moduler (med tvång)
Visa distributionsfönstret
Visa distributionsfönstret åt sidan

Dessa kommandon visas också på snabbmenyn när du högerklickar på en Bicep-fil:

Och när du högerklickar på en JSON-fil:

Mer information kan du hitta om kommandona i den här artikeln under Bicep CLI-kommandon.

Förutom Bicep-kommandona kan du även använda de inbyggda VS Code-kommandona, till exempel Format Documents, eller Skift+Alt+F.

Kommandot Skapa ARM-mall

Kommandot build konverterar en Bicep-fil till en JSON ARM-mall. Den nya mallen lagras i samma mapp med samma filnamn. Om det finns en fil med samma filnamn skriver den över den gamla filen. Se skapa för ett exempel och mer information.

Kommandot Skapa Parameterfil

Kommandot build-params konverterar också en Bicep-parameterfil till en JSON-parameterfil. Den nya parameterfilen lagras i samma mapp med samma filnamn. Om det finns en fil med samma filnamn skriver den över den gamla filen. Se build-params för ett exempel.

Kommandot Skapa Bicep-konfigurationsfil

bicepconfig.json filen är en Bicep-konfigurationsfil som kan förbättra din Bicep-utvecklingsmiljö. Du kan lägga till bicepconfig.json till flera kataloger. Konfigurationsfilen som är närmast Bicep-filen i kataloghierarkin används. När du väljer Skapa Bicep-konfigurationsfil i Visual Studio Code öppnas en dialogruta där du kan välja en mapp. Standardmappen är där du lagrar Bicep-filen. Om det redan finns en bicepconfig.json fil i mappen kan du skriva över den befintliga filen.

Så här skapar du en Bicep-konfigurationsfil:

Öppna Visual Studio Code.
På menyn Visa väljer du Kommandopalett (eller trycker på Ctrl/Cmd+Skift+P) och sedan Bicep: Skapa Bicep-konfigurationsfil.
Välj den filkatalog där du vill placera filen.
Spara konfigurationsfilen när du är klar.

Dekompilera till Bicep-kommando

Kommandot decompile dekompileras en JSON ARM-mall till en Bicep-fil och placerar den i samma katalog som den ursprungliga JSON ARM-mallen. Den nya filen har samma filnamn som .bicep tillägget. Om det redan finns en Bicep-fil med samma filnamn i samma mapp uppmanar Visual Studio Code dig att skriva över den befintliga filen eller skapa en kopia. Se dekompilera för ett exempel.

Kommandot Distribuera Bicep-fil

Du kan distribuera Bicep-filer direkt från Visual Studio Code. Välj Distribuera Bicep-fil från kommandopaletten eller på snabbmenyn. Tillägget uppmanar dig att logga in på Azure Portal, välja din prenumeration, skapa eller välja en resursgrupp och ange värden för parametrar.

Kommentar

Bicep-distributionskommandot i Visual Studio Code använder det nya inbyggda autentiserings-API: et för att hantera autentisering. Den använder inte molnprofiler från bicepconfig.json. Om du vill logga in på ett anpassat moln väljer du >> För närvarande stöds inte flera inloggade konton.

Kommandot för generering av parameterfil

Kommandot generate-params skapar en parameterfil i samma mapp som Bicep-filen. Du kan välja att skapa en Bicep-parameterfil eller en JSON-parameterfil. Det nya filnamnet för Bicep-parametrar är <bicep-file-name>.bicepparam, medan det nya JSON-parameterfilens namn är <bicep-file-name>.parameters.json. Se generera-params för ett exempel och mer information.

Kommandot Importera AKS-manifest (förhandsversion)

Det här kommandot importerar en AKS-manifestfil och skapar en Bicep-modul. Mer information finns i Bicep Kubernetes-tillägget (förhandsversion) och Snabbstart: Distribuera ett AkS-kluster (Azure Kubernetes Service) med hjälp av Bicep Kubernetes-tillägget (förhandsversion).

Infoga resurskommando

Det här kommandot deklarerar en resurs i Bicep-filen genom att ange resurs-ID för en befintlig resurs. Välj Infoga resurs i Visual Studio Code och ange resurs-ID:t i kommandopaletten. Det tar en stund att infoga resursen.

Du kan använda någon av dessa metoder för att hitta resurs-ID:t:

Använd Azure Resources-tillägget för Visual Studio Code.
Kontrollera Azure Portal.
Använd Azure CLI eller Azure PowerShell:
- Azure CLI
- Azure PowerShell
```
az resource list
```
```
Get-AzResource
```

På samma sätt som när du exporterar mallar försöker den här processen skapa en användbar resurs. De flesta infogade resurser måste dock ändras på något sätt innan de kan användas för att distribuera Azure-resurser. Mer information finns i Dekompilera ARM-mallens JSON till Bicep.

Öppna Bicep Visualizer-kommandot

Bicep Visualizer visar de resurser som definierats i Bicep-filen och beroendena mellan dem. Följande diagram är en visuell representation av en Bicep-fil för en virtuell Linux-dator.

Du kan öppna Bicep Visualizer sida vid sida med Bicep-filen.

Klistra in JSON som Bicep-kommando

Du kan klistra in ett JSON-kodfragment från en ARM-mall till en Bicep-fil. Visual Studio Code dekompilerar automatiskt JSON till Bicep. Den här funktionen är endast tillgänglig med Bicep-tillägget version 0.14.0 eller senare, och den är aktiverad som standard. Information om hur du inaktiverar funktionen finns i Visual Studio Code och Bicep-tillägget.

Med den här funktionen kan du klistra in:

Fullständiga JSON ARM-mallar.
En eller flera resurser.
JSON-värden som objekt, matriser eller strängar. En sträng med dubbla citattecken konverteras till en med enkla citattecken.

Du kan till exempel börja med följande Bicep-fil:

@description('Storage Account type')
@allowed([
  'Standard_LRS'
  'Standard_GRS'
  'Standard_ZRS'
  'Premium_LRS'
])
param storageAccountsku string = 'Standard_LRS'

@description('Location for all resources.')
param location string = resourceGroup().location

var storageAccountName = '${uniqueString(resourceGroup().id)}storage'

resource storageAccount 'Microsoft.Storage/storageAccounts@2023-04-01' = {
  name: storageAccountName
  location: location
  sku: {
    name: storageAccountsku
  }
  kind: 'StorageV2'
  tags: {
    ObjectName: storageAccountName
  }
  properties: {}
}

output storageAccountName string = storageAccountName

Klistra in följande JSON:

{
  "type": "Microsoft.Batch/batchAccounts",
  "apiVersion": "2024-02-01",
  "name": "[parameters('batchAccountName')]",
  "location": "[parameters('location')]",
  "tags": {
    "ObjectName": "[parameters('batchAccountName')]"
  },
  "properties": {
    "autoStorage": {
      "storageAccountId": "[resourceId('Microsoft.Storage/storageAccounts', variables('storageAccountName'))]"
    }
  }
}

Visual Studio Code konverterar automatiskt JSON till Bicep. Observera att du också måste lägga till en batchAccountName parameter.

Du kan ångra dekompileringen genom att trycka på Ctrl+Z. Den ursprungliga JSON-filen visas i filen.

Kommandot Återställ Bicep-moduler

När Bicep-filen använder moduler som publiceras i ett register restore hämtar kommandot kopior av alla nödvändiga moduler från registret. Den lagrar dessa kopior i en lokal cache. För mer information och ett exempel, se återställning.

Kommandot "Visa distributionsfönster"

Se distributionsfönstret.

Använda snabbkorrigeringsförslag

Glödlampan i VS Code representerar ett snabbkorrigeringsförslag. Det visas när redigeraren identifierar ett problem eller en förbättringsmöjlighet i koden. När du klickar på glödlampan visas en meny med åtgärder som kan åtgärda problemet eller förbättra koden.

Skärmbild av snabbkorrigeringsförslag för Visual Studio Code.

För extraheringskommandona, se Extrahera parametrar, variabler och typer. I Fler åtgärder föreslår det att du lägger till dekoratörer.

Extrahera parametrar, variabler och typer

Att extrahera variabler, parametrar och användardefinierade datatyper innebär att isolera och definiera dessa komponenter från befintlig kod för att förbättra kodstrukturen, underhållsbarheten och tydligheten.

Följande skärmbild visar en definition av en AKS-klusterresurs. Du kan extrahera en parameter eller en variabel eller en användardefinierad datatyp baserad på en egenskap, till exempel identity. Välj raden identity i koden och välj sedan den gula glödlampans ikon. Kontextfönstren visar tillgängliga alternativ för extrahering.

Skärmbild av variabel, parameter, typextrahering.

Extrahera variabel: Skapa en ny variabel, plus alternativet för att uppdatera variabelnamnet:
Extrahera parametern för en enkel datatyp: Skapa en ny parameter med en enkel datatyp, till exempel sträng, int osv., plus alternativet för att uppdatera parameternamnet:
Extrahera parametern för en användardefinierad datatyp: Skapa en ny parameter med en användardefinierad datatyp, plus alternativet att uppdatera parameternamnet:

Detta kräver viss anpassning efter extraheringen.
Skapa användardefinierad typ: Skapa en ny användardefinierad typ, plus alternativet att uppdatera typnamnet.

Till skillnad från de andra alternativen ersätter den inte den valda koden med en referens till den nya typen. I föregående exempel förblir värdet identity som det är. Om du vill använda den nya typen måste du införliva den i koden.

Visa dokumentationsalternativ

Från Visual Studio Code kan du öppna mallreferensen för den resurstyp där du arbetar. Det gör du genom att hovra markören över en resurs symboliska namn och välja Visa dokumentation.

Skärmbild av alternativet Visa dokumentation i Visual Studio Code.

Gå till fil

När du definierar en modul och oavsett vilken typ av fil som refereras – en lokal fil, modulregisterfil eller en mallspecifikation – kan du öppna filen genom att välja eller markera modulsökvägen och trycka på [F12]. Om den refererade filen är en Azure-verifierad modul, en AVM, kan du växla mellan den kompilerade JSON- eller Bicep-filen. Om du vill öppna Bicep-filen för en privat registermodul kontrollerar du att modulen publiceras i registret med växeln WithSource aktiverad. Mer information finns i Publicera filer till registret. Visual Studio Code Bicep-tillägget version 0.27.1 eller senare krävs för att öppna Bicep-filer från ett privat modulregister.

Distributionsfönster

Distributionsfönstret är en användargränssnittspanel som gör att du kan ansluta till din Azure-prenumeration och utföra verifierings-, distributions- och konsekvensåtgärder, vilket ger omedelbar feedback utan att lämna redigeraren.

Så här använder du distributionsfönstret:

Öppna en .bicep-fil eller .bicepparam-fil i VS Code.
Det finns två sätt att öppna distributionsfönstret:
- Välj knappen Visa distributionsfönster i det övre högra hörnet enligt följande skärmbild:
  
  Som standard öppnar VS Code distributionsfönstret på sidan. För att öppna den i en ny flik håller du Alt medan du väljer knappen.
- Ett annat sätt att öppna distributionsfönstret är via kommandopaletten. Tryck på Ctrl + Skift + P och välj sedan antingen Visa distributionsfönstret eller Visa distributionsfönstret åt sidan.
Följande skärmbild visar en lyckad distribution med valideringsresultatet för Bicep-filen.
Välj Ändra omfång för att definiera distributionsomfånget. Efter autentiseringen kan du välja prenumerationen och resursgruppen för önskad distribution.
Välj Pick JSON-parameterfil för att välja en JSON-parameterfil.
Välj önskad åtgärd – Distribuera, Verifiera eller Vad händer om.
- Distribuera: distribuerar till Azure, och resultatet, inklusive den definierade utdata, visas i distributionspanelen.
- Validate: utför en körningsvalidering av Bicep-filen mot Azure för att säkerställa att resurserna, parametrarna och principerna är korrekta i den faktiska distributionsmiljön. Till skillnad från en linter, som endast söker efter syntaxfel, interagerar den här valideringen med Azure för att identifiera potentiella driftsättningsproblem. Det motsvarar verifieringskommandot i Azure CLI och testkommandot i Azure PowerShell. Till exempel:
  - Azure CLI
  - Azure PowerShell
```
az deployment group validate --resource-group <resource-group-name> --template-file <template-file-path>        
```
```
Test-AzResourceGroupDeployment -ResourceGroupName <ResourceGroupName> -TemplateFile <TemplateFilePath>
```
- Konsekvensanalys: kör en Konsekvensanalys direkt från distributionsfönstret. I fönstret visas resultaten som visar planerade ändringar. Detta utför samma funktion som "vad händer om"-kommandot i Azure PowerShell och Azure CLI. Till exempel:
  - Azure CLI
  - Azure PowerShell
```
az deployment group what-if --resource-group <resource-group-name> --template-file <template-file-path>        
```
```
New-AzResourceGroupDeployment -Whatif -ResourceGroupName <ResourceGroupName> -TemplateFile <TemplateFilePath>
```
Mer information finns i en av följande artiklar:
- Bicep-utplacering tänk om-åtgärd
- Distribuera Bicep-filer med Visual Studio Code
- Distribuera Bicep-filer med Azure CLI
- Distribuera Bicep-filer med Azure PowerShell
- Distribuera Bicep-filer med Azure molnshell

Felsöka

Fönstret Problems sammanfattar felen och varningen i Bicep-filen:

Skärmbild av fönstret Problem i Visual Studio Code.

Bicep Core Diagnostics innehåller en lista över fel- och varningskoder .

Nästa steg

Fortsätt till Snabbstart: Skapa Bicep-filer med Visual Studio Code för en handledning om hur man tillämpar informationen i den här artikeln.

Feedback

Var den här sidan till hjälp?