Esta entrada del blog describe cómo configurar tu propio clúster Couchbase utilizando plantillas de Azure Resource Manager, también conocidas como plantillas ARM.
Requisitos previos:
Si quieres intentarlo, necesitarás algunas cosas:
- Azure Subscription, regístrese aquí para obtener una prueba gratuita.
- Azure CLI, instalado en su sistema, cómo instalar.
- Cuenta Githubopcional si desea experimentar con sus propias plantillas ARM.
Qué desplegará
Esta entrada de blog te guiará a través de los pasos necesarios para desplegar tu propio cluster de Couchbase Server 4.1 en Microsoft Azure. El tamaño del clúster es configurable pero, como mínimo, consistirá en un clúster de tres nodos con replicación a un nodo. También puedes elegir la ubicación del centro de datos para tu clúster entre todas las ubicaciones disponibles accesibles con tu suscripción a Microsoft Azure.
En el proceso de despliegue de Couchbase en Azure aprenderás sobre las plantillas de Azure Resource Manager y cómo editarlas para adaptarlas a tus necesidades. Esto te permitirá cambiar los valores por defecto en la plantilla ARM de Couchbase y también entender cómo usar las plantillas ARM en otros casos al usar Microsoft Azure.
Plantillas de Azure Resource Manager
Azure Resource Manager le permite aprovisionar aplicaciones en Microsoft Azure utilizando una plantilla declarativa. Con una sola plantilla, puede desplegar múltiples servicios junto con sus dependencias. También tiene la opción de dividir sus plantillas ARM en varias plantillas que describen recursos individuales. Puede utilizar las mismas plantillas individualmente o por separado para desplegar repetidamente su aplicación/recursos durante cada etapa del ciclo de vida de la aplicación.
Puede comparar las plantillas ARM con otras tecnologías de descripción de recursos como chef.io u otros.
He aquí un ejemplo de la plantilla ARM más sencilla:
|
1 2 3 4 5 6 7 8 |
{ "$schema": "http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#", "contentVersion": "", "parámetros": { }, "variables": { }, "recursos": [ ], "salidas": { } } |
Las plantillas ARM están escritas en JSON con la opción de utilizar algunas cadenas especialmente formateadas que pueden funcionar como referencias a variables y/o llamadas a métodos.
El siguiente fragmento de plantilla ARM muestra cómo definir una red virtual y el uso de variables y parámetros en una plantilla ARM.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
{ "apiVersion": "2015-05-01-preview", "tipo": "Microsoft.Network/virtualNetworks", "nombre": "[variables('virtualNetworkName')]", "localización": "[variables('ubicación')]", "propiedades": { "direcciónEspacio": { "prefijos de dirección": [ "[variables('addressPrefix')]" ] }, "subredes": [ { "nombre": "[variables('subnetName')]", "propiedades": { "prefijodireccion": "[variables('subnetPrefix')]" } } ] } }, |
Puede obtener más información sobre la creación de plantillas ARM en el sitio web de Microsoft Documentación de Azure.
También es posible ejecutar código externo, como shell scripts, etc., para permitir una configuración e instalación personalizadas directamente en una máquina virtual como parte del proceso de instalación.
En combinación, todo esto permite una configuración muy detallada de los recursos en Azure.
El fragmento de plantilla ARM anterior se ha extraído del archivo Plantilla Couchbase Cluster ARM en GitHub.
La opción de ejecutar scripts en la máquina virtual se utiliza para instalar y configurar Couchbase Server en cada máquina virtual individual y, por último, para configurar el clúster de Couchbase entre los nodos individuales de Couchbase.
|
1 2 3 4 5 6 7 8 9 10 |
"vmScripts": { "scriptsToDownload": [ "[concat(variables('templateBaseUrl'), 'couchbase-azure-install.sh')]", "[concat(parameters('cbPackageDownloadBase'), parameters('cbPackage'))]", "[concat(variables('templateBaseUrl'), 'vm-disk-utils-0.1.sh')]" ], "installCommand": "[concat('bash couchbase-azure-install.sh -d ', parameters('cbPackage'), ' -n ', parameters('clusterName'), ' -i ', concat(variables('networkSettings').nodesIpPrefix, '-', variables('clusterSpec').clusterSize), ' -a ', variables('machineSettings').adminUsername, ' -p ', variables('machineSettings').adminPassword, ' -r ', variables('clusterSpec').couchbaseRamQuota)]"., "setupCommand": "[concat('bash couchbase-azure-install.sh -d ', parameters('cbPackage'), ' -n ', parameters('clusterName'), ' -i ', concat(variables('networkSettings').nodesIpPrefix, '-', variables('clusterSpec').clusterSize), ' -a ', variables('machineSettings').adminUsername, ' -p ', variables('machineSettings').adminPassword, ' -r ', variables('clusterSpec').couchbaseRamQuota, ' -l')]". }, "clusterSpec": "[variables(concat('ttallaCamiseta', parámetros('ttallaCamiseta')))]" |
El fragmento anterior muestra cómo configurar un script externo como parte de la plantilla ARM y pasar argumentos de línea de comandos, utilizando parámetros.
Más adelante hablaremos de las plantillas ARM.
Azure CLI
En la sección anterior hemos aprendido brevemente acerca de las plantillas ARM y cómo se pueden utilizar para describir los recursos en Azure. Una receta para los recursos y sus configuraciones individuales según sea necesario para su configuración específica.
En esta sección nos centraremos en cómo utilizar la plantilla ARM o en la jerga de Azure, Desplegar plantillas ARM. Usted tiene algunas opciones de despliegue, vamos a caminar brevemente a través de ellos.
Mediante Azure Portal, opción 1
El nuevo portal Azure le ofrece la opción de realizar un "despliegue de plantillas" desde el propio portal.
Navegando hasta: Microsoft.Plantilla
puede copiar/pegar su plantilla ARM en el portal y ejecutarla. La interfaz de usuario admite incluso parámetros personalizados, etc.
El inconveniente es que sólo se puede copiar/pegar una plantilla ARM en el portal y todos los recursos tienen que estar con este único "archivo".
Usando Azure Portal, opción 2
Esta característica es muy parecida a la "opción 1" pero con algunas diferencias. Es posible ordenar a Azure que descargue una plantilla ARM de una fuente externa, el único requisito es que todos los recursos (plantillas, scritps, etc.) estén disponibles públicamente.
Esta característica puede verse y probarse desde el repositorio Microsoft Official Azure Quick Start Templates en GitHub, azure-quickstart-templates
Si visita esta plantilla específica101-vm-simple-windows verá un botón azul (Deploy to Azure). Al pulsar este botón, se le redirigirá a la implementación de la plantilla del portal de Azure, pero ahora con la plantilla pegada previamente en el portal.
¡Atención!
En azure-quickstart-templates es un gran recurso para aprender más sobre las plantillas ARM.
Azure PowerShell
Azure PowerShell es un módulo para PowerShell que le permite ejecutar comandos en Azure desde PowerShell. Puede crear, probar, desplegar y gestionar soluciones y servicios, incluidos los despliegues de plantillas de ARM.
PowerShell es una gran herramienta de línea de comandos para la plataforma Windows y ampliamente utilizada tanto por profesionales de TI como por desarrolladores, pero sólo está disponible en Windows.
Seguir leyendo PowerShell
Pero no todo el mundo utiliza Windows. Por eso Microsoft ha desarrollado la herramienta Azure CLI.
Azure CLI
Azure CLI es una herramienta de línea de comandos para trabajar con Microsoft Azure; creada para Mac, Linux y Windows.
Trabajar con una herramienta x-plataforma como Azure CLI te da el gran beneficio de que puedes usar tus conocimientos en todas las plataformas.
He optado por utilizar Azure CLI, ya que parece tener la audiencia más amplia y se puede utilizar en la mayoría de las plataformas.
El resto de este post asumirá el uso de Azure CLI, pero muchos (si no todos) los comandos también existen en Azure PowerShell.
Instalar Azure CLI
Dependiendo de sus preferencias, puede instalar Azure CLI desde un paquete de instalación dedicado para su plataforma o utilizando npmLas instrucciones completas se encuentran aquí, Instalar Azure CLI.
Suponiendo que tenga un Mac y npm ya está instalado en su sistema, entonces la instalación de Azure CLI es una sola línea:
|
1 |
sudo npm instale -g azure-cli |
Tenga en cuenta el uso del argumento de instalación global -gEsto asegura que Azure CLI está disponible globalmente en el sistema.
Uso de Azure CLI
Ahora que tenemos Azure CLI instalado vamos a seguir adelante y ver cómo utilizar la herramienta para implementar y administrar sus recursos de Azure con plantillas ARM.
Autenticación
Antes de usar Azure CLI necesitamos autenticarnos con Microsoft Azure. Hay varias maneras de autenticar la CLI con Azure, para una guía detallada visita Conectarse a un servidor Azure.
En esta guía utilizaremos este comando:
|
1 |
azure inicio de sesión |
Siga las instrucciones en pantalla para autenticar la CLI de Azure.
Establecer la cuenta de suscripción Azure a utilizar
Si tiene varias suscripciones a Azure, debe seleccionar la suscripción que desea utilizar.
Use este comando para listar las suscripciones disponibles para la cuenta:
|
1 |
azure cuenta lista |
Establezca la suscripción que desea utilizar como su por defecto para todas las instancias de la instancia de Azure CLI.
azure account set "Azure Pass"
Establecer el modo de Azure Resource Manager
Azure CLI puede trabajar en dos modos diferentes, classic y arm. Dependiendo del modo que selecciones estarás restringido a trabajar sólo con esos tipos de recursos (siempre puedes cambiar de modo más adelante).
Estamos trabajando con plantillas de Azure Resource Manager y por lo tanto necesitamos cambiar el modo a brazo.
El modo por defecto para Azure CLI es clásicoUtilice el siguiente comando para activar el modo Azure Resource Manager:
|
1 |
azure config modo brazo |
Crear un grupo de recursos
Cuando se trabaja con Azure Resource Manager siempre se trabaja dentro de un "grupo de recursos". Puede pensar en un "grupo de recursos como un cubo, contenedor o área lógica para sus recursos. El grupo de recursos encapsula todos los recursos necesarios para su aplicación y facilita la definición de límites entre recursos.
Es necesario crear un grupo de recursos dentro de una ubicación (región Azure).
Dependiendo de su suscripción, la ubicación disponible puede variar. Para obtener la lista completa de su suscripción, ejecute el siguiente comando:
|
1 |
azure ubicación lista |
Elige una ubicación para tu grupo de recursos y crea un grupo de recursos:
|
1 |
azure grupo crear -n CB_RESOURCE_GROUP -l "Eest US" |
Crear un despliegue y esperar a que tenga éxito
Con un grupo de recursos creado podemos "desplegar" una plantilla ARM al grupo de recursos. Esto creará todos los recursos definidos en la plantilla ARM al grupo de recursos.
El siguiente comando "enviará" la plantilla ARM a Azure e iniciará el despliegue de los recursos definidos en el grupo de recursos especificado.
¡Importante!
Este comando creará un clúster de tres nodos en su suscripción y con ello iniciará el consumo/uso de su suscripción Azure. Dependiendo de su tipo de suscripción, nivel, etc., esto puede suponer cargos en su suscripción que se le facturarán más adelante.
|
1 2 3 4 5 |
azure grupo despliegue crear --plantilla-uri https://raw.githubusercontent.com/martinesmann/couchbase-azure/master/src/templates/azuredeploy.json -e azuredeploy.parámetros.json CB_RESOURCE_GROUP DESPLIEGUE_AZURE |
Permítanme explicar el comando con un poco más de detalle.
En sólo se añade para permitir saltos de línea para un comando de una sola línea en la consola. Esto no es específico de Azure CLI.
La primera línea indica a Azure CLI que cree un nuevo despliegue.
La segunda línea es la referencia a la plantilla ARM, este valor puede ser tanto un archivo local o (como en este caso) una referencia a una ubicación pública.
ARM plantillas necesitan parámetros y variables, la tercera línea instruye Azure CLI dónde encontrar los parámetros. También puede agregar parámetros directamente desde la línea de comandos, pero me parece más conveniente utilizar un archivo.
Vale la pena señalar que cuando se utiliza un archivo de parámetros tiene que ser local, en su máquina. Supongo que Microsoft impone esta restricción para garantizar la seguridad y evitar que se compartan accidentalmente datos confidenciales.
El tiempo de ejecución del comando anterior es de unos 10-25 minutos. Por lo tanto, si usted necesita una taza de café, ahora sería un buen momento para conseguir que :)
IP pública para el grupo de recursos
Una vez que el despliegue se ha completado con éxito, es hora de inspeccionar el resultado.
Siempre puede navegar hasta el Portal Azure para obtener una visión de lo que se ha desplegado, pero también podemos utilizar Azure CLI.
La plantilla Couchbase ARM crea en realidad ¡cuatro máquinas virtuales! Tres nodos Couchbase combinados en un único cluster y una máquina virtual configurada como un caja de salto. La configuración es la mejor práctica recomendada por Couchbase y asegura que el Cluster Couchbase está protegido detrás de un firewall y sólo se puede acceder "directamente" a través de la máquina de la caja de salto.
En realidad la configuración de seguridad establecida por la plantilla ARM es realmente elegante, ninguno de los nodos Couchbase tiene una IP pública. ¡Esto significa que no hay manera de acceder a los nodos sin pasar por la caja de salto! Perfecto.
Podemos confirmarlo pidiendo a Azure CLI que nos devuelva TODAS las IP públicas asignadas para nuestro grupo de recursos.
|
1 |
azure red público-ip lista CB_RESOURCE_GROUP |
Ahora podemos usar esta IP para crear un túnel ssh a nuestro Cluster Couchbase.
|
1 2 |
[MAC SÓLO] ssh -D 8080 -C -N couchadmin@{ip-dirección} |
Info:
Si ha utilizado los parámetros por defecto:
Usuario: couchadmin
Contraseña: P@ssword1
El comando ssh abre una conexión proxy a la máquina de la caja de salto en Azure.
Si configuras tu conexión de red para usar el proxy para todo el tráfico de red, ¡podemos conectarnos al Cluster Couchbase!
[SÓLO MAC]
configura tu proxy:
- Abra "Preferencias del Sistema".
- Vaya a "Red".
- Seleccione "Avanzado".
- Haga clic en la pestaña "Proxies".
- Seleccione "Proxy SOCKS".
- Dirección del servidor proxy SOCKS:
127.0.0.1 - Puerto:
8080
- Dirección del servidor proxy SOCKS:
- Haz clic en "Aceptar".
- Haga clic en "Aplicar".
- Abra su navegador favorito y vaya a http://10.0.0.10:8091
- Inspeccione su instalación de Couchbase (usuario:
couchbaseadmincontraseña:P@ssword1)
Nota:
Recuerde deshacer los cambios en el proxy cuando termine de probar.
Eliminar el grupo de recursos
Si este despliegue se hizo sólo para probar la experiencia, entonces es seguro asumir que en algún momento en el tiempo le gustaría quitar el clúster Couchbase y liberar todos los recursos (tomar el servicio y los recursos hacia abajo)
Dado que todos los recursos se crearon en un único grupo de recursos, la eliminación de ese grupo de recursos eliminará todos los servicios y recursos. Usando Azure CLI, esto es una tarea muy fácil:
|
1 |
azure grupo borrar CB_RESOURCE_GROUP |
Este comando tardará varios minutos en completarse.
Plantilla Couchbase ARM
Hasta ahora no hemos entrado en muchos detalles sobre la plantilla ARM de Couchbase en sí. En esta sección tocaremos algunos de los aspectos más importantes de la plantilla y los que son específicos para Couchbase.
El código fuente completo, las plantillas y todas las dependencias se pueden encontrar en GitHub, couchbase-azure.
Navegar hasta el carpeta de plantillas...revelan once archivos separados:
azuredeploy.json
El punto de entrada principal para la plantilla ARM. Esta plantilla define todos los parámetros y variables que se utilizan en la plantilla. Todos los recursos, desde los nics de red hasta el tamaño de las máquinas virtuales, se especifican en este archivo:
Este fragmento define las propiedades de "camiseta talla mediana".
"tshirtSizeMedium": {
"storageAccountCount": 1,
"clusterSizeMinusOne": 3,
"lastNodeId": 3,
"clusterSize": 4,
"couchbaseRamQuota": 22000,
"vmSize": "Standard_A6",
"maxNumberOfDataDisksForVmSizeNotUsedButHereForReference": 8,
"vmTemplate": "[concat(variables('templateBaseUrl'), 'cluster-nodes-A6.json')]",
"backendIPConfigurations": [
{
"id": "[concat(resourceId('Microsoft.Network/networkInterfaces', 'nic0'),'/ipConfigurations/ipconfig1')]".
},
{
"id": "[concat(resourceId('Microsoft.Network/networkInterfaces', 'nic1'),'/ipConfigurations/ipconfig1')]".
},
{
"id": "[concat(resourceId('Microsoft.Network/networkInterfaces', 'nic2'),'/ipConfigurations/ipconfig1')]".
},
{
"id": "[concat(resourceId('Microsoft.Network/networkInterfaces', 'nic3'),'/ipConfigurations/ipconfig1')]".
}
]
},
Puedes navegar por el archivo para hacerte una mejor idea de la estructura y de cómo están configuradas las cosas.
azuredeploy.parameters.json
Este archivo contiene todos los parámetros predefinidos para la plantilla. Este archivo no es obligatorio, pero es muy útil cuando se inicia un despliegue.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
{ "$schema": "http://schema.management.azure.com/schemas/2015-01-01/deploymentParameters.json#", "contentVersion": "1.0.0.0", "parámetros": { "adminUsername": { "valor": "couchadmin" }, "adminContraseña": { "valor": "P@ssword1" }, "tshirtSize": { "valor": "Pequeño" }, "storageAccountNamePrefix": { "valor": "f180cbdply92" }, "región": { "valor": "Asia Oriental" }, "virtualNetworkName": { "valor": "couchVnet" }, "clusterName": { "valor": "couchbasefs180" }, "jumpbox": { "valor": "activado" } } } |
Si desea cambiar la contraseña, este es el lugar para hacerlo.
cluster-nodos-A2.json
Plantilla ARM parcial para la configuración utilizando las máquinas virtuales A2. Este es también el archivo que configura los recursos reales de la máquina virtual, red, discos, etc.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 |
{ "apiVersion": "2015-05-01-preview", "tipo": "Microsoft.Compute/virtualMachines", "nombre": "[concat(parameters('machineSettings').machineNamePrefix, parameters('nodeId'))]", "localización": "[parameters('commonSettings').region]", "dependeDe": [ "[concat('Microsoft.Network/networkInterfaces/', 'nic', parameters('nodeId'))]" ], "propiedades": { "availabilitySet": { "id": "[resourceId('Microsoft.Compute/availabilitySets', parameters('commonSettings').availabilitySet)]" }, "hardwareProfile": { "vmSize": "[parameters('vmSize')]" }, "osProfile": { "computerName": "[concat(parameters('machineSettings').machineNamePrefix, parameters('nodeId'))]", "adminUsername": "[parameters('machineSettings').adminUsername]", "adminContraseña": "[parameters('machineSettings').adminPassword]" }, "storageProfile": { "imageReference": "[parameters('machineSettings').imageReference]", "osDisk": { "nombre": "osdisk", "vhd": { "uri": "[concat('http://', parameters('storageAccountName'), '.blob.core.windows.net/',variables('vmStorageAccountContainerName'),'/', parameters('machineSettings').machineNamePrefix, parameters('nodeId'),'os-disk.vhd')]" }, "caché": "LecturaEscritura", "createOption": "FromImage" }, "dataDisks": [ { "nombre": "datadisk0", "diskSizeGB": "[parameters('machineSettings').dataDiskSize]", "lun": 0, "caché": "Ninguno", "createOption": "Vacío", "vhd": { "Uri": "[concat('http://', parameters('storageAccountName'), '.blob.core.windows.net/',variables('vmStorageAccountContainerName'),'/', parameters('machineSettings').machineNamePrefix, parameters('nodeId'),'dataDisk0' ,'.vhd')]" } }, { "nombre": "datadisk1", "diskSizeGB": "[parameters('machineSettings').dataDiskSize]", "lun": 1, "caché": "Ninguno", "createOption": "Vacío", "vhd": { "Uri": "[concat('http://', parameters('storageAccountName'), '.blob.core.windows.net/',variables('vmStorageAccountContainerName'),'/', parameters('machineSettings').machineNamePrefix, parameters('nodeId') ,'dataDisk1','.vhd')]" } }, { "nombre": "datadisk2", "diskSizeGB": "[parameters('machineSettings').dataDiskSize]", "lun": 2, "caché": "Ninguno", "createOption": "Vacío", "vhd": { "Uri": "[concat('http://', parameters('storageAccountName'), '.blob.core.windows.net/',variables('vmStorageAccountContainerName'),'/', parameters('machineSettings').machineNamePrefix, parameters('nodeId') ,'dataDisk2','.vhd')]" } }, { "nombre": "datadisk3", "diskSizeGB": "[parameters('machineSettings').dataDiskSize]", "lun": 3, "caché": "Ninguno", "createOption": "Vacío", "vhd": { "Uri": "[concat('http://', parameters('storageAccountName'), '.blob.core.windows.net/',variables('vmStorageAccountContainerName'),'/', parameters('machineSettings').machineNamePrefix, parameters('nodeId') ,'dataDisk3','.vhd')]" } } ] }, "perfil de red": { "interfaces de red": [ { "id": "[resourceId('Microsoft.Network/networkInterfaces',concat('nic', parameters('nodeId')))]" } ] } } }, |
cluster-nodos-A6.json
Plantilla parcial ARM para configuración utilizando las VM's A6, igual que A2.
cluster-nodos-D14.json
Plantilla parcial ARM para configuración utilizando las VM's D14, igual que A2.
couchbase-azure-install.sh
Este script de shell se descarga para descargar las máquinas virtuales y hace todo el trabajo necesario para instalar Couchbase Server en los nodos y configurar el Cluster.
La última parte del script se encarga de configurar el clúster. Si desea configurar un cubo este es el lugar para añadir la línea de comandos.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
si [ "$IS_LAST_NODE" -eq 1 ]; entonces registro "dormir durante 4 minutos para esperar a que el entorno se estabilice" dormir 4m registro "Inicializando el primer nodo del cluster en ${MY_IP}". /op/couchbase/papelera/couchbase-cli nodo-init -c "$MY_IP":8091 -u "${ADMINISTRADOR}" -p "${CONTRASEÑA}" --nodo-init-datos-ruta="${COUCHBASE_DATA}" --nodo-init-índice-ruta="${COUCHBASE_DATA}" registro "Configuración del clúster" /op/couchbase/papelera/couchbase-cli grupo-init -c "$MY_IP":8091 -u "${ADMINISTRADOR}" -p "${CONTRASEÑA}" --grupo-ramsize="${RAM_FOR_COUCHBASE}" --grupo-índice-ramsize=256 --servicios=datos,índice,consulta registro "Configurar autofailover" /op/couchbase/papelera/couchbase-cli ajuste-autofailover -c "$MY_IP":8091 -u "${ADMINISTRADOR}" -p "${CONTRASEÑA}" --active-auto-conmutación por error=1 --auto-conmutación por error-tiempo de espera=30 para (( i = 0; i < ${#MEMBER_IP_ADDRESSES[@]}; i++ )); do registro "Añadiendo nodo ${MEMBER_IP_ADDRESSES[$i]} al cluster" /op/couchbase/papelera/couchbase-cli servidor-añada -c "$MY_IP":8091 -u "${ADMINISTRADOR}" -p "${CONTRASEÑA}" --servidor-añada="${MEMBER_IP_ADDRESSES[$i]}":8091 --servidor-añada-nombre de usuario="${ADMINISTRADOR}" --servidor-añada-contraseña="${CONTRASEÑA}" --servicios=datos,índice,consulta hecho registro "Reequilibrar la agrupación" /op/couchbase/papelera/couchbase-cli reequilibrar -c "$MY_IP":8091 -u "${ADMINISTRADOR}" -p "${CONTRASEÑA}" /*OPCIONAL AÑADIR LÓGICA PARA CONFIGURAR UN CUBO*/ fi registro "¡Instalación de couchbase completa!" |
jumpbox-recursos-desactivados.json
Shell script a utilizar cuando la caja de salto está desactivada para la configuración.
jumpbox-recursos-habilitados.json
Shell script para configurar la máquina de jump box.
metadatos.json
Archivo utilizado para realizar un seguimiento de los cambios, heredado de la fuente original en couchbase-on-ubuntu.
recursos-compartidos.json
Recurso compartido, heredado de la fuente original en couchbase-on-ubuntu.
vm-disk-utils-0.1.sh
Utilidad de disco Linux.
Verano
En esta entrada de blog aprendiste sobre las plantillas Azure Resource Manager (ARM) y su uso. También abordamos brevemente los detalles específicos de la plantilla ARM de Couchbase y las diversas formas en que puedes interactuar con Azure e implementar plantillas ARM.
¡Feliz despliegue!
