Me deparei com um cenário que eu nunca havia vivenciado, pois todas as vezes que fiz a implantação de Azure Virtual Desktop, sempre utilizei Azure Firewall na borda, e com isso eu não precisava controlar de forma separada o que os usuários iriam acessar na internet, porém com um novo projeto de reestruturação de redes Azure com Fortigate, fui questionado se era possível criar níveis de regras de acesso a internet baseado em usuário com o Fortigate, igual fazemos em ambiente On Premises. Pois bem, eu não sabia, ai começa uma procurar referente ao assunto, e para minha alegria não foi difícil de achar rs…., se link de referência que utilizei (clique aqui). Super simples a instalação e compreensão.
Vamos ao nosso cenário:
Ambiente de Desktop Virtual Pool Host AVD 30 VM com Windows 11 Enterprise Multi Session Vnet 192.168.100.0/23 (Somente para utilização de VM Windows 11)
Ambiente de DNS e Autenticação VMs com Active Directory e FSSO (Fortigate) instalado Vnet 192.168.200.0/24
Ambiente Firewall EDGE (Fortigate) VM Fortigate Vnet 192.168.0.0/24 Route Table
Dentro de uma VM com o FSSO Agent instalado e configurado junto ao Fortigate (Escrevi um artigo sobre isso, clique aqui). Após o Agente instalado e configurado, se tentarem seguir desta forma, sempre verá o ultimo usuário logado na estação de trabalho, veja a figura abaixo:
Mas após a instalação do FSSO TS Agent nas estações de trabalho (Sim tem que ser instalado nas VMs com Windows 11, no final vou deixar um artigo de instalação via linha de comando para facilitar o deploy via imagem, GPO ou qualquer outro tipo de gerenciador de distribuição de softwares), nós conseguimos ver todos os usuários logados, cada um e suas respectivas sessões e com isso nosso Fortigate FSSO consegue tratar cada usuário de forma independente.
Veja como ficam os usuários no Fortigate (Temos duas regras 1º Bem restritiva para acesso a internet e 2º Bem alberta para acesso a internet)
Após a compreenção da Arquitetura fica relativamente simples a configuração.
Uma explicação no tutorial de instalação do FSSO TS vejam nesta imagem:
Onde esta o IP 172.31.128.12 (Este é o IP da VM no caso nosso Windows 11), pode deixar em branco, pois esta por trás do DHCP do Azure. Agora onde esta o IP 172.31.128.29 esse deve ser o IP onde esta instalado o FSSO Agent (Muitas pessoas instalam diretamente no AD).
Após essas configurações você terá o controle necessário para liberação de acesso a internet baseado em usuários.
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="WelCome_Az@#"
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
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.
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 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="WelCome_Az@#"
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…
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”
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
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
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.
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
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
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
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
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.
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).
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.
*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:
Neste artigo irei configurar um VPN IPSec entre AWS e Fortigate com Roteamente BGP.
Vamos ao nosso cenário:
AWS – Sao Paulo
VPC My-VPC-01 10.128.0.0/24
Subnet my-subnet-01 10.128.0.0/26
Route table my-routetable-01 (Subnet-01)
Security Group my-sg-01
My EC2 my-ec2-01 (my-subnet-01)
Temos nosso “Costumer Gateway”
Abaixo as configurações com as nossas configurações (IP/ASN do Fortigate), um ponto bem importante aqui vamos utilizar o “ASN” “65010”, ele tem que ser único na sua rede.
Agora vamos para os nossos Virtual Private Gateway (VPG) – “my-vpg”
Agora aqui iremos utilizar o “ASN” “64530”este ASN será o ASN da AWS.
Após a criação ficará desta forma
Agora teremos que anexar nosso VPV (iremos anexar “my-vpc-01”, “Action” “Attach to VPC”
Agora temos nosso vpg com vpc attach
Agora vamos voltar para nossos arquivos de “Route Table”
Vamos selecionar “my-route-table-01”, depois em “Propagação de Rotas”, editar propagação de Rotas e Habilitar a propagação, repita esses passos para os outros dois aquivos de Route Table.
Agora vamos criar nossa conexão com nosso Fortigate
Se tudo correu bem, teremos essa tela
Agora vamos para nosso fortigate, mas antes disso precisamos pegar as configurações, clique em “fazer download da configuração”
Fornecedor “Fortinet” Plataforma “Fortigate 40+ Series” Software “FortiOS 6.4.4 + (GUI) Ike Version “IKEv2”
Pronto, agora sim, vamos para nosso Fortigate
EM VPN, IPSec Wizard, Create New
Vamos utilzar este nome “TunnelAWS01” nos iremos criar dois tunneis para este exemplo.
Essas são as informações fornecidas para o Tunnel 01
New VPN Tunnel Window Appears (Here we configure the VPN settings):
Under “Network” Section:
a. IP Version: IPv4
b. Remote Gateway: Static IP Address
c. IP address: 54.207.145.204
d. Local Interface: wan1
e. Local Gateway: Select Specify and enter WAN port IP (Public IP)
f. Dead Peer Detection: Enable by selecting On Idle/ On Demand
g. Authentication Method: Pre-shared Key
h. Pre-Shared Key: KUGQkdF1Y3_hKD1mI5azR2JwEQRE463n
i. IKE Version: 2
Phase 1 Proposal:
j. Encryption: aes128
k. Authentication: sha1
l. DH group: 2 ! and deselect 5
m. Keylife: 28800 seconds
! NAT Traversal is enabled by default but if your FortiGate device is not behind a NAT/PAT device, please deselect NAT Traversal.
! --------------------------------------------------------------------------------
! #2: IPSec Configuration
Under Phase 2 Selectors --> New Phase 2
a. Name: vpn-04ec6648c35364924-0
b. Local Address: LAN subnet behind Fortigate/0.0.0.0/0
c. Remote Address: AWS Private Subnet/0.0.0.0/0
Under Advanced
d. Encryption: aes128
e. Authentication: sha1
f. Select Enable Replay Detection
g. Select Perfect Forward Secrecy
h. DH Group: 2 ! and deselect 5
i. Keylife: 3600 seconds
j. Enable Auto-negotiate ! Autokey Keep Alive is enabled automatically when Auto-negotiate is enabled
k. Click Ok
Se tudo correu bem temos esta tela
Agora vamos criar mais um Tunnel, mas as informações do .txt, para o Tunnel 02
Temos as seguintes configurações para o Tunnel02
New VPN Tunnel Window Appears (Here we configure the VPN settings):
New VPN Tunnel Window Appears (Here we configure the VPN settings):
Under “Network” Section:
a. IP Version: IPv4
b. Remote Gateway: Static IP Address
c. IP address: 54.232.159.40
d. Local Interface: wan1
e. Local Gateway: Select Specify and enter WAN port IP (Public IP)
f. Dead Peer Detection: Enable by selecting On Idle/ On Demand
g. Authentication Method: Pre-shared Key
h. Pre-Shared Key: AVxMUvS1A1GuxDVcJxm_K28O67CthcZU
i. IKE Version: 2
Phase 1 Proposal:
j. Encryption: aes128
k. Authentication: sha1
l. DH group: 2 ! and deselect 5
m. Keylife: 28800 seconds
! NAT Traversal is enabled by default but if your FortiGate device is not behind a NAT/PAT device, please deselect NAT Traversal.
! --------------------------------------------------------------------------------
! #2: IPSec Configuration
Under Phase 2 Selectors --> New Phase 2
a. Name: vpn-04ec6648c35364924-1
b. Local Address: LAN subnet behind Fortigate/0.0.0.0/0
c. Remote Address: AWS Private Subnet/0.0.0.0/0
Under Advanced
d. Encryption: aes128
e. Authentication: sha1
f. Select Enable Replay Detection
g. Select Perfect Forward Secrecy
h. DH Group: 2 ! and deselect 5
i. Keylife: 3600 seconds
j. Enable Auto-negotiate ! Autokey Keep Alive is enabled automatically when Auto-negotiate is enabled
k. Click Ok
Se tudo correu bem até aqui teremos esse resultado.
Agora vamos criar uma Zona chamada Trust-Cloud, em Network, Interfaces, Create new, Zone
Adicione os dois Tunneis para AWS
Se tudo correu bem teremos
Agora voltando em nosso .txt, vamos começar a configurar o BGP.
Nos temos essa configuração a fazer nas interfaces VPN que criamos
Go to Network Tab --> Interface --> wan1 and edit TunnelAWS01
a. IP : 169.254.92.86
b. Remote IP: 169.254.92.85/30
c. Select Ping
d. Administrative Status: Up
e. Select Ok.
## Vamos fazer a configuração da Interface via CLI do Fortigate
#Configurar interfaces para sessão BGP
config system interface
edit TunnelAWS01
set ip 169.254.92.86 255.255.255.255
set remote-ip 169.254.92.85 255.255.255.252
next
!You can set MTU and MSS on the tunnel by performing this from the CLI:
config system interface
edit "TunnelAWS01"
set mtu-override enable
set mtu 1427
set tcp-mss 1379
next
end
Resultado, edit a interface e habilite o ping (repita isso na segunta interface)
Configurando MTU (Repita isso na segunda interface)
Agora repita os passos para a segunda interface
Vamos utilizar as informações que constam no .txt que foi feito download
Go to Network Tab --> Interface --> wan1 and edit TunnelAWS02
a. IP : 169.254.31.218
b. Remote IP: 169.254.31.217/30
c. Select Ping
d. Administrative Status: Up
e. Select Ok.
#Configurar interfaces para sessão BGP
config system interface
edit TunnelAWS02
set ip 169.254.31.218 255.255.255.255
set remote-ip 169.254.31.217 255.255.255.252
next
!You can set MTU and MSS on the tunnel by performing this from the CLI:
config global
config system interface
edit "vpn-08d53f64bc31f682f-1" ! This name will be the same as the VPN tunnel name
set mtu-override enable
set mtu 1427
set tcp-mss 1379
next
end
Edit a interface e habilite o ping
Se tudo correu bem até aqui, teremos esse resultado.
Agora vamos criar as regras de Firewall, aqui iremos fazer simples, Any –> AWS e Any –> OnPremises.
Vamos criar via CLI que é muito mais rapido
#Criar regras de firewall
config firewall policy
edit 1
set name allow-gcp-to-lan
set srcintf Trust-Cloud
set dstintf Trust
set srcaddr all
set dstaddr all
set action accept
set schedule always
set service ALL
next
edit 2
set name allow-lan-to-gcp
set srcintf Trust
set dstintf Trust-Cloud
set srcaddr all
set dstaddr all
set action accept
set schedule always
set service ALL
end
Se tudo correu bem nos temos ida e volta
Agora nossos Tunneis devem estar UPs, vamos conferir
Agora vamos para nossa configuração BGP no Fortigate
Voltamos lá no nosso .txt que foi baixado com as configurações, lá nos temos todas as informações necessária para configurar o BGP.
#Vamos utlizar a informação que consta no .txt
Go to Network --> BGP
#Primeira interface
a. Local-AS : 65010
b. Router-ID: 191.232.210.141
c. Click Apply
d. Neighbor -> Create New:
1. IP: 169.254.92.8
2. Remote AS: 64530
3. Click Add/Edit
#Segunda interface
Go to Network --> BGP
d. Neighbor -> Create New:
1. IP: 169.254.190.113
2. Remote AS: 64530
3. Click Add/Edit
Agora vamos declara nosso CIDR para o BGP
Se tudo correu bem até aqui, devemos ter esse
Agora que os dois Tuneis estão UPs
Agora vamos ver nosso roteamento Vemos que nossa rota BGP aparece em nossa tabela (rede AWS)
Agora de volta a AWS, vamos verificar nossa tabela de routa e Security Group
Liberamos em nosso SG a rede 10.5.0.0/22
Agora vamos ver nossa tabela de rotas
Nossa rota foi propagada com sucesso, vamos testar a conectivdade
Em nossa rede 10.5.0.0/22 conseguimos chegar na rede 10.128.0.0/24
Agora vamos ver em nossa rede AWS 10.128.0.0/24 se conseguimos chegar na rede 10.5.0.0/22
Com isso concluimos este artigo, em um próximo artigo irei fazer a conexão utilizando “Transit Gateway” com redes em Sao Paulo e Virginia utilizando somente uma conexão VPN IPSec.
Neste artigo iremos demonstrar como configurar uma VPN IPSec HA entre GCP (Google Cloud) e Fortigate com roteamente Dinamico (BGP)
Este é nosso cenário:
Google Cloud: VPC “10.110.0.0/2 Subnet-A 10.110.0.0/24 Subnet-B 10.110.1.0/24 Subnet-C 10.110.2.0/24 Cloud Gateway de VPN Cloud Router Cloud Firewall
Vamos a mão na massa, vamos acessar nosso console do Google Cloud e vamos em redes VPC. Clique em “Criar VPC”
Nome “network-corp-sao” Sub-redes “Personalizado” Editar Sub-rede Nome: subnet-sao-br-a Região “southamerica-east1 Intervalo de endereços IP “10.110.0.0/24” Clique em concluir, repita esses passos até a até a sub-rede 10.110.2.0/24
Em regras de firewall deixe como esta “(Default) Mode de roteamento dinamico “Global”
Clique em “criar”, VPC criada com sucesso.
Agora vamos criar nossa conexão de VPN no Google Cloud, vamos em “VPN”
Criar uma Conexão VPN
Nesta etapa, temos que escolhar nosso topologia de conexão, neste exemplo iremos escolher “Alta Disponibilidade HA”
Selecione “Continuar”
Nas opções de “gateway”
Nome do gateway de VPN “gw-gcp-sao-br Rede “network-gcp-sao-br” Região “southamerica1 (São Paulo)\
Clique em “Criar e Continuar”
Agora vamos adicionar os tunneis de VPN
Gateway de VPN de Peering “No Local ou não relacionado ao Google Cloud” Criar novo gateway de VPN de mesmo nível”
Neste exemplo iremos utilizar 2 interfaces (1 de cada operadora, o Google aceita até 4 interfaces) Nome “connect-onpremises-fgt Interface “2” Endereço IP da interface “xxx.xxx.xxx.xxx” Operadora A Endereço IP da interface “xxx.xxx.xxx.xxx” Operadora B
Clique em “Criar”
Agora em “Alta disponibilidade” “Crie um par de túneis VPN” Cloud Route “Criar novo roteador”
Nome “rt-gcp-sao-br” ASN do Google “65534” Neste exemplo usaremos este ASN para o Google Rotas Anunciadas “Anunciar todas as sub-redes visiveis ao roteador da nume (padrão” Neste exemplo usaremos esta opção, mas nada nos impede de usar persolizada e declara apenas algumas redes)
Agora vamos criar os Tuneis
Vamos ao Tunel 1 Nome “tunnel-fgst-br-sao-01” Versão do IKE “IKEv2” Chaves “Gerar e Copia” (Guarde a chave)
Clique em concluir e vamos ao segundo Tunnel
As opções são as mesmas, pode inclusive utilizar a mesma chave
Clique em “Criar e continuar”
Agora nesta etapa iremos configurar o BGP (Do lado do Google Cloud)
Clique no primeiro Tunel em “Configurar sessão BGP Na primeira sessão BGP iremos utilizar as seguintes opções
Nome “ngp-fgt-br-sao-01 Par ASN “65000” Neste exemplo este seria o ASN OnPremises Muito atenção nesta etapa o Google utilizar rede /30 para PAR BGP IP do BGP do Cloud Route “169.254.0.1” IP do Par BGP “169.254.0.2
Par do BGO “Ativado”
Clique em Salvar em continuar
Vamos configurar a sessão do BGP no segundo Tunnel
Nome “bgp-gft-sao-02” Par ASN “65000” IP do BGP do Cloud Route “169.254.0.5” IP do Par BGP “169.254.0.6” Par BGP (Ativada)
Clique em “Salvar e Continuar”
Agora clique em “Salvar a configuração do BGP”
Guarde essas informações, iremos utilizar mais tarde
Clique em “ok”
Olhando o Status da conexão temos
Agora vamos configurar nosso fortigate
Iremos criar via CLI
Abaixo os comandos
#Criar interfaces VPN
#Phase1
config vpn ipsec phase1-interface
edit GCP-HA-VPN-INT0
set interface port1 (Interface WAN1)
set ike-version 2
set keylife 36000
set peertype any
set proposal aes128-sha1 aes128-sha512 aes128-md5
set remote-gw 34.124.19.151
set psksecret 123456789
next
edit GCP-HA-VPN-INT1
set interface port2 (Interface WAN2)
set ike-version 2
set keylife 36000
set peertype any
set proposal aes128-sha1 aes128-sha512 aes128-md5
set remote-gw 35.220.40.107
set psksecret 123456789
next
end
#Criar Phase2
config vpn ipsec phase2-interface
edit GCP-HA-VPN-INT0
set phase1name GCP-HA-VPN-INT0
set proposal aes128-sha1 aes256-sha1 aes128-sha256 aes256-sha256 aes128gcm aes256gcm
set dhgrp 15 14 5
set keylifeseconds 10800
next
edit GCP-HA-VPN-INT1
set phase1name GCP-HA-VPN-INT1
set proposal aes128-sha1 aes256-sha1 aes128-sha256 aes256-sha256 aes128gcm aes256gcm
set dhgrp 15 14 5
set keylifeseconds 10800
next
end
#Configurar interfaces para sessão BGP
config system interface
edit GCP-HA-VPN-INT0
set ip 169.254.0.2 255.255.255.255
set remote-ip 169.254.0.1 255.255.255.252
next
edit GCP-HA-VPN-INT1
set ip 169.254.0.6 255.255.255.255
set remote-ip 169.254.0.5 255.255.255.252
next
end
#Criar ZoneCloud
config system zone
edit ZoneCloud
set interface GCP-HA-VPN-INT0 GCP-HA-VPN-INT0
set intrazone deny
end
#Criar regras de firewall
config firewall policy
edit 1
set name allow-gcp-to-lan
set srcintf ZoneCloud
set dstintf port3 #(Interface Trust)
set srcaddr all
set dstaddr all
set action accept
set schedule always
set service ALL
next
edit 2
set name allow-lan-to-gcp
set srcintf port3 #(Interface Trust)
set dstintf ZoneCloud
set srcaddr all
set dstaddr all
set action accept
set schedule always
set service ALL
end
#Configurando BGP
config router bgp
set as 65000
set router-id 169.254.0.2
config neighbor
edit 169.254.0.1
set soft-reconfiguration enable
set remote-as 65534
next
end
config neighbor
edit 169.254.0.5
set soft-reconfiguration enable
set remote-as 65534
next
end
#Configurando anuncios de redes BGP Fortigate
config router bgp
config network
edit 1
set prefix 10.5.0.0/22
next
end
Temos agora nossos tunneis configurados e conectados
Google Cloud
Fortigate
Roteamento Fortigate
Route BGP Cloud
Com isso concluimos nosso artigo de VPN IPSec com Fortigate e Google Cloud.
Temos os seguintes objetos neste cenario: Azure –> Ambiente Fortigate em HA e vnet dedicada, ambiente “File Exchange” (Troca de arquivos) com vnet dedicada com peering, dois arquivos Route Table. AWS –> VPC, EC2,CG,VGW,CON.
Neste cenario iremos criar uma VPN IPSec entre AWS e Azure (sei que é possível utilizar os objetos das próprias clouds, mas neste cenário iremos utilizar Fortigate no Azure), vamos botar a mão na massa.
Para criar o ambiente do Fortigate com Vnet dedicada, iremos utilizar este artigo que escrevi há um tempo atrás “clique aqui”.
Ambiente Azure com Fortigate HA e Vnet dedicada.
Agora vamos ao nosso ambiente de “File Exchange” Este ambiente é composto por uma VM Windows Server 2016, com software de trocas de arquivos tradicionais (SFTP, CD-IBM, SMB (Este com DFS)). Então temos a vnet 10.128.10.0/24 conecta via peering com a vnet do firewall 10.126.0.0/24.
Ambiente “File Exchange” Azure
Agora vamos ao nosso ambiente na AWS: Temos uma VPC “172.28.0.0/16” Temos uma Subnet “172.28.31.0/24” Temos nosso servidor File Exchange “172.28.31.77”
Agora vamos as configurações, vamos inciar pela AWS (Lembrando que este é apenas um cenário que muitas empresas possuem, este artigo não significa que esta certo ou errado.) Vamos começar criando uma VPC na AWS.
Em “VPC” “Criar VPC”
nome da VPC “vpc-sao-paulo-bo” CIDR IPv4 “172.28.0.0/16
Não iremos utilizar “Tags” clique em “criar”
Agora temos nossa VPC criada
Vamos agora criar nossa Subnet, em “subnets”, “Criar Subnets”
Nome “Private” CIDR IPV4 “172.28.31.0/24”
Agora criaremos nossa VM (Windows Server 2016) nesta VPC e Subnet (Não irei mostrar aqui como criar uma EC2 na AWS)
Com nossa EC2 criada, vamos criar uma tabela de roteamento. Em “Route Table” “Criar Tabelas de Rotas” Nome “rt-subnet-bo-private” VPC “vpc-sao-paulo-bo”
Temos nossa tabela criada
Veja que só temos route 172.28.0.0/16, ainda não temos route para nossa VPN, não será criar essa rota de forma manual, pois iremos habilitar a “propagação de rotas”, mas isso depois de criarmos nossos objetos para conexão de nossa VPN IPSec. Agora vamos associar nossa subnet privada nesta tabela de roteamento, “Associação de sub-rede” “Editar Associação de sub-rede”
Marque nossa subnet private e clique em salva
Pronto agora nossa subnet esta associada, com isso qualquer rota propagada ja estará disponivél neste subnet
Agora vamos criar nossos objetos de VPN IPSec
Em Virtual Private Network (VPN), Customer Gateways “Create Customer Gateways”
Name “cgw-peer-azu-fortigate” IP Address “XXX.XXX.XXX.XXX” IP do nosso Load Balance do nosso Fortigate no Azure
Agora vamos criar nosso VGW, em Virtual Private Network (VPN)
vamos em “Create Virtual Private Gateway”
Name “vgw-aws-sao-paulo ASN “Amazon Default ASN” podemos deixar assim mesmo, pois neste exemplo iremos utilizar Static Route
Agora vamos anexar nossa VPC em nosso VGW
Selecione o VGW criada, depois “Actions” Attach VPC”
Selecione a VPC que criamos “vpc-sao-paulo-bo”
VGW criado e VPC anexada
Agora vamos criar nossa conexão
Em “Virtual Private Network (VPN), “Site-to-Site VPN Connections”
Criar conexão
Agora aqui, muita atenção pois se ficar errado aqui a VPN não irá funcionar
Tag “con-azure-fortigate” Target Gateway Type “Virtual Private gateway” escolha o que criamos na lista supensa Gateway do Cliente “Existente” Selecione o que criamos Opção de Roteamento “Estatico” pois neste exemplo não iremos utilizar BGP Prefixo “10.128.10.0/24” a rede de comunição do Azure Versão IP “IPv4” CIDR de rede IPV4 local “10.128.10.0/24” aqui é a rede do azure não a rede AWS CIDR de rede IPV4 remoto “172.31.0.0/16” aqui é a rede da AWS e não do Azure
As outras opções deixem como esta e clique em criar
Após alguns minutos (em média 10 minutos)
Aguarde até ficar disponivel
Com nossa conexão disponível
Podemos ver as configurações
O Tunnel ainda esta “DOWN” , pois ainda não criamos do lado do azure
Nossa rota estatica
Agora vamos em nosso ambiente Azure
Com disse no inicio deste post, não vou me aprofundar na criação do ambiente do Fortigate, pois o mesmo foi criado neste post já, utilizaremos a mesma infraestrutura para este artigo.
Depois de nossa infraestrutura de fortigate criada:
Vamos criar agora para nossa infra de “Fila Exchange”
Temos os seguintes objetos no ambiente de “File Exchange” no Azure
Resource Group “rg-file-exchange-brazilsouth” “10.128.10.0/24” Virtual Network “vnet-file-exchange-brazilsouth” “10.128.10.0/26” Subnet “snet-file-exchange-brazilsouth” Virtual Machine “BRAZUFE01” “Neste post ensino como criar Windows Server”
Vamos criar o peering entre a vnet do ambiente do “File Exchange” e do “Fortigate”
Agora vamos as rotas
Em nosso arquivo/objeto no Azure “Route Table” “rt-fw-edge-shared-brazilsouth-internal” vamos criar a rota para AWS
Assim ficará nosso roteamento
Route AWS
Agora vamos associar nossas snet
Temos que associar as seguintes subnet
snet-fwedge-shared-brazilsouth-Protected 10.126.0.128/27 (SNET dedicada para VMs) snet-fwedge-shared-brazilsouth-Internal 10.126.0.32/27 (Snet interna do Fortigate) snet-file-exchange-brazilsouth-01 10.128.10.0/26 (snet do ambiente do “File Exchange”
Agora com nosso roteamento pronto, vamos as configurações no Fortigate.
Mas para isso precisamos voltar na AWS, em VPN
Em Site-To-Site Connection clique selecione nossa conexão criada e depois “fazer download das configurações” em nosso exemplo selecione Fortigate, Fortigate 40+ Series, FortiOS 6.4.4, Ikev2
Fazer download
Com o arquivos de configuração em mãos
Vamos ao fortigate, em VPN, IPSec Tunnels
Create New -> IPSec Tunnel
Custon, TunnelAWS01
No arquivo que foi feito downoad, temos todas as informações necessário que precisamos para estabelecer as Phase1 e Phase2 da VPN
Temos o Peer “xxx.xxxx.xxxx.xxx Temos a PSK “xxxxxxxxxxxxxxxxxxxxx” Versão do IKE “V2”
i. IKE Version: 2 Phase 1 Proposal: j. Encryption: aes128 k. Authentication: sha1 l. DH group: 2 ! and deselect 5 m. Keylife: 28800 seconds
Under Phase 2 Selectors –> New Phase 2 a. Name: vpn-0179c76477325e5f9-0 b. Local Address: LAN subnet behind Fortigate/0.0.0.0/0 c. Remote Address: AWS Private Subnet/0.0.0.0/0
Under Advanced d. Encryption: aes128 e. Authentication: sha1 f. Select Enable Replay Detection g. Select Perfect Forward Secrecy h. DH Group: 2 ! and deselect 5 i. Keylife: 3600 seconds j. Enable Auto-negotiate ! Autokey Keep Alive is enabled automatically when Auto-negotiate is enabled k. Click Ok
Com o Tunnel criado, vamos as rotas
Vamos em network, static routes
Create New
Destination “172.28.0.0/16” Rede AWS Interface “TunnelAWS01” Nome que demos para nosso Tunnel
Agora vamos criar o roteamento dentro do Fortigate para nossa vnet 10.128.10.0/24 eu que temos um peering
Em Network, Static Route, Create New
Destination “10.128.10.0/24 gateway “10.126.0.33” (Gateway da Snet Azure) Clique em “OK”
Agora em Interface/Create Zone
Name “ZoneCloud” Interface “TunnelAWS01”, clique em OK
Agora vamos criar nossas regras de firewall
Em “Policy and Objetics” “Firewall Policy”
Create New
Name “Trust-to-ZoneCloud” Incoming interface “Trust(port2) Outgoing interface “ZoneCloud” Source “All” (Somente para este exemplo deixaremos tudo liberado) Destination “All” (Somente para este exemplo deixaremos tudo liberado) Schedule “Always” Service “All” (Somente para este exemplo deixaremos tudo liberado) Action “Accept” Inspection Mode “Flow-Based” Nat “Disable” Application Control “Default” Log Allowed traffic “All Sessions” Clique em “OK”
Neste momento nosso Tunnel IPSec ja encontra-se estabelecido
Nosso roteamento encontra-se ativo
AWS também encontra-se com o Tunnel Ativo
Na AWS vamos em VPC, Route Table
Vamos olhar nosso arquivo de roteamento
“rt-subnet-bo-private”
Podemos observar que nossa rota para Azure ja encontra-se propagada
Agora vamos a um teste basico, na nossa VM no Azure “BRAZUFE01”
vamos executar um ping para nossa VM de File Exchange que encontra-se na AWS
Temos resposta de nosso ping
Em nosso Fortigate temos respostas também.
Após este testes, podemos executar as instalação de nossos softwares de “File Exchange” normalmente, pois nossos ambientes que estão no Azure e na AWS ja possuem conectividade completa, após isso podemos refinar nossas regras de firewall para permitir somente o trafego necessário entre os ambientes.
E assim ficou nossa topologia
Espero ter ajudado.
*Obs: Para o sucesso desta conexão é imprescindível se atentar aos seguintes passos:
1º) Ao criar a conexão de VPN na AWS quando for informar a rede local (rede do cliente remoto) e rede remota (rede AWS). 2º) Lembre que habilitar a propação de rotas no arquivo de Route Table na AWS, desta forma você não precisa ficar criando routas de forma manual. 3º) Não esquece de liberar dentro do “SG” as redes remotas (aqui as redes do Azure) 4º) Na Route Table do Azure, sempre add as Subnet onde irão receber as conexão para o Firewall, neste exemplo a Snet Internal 5º) Sempre criar as rotas no arquivo Route Table do Azure (Fortigate), ele precisa saber para onde deve mandar o pacote (Sim no arquivo Route Table precisa ter a informação da rota, pois se não tiver, não chega o pacote no firewall) 6º) Se for necessário ter outra arquivos Route Table no azure, deve-se anexar a snet que receberá as rotas e a rota em sim definida, (Neste exemplo com dois arquivos Route Table no azure, os dois devem conter as rotas explicitas)
Você precisa fazer login para comentar.