La entrada Gestão de Recursos em Ambientes Virtualizados: Técnicas e Melhores Práticas se publicó primero en Aprende IT.

Neste artigo, mostraremos como montar um disco no WSL e acessá-lo a partir do Linux. Continue lendo para saber mais.

O que é o WSL?

O WSL é um recurso do Windows que permite aos usuários executar uma distribuição Linux no Windows. O WSL é uma camada de compatibilidade que traduz chamadas do sistema Linux em chamadas do sistema Windows, permitindo que os usuários executem aplicativos Linux no Windows.

O WSL é um recurso extremamente útil para desenvolvedores que precisam trabalhar em projetos de Linux enquanto usam o Windows como sistema operacional principal. A capacidade de acessar arquivos do Windows a partir do Linux no WSL é uma das vantagens deste recurso.

Como montar um disco no WSL

Montar um disco no WSL é um processo simples que pode ser feito com alguns comandos na linha de comando.

Abra o aplicativo “Terminal” no WSL. Se você não tiver o WSL instalado, pode baixá-lo na Microsoft Store.

Digite o seguinte comando no terminal para garantir que você tenha as permissões necessárias para montar o disco:

sudo mkdir /mnt/e

Este comando criará uma pasta chamada “e” na localização /mnt. O prefixo “sudo” dará permissões de administrador para executar o comando.

Em seguida, monte o disco E: na pasta /mnt/e com o seguinte comando:

sudo mount -t drvfs E: /mnt/e

Este comando usa a ferramenta “mount” para montar o disco E: na pasta /mnt/e. O parâmetro “-t drvfs” indica que o driver do sistema de arquivos do Windows está sendo usado para montar o disco.

Agora você deverá poder acessar o disco E: do terminal do WSL na pasta /mnt/e. Você pode mudar para o diretório E: com o seguinte comando:

cd /mnt/e

Como acessar um disco montado no WSL a partir do Linux

Depois de montar o disco no WSL, você pode acessá-lo do terminal do Linux.

Abra o terminal do Linux no WSL.

Para acessar o disco E:, mude para o diretório /mnt/e com o seguinte comando:

cd /mnt/e

Agora você deverá ser capaz de ver os arquivos e pastas no disco E: do terminal do Linux no WSL. Você pode usar os comandos Linux usuais para trabalhar com esses arquivos e pastas.
Como desmontar um disco no WSL

Para desmontar um disco no WSL, use o seguinte comando:

sudo umount /mnt/e

Este comando irá desmontar o disco E: da pasta /mnt/e no WSL.

La entrada Como montar um disco no WSL e acessá-lo a partir da terminal se publicó primero en Aprende IT.

O que é o Vagrant e por que você deve usá-lo?

O Vagrant é uma ferramenta de código aberto que nos permite criar, configurar e gerenciar ambientes de desenvolvimento virtualizados. Com o Vagrant, podemos ter um ambiente de desenvolvimento uniforme e controlado em nossa máquina, independentemente do sistema operacional que utilizamos. Dessa forma, evitamos problemas de compatibilidade e podemos nos concentrar no que realmente importa: desenvolver!

Mas quais são as vantagens do Vagrant? Bem, algumas delas são:

• Facilita a colaboração entre desenvolvedores, já que todos podem trabalhar no mesmo ambiente.
• Simplifica a configuração e administração de máquinas virtuais.
• Permite automatizar a criação e o provisionamento de ambientes de desenvolvimento.
• Promove o uso de boas práticas no desenvolvimento, como a infraestrutura como código.

Instalação e configuração do Vagrant

Para instalar o Vagrant, primeiro precisamos ter um provedor de virtualização em nossa máquina. Um dos mais populares é o VirtualBox, mas também podemos utilizar VMware, Hyper-V, entre outros. Neste artigo, vamos nos concentrar no VirtualBox. Para instalá-lo, basta seguir as instruções na página oficial do VirtualBox.

Depois de instalar o provedor de virtualização, podemos baixar o Vagrant em sua página oficial. Lá, encontraremos versões para Windows, macOS e Linux. Baixe e instale a versão adequada para o seu sistema operacional.

