Virtual Machine

Deploy Azure VM Pool and Load Balancer

Neste post iremos demonstrar o deploy de Virtuais Machines em Windows Server 2016 com IIS Habilitado, porém iremos fazer em alta disponibilidade com metade de nosso ambiente em ZONA 1 e a outra metade em ZONE 2, a diferença aqui será no deploy feito com @Array, com isso conseguimos criar varias VMs em apenas uma linha de comando azure cli bash.

Vamos ao nosso cenário:

Vamos ao nosso código bash (azure cli)

##Declarando Variaveis (Obrigatório)
export Subscription_Name="XXXXXXXXXXXXX"  ###Substituir pela sua subscription
export RG="rg"
export Depto_Corp="corp"
export ObjectNameCorp="web"
export Env="prod"
export Location="eastus"
export RGNameCorpWeb="${RG}"-"${Depto_Corp}"-"${ObjectNameCorp}"-"${Env}"-"${Location}"

##Declarando Variaveis de Rede
export vnet="vnet"
export VnetNameWEB="${vnet}"-"${Depto_Corp}"-"${ObjectNameCorp}"-"${Env}"-"${Location}"
export CIDR_WEB="10.40.50.0/24"
export Prefix_WEBFE01="10.40.50.0/26"
export Prefix_WEBFE02="10.40.50.64/26"
export snet="snet"
export SnetNameWebFE01="${snet}"-"${Depto_Corp}"-"${ObjectNameCorp}"-"${Env}"-"${Location}"-fe01
export SnetNameWebFE02="${snet}"-"${Depto_Corp}"-"${ObjectNameCorp}"-"${Env}"-"${Location}"-fe02

##Declarando Variaveis de VMs
export VM_Object_Name="vm"
export VMName="${VM_Object_Name}""${ObjectNameCorp}""${Env}"
export SKU="Standard_LRS"
export Image_Windows="Win2016Datacenter"
export OsDisk_Name="disk-os"
export Zone01="1"
export Zone02="2"
export UserName="azroot"
export Password="[email protected]#"
export VMSize="Standard_DS1_v2"

##Declarando Variaveis de Interfaces de Rede
export Int_Object_Name01="int"
export Int_Object_Name02="eth"
export Int_Number="0"
export IntNameWeb="${Int_Object_Name01}"-"${Int_Object_Name02}""${Int_Number}"-"${VM_Object_Name}"-"${ObjectNameCorp}"-"${Location}"

##Declarando Variaveis de Storage Account
export Storage_Object_Name01="stg"
export Storage_Object_Name02="diag"
export StorageNameFE="${Storage_Object_Name01}""${Storage_Object_Name02}""${VM_Object_Name}""${ObjectNameCorp}""${Depto_Corp}"

##Declarando Variaveis NSG
export NSG_Object_Name="nsg"
export NSGWEB="${NSG_Object_Name}"-"${snet}"-"${Depto_Corp}"-"${Env}"-"${Location}"-fe

##Variaveis de Load Balance
export ObjectNameWebLB="lb"
export ObjectName_WebLB="${ObjectNameWebLB}"-"${Depto_Corp}"-"${ObjectNameCorp}"-"${Env}"-"${Location}"
export SKULB="Standard"
export PoolFE="PoolFE"
export PoolBE="PoolBackend"

##Declarando Variaveis de IP Publico
export PublicIPWebObject="pip"
export PublicIPWebSku="Standard"
export PublicIPNameWeb01="${PublicIPWebObject}"-"${Depto_Corp}"-"${ObjectNameCorp}"-"${Env}"-"${Location}"-1

##Variaveis de Tags
export Description="Departamento"
export Value_Description="${Depto_Corp}"
export Cost_Center="Centro de Custo"
export Cost_Center_Value="${Depto_Corp}"
export Support_Description_Description="E-mail Suporte"
export Support_Description_Value="support"-"${Depto_Corp}""@xpto.com"

###Selecionar subscription
az account set --subscription "${Subscription_Name}"

###Criando Resource Group
az group create -n "${RGNameCorpWeb}" -l "${Location}" \
--tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

###Criando Storage Account
az storage account create -g "${RGNameCorpWeb}" -n "${StorageNameFE}" --sku "${SKU}" -l "${Location}" --tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

###Criando NSG
az network nsg create -g "${RGNameCorpWeb}" -n "${NSGWEB}" -l "${Location}" \
--tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

###Criando Regras NSG InBound
az network nsg rule create -g "${RGNameCorpWeb}" --nsg-name "${NSGWEB}"  --name 'AllowHttpsInBound' \
--protocol 'tcp' --direction 'inbound' --source-address-prefix 'internet' --source-port-range '*' \
--destination-address-prefix '*' --destination-port-range '443' --access 'Allow' --priority '120'

az network nsg rule create -g "${RGNameCorpWeb}" --nsg-name "${NSGWEB}"  --name 'AllowHttpInBound' \
--protocol 'tcp' --direction 'inbound' --source-address-prefix 'internet' --source-port-range '*' \
--destination-address-prefix '*' --destination-port-range '80' --access 'Allow' --priority '121'

###Criando Vnet
az network vnet create -g "${RGNameCorpWeb}" -n "${VnetNameWEB}" --address-prefix "${CIDR_WEB}" \
-l "${Location}" --tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

###Criando Snet
az network vnet subnet create -g "${RGNameCorpWeb}" --vnet-name "${VnetNameWEB}" \
-n "${SnetNameWebFE01}" --address-prefixes "${Prefix_WEBFE01}"

az network vnet subnet create -g "${RGNameCorpWeb}" --vnet-name "${VnetNameWEB}" \
-n "${SnetNameWebFE02}" --address-prefixes "${Prefix_WEBFE02}"

###Anexando NSG a Snet
az network vnet subnet update -g "${RGNameCorpWeb}" --vnet-name "${VnetNameWEB}" \
-n "${SnetNameWebFE01}" --network-security-group "${NSGWEB}"

az network vnet subnet update -g "${RGNameCorpWeb}" --vnet-name "${VnetNameWEB}" \
-n "${SnetNameWebFE02}" --network-security-group "${NSGWEB}"

###Criando IP Publico
az network public-ip create -g "${RGNameCorpWeb}" -n "${PublicIPNameWeb01}" --sku "${PublicIPWebSku}"

##Criando interfaces de Rede (Snet1)
array=("${IntNameWeb}"-001 "${IntNameWeb}"-002 "${IntNameWeb}"-003 "${IntNameWeb}"-004 "${IntNameWeb}"-005)
  for vmnic in "${array[@]}"
  do
    az network nic create \
    --resource-group "${RGNameCorpWeb}" --name $vmnic --vnet-name "${VnetNameWEB}" --subnet "${SnetNameWebFE01}"
  done

##Criando interfaces de Rede (Snet2)
array=("${IntNameWeb}"-006 "${IntNameWeb}"-007 "${IntNameWeb}"-008 "${IntNameWeb}"-009 "${IntNameWeb}"-010)
  for vmnic in "${array[@]}"
  do
    az network nic create \
    --resource-group "${RGNameCorpWeb}" --name $vmnic --vnet-name "${VnetNameWEB}" --subnet "${SnetNameWebFE02}"
  done

###Criando Maquinas Virtuais
array=(-001 -002 -003 -004 -005)
  for n in "${array[@]}"
  do
    az vm create -g "${RGNameCorpWeb}" --name "${VMName}"$n --nics "${IntNameWeb}"$n \
    --image "${Image_Windows}" \
    --admin-username "${UserName}" \
    --admin-password "${Password}" \
    --os-disk-name "${OsDisk_Name}"-"${VMName}"$n \
    --zone "1" --size "${VMSize}" \
    --boot-diagnostics-storage "${StorageNameFE}" \
    --tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"
    done

array=(-006 -007 -008 -009 -010)
  for n in "${array[@]}"
  do
    az vm create -g "${RGNameCorpWeb}" --name "${VMName}"$n --nics "${IntNameWeb}"$n \
    --image "${Image_Windows}" \
    --admin-username "${UserName}" \
    --admin-password "${Password}" \
    --os-disk-name "${OsDisk_Name}"-"${VMName}"$n \
    --zone "2" --size "${VMSize}" \
    --boot-diagnostics-storage "${StorageNameFE}" \
    --tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"
    done

###Ativando IIS nas VMs criadas
array=(-001 -002 -003 -004 -005 -006 -007 -008 -009 -010)
  for n in "${array[@]}"
  do
    az vm extension set --publisher Microsoft.Compute --version 1.8 --name CustomScriptExtension \
    --vm-name "${VMName}"$n --resource-group "${RGNameCorpWeb}" \
    --settings '{"commandToExecute":"powershell Install-WindowsFeature -Name Web-Server -IncludeAllSubFeature -IncludeManagementTools; powershell Add-Content -Path \"C:\\inetpub\\wwwroot\\Default.htm\" -Value $($env:computername)"}'
    done

