Esta postagem do blog descreve como configurar seu próprio cluster do Couchbase usando modelos do Azure Resource Manager, também conhecidos como modelos ARM.
Pré-requisitos:
Se você quiser tentar fazer isso, precisará de alguns itens:
- Azure Subscription, inscreva-se aqui para obter uma teste gratuito.
- CLI do Azure, instalada em seu sistema, Como instalar.
- Conta do Githubopcional se você quiser fazer experiências com seus próprios modelos de ARM.
O que você implantará
Esta postagem do blog o guiará pelas etapas necessárias para implantar seu próprio cluster do Couchbase Server 4.1 no Microsoft Azure. O tamanho do cluster é configurável, mas, no mínimo, consistirá em uma configuração de cluster de três nós com replicação em um nó. Você também pode escolher o local do data center para o cluster entre todos os locais disponíveis que podem ser acessados com sua assinatura do Microsoft Azure.
No processo de implantação do Couchbase no Azure, você aprenderá sobre os modelos do Azure Resource Manager e como editá-los para atender às suas necessidades. Isso permitirá que você altere os valores padrão no modelo do ARM do Couchbase e também entenderá como usar os modelos do ARM em outros casos ao usar o Microsoft Azure.
Modelos do Azure Resource Manager
O Azure Resource Manager permite que você provisione aplicativos para o Microsoft Azure usando um modelo declarativo. Com um único modelo, você pode implantar vários serviços juntamente com suas dependências. Você também tem a opção de dividir seus modelos de ARM em vários modelos, cada um descrevendo recursos individuais. Você pode usar os mesmos modelos individual ou separadamente para implantar repetidamente seu aplicativo/recursos durante cada estágio do ciclo de vida do aplicativo.
Você pode comparar os modelos ARM com outras tecnologias de descrição de recursos, como chef.io ou outros.
Aqui está um exemplo do modelo mais simples de ARM:
|
1 2 3 4 5 6 7 8 |
{ "$schema": "http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#", "contentVersion": "", "parâmetros": { }, "variáveis": { }, "recursos": [ ], "saídas": { } } |
Os modelos do ARM são escritos em JSON com a opção de usar algumas cadeias de caracteres especialmente formatadas que podem funcionar como referências a variáveis e/ou chamadas de métodos.
O snippet de modelo do ARM abaixo mostra como definir uma rede virtual e o uso de variáveis e parâmetros em um modelo 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", "name" (nome): "[variables('virtualNetworkName')]", "localização": "[variables('location')]", "propriedades": { "addressSpace": { "addressPrefixes": [ "[variables('addressPrefix')]" ] }, "subnets": [ { "name" (nome): "[variables('subnetName')]", "propriedades": { "addressPrefix": "[variables('subnetPrefix')]" } } ] } }, |
Você pode ler mais sobre como criar modelos ARM na seção Microsoft Documentação do Azure.
Também é possível executar códigos externos, como scripts de shell etc., para permitir a configuração e a instalação personalizadas diretamente em uma máquina virtual como parte do processo de configuração.
Em conjunto, tudo isso permite uma configuração e uma definição muito refinadas dos recursos no Azure.
O snippet do modelo ARM acima foi extraído do Modelo ARM do cluster do Couchbase no GitHub.
A opção de executar scripts na VM é usada para instalar e configurar o Couchbase Server em cada VM individual e, por fim, configurar o cluster do Couchbase entre os nós individuais do 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('tshirtSize', parameters('tshirtSize')))]" |
O snippet acima mostra como configurar um script externo como parte do modelo ARM e passar os argumentos da linha de comando, usando parâmetros.
Falaremos mais sobre os modelos ARM posteriormente.
CLI do Azure
Na seção anterior, aprendemos brevemente sobre os modelos ARM e como eles podem ser usados para descrever recursos no Azure. Uma receita para os recursos e suas configurações individuais, conforme necessário para sua configuração específica.
Nesta seção, vamos nos concentrar em como usar o modelo ARM ou, no jargão do Azure, implantar modelos ARM. Você tem algumas opções de implantação, vamos examiná-las brevemente.
Usando o Portal do Azure, opção 1
O novo portal do Azure oferece a opção de fazer a "implantação de modelos" no próprio portal.
Navegando para: Microsoft.Template
você pode copiar/colar seu modelo ARM no portal e executá-lo. A interface do usuário suporta até mesmo parâmetros personalizados etc.
A desvantagem é que você só pode copiar/colar um modelo de ARM no portal e todos os recursos precisam estar nesse único "arquivo".
Usando o Portal do Azure, opção 2
Esse recurso é muito próximo da "opção 1", mas com algumas diferenças. É possível instruir o Azure a baixar um modelo de ARM de uma fonte externa, o único requisito é que todos os recursos (modelos, scritps etc.) estejam disponíveis publicamente.
Esse recurso pode ser visto e testado no repositório oficial de modelos de início rápido do Microsoft Azure no GitHub, azure-quickstart-templates
Se você visitar esse modelo específico101-vm-simple-windows você verá um botão azul (Deploy to Azure). Ao pressionar esse botão, você será redirecionado para a implantação do modelo do portal do Azure, mas agora com o modelo pré-colado no portal.
Observação!
O azure-quickstart-templates é um ótimo recurso para saber mais sobre os modelos do ARM.
Azure PowerShell
O Azure PowerShell é um módulo para o PowerShell que lhe dá acesso para executar comandos contra o Azure a partir do PowerShell. Você pode criar, testar, implantar e gerenciar soluções e serviços, inclusive implantações de modelos do ARM.
O PowerShell é uma excelente ferramenta de linha de comando para a plataforma Windows e é amplamente utilizado por profissionais de TI e desenvolvedores, mas só está disponível no Windows.
Leia mais PowerShell
Mas nem todo mundo executa o Windows! É por isso que a Microsoft desenvolveu a ferramenta Azure CLI.
CLI do Azure
A CLI do Azure é uma ferramenta de linha de comando para trabalhar com o Microsoft Azure, desenvolvida para Mac, Linux e Windows.
Trabalhar com uma ferramenta de plataforma X, como a CLI do Azure, oferece a grande vantagem de poder usar seu conhecimento em todas as plataformas.
Optei por usar a CLI do Azure, pois ela parece ter o maior público e pode ser usada na maioria das plataformas.
O restante desta postagem pressupõe o uso da CLI do Azure, mas muitos comandos (se não todos) também existem no Azure PowerShell.
Instalar a CLI do Azure
Dependendo de suas preferências, você pode instalar a CLI do Azure a partir de um pacote de instalação dedicado para sua plataforma ou usando npmAs instruções completas podem ser encontradas aqui, Instalar a CLI do Azure.
Supondo que você tenha um Mac e npm já estiver instalado em seu sistema, a instalação da CLI do Azure será feita em uma única linha:
|
1 |
sudo npm instalar -g azul-cli |
Observe o uso do argumento de instalação global -gIsso garante que a CLI do Azure esteja disponível globalmente no sistema.
Usando a CLI do Azure
Agora que temos a CLI do Azure instalada, vamos seguir em frente e ver como usar a ferramenta para implantar e gerenciar seus recursos do Azure com modelos do ARM.
Autenticação
Antes de usar a CLI do Azure, precisamos nos autenticar no Microsoft Azure. Há várias maneiras de autenticar a CLI no Azure. Para obter um guia detalhado, acesse Conectar-se a um Azure.
Neste guia, usaremos esse comando:
|
1 |
azul login |
Siga as instruções na tela para autenticar a CLI do Azure.
Definir a conta de assinatura do Azure a ser usada
Se você tiver várias assinaturas do Azure, precisará selecionar a assinatura a ser usada.
Use esse comando para listar as assinaturas disponíveis para a conta:
|
1 |
azul conta lista |
Defina a assinatura que você gostaria de usar como sua padrão para todas as instâncias da instância da CLI do Azure.
conta do azure definida como "Passe do Azure"
Definir o modo do Azure Resource Manager
A CLI do Azure pode funcionar em dois modos diferentes, clássico e armado. Dependendo do modo selecionado, você estará restrito a trabalhar apenas com esses tipos de recursos (você sempre pode alterar o modo posteriormente).
Estamos trabalhando com modelos do Azure Resource Manager e, portanto, precisamos mudar o modo para braço.
O modo padrão da CLI do Azure é clássicoUse o seguinte comando para ativar o modo Azure Resource Manager:
|
1 |
azul configuração modo braço |
Criar um grupo de recursos
Ao trabalhar com o Azure Resource Manager, você sempre trabalha em um "grupo de recursos". Você pode pensar em um "grupo de recursos como um bucket, contêiner ou área lógica para seus recursos. O grupo de recursos encapsula todos os recursos necessários para seu aplicativo e facilita a definição de limites entre os recursos.
Um grupo de recursos precisa ser criado em um local (região do Azure).
Dependendo de sua assinatura, o local disponível pode variar. Para obter a lista completa de sua assinatura, execute o seguinte comando:
|
1 |
azul localização lista |
Escolha um local para seu grupo de recursos e crie um grupo de recursos:
|
1 |
azul grupo criar -n CB_RESOURCE_GROUP -l "Eest US" |
Crie uma implantação e aguarde o sucesso
Com um grupo de recursos criado, podemos "implantar" um modelo do ARM no grupo de recursos. Isso criará todos os recursos definidos no modelo do ARM para o grupo de recursos.
O comando abaixo "enviará" o modelo ARM para o Azure e iniciará a implantação dos recursos definidos para o grupo de recursos especificado.
Importante!
Esse comando criará um cluster de três nós em sua assinatura e, com isso, iniciará o consumo/uso em sua assinatura do Azure. Dependendo do seu tipo de assinatura, nível etc., isso pode gerar cobranças na sua assinatura, pelas quais você poderá ser cobrado mais tarde!
|
1 2 3 4 5 |
azul grupo implantação criar --modelo-uri https://raw.githubusercontent.com/martinesmann/couchbase-azure/master/src/templates/azuredeploy.json -e Azuredeploy.parâmetros.json CB_RESOURCE_GROUP AZURE_DEPLOYMENT |
Vou explicar o comando com um pouco mais de detalhes.
O é adicionado apenas para permitir quebras de linha para um comando de linha única no console. Isso não é específico da CLI do Azure.
A primeira linha instrui a CLI do Azure a criar uma nova implantação.
A segunda linha é a referência ao modelo ARM. Esse valor pode ser um arquivo local ou (como neste caso) uma referência a um local público.
Os modelos de ARM precisam de parâmetros e variáveis, e a terceira linha instrui a CLI do Azure sobre onde encontrar os parâmetros. Você também pode adicionar parâmetros diretamente da linha de comando, mas acho mais conveniente usar um arquivo.
Vale a pena observar que, ao usar um arquivo de parâmetros, ele precisa ser local, em seu computador. Acho que essa restrição é imposta pela Microsoft para garantir a segurança e evitar o compartilhamento acidental de dados confidenciais.
O tempo de execução do comando acima é de cerca de 10 a 25 minutos. Portanto, se você precisa de uma xícara de café, agora é um bom momento para tomá-lo :)
IP público para o grupo de recursos
Depois que a implementação for concluída e bem-sucedida, é hora de inspecionar o resultado.
Você sempre pode navegar até o Portal do Azure para ter uma visão do que foi implantado, mas também podemos usar a CLI do Azure.
O modelo ARM do Couchbase cria, na verdade, quatro máquinas virtuais! Três nós do Couchbase combinados em um único cluster e uma máquina virtual configurada como um caixa de salto. A configuração é a prática recomendada pela Couchbase e garante que o cluster do Couchbase esteja protegido por um firewall e só possa ser acessado "diretamente" por meio da máquina jump box.
Na verdade, a configuração de segurança definida pelo modelo ARM é realmente elegante, nenhum dos nós do Couchbase tem um IP público. Isso significa que não há como acessar os nós sem passar pela jump box! Perfeito.
Podemos confirmar isso solicitando à CLI do Azure que retorne TODOS os IPs públicos atribuídos ao nosso grupo de recursos.
|
1 |
azul rede público-ip lista CB_RESOURCE_GROUP |
Agora podemos usar esse IP para criar um túnel ssh para o nosso cluster do Couchbase.
|
1 2 |
[MAC SOMENTE] ssh -D 8080 -C -N administrador de sofá@{ip-endereço} |
Informações:
Se você usou os parâmetros padrão, então:
Usuário: couchadmin
Senha: P@ssword1
O comando ssh abre uma conexão proxy com a máquina jumpbox no Azure.
Se você configurar sua conexão de rede para usar o proxy para todo o tráfego de rede, poderemos nos conectar ao cluster do Couchbase!
[SOMENTE MAC]
Configure seu proxy:
- Abra "Preferências do sistema"
- Navegue até "Rede"
- Selecione "Advanced" (Avançado)
- Clique na guia "Proxies".
- Selecione "SOCKS Proxy"
- Endereço do servidor SOCKS Proxy:
127.0.0.1 - Porto:
8080
- Endereço do servidor SOCKS Proxy:
- Clique em "OK".
- Clique em "Apply" (Aplicar).
- Abra seu navegador favorito e navegue até http://10.0.0.10:8091
- Inspecione a instalação do Couchbase (usuário:
administrador do couchbase, senha:P@ssword1)
Observação:
Lembre-se de desfazer as alterações no proxy quando terminar o teste.
Excluir o grupo de recursos
Se essa implantação foi feita apenas para testar a experiência, então é seguro presumir que, em algum momento, você gostaria de desativar o cluster do Couchbase e liberar todos os recursos (desativar o serviço e os recursos)
Como todos os recursos foram criados em um único grupo de recursos, a exclusão desse grupo de recursos derrubará todos os serviços e recursos. Usando a CLI do Azure, essa é uma tarefa muito fácil:
|
1 |
azul grupo excluir CB_RESOURCE_GROUP |
Esse comando levará vários minutos para ser concluído.
Modelo ARM do Couchbase
Até o momento, não entramos em muitos detalhes sobre o modelo ARM do Couchbase em si. Nesta seção, abordaremos alguns dos aspectos mais importantes do modelo e os que são específicos do Couchbase.
O código-fonte completo, os modelos e todas as dependências podem ser encontrados no GitHub, couchbase-azure.
Navegando até o pasta de modelos, revelam onze arquivos separados:
azuredeploy.json
O ponto de entrada principal do modelo ARM. Esse modelo define todos os parâmetros e variáveis que são usados no modelo. Todos os recursos, desde nichos de rede até tamanhos de máquinas virtuais, são especificados nesse arquivo:
Esse snippet define as propriedades de "t-shirt size medium".
"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')]"
}
]
},
Você pode navegar pelo arquivo para ter uma ideia melhor da estrutura e de como as coisas estão configuradas.
azuredeploy.parameters.json
Esse arquivo contém todos os parâmetros padrão predefinidos para o modelo. Esse arquivo não é obrigatório, mas é ótimo ao iniciar uma implementação.
|
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" }, "adminPassword": { "valor": "P@ssword1" }, "tshirtSize": { "valor": "Pequeno" }, "storageAccountNamePrefix": { "valor": "f180cbdply92" }, "region" (região): { "valor": "Leste Asiático" }, "virtualNetworkName": { "valor": "couchVnet" }, "clusterName": { "valor": "couchbasefs180" }, "jumpbox": { "valor": "habilitado" } } } |
Se você quiser alterar a senha, este é o local para fazê-lo.
cluster-nodes-A2.json
Modelo parcial do ARM para configuração usando as VMs A2. Esse também é o arquivo que configura o recurso real da máquina virtual, a rede, os 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", "name" (nome): "[concat(parameters('machineSettings').machineNamePrefix, parameters('nodeId'))]", "localização": "[parameters('commonSettings').region]", "dependsOn": [ "[concat('Microsoft.Network/networkInterfaces/', 'nic', parameters('nodeId'))]" ], "propriedades": { "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]", "adminPassword": "[parameters('machineSettings').adminPassword]" }, "storageProfile": { "imageReference": "[parameters('machineSettings').imageReference]", "osDisk": { "name" (nome): "osdisk", "vhd": { "uri": "[concat('http://', parameters('storageAccountName'), '.blob.core.windows.net/',variables('vmStorageAccountContainerName'),'/', parameters('machineSettings').machineNamePrefix, parameters('nodeId'),'os-disk.vhd')]" }, "caching": "ReadWrite", "createOption": "FromImage" }, "dataDisks": [ { "name" (nome): "datadisk0", "diskSizeGB": "[parameters('machineSettings').dataDiskSize]", "lun": 0, "caching": "Nenhum", "createOption": "Vazio", "vhd": { "Uri": "[concat('http://', parameters('storageAccountName'), '.blob.core.windows.net/',variables('vmStorageAccountContainerName'),'/', parameters('machineSettings').machineNamePrefix, parameters('nodeId'),'dataDisk0' ,'.vhd')]" } }, { "name" (nome): "datadisk1", "diskSizeGB": "[parameters('machineSettings').dataDiskSize]", "lun": 1, "caching": "Nenhum", "createOption": "Vazio", "vhd": { "Uri": "[concat('http://', parameters('storageAccountName'), '.blob.core.windows.net/',variables('vmStorageAccountContainerName'),'/', parameters('machineSettings').machineNamePrefix, parameters('nodeId') ,'dataDisk1','.vhd')]" } }, { "name" (nome): "datadisk2", "diskSizeGB": "[parameters('machineSettings').dataDiskSize]", "lun": 2, "caching": "Nenhum", "createOption": "Vazio", "vhd": { "Uri": "[concat('http://', parameters('storageAccountName'), '.blob.core.windows.net/',variables('vmStorageAccountContainerName'),'/', parameters('machineSettings').machineNamePrefix, parameters('nodeId') ,'dataDisk2','.vhd')]" } }, { "name" (nome): "datadisk3", "diskSizeGB": "[parameters('machineSettings').dataDiskSize]", "lun": 3, "caching": "Nenhum", "createOption": "Vazio", "vhd": { "Uri": "[concat('http://', parameters('storageAccountName'), '.blob.core.windows.net/',variables('vmStorageAccountContainerName'),'/', parameters('machineSettings').machineNamePrefix, parameters('nodeId') ,'dataDisk3','.vhd')]" } } ] }, "networkProfile": { "networkInterfaces": [ { "id": "[resourceId('Microsoft.Network/networkInterfaces', concat('nic', parameters('nodeId')))]" } ] } } }, |
cluster-nodes-A6.json
Modelo parcial do ARM para configuração usando as VMs do A6, o mesmo que o A2.
cluster-nodes-D14.json
Modelo parcial do ARM para configuração usando as VMs do D14, igual ao A2.
couchbase-azure-install.sh
Esse script de shell é baixado para fazer o download das máquinas virtuais e realiza todo o trabalho necessário para instalar o Couchbase Server nos nós e configurar o cluster.
A última parte do script é responsável pela configuração do cluster. Se você quiser configurar um balde este é o local para adicionar a linha de comando.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
se [ "$IS_LAST_NODE" -eq 1 ]; então registro "dormir por 4 minutos para aguardar a estabilização do ambiente" dormir 4m registro "Inicializando o primeiro nó do cluster em ${MY_IP}." /optar/couchbase/caixa/couchbase-cli nó-inicial -c "$MY_IP":8091 -u "${ADMINISTRADOR}" -p "${PASSWORD}" --nó-inicial-dados-caminho="${COUCHBASE_DATA}" --nó-inicial-índice-caminho="${COUCHBASE_DATA}" registro "Configurando o cluster" /optar/couchbase/caixa/couchbase-cli agrupamento-inicial -c "$MY_IP":8091 -u "${ADMINISTRADOR}" -p "${PASSWORD}" --agrupamento-tamanho de rams="${RAM_FOR_COUCHBASE}" --agrupamento-índice-tamanho de rams=256 --serviços=dados,índice,consulta registro "Configuração do autofailover" /optar/couchbase/caixa/couchbase-cli configuração-autofailover -c "$MY_IP":8091 -u "${ADMINISTRADOR}" -p "${PASSWORD}" --ativar-automático-failover=1 --automático-failover-tempo limite=30 para (( i = 0; i < ${#MEMBER_IP_ADDRESSES[@]}; i++ )); do registro "Adicionando o nó ${MEMBER_IP_ADDRESSES[$i]} ao cluster" /optar/couchbase/caixa/couchbase-cli servidor-adicionar -c "$MY_IP":8091 -u "${ADMINISTRADOR}" -p "${PASSWORD}" --servidor-adicionar="${MEMBER_IP_ADDRESSES[$i]}":8091 --servidor-adicionar-nome de usuário="${ADMINISTRADOR}" --servidor-adicionar-senha="${PASSWORD}" --serviços=dados,índice,consulta feito registro "Reequilíbrio do cluster" /optar/couchbase/caixa/couchbase-cli reequilíbrio -c "$MY_IP":8091 -u "${ADMINISTRADOR}" -p "${PASSWORD}" /*LÓGICA DE ADIÇÃO OPCIONAL PARA CONFIGURAR UM BUCKET*/ fi registro "Instalação do couchbase concluída!" |
jumpbox-resources-disabled.json
Script de shell a ser usado quando a caixa de salto estiver desativada para a configuração.
jumpbox-resources-enabled.json
Shell script para configurar a máquina de jump box.
metadados.json
Arquivo usado para manter o controle das alterações, herdado da fonte original em couchbase-on-ubuntu.
shared-resources.json
Recurso compartilhado, herdado da fonte original em couchbase-on-ubuntu.
vm-disk-utils-0.1.sh
Utilitário de disco do Linux.
Verão
Nesta postagem do blog, você aprendeu sobre os modelos do Azure Resource Manager (ARM) e seu uso. Também abordamos brevemente os detalhes específicos do modelo ARM do Couchbase e as várias maneiras de interagir com o Azure e implantar modelos ARM.
Feliz implantação!