Primeiros passos com o Vagrant

Agora que temos o Vagrant instalado, vamos criar nosso primeiro ambiente de desenvolvimento virtualizado. Para fazer isso, seguiremos estas etapas:

Abra um terminal e crie um novo diretório para o nosso projeto:

mkdir meu-primeiro-ambiente-vagrant
cd meu-primeiro-ambiente-vagrant

Inicialize o Vagrant no diretório:

vagrant init

Este comando criará um arquivo chamado Vagrantfile em nosso diretório. Este arquivo é a chave para configurar e personalizar nosso ambiente de desenvolvimento virtualizado.

Edite o Vagrantfile com seu editor de texto favorito e adicione a seguinte linha:

config.vm.box = "hashicorp/bionic64"

Esta linha indica que vamos usar a imagem “hashicorp/bionic64” como base para nossa máquina virtual. Esta imagem é uma versão do Ubuntu 18.04 (Bionic Beaver) de 64 bits. Existem muitas outras imagens disponíveis no catálogo oficial do Vagrant, que você pode explorar no Vagrant Cloud.

Inicie a máquina virtual com o comando:

vagrant up

O Vagrant irá baixar a imagem (se ainda não o fez) e criar uma nova máquina virtual baseada nela. Esse processo pode levar um pouco de tempo, dependendo da velocidade da sua conexão com a internet e do seu computador.

Depois que a máquina virtual estiver em execução, podemos nos conectar a ela por meio do SSH:

vagrant ssh

Parabéns! Agora você está conectado ao seu primeiro ambiente de desenvolvimento virtualizado com o Vagrant. Você pode começar a instalar software, desenvolver aplicativos e experimentar sem medo de quebrar seu ambiente local.

Provisionamento de ambientes

Uma das características mais interessantes do Vagrant é o provisionamento, que nos permite automatizar a configuração e a instalação de software em nossas máquinas virtuais. O Vagrant é compatível com vários sistemas de provisionamento, como Shell, Puppet, Ansible e Chef, entre outros.

Para ilustrar como funciona o provisionamento, vamos usar um simples script de Shell. Adicione as seguintes linhas ao seu Vagrantfile, logo abaixo de config.vm.box = “hashicorp/bionic64”:

config.vm.provision "shell", inline: <<-SHELL
    sudo apt-get update
    sudo apt-get install -y git nginx
SHELL

Essas linhas indicam que o Vagrant deve executar um script de Shell que atualiza os repositórios de pacotes do Ubuntu e instala o Git e o Nginx. Para aplicar essas alterações, devemos provisionar nossa máquina virtual novamente com o comando:

vagrant reload --provision

Depois que o processo terminar, nossa máquina virtual terá o Git e o Nginx instalados.

Comandos básicos do Vagrant

Aqui está uma lista de alguns comandos básicos do Vagrant que serão úteis no seu dia a dia:

• vagrant init: Inicializa um novo ambiente de Vagrant no diretório atual.
• vagrant up: Inicia a máquina virtual.
• vagrant ssh: Conecta-se à máquina virtual por meio do SSH.
• vagrant halt: Desliga a máquina virtual.
• vagrant reload: Reinicia a máquina virtual.
• vagrant destroy: Exclui a máquina virtual e todos os seus recursos.
• vagrant status: Mostra o estado da máquina virtual.
• vagrant global-status: Mostra o estado de todas as máquinas virtuais em seu sistema.
• vagrant box: Gerencia as imagens de máquinas virtuais (boxes) em seu sistema.

Trabalhando com múltiplas máquinas virtuais

O Vagrant nos permite gerenciar facilmente várias máquinas virtuais em um mesmo projeto. Para fazer isso, basta adicionar uma nova definição de máquina virtual em nosso Vagrantfile. Por exemplo, se quisermos adicionar uma segunda máquina virtual com o CentOS 7, poderíamos fazer o seguinte:

config.vm.define "centos" do |centos|
    centos.vm.box = "centos/7"
    centos.vm.hostname = "centos.local"
    centos.vm.network "private_network", ip: "192.168.33.20"
end

