Compartir a través de

Creación de archivos Bicep mediante Visual Studio Code

  • Artículo

En este artículo, se muestra cómo usar Visual Studio Code para crear archivos Bicep.

Instalación de VS Code

A fin de configurar el entorno para el desarrollo de Bicep, consulte Instalación de las herramientas de Bicep. Después de completar esos pasos, tendrá Visual Studio Code y la extensión de Bicep. También tendrá la versión más reciente de la CLI de Azure o la versión más reciente del módulo de Azure PowerShell.

Comandos de Bicep

Visual Studio Code incluye varios comandos de Bicep.

Abra o cree un archivo Bicep en VS Code, seleccione el menú Ver y, a continuación, seleccione Paleta de comandos. También puede usar F1 o la combinación de teclas [CTRL]+[MAYÚS]+P para abrir la paleta de comandos. Escriba Bicep para enumerar los comandos de Bicep.

Captura de pantalla de los comandos de Bicep de Visual Studio Code en la paleta de comandos.

Entre estos comandos se incluyen:

Estos comandos también se muestran en el menú contextual al hacer clic con el botón derecho en un archivo Bicep:

Captura de pantalla de los comandos de Bicep en Visual Studio Code, en el menú contextual para archivos Bicep.

Al hacer clic con el botón derecho en un archivo JSON:

Captura de pantalla de los comandos de Bicep en Visual Studio Code, en el menú contextual para plantillas JSON de ARM.

Compilación de una plantilla de ARM

El comando build convierte un archivo de Bicep en una plantilla de Azure Resource Manager (plantilla de ARM). La nueva plantilla JSON se almacena en la misma carpeta con el mismo nombre de archivo. Si existe un archivo con el mismo nombre de archivo, sobrescribe el archivo anterior. Para más información, consulte Comandos de la CLI de Bicep.

Creación de un archivo de configuración de Bicep

El archivo de configuración de Bicep (bicepconfig.json) se puede usar para personalizar la experiencia de desarrollo de Bicep. Puede agregar bicepconfig.json en varios directorios. Se usa el archivo de configuración más cercano al archivo Bicep de la jerarquía de directorios. Al seleccionar este comando, la extensión abre un cuadro de diálogo para poder seleccionar una carpeta. La carpeta predeterminada es donde se almacena el archivo de Bicep. Si ya existe un archivo bicepconfig.json en la carpeta, puede sobrescribir el archivo existente.

Para crear un archivo de configuración de Bicep:

  1. Abra Visual Studio Code.
  2. En el menú Ver, seleccione Paleta de comandos (o presione Ctrl/Cmd][Mayús+P) y seleccione Bicep: Creación de un archivo de configuración de Bicep.
  3. Seleccione el directorio de archivos donde desea colocar el archivo.
  4. Guarde el archivo de configuración cuando haya terminado.

Descompilación como Bicep

Este comando descompila una plantilla JSON de ARM en un archivo de Bicep y lo coloca en el mismo directorio que la plantilla JSON de ARM. El nuevo archivo tiene el mismo nombre de archivo con la extensión .bicep. Si ya existe un archivo de Bicep con el mismo nombre en la misma carpeta, Visual Studio Code le preguntará si quiere sobrescribir ese archivo o crear una copia.

Implementación de un archivo de Bicep

Puede implementar archivos de Bicep directamente desde Visual Studio Code. Seleccione Deploy Bicep file (Implementar archivo Bicep) en la paleta de comandos o en el menú contextual. La extensión le pide que inicie sesión en Azure, seleccione la suscripción, cree o seleccione un grupo de recursos y escriba los valores de los parámetros.

Nota

El comando de implementación de Bicep en vscode usa la extensión de Cuenta de Azure para la autenticación. No usa perfiles de nube de bicepconfig.json.

Generación del archivo de parámetros

Este comando crea un archivo de parámetros en la misma carpeta que el archivo Bicep. Puede optar por crear un archivo de parámetros de Bicep o un archivo de parámetros JSON. El nuevo nombre del archivo de parámetros de Bicep es <bicep-file-name>.bicepparam, mientras que el nuevo nombre de archivo de parámetros JSON es <bicep-file-name>.parameters.json.