##Criando Load Balance
az network lb create -g "${RGNameCorpWeb}" -n "${ObjectName_WebLB}" --sku "${SKULB}" \
--frontend-ip-name "${PoolFE}" --backend-pool-name "${PoolBE}" --public-ip-address "${PublicIPNameWeb01}" \
--tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

#Create health probe on port 80/443
az network lb probe create -g "${RGNameCorpWeb}" --lb-name "${ObjectName_WebLB}" \
--name "Probe-HTTPS" --protocol tcp --port 443

az network lb probe create -g "${RGNameCorpWeb}" --lb-name "${ObjectName_WebLB}" \
--name "Probe-HTTP" --protocol tcp --port 80

#Create load balancer rule for port 80/443
az network lb rule create -g "${RGNameCorpWeb}" --lb-name "${ObjectName_WebLB}" \
--name "HTTP" --protocol "tcp" --frontend-port 80 --backend-port 80 --frontend-ip-name "${PoolFE}" \
--backend-pool-name "${PoolBE}" --probe-name Probe-HTTP

az network lb rule create -g "${RGNameCorpWeb}" --lb-name "${ObjectName_WebLB}" \
--name "HTTPS" --protocol "tcp" --frontend-port 443 --backend-port 443 --frontend-ip-name "${PoolFE}" 
--backend-pool-name "${PoolBE}" --probe-name Probe-HTTPS

#Adicionando Inteface REDE ao pool de backend Load Balance
array=("${IntNameWeb}"-001 "${IntNameWeb}"-002 "${IntNameWeb}"-003 "${IntNameWeb}"-004 "${IntNameWeb}"-005 "${IntNameWeb}"-006 "${IntNameWeb}"-007 "${IntNameWeb}"-008 "${IntNameWeb}"-009 "${IntNameWeb}"-010)
  for vmnic in "${array[@]}"
  do
    az network nic ip-config address-pool add \
        --resource-group "${RGNameCorpWeb}" \
        --nic-name $vmnic \
        --address-pool "${PoolBE}" \
        --ip-config-name "ipconfig1" \
        --lb-name "${ObjectName_WebLB}"
        done

####Fim do Script

Vamos aos objetos criados

Nossas VM em Zonas diferentes ###

Nosso LB

Vamos ver nossoas VM com ISS instalado

Agora vamos ver na prática o funcionamento, fiz os acessos via celular

Espero ter ajudado.

Seja Feliz!!!!!!!!!!!!!

Azure Bastion Host

Neste post irei demonstrar o deploy e utilização do Azure Bastion Host.
Azure Bastion Host, nada mais é de que um acesso RDP/SSH via Browser, isso facilita e muito o acesso a suas VMs via WEB, ele pode ser utilizado por consultores, prestadores de serviços, onde eles não possuem acesso a sua infraestrutura internet, com ele podemos dar permissão a uma VMs por exemplo, para um Consultor DBA Acessar um SQL Server, ou um alguém da área de operação/noc poder acessar uma VM com IIS e coletar alguns Logs.
Vamos a nossa topologia.

Agora uma breve explicação sobre nossa topologia:
Iremos criar um Resource Group, uma Vnet, uma Snet, um NSG (Nele iremos criar as Rules de InBound e OutBound), e nosso Azure Bastion, veja que em nosso exemplo não temos nenhuma VM na Vnet do Azure Bastion, gosto de deixar assim, “cada macado no seu galho”, a partir desta Vnet, basta termos Peering com outras Vnets para podermos fazer a conexão com nosso Azure Bastion.

Vamos ao nosso código:

####Explicação####
##Aqui declaramos as varias padrão de resource groupo, subscription name, Ambiente
de Dev/HML/Prd/Shared, nomes de objetos que serão utilizados na momenclatura

##Declarando Variaveis (Obrigatório)
export Subscription_Name="XXXXXXX" Substituir pela sua Subscription
export RG="rg"
export Depto_Corp="sec"
export ObjectBastion="bastion"
export Env="shared"
export Location="eastus"
export RGNameSec="${RG}"-"${Depto_Corp}"-"${Env}"-"${Location}"

####Explicação####
##Aqui declaramos as variaveis para criação da Vnet e Subnet

##Declarando Variaveis de Rede
export vnet="vnet"
export VnetName="${vnet}"-"${Depto_Corp}"-"${Env}"-"${Location}"
export CIDR="10.128.0.0/24"
export Prefix_Bastion="10.128.0.192/26"
export snet="snet"
export SnetNameBastion="AzureBastionSubnet"

####Explicação####
##Aqui declaramos a variavel para nome do nosso Azure Bastion

##Declarando Variaveis de Bastion
export BastionName="${ObjectBastion}"

####Explicação####
##Aqui declaramos as variaveis para criação de IP Publico para ser utilizamos em nosso Azure Bastion

##Declarando Variaveis de IP Publico
export PublicIPObject="pip"
export PublicIPSku="Standard"
export PublicIPName01="${PublicIPObject}"-"${BastionName}"-1

####Explicação####
##Aqui declaramos as variaveis para criação de nosso NSG

##Declarando Variaveis NSG
export NSG_Object_Name="nsg"
export NSGNameBastion="${NSG_Object_Name}"-"${snet}"-"${Depto_Corp}"-"${Env}"-"${Location}"-"${SnetNameBastion}"

####Explicação####
##Aqui declaramos as variaveis da nossas Tags

##Variaveis de Tags
export Description="Departamento"
export Value_Description="${Depto_Corp}"
export Cost_Center="Centro de Custo"
export Cost_Center_Value="${Depto_Corp}"
export Support_Description_Description="E-mail Suporte"
export Support_Description_Value="support"-"${Depto_Corp}""@xpto.com"


####Explicação####
##Aqui selecionamos nossa subscription

###Selecionar subscription
az account set --subscription "${Subscription_Name}"

####Explicação####
##Aqui criamos nosso Resource Group com nossas Tasg

###Criando Resource Group
az group create -n "${RGNameSec}" -l "${Location}" \
--tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

####Explicação####
##Aqui criamos nosso NSG com nossas Tasg

###Criando NSG
az network nsg create -g "${RGNameSec}" -n "${NSGNameBastion}" -l "${Location}" \
--tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

####Explicação####
##Aqui criamos nossas regras em nosso NSG de InBound

###Criando Regras NSG Bastion InBound
az network nsg rule create -g "${RGNameSec}" --nsg-name "${NSGNameBastion}" --name 'AllowHttpsInBound' \
--protocol 'tcp' --direction 'inbound' --source-address-prefix 'internet' --source-port-range '*' \
--destination-address-prefix '*' --destination-port-range '443' --access 'Allow' --priority '120'

az network nsg rule create -g "${RGNameSec}" --nsg-name "${NSGNameBastion}" --name 'AllowGatewayManagerInBound' \
--protocol 'tcp' --direction 'inbound' --source-address-prefix 'GatewayManager' --source-port-range '*' \
--destination-address-prefix '*' --destination-port-range '443' --access 'Allow' --priority '130'

az network nsg rule create -g "${RGNameSec}" --nsg-name "${NSGNameBastion}" --name 'AllowAzureLoadBalancerInBound' \
--protocol 'tcp' --direction 'inbound' --source-address-prefix 'AzureLoadBalancer' --source-port-range '*' \
--destination-address-prefix '*' --destination-port-range '443' --access 'Allow' --priority '140'

az network nsg rule create -g "${RGNameSec}" --nsg-name "${NSGNameBastion}" --name 'AllowbastionHostCommunication' \
--protocol '*' --direction 'inbound' --source-address-prefix 'VirtualNetwork' --source-port-range '*' \
--destination-address-prefix '*' --destination-port-range '8080' '5701' --access 'Allow' --priority '150'

####Explicação####
##Aqui criamos nossas regras em nosso NSG de OutBound

###Criando Regras NSG Bastion OutBound
az network nsg rule create -g "${RGNameSec}" --nsg-name "${NSGNameBastion}" --name 'AllowSshRdpOutBound' \
--protocol '*' --direction 'outbound' --source-address-prefix '*' --source-port-range '*' \
--destination-address-prefix 'VirtualNetwork' --destination-port-range '22' '3389' --access 'Allow' --priority '100'

az network nsg rule create -g "${RGNameSec}" --nsg-name "${NSGNameBastion}" --name 'AllowAzureCloudOutBound' \
--protocol 'tcp' --direction 'outbound' --source-address-prefix '*' --source-port-range '*' \
--destination-address-prefix 'AzureCloud' --destination-port-range '443' --access 'Allow' --priority '110'

az network nsg rule create -g "${RGNameSec}" --nsg-name "${NSGNameBastion}" --name 'AllowBastionCommunication' \
--protocol '*' --direction 'outbound' --source-address-prefix 'VirtualNetwork' --source-port-range '*' \
--destination-address-prefix 'VirtualNetwork' --destination-port-range '443' --access 'Allow' --priority '120'

