10/12/2024

Azure | Tutorial prático - Como criar um Azure Load Balancer com 2 backends

Este tutorial faz parte do estudo que estou a realizar para a certificação AZ-104. Demonstra como criar um Azure Load Balancer para balancear o tráfego entre duas máquinas virtuais de backend. O objetivo não é explorar ou explicar todas as configurações e opções disponíveis.




1. Criar o Resource Group, VNet e Subnet:

az group create --location westeurope --name backend_RG

az network vnet create --resource-group backend_RG --name backend_VNET --address-prefix 10.0.0.0/16

az network vnet subnet create --resource-group backend_RG --vnet-name backend_VNET --name backend_SUBNET01 --address-prefix 10.0.1.0/24

Backend01: Criar a interface de rede (NIC), Public IP (PIP)  e associar a NIC ao PIP:

az network nic create --resource-group backend_RG --name backend01_NIC01 --vnet-name backend_VNET --subnet backend_SUBNET01

az network public-ip create --resource-group backend_RG --name backend01_PIP01

az network nic ip-config update --resource-group backend_RG --nic-name backend01_NIC01 --name ipconfig1 --public-ip-address backend01_PIP01

Backend02: Criar a interface de rede (NIC), Public IP (PIP)  e associar a NIC ao PIP:

az network nic create --resource-group backend_RG --name backend02_NIC01 --vnet-name backend_VNET --subnet backend_SUBNET01

az network public-ip create --resource-group backend_RG --name backend02_PIP01

az network nic ip-config update --resource-group backend_RG --nic-name backend02_NIC01 --name ipconfig1 --public-ip-address backend02_PIP01



2. Criar VM backend01:

az vm create \
--resource-group backend_RG \
--name backend01 \
--nics backend01_NIC01 \
--image Canonical:UbuntuServer:18.04-LTS:latest \
--size Standard_DS1_v2 \
--admin-username azureuser \
--generate-ssh-keys

Criar uma NSG, criar uma regra inbound para permitir tráfego 22 (ssh) e associar a NSG à NIC do backend01:

az network nsg create --resource-group backend_RG --name backend_NSG

az network nsg rule create --resource-group backend_RG --nsg-name backend_NSG --name Allow-SSH --priority 1000 --destination-port-ranges 22 --direction Inbound --access Allow --protocol Tcp --description "Allow SSH"

az network nic update --resource-group backend_RG --name backend01_NIC01 --network-security-group backend_NSG

Obter o endereço IP público do backend01, aceder via ssh e instalar o NGINX:

az vm list-ip-addresses --name backend01 --output table
ssh azureuser@IP-Publico
sudo apt-get -y update && sudo apt-get -y install nginx


Adicionar uma descrição ao index.html, para sabermos qual o backend que estamos a aceder quando usarmos o IP do LB:

sudo vim /var/www/html/index.nginx-debian.html

<h1>Welcome to nginx! - backend01</h1>


Abrir o porto 80 para inbound (desta vez via portal):

Portal Azure > backend01 > Networking > Network settings > Rules > + Create port rule:


Verificar se o NGINX funciona:

Colocar no navegador de internet o ip público do backend01 e deverão ter uma resposta do NGINX:
...
Welcome to nginx! - backend01
...



3. Criar a VM backend02:

Nota: Na criação deste VM, usei outra forma propositadamente para dar a conhecer o parâmetro --custom-data que permite que depois da VM criada seja executado um script. Neste caso, instala o nginx, inicia o serviço e altera o index.html.
Mais info: https://learn.microsoft.com/en-us/azure/virtual-machines/custom-data.


Criar o ficheiro cloud-init.txt com o conteúdo mais abaixo. Podem usar o comando vi cloud-init.txt:

#cloud-config
package_upgrade: true
packages:
  - nginx
runcmd:
  - systemctl start nginx
  - sed -i 's/<h1>Welcome to nginx!<\/h1>/<h1>Welcome to nginx! - backend02<\/h1>/' /var/www/html/index.nginx-debian.html

Criar a vm backend02 usando como parâmetro o script cloud-init.txt:

az vm create \
--resource-group backend_RG \
--name backend02 \
--nics backend02_NIC01 \
--image Canonical:UbuntuServer:18.04-LTS:latest \
--size Standard_DS1_v2 \
--admin-username azureuser \
--ssh-key-values ~/.ssh/id_rsa.pub \
--custom-data cloud-init.txt