Importación del manifiesto de Kubernetes (versión preliminar)

Este comando importa un archivo de manifiesto de Kubernetes y crea un módulo de Bicep. Para obtener más información, consulte Proveedor de Kubernetes de extensibilidad de Bicep e Inicio rápido: Implementación de aplicaciones de Azure en clústeres de Azure Kubernetes Service (AKS) mediante el proveedor de Kubernetes de Bicep (versión preliminar).

Insertar recurso

El comando insert resource agrega una declaración de recursos en el archivo Bicep proporcionando el identificador de recurso de un recurso existente. Después de seleccionar Insert Resource, escriba el identificador de recurso en la paleta de comandos. La inserción del recurso tarda algunos minutos.

Para encontrar el identificador de recurso, use uno de estos métodos:

De forma similar a la exportación de plantillas, el proceso intenta crear un recurso utilizable. Sin embargo, la mayoría de los recursos insertados requieren algunas modificaciones antes de poder usarse para implementar recursos de Azure.

Para más información, consulte Descompilación del código JSON de plantilla de ARM en Bicep.

Apertura del visualizador de Bicep

El visualizador muestra los recursos definidos en el archivo Bicep con la información sobre las dependencias entre recursos. El diagrama es la visualización de un archivo Bicep de una máquina virtual Linux.

Visualizador de Bicep de Visual Studio Code

También puede abrir el visualizador en paralelo con el archivo Bicep.

Restauración de módulos de Bicep

Cuando el archivo Bicep usa módulos publicados en un registro, el comando restore obtiene copias de todos los módulos necesarios del registro. Almacena esas copias en una caché local. Para más información, consulte Comando restore.

Ver documento de tipos

Desde Visual Studio Code, puede abrir la referencia de plantilla del tipo de recurso en el que está trabajando. Para ello, mantenga el cursor sobre el nombre simbólico del recurso y, a continuación, seleccione View type document (Ver documento de tipos).

Captura de pantalla del documento de la vista Bicep de Visual Studio Code.

Ir a la definición

Al definir un módulo, independientemente del tipo de archivo de referencia (archivo local, archivo de registro del módulo, especificación de plantilla), puede abrir el archivo de referencia seleccionando o resaltando la ruta del módulo y pulsando [F12]. Si el archivo al que se hace referencia es del tipo Módulos verificados de Azure (AVM), puede alternar entre el archivo compilado JSON o Bicep. Para poder abrir el archivo Bicep de un módulo de registro privado, asegúrese de que el módulo esté publicado en el registro con el modificador de WithSource habilitado. Para obtener más información, consulte Publicar archivos en el registro. Es necesaria la versión 0.27.1 o posterior de la extensión de Bicep de Visual Studio Code para abrir el archivo Bicep desde el registro de módulo privado.

Pegar como Bicep

Puede pegar un fragmento de código JSON de una plantilla de ARM en el archivo de Bicep. Visual Studio Code descompila automáticamente el JSON en Bicep. Esta característica solo está disponible con la versión 0.14.0 o posteriores de la extensión de Bicep. Esta característica está habilitada de forma predeterminada. Para deshabilitar la característica, consulte VS Code y la extensión de Bicep.

Con esta característica, puede pegar:

  • Plantillas JSON completas de ARM.
  • Recursos únicos o varios recursos.
  • Valores JSON, como objetos, matrices y cadenas. Las comillas dobles de una cadena se convierten a comillas simples.

Por ejemplo, puede empezar con el siguiente archivo de Bicep:

@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

Y pegar el siguiente código 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 convierte automáticamente el JSON a Bicep. Tenga en cuenta que también debe agregar el parámetro denominado batchAccountName.

Puede deshacer la descompilación con Ctrl+Z. El JSON original aparece en el archivo.

Solución de problemas

En el panel Problems resumen los errores y la advertencia en el archivo de Bicep.

Recorte de pantalla del panel problemas de Bicep de Visual Studio Code.

Para obtener la lista de códigos de error o advertencia, consulte Códigos de error y advertencia de Bicep.

Pasos siguientes

Para recorrer un inicio rápido, consulte Inicio rápido: Creación de archivos Bicep con Visual Studio Code.