az network nsg rule create -g "${RGNameSec}" --nsg-name "${NSGNameBastion}" --name 'AllowGetSessionInformation' \
--protocol '*' --direction 'outbound' --source-address-prefix 'VirtualNetwork' --source-port-range '*' \
--destination-address-prefix 'Internet' --destination-port-range '80' --access 'Allow' --priority '130'

####Explicação####
##Aqui criamos nossa Vnet

###Criando Vnet
az network vnet create -g "${RGNameSec}" -n "${VnetName}" --address-prefix "${CIDR}" \
-l "${Location}" --tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

####Explicação####
##Aqui criamos nossa Subnet

###Criando Snet
az network vnet subnet create -g "${RGNameSec}" --vnet-name "${VnetName}" \
-n "${SnetNameBastion}" --address-prefixes "${Prefix_Bastion}"

####Explicação####
##Aqui anexamos nosso NSG a subnet do Azure bastion

###Anexando NSG a Snet
az network vnet subnet update -g "${RGNameSec}" --vnet-name "${VnetName}" \
-n "${SnetNameBastion}" --network-security-group "${NSGNameBastion}"

####Explicação####
##Aqui criamos nosso IP Publico para ser utilizado em nosso Azure Bastion

###Criando IP Publico
az network public-ip create -g "${RGNameSec}" -n "${PublicIPName01}" --sku "${PublicIPSku}"

####Explicação####
##Aqui Criamos nosso Azure Bastion

###Criando Bastion Host
az network bastion create -g "${RGNameSec}" --name "${BastionName}" \
--public-ip-address "${PublicIPName01}" --vnet-name "${VnetName}" --location "${Location}"

Agora veja ele em funcionado (pelo menos as imgens rs..)

Temos uma VM-1 (Windows Server 2016) na mesma região porém em outra vnet 10.1.0.0/16, nela temos um peering com a vnet do nosso Azure Bastion
A partir deste peering nosso Azure Bastion consegue chegar nesta VM e conseguimos ter o acesso, veja abaixo

Agora acessamos a VM via portal do Azure

Veja que ela esta em outra Vnet

Agora no menu, vamos até “Bastion”

Após será exibido uma tela solicitando usuário e senha

Clique com “connect”

Agora temos total acesso a nossa VM (Neste exemplo Windows Server), se fosse uma VM em linux, teriamos o acesso via SSH pelo próprio Browser.

Espero ter ajudado

Links de referencia

https://docs.microsoft.com/en-us/cli/azure/network/nsg/rule?view=azure-cli-latest#az-network-nsg-rule-create
https://docs.microsoft.com/en-us/azure/bastion/bastion-nsg
https://docs.microsoft.com/en-us/cli/azure/network/bastion?view=azure-cli-latest
https://docs.microsoft.com/en-us/cli/azure/network/vnet?view=azure-cli-latest
https://docs.microsoft.com/en-us/cli/azure/network/vnet/subnet?view=azure-cli-latest

Seja Feliz!!!

Private Endpoint (Azure SQL Data base) (DNS Azure)

Neste post iremos demonstrar a utilização de Private Endpoint com Azure SQL PaaS.
Nossa aplicação roda em cima de duas VM com Windows Server 2016 com IIS e DFS para replicação de dados, utilizando banco de dados SQL Server (Azure Data Base SQL PaaS)
Nossa infraestrutura possui Load Balance para alta disponibilidade da aplicação além de cada VM estar em uma zona de disponibilidade.
Este post visa demonstrar a utilização do Private Endpoint com DNS Azure.

*Obs: O foco deste post é o private endpoint e não de como expor um serviço na internet com segurança.

Vamos à mão na massa!!!! (Nosso Topologia)

O script abaixo criará os seguintes objetos

Load Balancer
lb-corp-web-shd-eastus

Network interface
int-eth0-vmcorpwebshd01
int-eth0-vmcorpwebshd02
pe-sql-corp-sql-shd-eastus.nic.bf0f2b6b-5785-40d2-a9bf-851187f3e158

Network security group
nsg-snet-corp-shd-eastus-LoadBalance
nsg-snet-corp-shd-eastus-database
nsg-snet-corp-shd-eastus-webserver

Private DNS zone
privatelink.database.windows.net

Private endpoint
pe-sql-corp-sql-shd-eastus

Public IP address
pip-bastion-1

SQL database
db-corp-sql-shd-eastus (sql-corp-sql-shd-eastus/db-corp-sql-shd-eastus)

SQL server
sql-corp-sql-shd-eastus

Storage account
stgvmcorpshdeastus

Virtual machine
vmcorpwebshd01
vmcorpwebshd02

Virtual network
vnet-corp-shd-eastus

Vamos ao nosso script (muito atenção as variaveis)

#!/bin/bash

##Declarando Variaveis (Obrigatório)
export Subscription_Name="XXXXXXXXXXXXXXXX" ###Substituir pela sua subscription
export RG="rg"
export Depto_Corp="corp"
export ObjectNameWEB="web"
export ObjectSQL="sql"
export ObjectBastion="bastion"
export Env="shd"
export Location="eastus"
export RGNameCorp="${RG}"-"${Depto_Corp}"-"${ObjectNameWEB}"-"${Env}"-"${Location}"

##Declarando Variaveis de Bastion
export BastionName="${ObjectBastion}"

##Declarando Variaveis de VMs
export VM_Object_Name="vm"
export VMNumber01="01"
export VMNumber02="02"
export VMName01="${VM_Object_Name}""${Depto_Corp}""${ObjectNameWEB}""${Env}""${VMNumber01}"
export VMName02="${VM_Object_Name}""${Depto_Corp}""${ObjectNameWEB}""${Env}""${VMNumber02}"
export SKU="Standard_LRS"
export IMGWindows="Win2016Datacenter"
export OsDisk_Name="disk-os"
export OsDiskName01="${OsDisk_Name}"-"${VMName01}"
export OsDiskName02="${OsDisk_Name}"-"${VMName02}"
export Int_Object_Name01="int"
export Int_Object_Name02="eth"
export Int_Number="0"
export IntName01="${Int_Object_Name01}"-"${Int_Object_Name02}""${Int_Number}"-"${VMName01}"
export IntName02="${Int_Object_Name01}"-"${Int_Object_Name02}""${Int_Number}"-"${VMName02}"
export Zone01="1"
export Zone02="2"
export UserName="azroot"
export Password="[email protected]#"
export VMSize="Standard_DS1_v2"

##Declarando Variaveis de Vnet
export vnet="vnet"
export VnetNameWeb="${vnet}"-"${Depto_Corp}"-"${Env}"-"${Location}"
export CIDR_Web="10.128.12.0/24"
export Prefix_WebServer="10.128.12.0/26"
export Prefix_WebDatabase="10.128.12.64/26"
export Prefix_loadBalance="10.128.12.128/26"
export Prefix_Bastion="10.128.12.192/26"
export snet="snet"
export Snet_WebServer="webserver"
export Snet_Database="database"
export Snet_LoadBalance="LoadBalance"
export Snet_Bastion="Bastion"
export SnetNameWeb="${snet}"-"${Depto_Corp}"-"${Env}"-"${Location}"-"${Snet_WebServer}"
export SnetNameDatabase="${snet}"-"${Depto_Corp}"-"${Env}"-"${Location}"-"${Snet_Database}"
export SnetNameLoadBalance="${snet}"-"${Depto_Corp}"-"${Env}"-"${Location}"-"${Snet_LoadBalance}"
export SnetNameBastion="AzureBastionSubnet"

##Declarando Variaveis NSG
export NSG_Object_Name="nsg"
export NSGNameWEB="${NSG_Object_Name}"-"${snet}"-"${Depto_Corp}"-"${Env}"-"${Location}"-"${Snet_WebServer}"
export NSGNameSQL="${NSG_Object_Name}"-"${snet}"-"${Depto_Corp}"-"${Env}"-"${Location}"-"${SnetNameDatabase}"
export NSGNameLoadBalance="${NSG_Object_Name}"-"${snet}"-"${Depto_Corp}"-"${Env}"-"${Location}"-"${Snet_LoadBalance}"

##Declarando Variaveis de IP Publico
export PublicIPObject="pip"
export PublicIPSku="Standard"
export PublicIPName01="${PublicIPObject}"-"${ObjectBastion}"-1
export PublicIPName02="${PublicIPObject}"-"${ObjectNameLB}"-"${Depto_Corp}"-"${ObjectNameWEB}"-"${Env}"-"${Location}"-1

##Declarando Variaveis de Storage Account
export StorageObjectName="stg"
export StorageNameWEB="${StorageObjectName}""${VM_Object_Name}""${Depto_Corp}""${Env}""${Location}"