Agora não precisamos de criar uma nova NSG, vamos apenas associar a backend_NSG à interface de rede backend02_NIC01:

az network nic update --resource-group backend_RG --name backend02_NIC01 --network-security-group backend_NSG


Abrir o porto 80 para inbound:

az vm open-port \
    --port 80 \
    --resource-group "backend_RG" \
    --name backend02


Verificar se o NGINX funciona:

Colocar no navegador de internet o ip público do backend01 e deverão ter uma resposta do NGINX:
...
Welcome to nginx! - backend02
...


4. Criar o Load Balancer

Iremos criar um LB básico de L4 (Camada 4), ou seja, o reencaminhamento do tráfego será via sockets (IP:porto).

Como existe mais que uma solução de balanceamento de tráfego no Azure, o mais simples é colocar na barra de pesquisa do portal Azure "Load Balancing - Help me choose". Uma vez, destro deste assistente vamos respondendo a questões até o Azure no sugerir o melhor LB:

Does your application use HTTP/HTTPS? [No]

Is your application public (internet facing)? [Yes]

Is your application deployed in multiple regions? [No]

Se respondermos desta forma termos a sugestão de um Load Balancer com L4. Clicamos em Create.












4. Testes a efetuar:

Num navegador de internet colocar o IP público do load balancer e verificar que backend é aberto. Lembrem-se que adicionamos uma desrcição (backend01 ou backend02) no index.html para termos a certeza de qual backend nos será mostrado.
Podemos efetuar várias refrescamentos do browser para ver se o backend é alterado. Podemos também forçar a desligar um dos backends para ver se o LB encaminha para a VM disponível.



5. Conclusão

Criámos um load balancer baseado em encaminhamento de IP:porto, ou seja, tudo o que chega a determinado IP público é encaminhado para um de dois backends (backend01 e backend02). Começámos por criar as componentes de rede, bem como as interfaces de rede a serem usadas nas VMs. Para além de criar as VMs, foi também necessário criar um NSG com uma regra para conseguirmos ligar por SSH para efetuar a instalação de pacotes e algumas alterações.

Neste tutorial, tentei demonstrar como realizar alguns passos através do Azure CLI e outros através do Portal do Azure. Após criar o load balancer, os PIPs dos backends podem ser removidos para melhorar a segurança e evitar a exposição dessas VMs à internet pública.


Explorar:
Podem agora criar uma nova VM (backend03), inseri-la num novo backend e encaminhar por exemplo o tráfego no porto 81 do IP público para o 80 do backend03. 
Explorem as várias opções disponíveis no load balancer, por exemplo, as Session persistence (None, Client IP e Client IP and Protocol) que podem ser interessantes dependendo objetivo que se pretende.
Criar uma Inbound NAT rule par adirecionar tráfego apenas para uma VM ou as Outbound rules para controlar o tráfego de saídas das VM são outras configurações a explorar.

Mais info:






Share:

19/02/2024

14/01/2024

Os 12 Comandos GIT mais usados

git init - Initialize a new Git repository.
git clone - Clone a remote repository to your local machine.
git status - Check the current state of your working directory.
git add - Stage changes for the next commit.
git commit - Record staged changes and create a snapshot.
git push - Upload local changes to a remote repository.
git pull - Fetch and merge changes from a remote repository.
git branch - List, create, or delete branches.
git checkout / git switch - Switch between branches or commits.
git merge - Integrate changes from one branch into another.
git diff - View differences between working directory and staging area.
git log - Display a chronological list of commits.



Share:

29/11/2023

Linux - Configuração de rede com Netplan

Exemplo de configuração de rede com Netplan:

$ vim /etc/netplan/00-installer-config.yaml

network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      addresses:
        - 10.0.0.1/24
      routes:
        - to: default
          via: 10.0.0.254
      nameservers:
          search: [meuDomain, outroDomain]
          addresses: [10.10.10.10, 10.10.10.11]
$ sudo netplan apply

 

Share:

Linux - Instalação minima

Já vos aconteceu usarem a instalação mínima e não terem ferramentas como o VI ou o Ping?! E depois reconfigurar a rede sem estas ferramentas?! Aqui ficam alguns comandos rápidos para desenrascar:

 