Com essa configuração, criamos uma nova máquina virtual chamada “centos” com base na imagem “centos/7”. Além disso, atribuímos um nome de host e um endereço IP em uma rede privada.

Para iniciar ambas as máquinas virtuais, basta executar o comando vagrant up. Se quisermos iniciar apenas uma delas, podemos especificar seu nome:

vagrant up centos

Podemos nos conectar à máquina virtual do CentOS por meio do SSH com o seguinte comando:

vagrant ssh centos

Sincronização de arquivos entre o host e a máquina virtual

O Vagrant facilita a sincronização de arquivos entre nosso host e as máquinas virtuais. Por padrão, o diretório em que nosso Vagrantfile está localizado é sincronizado automaticamente com o diretório /vagrant dentro da máquina virtual. Isso nos permite compartilhar arquivos facilmente entre os dois ambientes.

Se quisermos configurar uma pasta compartilhada personalizada, podemos fazê-lo adicionando a seguinte linha ao nosso Vagrantfile:

config.vm.synced_folder "minha-pasta-local", "/minha-pasta-remota"

Essa linha indica que a pasta “minha-pasta-local” em nosso host será sincronizada com a pasta “/minha-pasta-remota” na máquina virtual. O Vagrant se encarregará de manter ambos os diretórios sincronizados automaticamente.

Redes no Vagrant

O Vagrant oferece várias opções para configurar a rede em nossas máquinas virtuais. Algumas das mais comuns são:

Rede privada: Permite que as máquinas virtuais se comuniquem entre si e com o host por meio de uma rede privada. Para configurar uma rede privada, adicione a seguinte linha ao seu Vagrantfile:

config.vm.network "private_network", ip: "192.168.33.10"

Rede pública: Conecta a máquina virtual diretamente à rede pública, permitindo que outras máquinas na rede a acessem. Para configurar uma rede pública, adicione a seguinte linha ao seu Vagrantfile:

config.vm.network "public_network"

Redirecionamento de porta: Permite acessar serviços na máquina virtual por meio de uma porta específica no host. Para configurar o redirecionamento de porta, adicione a seguinte linha ao seu Vagrantfile:

config.vm.network "forwarded_port", guest: 80, host: 8080

Essa linha indica que a porta 80 na máquina virtual será redirecionada para a porta 8080 em nosso host.

La entrada Introdução ao Vagrant: Gerenciamento de Ambientes de Desenvolvimento Virtualizados se publicó primero en Aprende IT.

Antes de começarmos, é importante salientar que a monitorização dos recursos do teu ESX é crucial para garantir que a tua infraestrutura está a funcionar de forma eficiente e evitar problemas de desempenho e tempo de inatividade. Além disso, ao automatizar este processo com um script em Python, podes poupar tempo e esforço ao não teres de o fazer manualmente.

Para começar o processo de monitorização dos recursos do teu ESX a partir do Python, precisarás de instalar as seguintes bibliotecas:

• pyVmomi: é uma biblioteca em Python que fornece uma API para interagir com vSphere e ESX.
• ssl: é uma biblioteca em Python que fornece funcionalidades de segurança de camada de sockets.

Assim que tiveres instalado estas bibliotecas, podes começar a escrever o teu script para monitorizar os recursos do teu ESX. O script que vamos utilizar neste artigo vai ligar-se ao teu ESX e recuperar a informação do hardware do host, bem como a informação das máquinas virtuais em execução. Depois, calculará a quantidade total de CPU e RAM atribuída às máquinas virtuais e mostrará os resultados na saída.

Mas não te preocupes se tudo isto parece um pouco complicado! Vou explicar como é que o script funciona passo a passo.

Primeiro, importamos as bibliotecas necessárias e definimos as credenciais de login para o nosso hypervisor ESX:

import ssl
from pyVim.connect import SmartConnect, Disconnect
from pyVmomi import vim

# Informações de login para o hypervisor ESX
hostname = 'esx_hostname_or_ip'
username = 'username'
password = 'password'

Em seguida, criamos um contexto SSL personalizado que nos permitirá ligar-nos ao hypervisor ESX:

# Criar um contexto SSL personalizado
context = ssl.create_default_context()
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE

# Ligação ao hypervisor ESX com o contexto SSL personalizado
si = SmartConnect(host=hostname, user=username, pwd=password, sslContext=context)
content = si.RetrieveContent()

Depois, recuperamos a informação do hardware do host utilizando o objeto content que criámos no passo anterior:

# Obter a informação do hardware do host
host_system = content.rootFolder.childEntity[0].hostFolder.childEntity[0].host[0].summary.hardware
num_cpu_cores = host_system.numCpuCores
num_cpu_threads = host_system.numCpuThreads
total_memory = host_system.memorySize / (1024 ** 3)
cpu_model = host_system.cpuModel

A seguir, recuperamos a informação das máquinas virtuais em execução utilizando novamente o objeto content:

# Obter a informação das máquinas virtuais em execução
vm_properties = ['name', 'config.hardware.numCPU', 'config.hardware.memoryMB']
vm_view = content.viewManager.CreateContainerView(content.rootFolder, [vim.VirtualMachine], True)
vms = vm_view.view
vm_view.Destroy()

Depois, calculamos a quantidade total de CPU e RAM atribuída às máquinas virtuais em execução e mostramo-la na saída:

# Calcular a quantidade total de CPU e RAM atribuída às máquinas virtuais
num_vcpu_assigned = sum(vm.config.hardware.numCPU for vm in vms if vm.summary.runtime.powerState == vim.VirtualMachinePowerState.poweredOn)
total_memory_assigned = sum(vm.config.hardware.memoryMB for vm in vms if vm.summary.runtime.powerState == vim.VirtualMachinePowerState.poweredOn) / 1024

print(f"Tipo de processador do host: {cpu_model}")
print(f"Número de núcleos com hyperthreading disponíveis: {num_cpu_threads}")
print(f"Quantidade total de CPU atribuída às máquinas virtuais: {num_vcpu_assigned}")
print(f"Quantidade total de memória atribuída às máquinas virtuais: {total_memory_assigned:.2f} GB")
print(f"Memória total do host: {total_memory:.2f} GB")

Por fim, fechamos a ligação ao hypervisor ESX:

# Desligar do hypervisor ESX
Disconnect(si)

Com este script, podemos obter informações valiosas sobre os nossos recursos ESX e garantir que tudo está a funcionar corretamente. Além disso, ao usar um script em Python para monitorizar os recursos do nosso ESX, podemos automatizar este processo e poupar tempo e esforço.

Em resumo, a monitorização dos recursos de CPU e RAM do teu ESX é fundamental para garantir que a tua infraestrutura está a funcionar de forma eficiente e evitar problemas de desempenho e tempo de inatividade. Ao automatizar este processo com um script em Python, podes poupar tempo e esforço ao não teres de o fazer manualmente. Espero que este artigo te tenha sido útil e incentivo-te a experimentar este script no teu próprio ambiente!

La entrada Como Monitorizar os Recursos de CPU e RAM do teu ESX a partir do Python se publicó primero en Aprende IT.

esxcli network ip interface ipv4 set -i vmnic0 -I 192.168.1.100 -N 255.255.255.0 -G 192.168.1.1

esxcli network vswitch standard add -v vSwitch1

esxcli network vswitch standard uplink add -u vmnic0 -v vSwitch1

esxcli network firewall set --enabled true

esxcli network firewall ruleset list

esxcli network firewall ruleset rule add -r sshServer -p TCP -o inbound -y allow

esxcli storage nmp device list

esxcli storage san fc list

esxcli storage vmfs extent list

esxcli network vswitch standard portgroup set -p "Rede de gerenciamento" -v vSwitch0

esxcli network vswitch standard portgroup policy security set -p "Rede de gerenciamento" -m promiscuous-mode -M accept

esxcli network vswitch standard portgroup policy vlan set -p "Rede de gerenciamento" -v 4095

esxcli storage san fc rule add -d naa.xxxx -n VMW_SATP_ALUA -p VMW_PSP_RR

La entrada Comandos de rede e FC para ESXi se publicó primero en Aprende IT.

Agradecemos que partilhe este artigo nas suas redes sociais e/ou deixe um comentário.