##Variaveis de Load Balance
export ObjectNameLB="lb"
export ObjectName_LB="${ObjectNameLB}"-"${Depto_Corp}"-"${ObjectNameWEB}"-"${Env}"-"${Location}"
export SKULB="Standard"
export FE_LB_NAME="fe-lb-web"
export BE_LB_NAME="be-lb-web"
export PoolFE="PoolFE"
export PoolBE="PoolBackend"

##Variaveis de SQL
export SQLName01="sql"
export SQLName02="db"
export SQLName="${SQLName01}"-"${Depto_Corp}"-"${ObjectSQL}"-"${Env}"-"${Location}"
export SQLNameDB01="db"
export SQLNameDB="${SQLName02}"-"${Depto_Corp}"-"${ObjectSQL}"-"${Env}"-"${Location}"
export SQLService="s0"
export SQLPass="Pe7I8xE5dE2i22A3gU1a3c4Do2e"

##Variaveis Private Endpoint SQL
export PrivateEndpointNameObject="pe"
export PrivateEndpointName="${PrivateEndpointNameObject}"-"${SQLName01}"-"${Depto_Corp}"-"${ObjectSQL}"-"${Env}"-"${Location}"

##Variaveis de Tags
export Description="Departamento"
export Value_Description="${Depto_Corp}"
export Cost_Center="Centro de Custo"
export Cost_Center_Value="${Depto_Corp}"
export Support_Description_Description="E-mail Suporte"
export Support_Description_Value="support"-"${Depto_Corp}""@xpto.com"

###Selecionar subscription
az account set --subscription "${Subscription_Name}"

###Criando Resource Group
az group create -n "${RGNameCorp}" -l "${Location}" \
--tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

###Criando Storage Account
az storage account create -g "${RGNameCorp}" -n "${StorageNameWEB}" --sku "${SKU}" -l "${Location}" \
--tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

###Criando NSG
az network nsg create -g "${RGNameCorp}" -n "${NSGNameWEB}" -l "${Location}" \
--tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

az network nsg create -g "${RGNameCorp}" -n "${NSGNameSQL}" -l "${Location}" \
--tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

az network nsg create -g "${RGNameCorp}" -n "${NSGNameLoadBalance}" -l "${Location}" \
--tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

###Criando Vnet
az network vnet create -g "${RGNameCorp}" -n "${VnetNameWeb}" --address-prefix "${CIDR_Web}" \
-l "${Location}" --tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

###Criando Snet
az network vnet subnet create -g "${RGNameCorp}" --vnet-name "${VnetNameWeb}" \
-n "${SnetNameWeb}" --address-prefixes "${Prefix_WebServer}"
az network vnet subnet create -g "${RGNameCorp}" --vnet-name "${VnetNameWeb}" \
-n "${SnetNameDatabase}" --address-prefixes "${Prefix_WebDatabase}"
az network vnet subnet create -g "${RGNameCorp}" --vnet-name "${VnetNameWeb}" \
-n "${SnetNameLoadBalance}" --address-prefixes "${Prefix_loadBalance}"
az network vnet subnet create -g "${RGNameCorp}" --vnet-name "${VnetNameWeb}" \
-n "${SnetNameBastion}" --address-prefixes "${Prefix_Bastion}"

###Anexando NSG a Snet
az network vnet subnet update -g "${RGNameCorp}" --vnet-name "${VnetNameWeb}" \
-n "${SnetNameWeb}" --network-security-group "${NSGNameWEB}"
az network vnet subnet update -g "${RGNameCorp}" --vnet-name "${VnetNameWeb}" \
-n "${SnetNameDatabase}" --network-security-group "${NSGNameSQL}"
az network vnet subnet update -g "${RGNameCorp}" --vnet-name "${VnetNameWeb}" \
-n "${SnetNameLoadBalance}" --network-security-group "${NSGNameLoadBalance}"

###Criando IP Publico
az network public-ip create -g "${RGNameCorp}" -n "${PublicIPName01}" --sku "${PublicIPSku}"
az network public-ip create -g "${RGNameCorp}" -n "${PublicIPName02}" --sku "${PublicIPSku}"

###Criando Bastion Host
az network bastion create -g "${RGNameCorp}" --name "${BastionName}" \
--public-ip-address "${PublicIPName01}" --vnet-name "${VnetNameWeb}" --location "${Location}"

##Declarando Variaveis para utilizar Snet existente
Snet01=$(az network vnet subnet show -n "${SnetNameWeb}" --vnet-name "${VnetNameWeb}" -g "${RGNameCorp}" --query id --output tsv)
Snet02=$(az network vnet subnet show -n "${SnetNameDatabase}" --vnet-name "${VnetNameWeb}" -g "${RGNameCorp}" --query id --output tsv)

###Criando Interface de rede
az network nic create -g "${RGNameCorp}" -n "${IntName01}" -g "${RGNameCorp}" --subnet $Snet01 \
--accelerated-networking false --tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

az network nic create -g "${RGNameCorp}" -n "${IntName02}" -g "${RGNameCorp}" --subnet $Snet01 \
--accelerated-networking false --tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

##Declarando varivel para utilizar IP Fixo existente
FixIP01=$(az network nic ip-config show -g "${RGNameCorp}" -n ipconfig1 --nic-name "${IntName01}" --query privateIpAddress --output tsv)
FixIP02=$(az network nic ip-config show -g "${RGNameCorp}" -n ipconfig1 --nic-name "${IntName02}" --query privateIpAddress --output tsv)


###Fixando IP nas interfaces
az network nic ip-config update -g "${RGNameCorp}" --nic-name "${IntName01}" \
-n ipconfig1 --private-ip-address $FixIP01

az network nic ip-config update -g "${RGNameCorp}" --nic-name "${IntName02}" \
-n ipconfig1 --private-ip-address $FixIP02

##Variavel para criacao da VM
NIC01=$(az network nic show -n "${IntName01}" -g "${RGNameCorp}" --query id --output tsv)
NIC02=$(az network nic show -n "${IntName02}" -g "${RGNameCorp}" --query id --output tsv)

###Criando as VMs
az vm create -n "${VMName01}" -g "${RGNameCorp}" -l "${Location}" --zone "${Zone01}" \
--boot-diagnostics-storage "${StorageNameWEB}" \
--os-disk-name "${OsDiskName01}" --image "${IMGWindows}" --nics $NIC01 --admin-username "${UserName}" \
--admin-password "${Password}" --size "${VMSize}" \
--tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

az vm create -n "${VMName02}" -g "${RGNameCorp}" -l "${Location}" --zone "${Zone02}" \
--boot-diagnostics-storage "${StorageNameWEB}" \
--os-disk-name "${OsDiskName02}" --image "${IMGWindows}" --nics $NIC02 --admin-username "${UserName}" \
--admin-password "${Password}" --size "${VMSize}" --tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

## Instalanado IIS VMs WEB
az vm extension set --publisher Microsoft.Compute --version 1.8 --name CustomScriptExtension \
--vm-name "${VMName01}" --resource-group "${RGNameCorp}" \
--settings '{"commandToExecute":"powershell Add-WindowsFeature Web-Server -IncludeManagementTools; powershell Add-Content -Path \"C:\\inetpub\\wwwroot\\Default.htm\" -Value $($env:computername)"}'

az vm extension set --publisher Microsoft.Compute --version 1.8 --name CustomScriptExtension \
--vm-name "${VMName02}" --resource-group "${RGNameCorp}" \
--settings '{"commandToExecute":"powershell Add-WindowsFeature Web-Server -IncludeManagementTools; powershell Add-Content -Path \"C:\\inetpub\\wwwroot\\Default.htm\" -Value $($env:computername)"}'

##Criando Load Balance
az network lb create -g "${RGNameCorp}" -n "${ObjectName_LB}" --sku "${SKULB}" \
--public-ip-address "${PublicIPName02}"  \
--frontend-ip-name "${PoolFE}" --backend-pool-name "${PoolBE}" \
--tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

#Create health probe on port 80/443
az network lb probe create -g "${RGNameCorp}" --lb-name "${ObjectName_LB}" \
--name "Probe-HTTPS" --protocol tcp --port 443

az network lb probe create -g "${RGNameCorp}" --lb-name "${ObjectName_LB}" \
--name "Probe-HTTP" --protocol tcp --port 80

#Create load balancer rule for port 80/443
az network lb rule create -g "${RGNameCorp}" --lb-name "${ObjectName_LB}" \
--name "HTTP" --protocol "tcp" --frontend-port 80 --backend-port 80 --frontend-ip-name "${PoolFE}" \
--backend-pool-name "${PoolBE}" --probe-name Probe-HTTP

az network lb rule create -g "${RGNameCorp}" --lb-name "${ObjectName_LB}" \
--name "HTTPS" --protocol "tcp" --frontend-port 443 --backend-port 443 --frontend-ip-name "${PoolFE}" \
--backend-pool-name "${PoolBE}" --probe-name Probe-HTTPS

#Adicionando Inteface REDE ao pool de backend Load Balance
az network nic ip-config address-pool add \
--address-pool "${PoolBE}" \
--ip-config-name "ipconfig1" \
--nic-name "${IntName01}" \
--resource-group "${RGNameCorp}" \
--lb-name "${ObjectName_LB}"

