Criando uma VM azure usando chef.

O propósito aqui é de criar uma VM Azure usando chef em local-mode, ou seja a partir de uma máquina de trabalho.

Instalar ChefDK https://downloads.chef.io/chefdk
Instalar o plugin chef-provisioning-azurerm
Em qualquer terminal, seja num sistema Linux, Mac ou Windows Powershell o procedimento é o mesmo.
```
chef gem install chef-provisioning-azurerm
```

Instalar o Python azure-cli ou Azure SDK para configurar as credenciais para o Chef.

Nos UNIX instalamos o Python azure-cli
```
pip install --user azure-cli
```
Acrescente o directório bin de instalação do python local na variável PATH do usuário.
```
echo 'PATH=~/.local/bin:$PATH' >> ~/.bashrc
source ~/.bashrc
```

No Windows, Azure Powershell.
Os detalhes podem ser encontrados aqui.

Install-Module AzureRM

Se receber o prompt abaixo, digite Y ou A:

Untrusted repository
You are installing the modules from an untrusted repository. If you trust this repository, change its
InstallationPolicy value by running the Set-PSRepository cmdlet. Are you sure you want to install the modules from      'PSGallery'?
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "N"): Y

Importe o módulo

Import-Module AzureRM

Criar um repositório Chef. Eu costumo criar meus ambientes de trabalho em ~/Projects. Mas você pode organizar de outra forma, em outro diretório. O nome do repositório chef também fica a critério de cada um.
```
cd ~/Projects
chef generate repo chef-repo
```
Para facilitar, vamos exportar uma variável temporária para a raiz do repositório.
1. Num shell UNIX:
```
export CHEF_REPO=~/Projects/chef-repo
```
2. No Powershell:
```
$CHEF_REPO = "~\Projects\chef-repo"
```
No decorrer do tutorial vamos usar a localização de diretórios a partir desta variável, $CHEF_REPO
Crie um diretório .chef dentro do repositório que acabamos de criar.
```
mkdir $CHEF_REPO/.chef
```

Crie o arquivo knife.rb. Este é um arquivo de configuração básico do nosso ambiente de Chef local. Use o seu editor favorito.

# $CHEF_REPO/.chef/knife.rb
log_level                :info
current_dir = File.dirname(__FILE__)
node_name                "provisioner"
client_key               "#{current_dir}/dummy.pem"
validation_key           "#{current_dir}/dummy.pem"
validation_client_name   "validator"

Vamos criar uma chave SSH. Ela vai ser nossa forma de autenticação para a nova VM.
1. Nos UNIX
```
cd $CHEF_REPO/.chef
ssh-keygen -f dummy.pem
```
  Repare que foram gerados dois arquivos: dummy.pem e dummy.pem.pub. dummy.pem é a nossa chave privada. Ela só vai ser utilizada na execução do ssh quando a VM estiver pronta. A dummy.pem.pub vai ser utilizada no template logo mais.
2. No Windows, se você não tiver um shell POSIX ou não quiser instalar um, pode instalar o PuTTY. https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html
  
  Execute PuTTYgen. Deixe os valores padrão, ou pelo menos adicione uma senha e clique em generate. Clique em Save private key. Escolhe um nome. Aqui estamos usando dummy mas o critério é seu. Navegue até a pasta .chef dentro do nosso repositório chef e salve sua chave privada. Clique em Save public key.
  Por coerência, use o mesmo nome mas acrescente uma extensão, que por convenção estamos chamando de .ppk.pub. No nosso exemplo dummy.ppk.pub.
  Volte ao Powershell e liste o conteúdo de $CHEF_REPO/.chef. o comando deve te listar três arquivos.
```
PS C:\Users\aline\Projects\chef-repo\.chef> dir


    Directory: C:\Users\aline\Projects\chef-repo\.chef


Mode                LastWriteTime         Length Name
----                -------------         ------ ----
-a----       22/06/2017     20:13           1460 dummy.ppk
-a----       22/06/2017     20:13            477 dummy.ppk.pub
-a----       22/06/2017     20:13            252 knife.rb
```
Crie as credenciais de acesso ao Azure pelo Chef.
1. UNIX
```
az login
```
  Siga os passos, se autentique no navegador. Quando terminar execute