Vamos começar!

1- O que é o docker?

Há pessoas que consideram o docker um sistema de virtualização como a KVM, Vmware, etc. Isto é falso. Docker é um sistema de contentores como o LXC, mas mais avançado. Tem uma melhor gestão das instâncias levantadas e dispõe de um sistema de gestão de modelos.

Por outras palavras, o Docker é um sistema para abstrair a aplicação e tornar o seu ecossistema independente do sistema operativo. Isto significa que tudo configurado dentro de um contentor funciona correctamente em qualquer sistema operativo com o docker instalado.

2- Quais são as vantagens?

As vantagens são várias, dependendo daquilo a que o comparamos.

Se o compararmos com aplicações em execução directa num sistema, a principal vantagem é a compatibilidade, uma vez que o que foi testado no contentor, no mesmo contentor num outro sistema funcionará da mesma forma.

Se nos referirmos à vantagem sobre a utilização de uma virtualização completa, a principal vantagem é que cada contentor utiliza praticamente a memória da aplicação, enquanto que uma instância de KVM, Vmware, etc. também requer consumo de memória para o kernel do sistema virtual, etc.

Outra vantagem é que se pode executar aplicações como se tivesse um sistema diferente. Ou seja, no sistema anfitrião temos um sistema CentOS por exemplo e no contentor podemos ter, Free BSD ou Debian, ou Arch ou qualquer outro. Assim, se funcionar melhor num sistema do que no anfitrião, podemos utilizar esta vantagem.

3- Como posso utilizá-lo?

Pode ser utilizado para criar ambientes de desenvolvimento e depois carregar o contentor para a produção (ter em mente que antes de colocar qualquer coisa em produção com o docker, o hospedeiro e o contentor devem ser assegurados para evitar problemas). Desta forma, podemos evitar problemas nas implementações de códigos.

A primeira coisa a fazer é instalar o docker. No CentOS é feito da seguinte forma: #yum install docker -y

Em debian e derivados: #apt install docker.io

Após a sua instalação, se for um sistema moderno, baseado no systemd, elevamos o serviço: #systemctl start docker

Se não tiver systemd, corra #service docker start

4- Comandos úteis

Iniciar contentores (mesmo que as imagens não tenham sido descarregadas):

docker run -i -t -d   IMAGEN:VERSION

Onde a imagem e a versão podem ser especificadas como se segue:

docker run -i -t -d   centos:latest

Podemos definir um nome para o recipiente com –name NOME

[root@localhost ~]# docker run -i -t -d --name testing debian:9
Unable to find image 'debian:9' locally
Trying to pull repository docker.io/library/debian ... 
9: Pulling from docker.io/library/debian
54f7e8ac135a: Pull complete 
Digest: sha256:df6ebd5e9c87d0d7381360209f3a05c62981b5c2a3ec94228da4082ba07c4f05
Status: Downloaded newer image for docker.io/debian:9
b6f568b78470b417b8a141f4b7c5686420df7cc1050402239ab1847310a67116
[root@localhost ~]# 

É possível especificar um porto a ser encaminhado da máquina anfitriã para o contentor:

docker run -i -t -d -p PUERTO_EXTERIOR:INTERIOR IMAGEN

Ou também pode ser feito especificando o ip do hospedeiro:

docker run -i -t -d -p IP_ANFITRION:PUERTO_EXTERIOR:INTERIOR IMAGEN

Acrescentando “–restart always” à equação, consegue-se que sempre que o recipiente é parado, é reiniciado. Mesmo no recomeço do programa de acolhimento:

docker run -i -t -d -p PUERTO_EXTERIOR:INTERIOR --restart always IMAGEN

Criar um recipiente e não o levantar imediatamente:

docker create -i -t centos:6 /bin/bash

Descarregar imagens e geri-las

Para descarregar uma imagem e tê-la disponível no momento de levantar um novo contentor sem ter de esperar que seja descarregada do docker-hub, só temos de fazer o seguinte:

docker pull IMAGEN:VERSION

Ou também:

docker pull IMAGEN

Por exemplo:

#Eligiendo version
docker pull centos:7
#o seleccionando la ultima disponible
docker pull centos:latest

Também podemos ver as imagens disponíveis localmente ao correr:

docker images

Por exemplo:

ger@portatil$ sudo docker images
[sudo] contraseña para ger: 
REPOSITORY                                  TAG                 IMAGE ID            CREATED             SIZE
debian                                      9                   4879790bd60d        9 days ago          101MB
ubuntu                                      18.04               ea4c82dcd15a        5 weeks ago         85.8MB
centos                                      6                   0cbf37812bff        6 weeks ago         194MB
centos                                      7                   75835a67d134        6 weeks ago         200MB
ubuntu                                      17.04               fe1cc5b91830        11 months ago       95.6MB

Podemos procurar por imagens disponíveis em docker hub:

ger@portatil$ sudo docker search ubuntu
NAME                                                   DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
ubuntu                                                 Ubuntu is a Debian-based Linux operating sys…   8793                [OK]                
dorowu/ubuntu-desktop-lxde-vnc                         Ubuntu with openssh-server and NoVNC            244                                     [OK]
rastasheep/ubuntu-sshd                                 Dockerized SSH service, built on top of offi…   184                                     [OK]
consol/ubuntu-xfce-vnc                                 Ubuntu container with "headless" VNC session…   136                                     [OK]
ansible/ubuntu14.04-ansible                            Ubuntu 14.04 LTS with ansible                   95                                      [OK]
ubuntu-upstart                                         Upstart is an event-based replacement for th…   92                  [OK]                
neurodebian                                            NeuroDebian provides neuroscience research s…   55                  [OK]                
1and1internet/ubuntu-16-nginx-php-phpmyadmin-mysql-5   ubuntu-16-nginx-php-phpmyadmin-mysql-5          47                                      [OK]
ubuntu-debootstrap                                     debootstrap --variant=minbase --components=m…   40                  [OK]                
nuagebec/ubuntu                                        Simple always updated Ubuntu docker images w…   23                                      [OK]
tutum/ubuntu                                           Simple Ubuntu docker images with SSH access     18                                      
i386/ubuntu                                            Ubuntu is a Debian-based Linux operating sys…   15                                      

Podemos importar uma imagem personalizada: docker import /path/to/exampleimage.tgz:

[root@localhost ~]# docker import /tmp/debian-personalizado.tgz
[root@localhost ~]#

Ver o estado dos contentores e os seus dados

Para ver os contentores criados e o seu estado actual, só temos de executar:

docker ps -a

Por exemplo:

[root@localhost ~]# docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED              STATUS              PORTS               NAMES
b6f568b78470        debian:9            "bash"              About a minute ago   Up About a minute                       testing
[root@localhost ~]# 

Para montar uma máquina só temos de correr docker start ID-DO-CONTENTOR el ID lo podemos encontrar ejecutando docker ps -a :

[root@localhost ~]# docker start b6f568b78470
b6f568b78470
[root@localhost ~]#

Gestão de contentores

Para parar um recipiente docker stop id-do-container:

[root@localhost ~]# docker stop b6f568b78470
b6f568b78470
[root@localhost ~]#

E para apagar um recipiente docker stop id-do-container:

[root@localhost ~]# docker rm b6f568b78470
b6f568b78470
[root@localhost ~]#

Podemos fazer uma cópia de um recipiente correndo: docker export -o filesystem.tar ID_DO_CONTAINER:

[root@localhost ~]# docker export -o filesystem.tar b6f568b78470
[root@localhost ~]#

Podemos aceder a uma consola de contentores: docker exec -it “id of running container” bash:

[root@localhost ~]# docker exec -it b6f568b78470 bash
[root@b6f568b78470 ~]#

Se estiver interessado em aprender Docker, pode adquirir o nosso livro aqui.

Docker para novatos

E é tudo sobre como começar com Docker, num próximo post, falaremos sobre como gerir Docker com Python.

Lembre-se de que se gostou deste post, por favor partilhe-o nas suas redes sociais e/ou comente sobre o post.

Até breve!

La entrada Começar com o docker se publicó primero en Aprende IT.