az network nic ip-config address-pool add \
--address-pool "${PoolBE}" \
--ip-config-name "ipconfig1" \
--nic-name "${IntName02}" \
--resource-group "${RGNameCorp}" \
--lb-name "${ObjectName_LB}"

##Criando Azure Data Base SQL Server
az sql server create -g "${RGNameCorp}" -n "${SQLName}" --admin-user "azroot" --admin-password "${SQLPass}" --enable-public-network "false" -l "${Location}" --minimal-tls-version "1.2"

##Criando Azure Data Base SQL DB
az sql db create -g "${RGNameCorp}" -s "${SQLName}"  -n "${SQLNameDB}" --service-objective "${SQLService}" 

###https://docs.microsoft.com/en-us/azure/templates/microsoft.sql/servers?tabs=bicep
###Variaveis de PEP
SQL_ID=$(az resource show -g "${RGNameCorp}" -n "${SQLName}" --resource-type "Microsoft.Sql/servers" --query "id" -o tsv)

##Segunda Opção para conseguri o ID
SQL_ID2=$(az sql server list \
    --resource-group "${RGNameCorp}" \
    --query '[].[id]' \
    --output tsv)

##Desabilitando Politica de rede
#https://docs.microsoft.com/pt-br/azure/private-link/disable-private-endpoint-network-policy
az network vnet subnet update --disable-private-endpoint-network-policies "true" \
--name "${SnetNameDatabase}" \
--resource-group "${RGNameCorp}" \
--vnet-name "${VnetNameWeb}"

###Variavel para GroupID
GroupID_SQL=$(az network private-link-resource list -g "${RGNameCorp}" -n "${SQLName}" --type "Microsoft.Sql/servers" --query "[]".properties[].groupId -o tsv)

##Criando Private Endpoint SQL
az network private-endpoint create --connection-name "connect-private-sql" \
--group-id $GroupID_SQL --name "${PrivateEndpointName}" \
--private-connection-resource-id $SQL_ID2 -g "${RGNameCorp}" \
--subnet "${SnetNameDatabase}" --vnet-name "${VnetNameWeb}" \
--tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

###Variaveis para Zone Names
ZoneName_SQL=$(az network private-link-resource list -g "${RGNameCorp}" -n "${SQLName}" --type "Microsoft.Sql/servers" --query "[]".properties[].requiredZoneNames -o tsv)

##Somente se não existir uma private zone igual a desejada na mesma subscription

#Create Private DNS Zone
az network private-dns zone create -g "${RGNameCorp}" \
--name $ZoneName_SQL

#Create DNS records 
az network private-dns record-set a create --name "${SQLName}" \
--zone-name $ZoneName_SQL --resource-group "${RGNameCorp}"

###Variaveis para utilizar IP da interface Private Endpoint
V01=$(az network nic list -g "${RGNameCorp}" --query "[].ipConfigurations[?contains (name, 'private')].name" -o tsv)
V02=$(az network nic list -g "${RGNameCorp}" --query "[?contains(name, 'pe-sql')].name" -o tsv)
V03=$(az network nic ip-config show -g "${RGNameCorp}" -n $V01 --nic-name $V02 --query privateIpAddress --output tsv)

##Informando IP na Zona de DNS Privada
az network private-dns record-set a add-record --record-set-name "${SQLName}" \
--zone-name $ZoneName_SQL --resource-group "${RGNameCorp}" -a $V03


#Link private vnet
az network private-dns link vnet create -g "${RGNameCorp}" \
--zone-name  $ZoneName_SQL \
--name "link-sql-dns" --virtual-network "${VnetNameWeb}" \
--registration-enabled false

###Fim do Script

Após execução do script acima, todos os objetos foram criados, vamos ver o funcinamento

Vamos acessar uma das VMs via “Bastion Host” e ver as informação de rede

Vamos ver nosso WebServer

Vamos para a outra VM

Vamos ver nosso WebServer

Agora vamos acessar via LB

Vamos ver nosso Banco de dados

Nosso server de banco de dados tem esse endereço “sql-corp-sql-shd-eastus.database.windows.net” e private link “sql-corp-sql-shd-eastus.privatelink.database.windows.net”, vamos confirmar o DNS que estamos utilizando

o DNS utilizado é “168.63.129.16” DNS padrão do azure, vamos ver como ele resolver nosso private link:

Vamos ai teste de acesso por dentro de uma das VM WEB

Essa Feature é muito util para não expor seus objetos para internet, isso server para Azure Cache Redis, Storare Account, etc…

Espero ter ajudado.

Seja Feliz!!!!

Azure Firewall EDGE (Single)

Neste post vamos criar uma infraestrutura no Azure utilizando Azure Firewall.
Teremos o Azure Firewall em nossa Borda (EDGE), neste exemplo a rota Default “0.0.0.0/0” (Para internet) passará obrigatoriamente pelo Azure Firewall, com isso qualquer serviços que estiver anexado a snet que com a rota para o Azure Firewall terá que possuir regras de OutBound para poder acessar a internet. Vamos lá!!!!

Vamos aos nossos objetos:

Neste exemplo teremos:

Resource Group “rt-sec-fwedge-shared-eastus”
Public IP “pip-mgt-sec-fwedge-shared-eastus”
Public IP “pip-sec-fwedge-shared-eastus”
Route Table “rt-sec-fwedge-shared-eastus”
Vnet “vnet-sec-fwedge-shared-eastus”
Snet “AzureFirewallSubnet”
Snet “AzureFirewallManagementSubnet”
Snet “Snet-Protected”

Vamos ao nosso código (Shell)

#!/bin/bash

##Declarando Variaveis (Obrigatório)
export Subscription_Name="XXXXXXXXXXXXXXX" ##Substituir pela sua Subscription
export RG="rg"
export Depto="sec"
export Object_Name="fwedge"
export Env="shared"
export Location="eastus"
export RGName="${RG}"-"${Depto}"-"${Object_Name}"-"${Env}"-"${Location}"

##Declarando Variaveis Vnet/Snet
export Vnet="vnet"
export CIDR="10.128.1.0/24"
export VNetName="${Vnet}"-"${Depto}"-"${Object_Name}"-"${Env}"-"${Location}"

##Variaveis de Snet
export Snet="snet"
export SubnetName01="AzureFirewallSubnet"
export SubnetName02="AzureFirewallManagementSubnet"
export SubnetName03="Snet-Protected"
export Prefix01_01="10.128.1.0/26"
export Prefix01_02="10.128.1.64/26"
export Prefix01_03="10.128.1.128/26"

##Declarando Variaveis SKU/TIER
export SKU="AZFW_VNet"
export TIER="Standard"

##Declarando Variaveis de IPs Publicos
export PublicIP_Object="pip"
export NameIP_Config="ifconfig"
export Config_IP01="1"
export Config_IP02="2"
export SKU_IP="Standard"
export AlLocation="Static"
export Tier_IP="Regional"
export PublicIP_Name="${PublicIP_Object}"-"${Depto}"-"${Object_Name}"-"${Env}"-"${Location}"
export PublicIP_NameMGT="${PublicIP_Object}"-"mgt"-"${Depto}"-"${Object_Name}"-"${Env}"-"${Location}"

##Declarando variaveis de ZONA
export Zone="1"

##Variaveis do Firewall
export Tier_FW="Standard"
export Threat="Alert"
export SKU_FW="AZFW_VNet"
export FWName_Object="fw"
export FWName="${FWName_Object}"-"${Depto}"-"${Object_Name}"-"${Env}"-"${Location}"

##Variaveis de Route Table
export RTName_Object="rt"
export RTName="${RTName_Object}"-"${Depto}"-"${Object_Name}"-"${Env}"-"${Location}"
export RouteName="Default"
export RT_Prefix="0.0.0.0/0"

##Variaveis de Rules/Colletion (Firewall)
export Colletion_Name_Internet="AcessoInternet"

##Variaveis de Tags
export Description="Departamento"
export Value_Description="${Depto}"
export Cost_Center="Centro de Custo"
export Cost_Center_Value="${Depto}"
export Support_Description_Description="E-mail Suporte"
export Support_Description_Value="[email protected]"

###Selecionar subscription
az account set --subscription "${Subscription_Name}"

##Criando RG
az group create -n "${RGName}" -l "${Location}" --tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

##Criando Vnet
az network vnet create -g "${RGName}" -n "${VNetName}" --address-prefix "${CIDR}" -l "${Location}" --tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

##Criando Snet
az network vnet subnet create -g "${RGName}" --vnet-name "${VNetName}" -n "${SubnetName01}" --address-prefixes "${Prefix01_01}"
az network vnet subnet create -g "${RGName}" --vnet-name "${VNetName}" -n "${SubnetName02}" --address-prefixes "${Prefix01_02}"
az network vnet subnet create -g "${RGName}" --vnet-name "${VNetName}" -n "${SubnetName03}" --address-prefixes "${Prefix01_03}"