```
az account list
```
  Tenha certeza que a assinatura (subscription) que você vai utilizar esteja com o valor IsDefault para true.
  
  Substitua a subscription ID do comando anterior com SUA_SUBSCRIPTION_ID no parâmetro 'scopes' a seguir.
```
az ad sp create-for-rbac --role="Contributor" --scopes="/subscriptions/SUA_SUBSCRIPTION_ID"
```
  Crie o arquivo ~/.azure/credentials neste formato
```
[SUA_SUBSCRIPTION_ID]
client_id = "48b9bba3-YOUR-GUID-HERE-90f0b68ce8ba"
client_secret = "your-client-secret-here"
tenant_id = "9c117323-YOUR-GUID-HERE-9ee430723ba3"
```
  Sendo: SUA_SUBSCRIPTION_ID, a subscription ID utilizada anteriormente.
  client_id, o valor de AppId.
  client_secret, o valor de Password. tenant_id, o valor de tenant.
2. Windows Powershell
```
Login-AzureRmAccount
```
  Anote o nome e a ID da sua subscription. A ID vamos usar logo mais no recipe.
  Faça o download do script, altere a política de execução e depois execute.
```
Invoke-WebRequest -URI https://gist.githubusercontent.com/sjkp/186d36334b27656a05cd/raw/6acba8599e0906e7fc1957195cd5f7204673d952/New-AzureRmServicePrincipal.ps1 -OutFile New-AzureRmServicePrincipal.ps1
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\New-AzureRmServicePrincipal.ps1
```
  Ele pede subscriptionName, que mencionei logo acima. Observe que é o nome, não a ID. E ele pede uma senha, que vai ser a senha que irá utilizar para seu APP. Gere uma senha ramdomica complexa, já que ela vai ficar salva numa variável de ambiente.
  
  Adicione as variáveis de ambiente em System -> Advanced System Settings -> Environment Variables.
  Em User variables adicione as variáveis.
  AZURE_CLIENT_ID com o valor de Service Principal Id.
  AZURE_CLIENT_SECRET com o valor da senha que você criou.
  AZURE_TENANT_ID com o valor de Tenant Id.
  
  É preciso abrir uma nova instância de powershell para poder usar as novas variáveis de ambiente.
  Feche o atual e abra um novo.
  Adicione novamente a variável temporária $CHEF_REPO da mesma forma que setou anteriormente. No meu exemplo:
```
$CHEF_REPO = "~\Projects\chef-repo"
```
Criar um cookbook para nosso recipe, ou seja, nossa receita de criação de uma VM Azure.
```
cd $CHEF_REPO/cookbooks
chef generate cookbook chef-azure
```

Vamos criar o recipe propriamente. Use seu editor favorito e edite o arquivo $CHEF_REPO/cookbooks/chef-azure/recipes/default.rb

# $CHEF_REPO/cookbooks/chef-azure/recipes/default.rb
# criar um recipe neste novo cookbook.
# cookbooks/chef-azure/recipes/default.rb
#
# Cookbook:: chef-azure
# Recipe:: default
#
# Copyright:: 2017, The Authors, All Rights Reserved.

require 'chef/provisioning/azurerm'
with_driver 'AzureRM:SUA_SUBSCRIPTION_ID'

azure_resource_group 'chefrg' do
  location 'East US'
  tags businessUnit: 'IT'
end

azure_resource_template 'MyDeployment' do
  resource_group 'chefrg'
  template_source "#{Chef::Config[:cookbook_path]}/#{cookbook_name}/files/azuredeploy.json"
  parameters adminUsername: 'ubuntu',
             sshKeyData: 'ssh-rsa    AAAAB3NzaC1yc2EAAAADAQABAAABAQDEuQU6lzNTv6i8LpHqgO9Q4BEi0JDIsBIHBDftr8gDgrLokJn6u7PDHQZjrXIvkBWudqQoJsujh4loKi19PgBjJgwoE0W/QUFiq   OK6oAoMQ11GJPbTQiCGn7NJPd7Mw8dN8tPtiDx0qkVdrkW9hE4Ie/FhWBFaBnprnCK9yiVbvtiW3cuMh38oZGzODyoNbzaMBlUSb6hiDiDrYJhkLIiM9cvtdyS+rBgb3I   Vf4g3MI9SHOnQ4BLW9ydJc0UgDYg2feEMCTrINlnGsNlKWL11lnZ8gFisTNk0qwtGwXeYeSIHCnyVLthi5pvwhueNxd6bDIVic1Oce8mh9KWWT25ez    aline@chiquinha-gonzaga'