$ ip a add 192.168.0.10/24 dev eth0

$ echo "nameserver 8.8.8.8" > /etc/resolv.conf

$ ip route add default via 192.160.0.254


Ferramentas a instalar que podem ser necessárias:

$ apt-get install vim

$ apt-get install iputils-ping

# Instalar ifconfig, ...
$ apt-get install net-tools

# Instalar dig, Nslookup, ...
$ apt-get install bind9-utils

$ apt-get install telnet




Share:

22/11/2023

LVM - Caso prático para estender um volume

Trago aqui um caso prático que me deparei esta semana. Aumentar um volume (VG - Volume Group) que contém 2 discos, ou seja, 2 Physical Volumes, onde um deles é uma partição e o outro é o disco inteiro:

vg-01 = /dev/sda2 (49GB) + /dev/sdb (151GB)

Podemos ver obter a informação acima com o comando pvdisplay.

Passos para incrementar o disco:

- Aumentar o disco físico nas propriedades da VM.

- No Linux, aumentar o PV.

- E de seguida aumentar o LV.

- E por fim aumentar o sistema de ficheiros.

$ pvresize /dev/sdb
$ lvextend -l +100%FREE /dev/vg-01/lv-01
$ resize2fs /dev/vg-01/lv-01

Comandos para verificar os vários passos:

pvdisplay - Verificar se o PV foi aumentado.

lvdisplay - Verificar se o LV foi aumentado.

fdisk - l - Identificar antes de toda a operação os discos e partições existentes.

df -h - Verificar se o aumento de espaço se refletiu.


Share:

13/11/2023

Linux - O comando find

 

$ find /usr/share -name 'ficheiro.txt'

#Igual ao anterior mas com case insensitive:
$ find /usr/share -name 'ficheiro.txt'

#Encontrar todos os ficheiros que iniciem por f:
$ find /usr/share -name 'f*'

#Encontrar todos os ficheiros que Não iniciem por f:
$ find /usr/share -not -name 'f*'


$ find /usr/share -size +10M

#Econtrar ficheiro com o tamanho exato de 512k:
$ find /usr/share -size 512k


#Ficheiros modificados no último minuto:
$ find /usr/share -mmin -1

#Ficheiros modificados nas últimmas 24h
$ find /usr/share -mtime -0

#Ficheiros modificados nas últimmas 24h
$ find /usr/share -mtime -0

#Econtra pelo nome e pelo tamanho:
$ find -name 'ficheiro.txt' -size 10M

#Encontra pelo nome ou pelo tamanho:
$
find -name 'ficheiro.txt' -o -size 10M

$ find -perm 664

 

 

Share:

12/11/2023

Linux - journalctl

Aqui ficam alguns comando do jornalctl que são uma alternativa à análise de logs tradicional do /var/log. 

$ journalctl -e

$ journalctl -p err

$ journalctl -p warning

$ journalctl /usr/bin/sudo

$ journalctl -u sshd.service

$ journalctl -f #Fica ativo para ir mostrando os logs que estão a ser gerados

$ journalctl -S 04:00

$ journalctl -S 04:00 -U 05:00

$ journalctl -S '2022-11-11 13:05:00'

$ journalctl -b 0 #Logs desde o atual booy

$ journalctl -b -1 #Logs do boot anterior. (É preciso instruções adicionais)

$ last #Histórico de logs de quem entrou no sistema

$ lastlog




Share:

08/11/2023

29/10/2023

Linux - Instalar uma versão especifica do Java

Uma forma rápida e fácil de instalar uma versão específica do java:

$ sudo curl https://download.java.net/java/GA/jdk20/bdc68b4b9cbc4ebcb30745c85038d91d/36/GPL/openjdk-20_linux-x64_bin.tar.gz --output /opt/openjdk-20_linux-x64_bin.tar.gz

$ sudo tar -xf /opt/openjdk-20_linux-x64_bin.tar.gz -C /opt/

$ /opt/jdk-20/bin/java -version

$ export PATH=$PATH:/opt/jdk-20/bin

 

 

Share:

21/10/2023

Docker - Networking

Existem 3 tipos de rede por defeito no Docker: Bridge, None e Host.

Bridge - docker run ubuntu