##Criando IP Publico
az network public-ip create -g "${RGName}" -n "${PublicIP_Name}" -l "${Location}" --zone "${Zone}" --allocation-method "${AlLocation}" --sku "${SKU_IP}" --tier "${Tier_IP}" --tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"
az network public-ip create -g "${RGName}" -n "${PublicIP_NameMGT}" -l "${Location}" --zone "${Zone}" --allocation-method "${AlLocation}" --sku "${SKU_IP}" --tier "${Tier_IP}" --tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

##Criando Azure Firewall
az network firewall create -g "${RGName}" -n "${FWName}" --sku "${SKU_FW}" --tier "${Tier_FW}" -z "${Zone}" --threat-intel-mode "${Threat}" --tags "${Description}"="${Value_Description}" "${Cost_Center}"="${Cost_Center_Value}" "${Support_Description_Description}"="${Support_Description_Value}"

##Associando IP Publico Azure Firewall
az network firewall ip-config create -g "${RGName}" -f "${FWName}" -n "${NameIP_Config}"-"${Config_IP01}" --public-ip-address "${PublicIP_Name}"  --vnet-name "${VNetName}" --m-name "${NameIP_Config}"-"${Config_IP02}" --m-public-ip-address "${PublicIP_NameMGT}"  --m-vnet-name "${VNetName}"
az network firewall ip-config create -g "${RGName}" -f "${FWName}" --m-name "${NameIP_Config}"-"${Config_IP02}" --m-public-ip-address "${PublicIP_NameMGT}"  --m-vnet-name "${VNetName}"

##Update Firewall
az network firewall update -g "${RGName}" -n "${FWName}" 

###Declarando Variaveis para utilizar IP privado do Azure Firewall
export fwprivaddr="$(az network firewall ip-config list -g "${RGName}" -f "${FWName}" --query "[?name=='ifconfig-1'].privateIpAddress" --output tsv)"

###Crando Route Table
az network route-table create -g "${RGName}" -n "${RTName}" -l "${Location}" --disable-bgp-route-propagation "true"

###Associando Route Table a Subnet
az network vnet subnet update -g "${RGName}" -n "${SubnetName03}" --vnet-name "${VNetName}" --address-prefixes "${Prefix01_03}" --route-table "${RTName}"
az network vnet subnet update -g "${RGName}" -n "${SubnetName01}" --vnet-name "${VNetName}" --address-prefixes "${Prefix01_02}" --route-table "${RTName}"

###Criando Static Route
az network route-table route create -g "${RGName}" --name "${RouteName}" --route-table-name "${RTName}" --address-prefix "${RT_Prefix}" --next-hop-type "VirtualAppliance" --next-hop-ip-address "${fwprivaddr}"

###Criando Regras de acesso para Internet (somente HTTP/HTTPs)
az network firewall network-rule create -c "${Colletion_Name_Internet}" \
--destination-ports "80" "443" -f "${FWName}" -n "Acesso Internet" \
--protocols "TCP" -g "${RGName}" --action "Allow" \
--description "Internet Access Network Protected" --dest-addr "0.0.0.0/0" \
--priority "200" --source-addresses "${Prefix01_03}" 

Após execução do Shell acima, além dos objetos criados, as VMs que estiverem na rede Snet-Protected teram acesso a internet, pois foi criado uma Rule Network para este fim.

*Obs, é possivel criar regras de InBound (NAT) para acessar um serviços dentro de uma VM que esta atrás do Azure Firewall. Consulte neste Post

Links de Referencias:

https://docs.microsoft.com/en-us/cli/azure/network/firewall?view=azure-cli-latest
https://docs.microsoft.com/en-us/azure/firewall/deploy-cli
https://docs.microsoft.com/en-us/cli/azure/network/firewall/network-rule?view=azure-cli-latest
https://docs.microsoft.com/en-us/cli/azure/network/firewall/policy?view=azure-cli-latest
https://docs.microsoft.com/en-us/cli/azure/network/firewall/application-rule?view=azure-cli-latest
https://docs.microsoft.com/en-us/cli/azure/network/firewall/ip-config?view=azure-cli-latest#az-network-firewall-ip-config-list

Transit Gateway AWS, Two Regions, Route BGP, VPN IPSec, Fortigate

Como havia comentado anteriormente, neste post irei demonstrar um cenário onde vamos utilizar “Transit Gateway” na AWS, para substituir o peering entre as VPC, e utilizá-lo em uma VPN IPSec com Fortigate com roteamento BGP.

Topologia Transit Gateway com 2 regiões e VPN IPSec com Fortigate

Vamos ao nosso cenário:

AWS Cloud (sa-east-1)
my-vpc-01 (10.120.0.0/24)
                my-subnet-01 (10.120.0.0/24)
my-vpc-02 (10.120.1.0/24)
                my-subnet-01 (10.120.1.0/24)

my-route-table-01
                my-subnet-01 (10.120.0.0/24) (anexado a subnet)
my-route-table-02
                my-subnet-02 (10.120.1.0/24) (anexado a subnet)
my-sg-01
TGW-01 (transit gateway)

AWS Cloud (us-east-2)
my-vpc-03 (10.120.2.0/24)
                my-subnet-01 (10.120.2.0/24)
my-vpc-04 (10.120.3.0/24)
                my-subnet-01 (10.120.3.0/24)
my-route-table-03
                my-subnet-01 (10.120.2.0/24) (anexado a subnet)

my-route-table-04
                my-subnet-02 (10.120.3.0/24) (anexado a subnet)
my-sg-02
TGW-02 (transit gateway)

Fortigate (OnPremises)
Rede01 10.126.0.0/24
Rede02 10.126.1.0/24
Rede03 10.126.2.0/24

Agora vamos a mão na massa, não vou dar tantos detalhes na criação dos objetos neste post.


*Obs neste post, temos redes simples e roteamente FULL ou seja todo mundo fala com todo mundo, SG e ACL liberado Any, isso para facilita o entendimento, em produção isso deve ser revisto e liberado somente o que for necessário para seu pleno funcionamento. Colocamos todas as subnets na mesma zona para faciliar o artigo, mas em produção sugiro ter pelo menos duas subnets, uma em cada zona, exemplo subnet1 zona A e subnet2 zona B.

Nossas VPCs (AWS sa-east-1)

Nossas Subnets

Nossos Route Tables

Agora vamos criar nosso Transit Gateway (sa-east-1)

Name tag “tgw-01”
Description “Transit Gateway Sao Paulo”
ASN “64530” esse será nosso ASN
Auto accept shared attachments *Deixe habilitado
O restante deixem como mostrado na figura abaixo

Transit Gateway criado em “transit Gateways” Create

Agora vamos criar nosso Transit Gateways Attachment

Name tag “tgw-attch-01”
Transit gateway ID “escolha o que acabamos de criar”
Attachment type “Escolha VPC”
VPC attachment “Habilite DNS Support”
VPC ID “Escolha my-vpc-01”

Clique em criar

Repita os mesmos passos para attachment a “my-vpc-02”

Agora temos dois transit attachment

Agora que temos o Transit Gateway criado e temos as VPC anexadas, vamos criar o roteamento para nossas VPCs (sa-east-1) (us-east-2) (rede Fortigate)
Em route table vamos associar da subnet em seus respectivo arquivo de rota

Após associar as subnets, vamos criar o roteamento para nosso transit gateway
10.120.1.0/24 (rede aws sa-east-1) para nosso tgw
10.120.2.0/24 (rede aws us-east-2) para nosso tgw
10.120.3.0/24 (rede aws us-east-2) para nosso tgw
10.126.0.0/24 (rede Fortigate) para nosso tgw
10.126.1.0/24 (rede Fortigate) para nosso tgw
10.126.2.0/24 (rede Fortigate) para nosso tgw

Repita os passos para my-route-table-02
10.120.1.0/24 (rede aws ea-east-1) para nosso tgw
10.120.2.0/24 (rede aws us-east-2) para nosso tgw
10.120.3.0/24 (rede aws us-east-2) para nosso tgw
10.126.0.0/24 (rede Fortigate) para nosso tgw
10.126.1.0/24 (rede Fortigate) para nosso tgw
10.126.2.0/24 (rede Fortigate) para nosso tgw

Até o presente momento ja temos essa topologia

Agora em nossos SG, vamos liberar os trafego

Liberamos aqui as seguintes redes
10.120.1.0/24 (rede aws ea-east-1)
10.120.2.0/24 (rede aws ea-east-2)
10.120.3.0/24 (rede aws ea-east-2)
10.126.0.0/24 (rede Fortigate 01)
10.126.1.0/24 (rede Fortigate 02)
10.126.2.0/24 (rede Fortigate 03)

Repita os passos para “my-sg-02”