end

O campo with_driver 'AzureRM:SUA_SUBSCRIPTION_ID' precisa ser corrigido com a sua SUBSCRIPTION ID que usamos outras vezes.
O campo sshKeyData precisa ser substituído com o conteúdo do arquivo $CHEF_REPO/.chef/dummy.pem.pub.
No Windows a chave é $CHEF_REPO\.chef\dummy.ppk.pub.
adminUsername pode ser substituído por outro nome de usuário a sua escolha.

Precisamos acrescentar o template da nossa VM. Aqui vamos utilizar um template bem simples, que cria uma VM Ubuntu usando uma chave SSH como método de autenticação.

mkdir $CHEF_REPO/cookbooks/chef-azure/files
cd $CHEF_REPO/cookbooks/chef-azure/files

UNIX

wget https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/101-vm-sshkey/azuredeploy.json

Powershell

Invoke-WebRequest -URI https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/101-vm-sshkey/azuredeploy.json -OutFile azuredeploy.json

E por fim vamos executar a criação do nosso ambiente.
```
cd $CHEF_REPO
chef-client -o chef-azure -z
```
O chef-azure aqui no comando é o nome do nosso cookbook. Lembre-se de substituir se o cookbook for criado com outro nome.
Agora podemos nos logar na nossa nova VM. Em um cenário de produção, o nome da VM seria dado como um parâmetro, ou gerado automaticamente através de algum critério do usuário. No caso deste template, como ele é bem simples, apenas para demonstração, o nome da VM é hardcoded: sshvm.
1. UNIX
  Precisamos novamente do azure-cli para obter o IP da nossa VM.
```
az vm list-ip-addresses -n sshvm
```
  O output vai ser algo assim:
```
   VirtualMachine        PublicIPAddresses    PrivateIPAddresses
   ----------------      -------------------  --------------------
   sshvm                 91.169.135.236       10.0.1.35
```
  Então se logar é bem simples. Lembre-se no nosso recipe, o nome de usuário utilizado foi ubuntu.
```
ssh -i $CHEF_REPO/.chef/dummy.pem.pub [email protected]
```
2. Powershell
  Como tivemos que abrir uma nova instância de powershell, talvez você precise se logar novamente.
```
Import-Module AzureRM
Login-AzureRmAccount
```
  E no snippet abaixo informe o nome do Resource Group utilizado na criação da sua VM. No exemplo nosso foi chefrg.
  Como o template é bem simples, apenas para demonstração, o nome da VM é hardcoded: sshvm
```
$vm = Get-AzureRmVM -Name "sshvm" -ResourceGroupName "chefrg"
$NIC = Get-AzureRmNetworkInterface  | where { $_.Id -eq $vm.NetworkProfile.NetworkInterfaces[0].Id }
Get-AzureRmPublicIpAddress | where {$_.Id -eq $NIC.IpConfigurations[0].PublicIpAddress.Id} | Select IpAddress
```
  O output vai ser algo assim.
```
IpAddress
---------
91.169.135.236
```
  Para se logar, abra o PuTTY. Pelo menu Category do lado esquerdo navegue para Connection -> SSH -> Auth.
  Em Private key for authentication navegue até a nossa chave, que chamamos de dummy.
  No mesmo menu Category, clique no primeiro item, Session.
  Em Host Name (or IP Address) insira no formato usuário@IP.
  No nosso exemplo fica: [email protected].
Se você chegou num shell prompt parabéns!

alinefr/chef-azure.md

Criando uma VM azure usando chef.