O Docker cria esta rede privada interna por defeito no anfitrião (host, máquina virtual ou computador físico onde está a correr o Docker) e todos os containers obtêm um IP interno normalmente na gama 172.17.x.x. Os containers ligam-se uns aos outros usando esta rede interna.

Para as redes externas se ligarem a estes containers é preciso mapear portos de rede entre si (anfitrião:80 <-->container:8080).


None - docker run ubuntu --network=none

Os containers estão desligados de qualquer rede estando completamente isolados.


Host - docker run ubuntu --network=host

Outra forma de redes externas obterem acesso aos containers é associar o container à rede do anfitrião quebrando-se desta forma o isolamento que existe entre o anfitrião e o container. Assim, qualquer aplicação a correr no container num porto qualquer fica imediatamente exposto ao exterior no mesmo porto.


Por defeito o Docker cria uma rede interna para os containers comunicarem entre si na gama 172.17.x.x. É possível criar outra rede interna, noutra gama, com o seguinte comando:

$ docker network create --driver bridge --subnet 10.10.0.0/16 custom-isolated-network


DNS

Os containers conseguem comunicar entre si usando o seu nome que por sua vez é um nome DNS no servidor de nomes embebido no Docker.

Quando queremos que uma aplicação num container, aceda a outra noutro container, no mesmo Docker Host, podemos usar o IP interno (por exemplo: 172.17.0.3 <--> 172.17.0.8). Mas a forma mais correta é usar o nome do container, uma vez que ao reiniciar o container, este pode não assumir o mesmo IP.

O servidor DNS embebido no Docker é executado com o IP 127.0.0.11.


Share:

14/10/2023

Docker - Comandos básicos mais usados

Deixo aqui alguns dos comandos (básico) mais usados no Docker:

$ docker ps

$ docker ps -a

$ docker rm CONTAINER

$ docker rmi IMAGEM

$ docker run ubuntu

# -it disponibiliza uma shell interativa
$ docker run -it ubuntu
$ docker run -it ubuntu bash

$ docker run -d centos sleep 500

$ docker images

$ docker pull nginx

$ docker run -d ubuntu sleep 500

$ docker exec CONTAINER_ID cat /etc/*release*

$ docker stop $(docker ps -aq)

$ docker rm $(docker ps -aq)

$ docker run -i CONTAINER

# -p mapeia o porto 80 do anfitrião para o 5050 do container nginx
$ docker run -p 80:5050 nginx
$ docker run -p 3306:3306 mysql

# Executa o container mysql mapeando a dir /var/lib/mysql na dir /dados/mysql do anfitrião(host), de forma a persistir os dados:
$ docker run -v /dados/mysql:/var/lib/mysql mysql

# Obter informações do container no formato json:
$ docker inspect CONTAINER

$ docker logs CONTAINER

 


 

Share:

13/10/2023

Permissões corretas para o .ssh/authorized_keys

 

# Criar o dir .ssh directory, e aplicar permissões:
mkdir ~joselito/.ssh
chown joselito ~joselito/.ssh
chmod 0700 ~joselito/.ssh

# Criar o ficheiro authorized_keys e aplicar permissões:
touch ~joselito/.ssh/authorized_keys
chown joselito ~joselitos/.ssh/authorized_keys
chmod 0600 ~joselito/.ssh/authorized_keys

 

 

 

Share:

01/10/2023

Vamos beber um café?

Your language

Categories

Actualizações (3) Aplicativos (8) Apple (1) AZ-104 (1) Azure (1) Bash/Shell (32) Berbicachos (5) CentOS (9) CM (17) Containers (1) Curiosidades (1) Debian (21) Dicas (2) Docker (2) encriptação (1) FreeBSD (1) Freenas (1) Gnome (5) Informação (20) Java (1) Jogos (1) Kde (5) Kubernetes (4) Kubuntu (25) LibreOffice (1) Linu (1) Linux (10) LinuxMint (7) LoadBalancer (1) MAC OS X (1) Monitorização (2) Multimédia (5) MySQL (7) openSuse (7) Opinião (3) Oracle Linux (1) Perl (1) PHP (4) Plugin (1) ppc (1) Rapidinhas (21) Redhat (2) Scripts (1) Segurança (3) Tutoriais (8) Ubuntu (28) Virtualizacao (6) Wine (1)

Popular Posts

Blog Archive

Aventux. Com tecnologia do Blogger.

Seguidores