Liberamos aqui as seguintes redes
10.120.0.0/24 (rede aws ea-east-1)
10.120.2.0/24 (rede aws ea-east-2)
10.120.3.0/24 (rede aws ea-east-2)
10.126.0.0/24 (rede Fortigate 01)
10.126.1.0/24 (rede Fortigate 02)
10.126.2.0/24 (rede Fortigate 03)

Ficará desta forma

Agora vamos partir da nosso ambiente na AWS em us-east-2

Vamos as nossas VPCs
my-vpc-03 10.120.2.0/24
my-vpc-03 10.120.3.0/24

Nossas subnets

Nossos Route table, ja deixei associado nossas subnet as tabelas de rotas

Agora vamos criar nosso Transit Gateway em us-east-2

As opções são as mesmas

Name tag “tgw-02”
Description “Transit Gateway Ohio”
ASN “64530” esse será nosso ASN
Auto accept shared attachments *Deixe habilitado
O restante deixem como mostrado na figura abaixo

Nosso TGW

Agora vamos criar nosso Transit Gateways Attachment

Name tag “tgw-attch-02”
Transit gateway ID “escolha o que acabamos de criar”
Attachment type “Escolha VPC”
VPC attachment “Habilite DNS Support”
VPC ID “Escolha my-vpc-03”

Clique em criar

Repita os mesmos passos para attachment a “my-vpc-03”

Agora que temos o Transit Gateway criado e temos as VPC anexadas, vamos criar o roteamento para nossas VPCs (sa-east-1) (us-east-2) (rede Fortigate)

10.120.0.0/24 (rede aws sa-east-1) para nosso tgw
10.120.1.0/24 (rede aws sa-east-1) para nosso tgw
10.120.3.0/24 (rede aws us-east-2) para nosso tgw
10.126.0.0/24 (rede Fortigate) para nosso tgw
10.126.1.0/24 (rede Fortigate) para nosso tgw
10.126.2.0/24 (rede Fortigate) para nosso tgw

Repita os mesmos passos para “my-rote-table-02”

10.120.0.0/24 (rede aws sa-east-1) para nosso tgw
10.120.2.0/24 (rede aws sa-east-1) para nosso tgw
10.120.4.0/24 (rede aws us-east-2) para nosso tgw
10.126.0.0/24 (rede Fortigate) para nosso tgw
10.126.1.0/24 (rede Fortigate) para nosso tgw
10.126.2.0/24 (rede Fortigate) para nosso tgw

Até aqui temos essa infra em us-east-2

Agora em nossos SG, vamos liberar os trafego

Liberamos aqui as seguintes redes
10.120.0.0/24 (rede aws ea-east-1)
10.120.1.0/24 (rede aws ea-east-1)
10.120.3.0/24 (rede aws us-east-2)
10.126.0.0/24 (rede Fortigate 01)
10.126.1.0/24 (rede Fortigate 02)
10.126.2.0/24 (rede Fortigate 03)

Repita os passos para “my-sg-04”

10.120.0.0/24 (rede aws ea-east-1)
10.120.1.0/24 (rede aws ea-east-1)
10.120.3.0/24 (rede aws us-east-2)
10.126.0.0/24 (rede Fortigate 01)
10.126.1.0/24 (rede Fortigate 02)
10.126.2.0/24 (rede Fortigate 03)

Ficará desta forma

Calma ainda não acabou .rs…… agora vamos compartilhar nosso transit gateway de sa-east-1 com us-east-2, agora precisar pegar o ID do nosso transit gateway de us-east-2, anotem esse numero (não o meu mas sim o seu rs..)

Agora vamos voltar para sao paulo, em nosso transit gateway de sao paulo e vamos em transit gateway attchments, create transit gateway attchments

name tag “shared-tgw-ohio
transit gateway ID “nosso tgw de sao paulo”
Attchment Type “Peering Coonection”
Account “My Account”
Region “US East (Ohio) (us-east-2)
Transit Gateway ID “O ID que separamos do TGW de Ohio”
Clique em create

Se tudo deu certo, estamos neste ponto

Agora temos que aceitar o peering lá em Ohio

Estamos assim em Ohio

Vamos aceitar o peering

Selecione o transit gateway attchment, depois em actions, Accep transit gateway attachment

Mais um vez

Estamos assim em nosso transit gateway em ohio

Estamos assim em nosso transit gateway em são paulo

Até agora temos essa infraestrutura de rede na AWS em sa-east-1 (sao paulo) e us-east-2 (Ohio), o roteamento entre as regiões está sendo feito via “Transit Gateway”, temos rotas cadastradas e liberação em nossos SG.

Ainda não acabou ..rs….calma respira, estamos quase em 50%, simmmm isso mesmo 50% rs… ainda temos que criar o roteamente dentro do Transit Gateway em Sao Paulo e Ohio, mais é simples, bora lá.

Em “Transit Gateways, vamos em Transit gateway Route Tables

Temos este Route Table (Transit Gateway) “my-route-table-tgw”

Em Associations, veja que temos nossos anexos criados anteriormente

Agora vamos em “Routes”

Veja que temos ‘route’ para nossas VPC de sa-east-1, vamos adicionar rotas para as VPCs de us-east-2

Em create routre, CIDR “10.120.2.0/24 e escolha o attchment “Peering”, clique em create static route

Repita os passos para a segunda VPC de Ohio

Se tudo deu certo até agora, temos esse cenário:

Vamos aproveitar e fazer a mesma coisa no transit gateway de Ohio, ufa…..dá trabalho né….rs…., estamos quase lá…

Em Ohio (us-east-2), temos nosso route table transit gateway

Temos nossas associações

Agora vamos criar todas da mesma maneira que fizemos em sa-east-1, porém em us-east-2 iremos criar as rotas para a rede do Fortigate também, associando elas ao peering.

Se tudo correu bem, temos este cenário

Em us-east-2 (Ohio) tudo certo agora, vamos voltar para sa-east-1 (Sao Paulo)

Vamos partir para nossa VPN com Fortigate, em “Virtual Private Network (VPN), vamos criar um Customer Gateway

Name “cg-fgt”
Routing “Dynamic”
BGP ASN “65010” esta ASN será do nosso Fortigate
Cetificate ARN “Deixe como esta”
Device “Fortigate” este item não é obrigatório
Clique em “Create Customer Gateway”

Se tudo correu bem

Agora vamos voltar para nosso Transit Gateway Attchment em sa-east-1 e vamos anexar nossa VPN
Transit Gateway ID “escolha nosso transit gateway”
Attchment Type “VPN”
VPN Attchment “”Existing” escolha a que foi criada (customer gateway)
Routing Options “Dymanic BGP”
Enable Accleration “habilite”
O restante deixe como esta

Se tudo correu bem, temos este cenário, temos anexados em nosso transit gateway duas VPCs, um Peering e uma VPN.

Feito isso, nossa conexão Site-to-Site é criada automaticamente. Veja como ficou:
Temos transit gateway criado e cg criado

Temos aqui os detalhes dos Tunneis que estão DOWN (pois ainda não chegamos no fortigate)

Agora por fim e não menos importante (rs…) vamos para o fortigate. Antes disso precisamos pegar o arquivos na AWS para sabermos nossa PSK, pegamos ele em connections mesmo, fazer download e escolher Fortigate, feito download do arquivo, bora lá fazer as configurações.
Vamos criar nossos Tuneis Phase1 e Phase2

Phase1

Phase2

Agora vamos criar o Segundo Tunel

Phase1

Phase2

Se tudo correu bem, temos dois tuneis VPN

Agora vamos configura nosso BGP.

#Vamos fazer via CLI no prompt do Fortigate

##Aqui vamos configura as interfaces (VPN)
##As informações de configurações encontra-se no arquivo .txt que fizemos download do console da AWS


config system interface
    edit TunnelAWS01
        set ip 169.254.97.118 255.255.255.255
        set remote-ip 169.254.97.117 255.255.255.252
    next
    edit TunnelAWS02
        set ip 169.254.72.94 255.255.255.255
        set remote-ip 169.254.72.93 255.255.255.252
    next
end

Se tudo correu bem, temos essa saída:

E temos as configurações nas interfaces

Vamos adicionar essas Interfaces a nossa Zona “Cloud”, aconselho a trabalhar com zonas, isso facilita o trabalho administrativo.

Agora vamos criar as regras de Firewall, neste post criaremos regras de InBound e OutBound Any para facilitar o artigo, é claro que no ambiente de produção isso não deve acontecer (mas sabemos por ai que é assim que funciona rs…)

##Vamos criar as regras via CLI do Fortigate

#Criar regras de firewall
###Eu trabalho com Zonas, então Trust é minha LAN e UnTrust é minha WAN

config firewall policy
    edit 1
        set name Cloud-to-Trust
        set srcintf Cloud
        set dstintf Trust
        set srcaddr all
        set dstaddr all
        set action accept
        set schedule always
        set service ALL
    next
    edit 2
        set name Trust-to-Cloud
        set srcintf Trust
        set dstintf Cloud
        set srcaddr all
        set dstaddr all
        set action accept
        set schedule always
        set service ALL
end

Se tudo correu bem temos essa saída

Temos nossas regras criadas

Vamos ver se nossa VPN esta UP!. Nossos tuneis estão UP, Phase1 e Phase2

Porém nosso BGP ainda não esta UP!

Vamos configura o nosso anuncio de BGP para a AWS
Vamos fazer via CLI do Fortigate

#Configurando BGP

config router bgp
    set as 65010
    set router-id 20.201.30.224
    config neighbor
        edit 169.254.97.117
            set soft-reconfiguration enable
            set remote-as 64530
        next
    end
    config neighbor
        edit 169.254.72.93
            set soft-reconfiguration enable
            set remote-as 64530
        next
end

Se tudo correu bem

Agora vamos anunciar nossas rotas para AWS

Fortigate –> Network –> BGP
10.126.0.0/24
10.126.1.0/24
10.126.2.0/24
Se tudo correu bem temos essas rotas anunciadas.

E temos esses vizinhos configuradores

Vejam que com essas configurações nossas Rotas BGP para AWS já estão sendo recebidas

Vamos ver se na AWS nosso Transit Gateway ja esta recebendo nossas rotas anunciado pelo Fortigate? Vamos lá em “Transit Gateways” depois em “Transit Gateway Attchments”, vamos selecionar nosso transit gatewsy route table e em “routes”.
Vejam pela imagem abaixo que nossas redes anunciadas pelo Fortigate já estão aparecendo

Agora vamos ver se tudo isso que foi feito acima (Vamos combinar que dá um certo trabalho e um pouco de conhecimento) esta funcionando.

Agora fazer os testes a partir de uma VM que esta atras do Fortigate
IP: 10.126.0.132, a partir desta VM temos que conseguir chegar em todas as EC2 que estão na AWS, tanto em sa-east-1 (sao paulo) como em us-east-2 (ohio).
IPs de destinos de nossas EC2
my-ec2-01 IP 10.120.0.173
my-ed2-02 IP 10.120.1.221
Conforme imagem abaixo:

Vamos verificar a conectividade entre nossa rede 10.126.0.0/24 (Fortigate) e as redes da AWS (sao paulo) 10.120.0.0/24 e 10.120.1.0/24
1 teste OK

2 teste ok

Conseguimos conectividade para AWS sa-east-1, agora vamos para us-east-2.
IPs de destinos de nossas EC2
my-ec2-03 IP 10.120.2.164
my-ed2-04 IP 10.120.3.223
Conforme imagem abaixo:

Vamos verificar a conectividade entre nossa rede 10.126.0.0/24 (Fortigate) e as redes da AWS (sao paulo) 10.120.2.0/24 e 10.120.3.0/24
1 teste ok

2 teste ok

Imagem do Debug do Fortigate onde vemos os pacotes

Agora vamos ver o a conectividade da AWS para nossa rede Fortigate.
VMs fortigate
my-vm-01 IP 10.126.0.132
my-vm-02 IP 10.126.1.4
my-vm-03 IP 10.126.2.4
Vamos executar os teste a partir da my-ec2-01 IP 10.120.0.173
Estou dentro da VM my-ec2-01 IP 10.120.0.173
Vamos aos teste de conectividades para Fortigate
1 teste ok

2 teste ok

3 teste ok

Temos conectividade entre AWS sa-east-1 e as redes do Fortigate, agora vamos para us-east-1>
Estou dentro da my-ec2-03 em us-east-2 (Ohio) vamos ver se termos conectividade

1 teste ok

2 teste ok

3 teste ok

4 teste ok

Teste de da rede 10.126.1.0/24, conforme figura abaixo, teste de conectividade esta ok.

Com os testes concluímos nosso artigo, ufá, deu trabalho mas no final deu tudo certo.

Abaixo a topologia final.

Espero ter ajudado.

Links de referencias:

https://pt.wikipedia.org/wiki/Border_Gateway_Protocol
https://aws.amazon.com/pt/transit-gateway/?whats-new-cards.sort-by=item.additionalFields.postDateTime&whats-new-cards.sort-order=desc
https://docs.aws.amazon.com/pt_br/vpc/latest/peering/create-vpc-peering-connection.html
https://pt.wikipedia.org/wiki/IPsec
https://docs.fortinet.com/document/fortigate-public-cloud/7.0.0/aws-administration-guide/506140/connecting-a-local-fortigate-to-an-aws-vpc-vpn
https://docs.aws.amazon.com/vpc/latest/tgw/transit-gateway-peering-scenario.html

Seja Feliz!!!!


VPN IPSec Azure and AWS (Static Route), native resources.

Neste post irei ensinar a configurar uma VPN IPSec entre Azure e AWS de forma nativa com os recursos das Clouds Públicas sem utilizar recursos de Marketplace (Terceiros).

Em nosso cenário temos:

AWS (Região Sao Paulo sa-east-1)
VPC 10.15.0.0/16 (my-vpc-01)
Subnet 10.15.1.0/24 (my-subnet-01)
Route Table (my-routetable-01)
EC2 (my-ec2-)
Security Group (my-sg-01)
Costumer Gateway (my-cgw-01)
Virtual Private Gateway (my-vpg-01)
Site-to-Site Connection (my-con-01)

Azure (Região brazilsouth)
Vnet 10.5.0.0/16 (vnet-vgw-shared-brazilsouth)
Snet 10.5.0.192/26 (GatewaySubnet)
Snet 10.5.1.0.0/24 (snet-vgw-shared-brazilsouth-01)
NSG (NSG-Snet-01)
Virtual Machine (vm-jump-01)
Local Gateway Network (lgw-peer-aws-01)
Connections (con-aws-01)

Vamos a nossa configuração, iremos iniciar pela AWS, não irei criar todos os objetos (ja vimos isso antes), irei focos apenas na configuração.

Nossa VPC

Nossa Subnet

Nosso Route Table

Nossa EC2

Nosso SG (Security Group)

Nosso Costumer Gateway (Static Route)

Nosso VPG com nossa VPC anexada

Nossa conexão Site-to-Site

Agora vamos as configurações, vamos habilitar a propagação de rotas de nosso VPG e adicionar as redes em nosso SG (AWS)

1-) em nosso Route Table

1-) Vamos associar nossa subnet

3-) Em nosso SG, vamos deixar liberadas as conexões de entrada para as redes da AWS 10.15.0.0/16 e rede Azure 10.5.0.0/16

Agora vamos para as nossas configurações no Azure.

Nosso Gateway de VPN

Nosso Local Network Gateway

Nossa Vnet

Agora as configurações

1-) Local Network Gateway
IP do Peer da AWS (aws fornece dois, vamos utilizar somente um) 54.207.82.77
Address Space (rede AWS) 10.15.0.0/16
2-) A conexão, aqui somente precisaremos informar a PSK que encontra-se no arquivo para download na AWS
3-) No NSG no Azure não é preciso fazer nada, pois no Azure o NSG é permissivo (ou seja libera tudo “VirtualNetwork”)
4-) Não é preciso criar routas, pois quando informamos a rede remota em nosso “local gateway network” automaticamente ja é criada a roda para vnet toda, vejam as rotas efetivas na interface da VM em nossa subnet no azure:

Agora nossa conexão no Azure (Status Connected)

Agora nossa conexão na AWS (Status Ativo)

Agora tem conseguimos estabelecer o Tunel VPN, vamos testar a conectividade

Em nossa VM Azure (Windows), vamos testar a conectividade com a rede AWS 10.15.0.0/16

Temos resposta positiva, agora em nossa EC2 na AWS

Nossa EC2

Como mostrado na figura acima temos conectividade com a rede Azure.

Espero ter ajudado.

Referencias
https://aws.amazon.com/pt/blogs/aws-brasil/configurando-uma-conexao-vpn-site-a-site-entre-a-aws-e-o-azure/

https://techcommunity.microsoft.com/t5/fasttrack-for-azure/how-to-create-a-vpn-between-azure-and-aws-using-only-managed/ba-p/2281900

*Obs: Obviamente deixei os recursos de segurança como SG (Security Group AWS) e NSG (Network Security Group Azure) abertos para facilitar o aprendizado, mas em um ambiente de produção, logicamente não deixaremos tudo aberto, somente as portas necessárias.

**Obs: Se houver mais de uma VPC/Vnet que precisam de comunica por este mesmo tunel de VPN, se necessário configurar um transit gateway para este fim, em um próximo post irei criar VPN IPSec entre Azure e AWS, utilizando Transit Gateway, o cenário ficará assim:

AWS sa-east-1 VPC-1 10.128.0.0/24 VPC-2 10.129.0.0/24
Azure brazilsouth Vnet-1 10.130.0.0/24 Vnet-2 10.131.0.0/24

Seja feliz!!!!!!!!!!!!!!!!