Thor Rachaus

Posted on Mar 23

Passo a Passo: Configuração do WSL para DevOps e SRE no Windows

#devops #sre #ubuntu #microsoft

O que é WSL

O texto busca auxiliar usuários na criação de um ambiente de desenvolvimento Windows utilizando o WSL.

O WSL (Windows Subsystem for Linux) permite ter um ambiente Linux com terminal e interface gráfica dentro do Windows, sem necessidade de dual boot ou mudança de sistema operacional. Assim, é possível usar o Windows para rotinas de programação e softwares/jogos exclusivos, e o Linux para desenvolvimento.

Requisitos de Hardware

Antes de iniciar a instalação do WSL no Windows, é preciso garantir que o hardware atenda aos requisitos mínimos:

Configuração de Hardware Intel:
I5 de 8ª Geração ou superior
16 GB de RAM
Mínimo de 50 GB de disco
Virtualização ativada na BIOS

Configuração de Hardware AMD:
AMD Ryzen 5 5600 ou superior
16 GB de RAM
Mínimo de 50 GB de disco
Virtualização ativada na BIOS

O WSL funciona como uma virtualização dentro do Windows, portanto, para uma boa experiência, é necessário ter pelo menos o hardware listado. Para cargas de trabalho mais intensas no Windows, recomenda-se hardware superior às especificações mínimas.

Como Ativar a Virtualização na BIOS
Antes de começarmos, é fundamental garantir que a virtualização esteja habilitada na BIOS. Para isso, ao ligar o computador, pressione a tecla F2, F10 ou Delete, dependendo do modelo da sua placa-mãe. Você verá uma tela semelhante à mostrada abaixo:

Habilitando em Placas AMD:

Habilitando em Placas Intel:

Importante: Cada placa-mãe possui um menu de configuração diferente. Consulte o manual da sua placa-mãe e procure pelas opções 'SVM Mode', 'Intel Virtualization Technology' ou o nome correspondente para a virtualização.

Requisitos de Software
Para garantir a melhor experiência na instalação do WSL, utilize o Windows 11, preferencialmente a última versão 24H2. O suporte da Microsoft para o Windows 10 termina em 14 de outubro de 2025.

Ao iniciar o Windows, o primeiro passo é garantir que o App Installer esteja na versão mais recente. Abra a Microsoft Store (ícone de sacola com o logotipo do Windows) e clique no ícone de nuvem com seta para baixo, como ilustrado na imagem a seguir.

Precisamos assegurar que o App Installer esteja atualizado. Clique em 'Get Update' ou 'Obter atualização' (a localização é idêntica, independentemente do idioma do seu Windows).

O Processo de atualização pode demorar um pouco devido à quantidade de atualizações disponíveis e à sua velocidade de conexão, basta aguardar e certificar que tudo foi atualizado corretamente.

Após atualizar o App Installer, é hora de iniciar o PowerShell como administrador para instalarmos a versão mais recente (7.5, na data deste artigo).

Você verá uma tela como a imagem acima. Nela, executaremos o seguinte comando no PowerShell:

winget install Microsoft.PowerShel

Aguarde o processo de instalação e, em seguida, você pode fechar o PowerShell atual. Vá até o menu Iniciar, pesquise por PowerShell e inicie o PowerShell na cor azul escura como administrador, conforme a imagem a seguir:

Com o PowerShell aberto como administrador, chegou a hora de criar o arquivo de configuração .wslconfig. Ele será responsável por limitar o uso máximo de hardware permitido para o WSL, fazendo com que o WSL não utilize todos os recursos do seu computador. Para isso, execute o comando abaixo:

notepad "$env:USERPROFILE/.wslconfig"

Ao executar o comando, um Bloco de Notas em branco será aberto:

O comando acima vai criar um arquivo de texto na pasta inicial do seu usuário, que será responsável por aplicar algumas configurações avançadas. O arquivo de configuração possui uma sintaxe bem simples, que pode ser conferida aqui: Configuração de definições avançadas no WSL | Microsoft Learn

Dentro do arquivo, insira as seguintes linhas (as que considero mais importantes):

# Configuração avançada do WSL

[wsl2]

# Defina o limite de memória RAM que será utilizado no WSL, ajustando-o conforme a sua carga de trabalho.

memory=8GB 

# Limite a quantidade de processadores disponíveis no WSL, ajustando conforme a sua carga de trabalho.

processors=4

# Crie um espaço de Swap para evitar o esgotamento de memória em altas cargas de trabalho.

swap=8GB

# Habilite a comunicação entre os serviços do WSL e o host do Windows para o funcionamento dos serviços e das portas do Docker.

localhostforwarding=true

Observação: Vale ressaltar que existem outros padrões que podem atender melhor ao seu caso de uso. Para isso, consulte o link acima e confira todas as opções disponíveis. As opções mencionadas acima, na minha opinião, são as mais importantes para evitar o uso excessivo de hardware no seu sistema.

Agora, salve o arquivo de configuração pressionando a combinação de teclas Ctrl + s e, em seguida, feche o bloco de notas.

Instalando o WSL

Uma vez configurados os pré-requisitos, chegou o momento de instalar as dependências necessárias para o funcionamento do WSL. Para isso, abra novamente o PowerShell 7.5 como administrador e execute o comando wsl --install, pressionando Enter. Você verá uma tela semelhante à abaixo, iniciando a instalação:

Aguarde a conclusão do processo e, em seguida, reinicie o Windows para que as alterações tenham efeito.

Escolhendo uma Distribuição Linux
Antes de escolhermos uma distribuição, vamos garantir que as dependências do WSL foram instaladas corretamente. Para isso, basta abrir o menu Iniciar e verificar se os ícones do WSL estão presentes.

Agora é o momento de escolhermos a distribuição Linux que melhor nos atenda. Podemos instalar a distribuição Linux de nossa preferência pela Microsoft Store ou procurar alguma distribuição comunitária através do GitHub, GitLab ou pela internet. É importante ressaltar que, ao utilizar essas distribuições comunitárias, é necessário ter cautela, pois não sabemos sua procedência. Por isso, recomendo fortemente a instalação de uma distribuição pela Microsoft Store.

Com a Microsoft Store aberta, vamos buscar na barra de endereços por "Linux" e nos deparar com várias distribuições. Podemos escolher a que melhor nos atenda. Entre as opções, temos:

Alpine
Debian
Fedora
Kali Linux
Oracle Linux
Slackware
Ubuntu

Entre outras.

Também é possível instalar distribuições que estão fora da Microsoft Store, como é o caso do Manjaro WSL ou do Linux Mint WSL:

Manjaro Linux O Manjaro Linux pode ser obtido neste repositório do GitHub, por exemplo:

Linux Mint O Linux Mint pode ser obtido neste repositório do GitHub, por exemplo:

Observação: É importante ressaltar que é necessário verificar cuidadosamente as distribuições Linux que serão instaladas, pois pode haver o risco de instalar algo que comprometa o sistema Windows.

Neste artigo, vamos realizar a instalação do Ubuntu 24.04 LTS. Para isso, vamos buscar o termo "Ubuntu 24.04" na Microsoft Store:

Vamos selecionar a distribuição conforme a imagem acima e instalá-la com a opção "Obter":

Após a conclusão da instalação, o usuário deve clicar em "Abrir" para iniciar o processo de configuração. Durante esse processo, será necessário definir um nome de usuário e senha para o usuário root (sudo su).

Feito isso, estaremos com o nosso Ubuntu 24.04 instalado e você estará dentro do terminal bash no Ubuntu, conforme a imagem a seguir:

Instalação da Fonte MesloLGS e Tema no Windows Terminal

Agora, vamos fechar o terminal do Ubuntu, pois vamos aprimorar a estética do nosso ambiente. Perceba que ele está com o tema roxo (que, embora seja característico do Ubuntu, não é muito agradável visualmente) e a fonte utilizada é simples, não sendo ideal para trabalhar com ícones, o que é necessário para o Powerlevel10k. Para isso, o primeiro passo será baixar o pacote de fontes para o Powerlevel10k diretamente no repositório do GitHub.

Com o download das fontes concluído, é hora de realizarmos a instalação utilizando o método de instalação como administrador. Para isso, vamos clicar com o botão direito do mouse, selecionar a opção "Mostrar mais" e, em seguida, clicar em "Instalar para todos os usuários", com o ícone de escudo, para executar como administrador.

Com as fontes instaladas, é hora de modificar o tema do Windows Terminal a nível global. Para isso, vamos iniciar o Windows Terminal.

Vamos abrir o arquivo de configuração do Windows Terminal. Para isso, clique no ícone ▼ e selecione a opção Configurações. Você pode usar o Bloco de Notas, Notepad++ ou o editor de sua preferência; neste caso, usaremos o Visual Studio Code.

Nessa nova tela, vamos criar na última opção a sua esquerda, onde vamos localizar a opção abrir o arquivo Json conforme a imagem a seguir:

Nessa nova tela, vamos criar, na última opção à esquerda, a opção para abrir o arquivo JSON, conforme a imagem a seguir:

Ao clicar na opção acima, o Windows exibirá uma caixa de diálogo para que possamos escolher o editor de arquivos de nossa preferência. Neste tutorial, utilizaremos o Visual Studio Code:

Neste trecho, vamos inserir os seguintes valores abaixo:

{
        "defaults": 
        {
            "colorScheme": "Rapture",
            "font": 
            {
                "face": "MesloLGS NF"
            },
            "opacity": 80,
            "useAcrylic": false
        },

Agora, vamos habilitar o tema Rapture para o nosso Windows Terminal, o que proporcionará um visual mais agradável, na minha opinião. Para isso, vá até a seção Schemes e cole o código abaixo:

{
  "name": "Rapture",
  "black": "#000000",
  "red": "#fc644d",
  "green": "#7afde1",
  "yellow": "#fff09b",
  "blue": "#6c9bf5",
  "purple": "#ff4fa1",
  "cyan": "#64e0ff",
  "white": "#c0c9e5",
  "brightBlack": "#304b66",
  "brightRed": "#fc644d",
  "brightGreen": "#7afde1",
  "brightYellow": "#fff09b",
  "brightBlue": "#6c9bf5",
  "brightPurple": "#ff4fa1",
  "brightCyan": "#64e0ff",
  "brightWhite": "#ffffff",
  "background": "#111e2a",
  "foreground": "#c0c9e5",
  "selectionBackground": "#304b66",
  "cursorColor": "#ffffff"
}

Ficando semelhante à imagem abaixo:

Agora, vamos salvar utilizando a combinação de teclas Ctrl + S ou indo em Arquivo e, em seguida, selecionando Salvar.

Após isso vamos está com essa estética:

Caso queira outros temas, você pode consultar este link.

Por fim, vamos definir o Ubuntu 24.04 como o sistema padrão do nosso Windows Terminal. Para isso, acesse as configurações do Windows Terminal, conforme a imagem abaixo.

Agora, vamos definir o Ubuntu como o shell padrão do Windows Terminal.

Agora, basta salvar as alterações e, ao iniciar um novo Windows Terminal, ele abrirá automaticamente com o Ubuntu 24.04 como padrão.

Configuração do Ubuntu para Desenvolvimento e Operações (DevOps/SRE)

Feitas todas as configurações anteriores, chegou o momento de começarmos a configurar e instalar os pacotes necessários para o nosso fluxo de desenvolvimento utilizando o WSL com o Ubuntu Linux.

Para isso, vamos abrir o Windows Terminal e nos logar como root utilizando o comando sudo su, seguido da senha que definimos na etapa anterior.

Agora, vamos realizar dois passos que considero essenciais. O primeiro é habilitar o suporte para a arquitetura 32 bits. Em seguida, vamos ativar o Ubuntu Pro para garantir suporte estendido no WSL e obter patches adicionais de segurança.

Para ativar o suporte à arquitetura 32 bits, execute o comando a seguir como root:

dpkg --add-architecture i386

Agora, vamos habilitar o Ubuntu Pro, uma funcionalidade da Canonical, que oferece suporte estendido para versões Ubuntu LTS, além de patches de segurança, sem custo para uso doméstico. Para isso, acesse este link e crie uma conta.

Após criarmos a conta, é o momento de obter a nossa chave do Ubuntu Pro. Para isso, vamos acessar a opção Your Subscription, conforme a imagem a seguir:

Agora, vamos copiar o comando abaixo, colá-lo no nosso terminal e pressionar Enter.

Se tudo correr como esperado, você verá uma tela semelhante a esta:

Agora, vamos atualizar os repositórios e o sistema utilizando o comando a seguir:

sudo apt update && sudo apt dist-upgrade -y

Com o comando acima, teremos nossa lista de repositórios atualizada, além de garantir que todos os pacotes iniciais do Ubuntu estejam na versão mais recente.

Instalando ferramentas essenciais
Agora, chegou o momento de realizar a instalação dos pacotes, com o objetivo de garantir um ambiente capaz de suportar adequadamente a carga de trabalho de DevOps e SRE.

Iniciaremos a instalação dos pacotes abaixo, responsáveis por fornecer ferramentas essenciais para o desenvolvimento, como build-essential, default-jdk, cmake, além de utilitários para análise de rede e vulnerabilidades, como nmap, sqlmap, sslscan, e ainda o git para versionamento de código, o curl para transferência de dados entre domínios e servidores, o poderoso editor de texto via terminal Neovim e um shell mais performático e customizado com o zsh.

Além dos pacotes mencionados, também instalaremos o suporte a múltiplas linguagens de programação, como Python, Rust, OCaml, Haskell, Lua, R, o navegador de terminal Lynx, ferramentas para SecOps, como nikto, e o john para testes de vulnerabilidades e pentest. Também será instalado o pacote ubuntu-restricted-extras, que inclui codecs e as fontes da Microsoft, caso desejemos utilizar o WSLG, a interface gráfica dentro do WSL.

Para realizar a instalação dos pacotes acima, basta executar o seguinte comando:

sudo apt install build-essential default-jdk libssl-dev exuberant-ctags ncurses-term ack-grep silversearcher-ag curl gnupg fontconfig imagemagick libmagickwand-dev software-properties-common git vim-gtk3 neovim emacs micro lyx net-tools nmap sqlmap sslscan traceroute nikto ubuntu-restricted-extras gdebi-core cmake cmake-extras flatpak flatpak-builder python3 python3-pip python3-dev python3-apt python3-venv rust-all elinks links lynx jq bc mc opam ocaml lua5.4 haskell-stack cabal-install ghc john rlwrap gawk sassc r-base zsh neofetch eza bat dialog zenity -y

Com a instalação acima finalizada, vamos instalar ferramentas essenciais para complementar a instalação anterior, que incluem bibliotecas para gráficos e interfaces gráficas, suporte a OpenGL, manipulação de XML, utilitários para automação, comunicação segura via SSH e acesso a complementos para comunicação de banco de dados.

Para isso, vamos executar o comando a seguir:

sudo apt-get -y install autoconf m4 libwxgtk3.2-dev libwxgtk-webview3.2-dev libgl1-mesa-dev libglu1-mesa-dev libpng-dev unixodbc-dev xsltproc fop libxml2-utils

Com a instalação anterior finalizada, vamos instalar agora pacotes cruciais para automação de builds e configuração de projetos, pacotes para trabalhar com arquivos YAML, bibliotecas para a linguagem C, libtool para gerenciamento de bibliotecas compartilhadas, extrator de arquivos com Unzip e suporte ao SQLite, ideais para bancos de dados pequenos, leves e embarcarados.

Para isso, executaremos o comando a seguir:

sudo apt install automake autoconf libreadline-dev libyaml-dev libxslt-dev libffi-dev libtool unzip zlib1g-dev sqlite3 libsqlite3-dev

Agora, vamos instalar pacotes essenciais para lidarmos tanto com o poderoso framework web em C++ chamado Drogon Framework, compiladores padrão para C e C++ com gcc e g++, cmake para automação de processos de construção de projetos e garantir conexões seguras e criptografadas nas conexões SSH.

Para isso, vamos executar o trecho a seguir:

sudo apt install gcc g++ cmake libjsoncpp-dev uuid-dev openssl

Agora, vamos instalar os extratores para arquivos compactados em diversas extensões, como RAR, ZIP, TAR, entre outros.

Basta executar o comando abaixo para realizar a instalação:

sudo apt install unace unrar p7zip-full sharutils uudeview arj cabextract lzip zlib1g-dev lbzip2 lrzip pbzip2 lzop

Por fim, vamos instalar os pacotes necessários para compilar e otimizar códigos tanto na linguagem C quanto na linguagem C++, incluindo o LLVM (nas versões 14 a 17), o compilador Clang, o mingw-w64 para códigos compatíveis com Windows, além do gcc-multilib e g++-multilib para suportar a criação de binários tanto em 32 como em 64 bits.

Basta executar o comando abaixo para realizar a instalação:

sudo apt install llvm llvm-14 llvm-15 llvm-16 llvm-17 clang mingw-w64 gcc-multilib g++-multilib

Com a instalação dos pacotes acima, vamos ter um ambiente de desenvolvimento capaz de lidar com uma boa gama de aplicações, além de permitir compilações de código para múltiplas plataformas como Linux, Windows e MacOS. Também deixamos o ambiente preparado para trabalhar inicialmente com algumas ações de DevSecOps (que vamos aprimorar a seguir).

Instalação do Suporte ao .NET (C#)
Com o passo anterior concluído, vamos agora configurar o suporte à linguagem .NET no nosso Ubuntu rodando via WSL. Embora seja possível usar o próprio Windows para essa finalidade, o foco deste artigo é utilizar o WSL como ambiente de desenvolvimento, portanto, é altamente recomendável realizar a instalação do suporte ao .NET diretamente dentro dele.

Para começar a trabalhar com .NET, precisamos primeiro adicionar o suporte ao PPA da Microsoft com o seguinte comando:

sudo add-apt-repository ppa:dotnet/backports

Com o repositório acima adicionado, vamos realizar a instalação de duas versões do .NET: primeiro a versão 8.0 e, em seguida, a versão 9.0. Para isso, vamos executar os seguintes comandos:

Instalando o SDK 8.0 no Ubuntu:

sudo apt-get update && \
  sudo apt-get install -y dotnet-sdk-8.0

Instalando o SDK 9.0 no Ubuntu:

sudo apt-get update && \
  sudo apt-get install -y dotnet-sdk-9.0

Instalação do Suporte aos Pacotes Nix (Opcional)

No mundo Linux, encontramos diversas distribuições com particularidades bem interessantes. Temos os pacotes .deb, utilizados na família Debian/Ubuntu, os pacotes .rpm, usados pela família Red Hat e OpenSuse, Snap, que é um pacote próprio do Ubuntu, AppImage e Flatpak, que são pacotes multi-distro, visando oferecer uma aplicação isolada, como uma espécie de "container", sem comprometer as bibliotecas e o sistema raiz, permitindo que seja portável.

Dentre os exemplos citados acima, encontramos uma distribuição Linux interessante chamada NixOS, cujo grande diferencial é ser uma distribuição imutável e trabalhar com aplicações segregadas da raiz do sistema, em uma espécie de sandbox, utilizando o Nix Shell.

A grande vantagem dos pacotes Nix é a escrita de uma derivação, muito parecida com a lógica do Ansible ou do Terraform, permitindo que você versionem e compartilhem um arquivo .nix. Dessa forma, outros usuários podem ter o ambiente necessário para realizar manutenções e alterações no projeto, sem a necessidade de "poluir" o seu sistema.

Para maiores detalhes sobre o NixOS e seu sistema de pacotes, consulte este link.

Vamos instalar o suporte ao Nix e NixShell com o seguinte comando como root:

sudo sh <(curl -L https://nixos.org/nix/install) --daemon

O processo de instalação é bem simples. Ele solicitará algumas confirmações, nas quais devemos pressionar y e seguir até o final. Isso habilitará o suporte aos pacotes Nix.

Instalação do Suporte ao CUDA (Somente para Nvidia):

Caso você tenha uma placa Nvidia da série RTX (preferencialmente) e pretenda trabalhar com alta carga de processamento de dados, aplicações em IA ou utilizar a sua GPU no processo de desenvolvimento, como por exemplo com PyTorch ou Anaconda, é fortemente recomendado que instale este pacote.

Como a Nvidia constantemente atualiza a versão do driver, é recomendado seguir as instruções para a última versão disponível, que pode ser obtida aqui

Na data deste arquivo, a última versão disponível é a 12.8. Para isso, vamos executar o seguinte comando:

cd /tmp
wget https://developer.download.nvidia.com/compute/cuda/repos/wsl-ubuntu/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt-get update
sudo apt-get -y install cuda-toolkit-12-8

Após executar o trecho acima, o CUDA estará instalado em nosso Ubuntu 24.04.

Observação: Caso tenha optado por outra distribuição durante o processo de instalação do WSL, basta selecionar a sua versão do Linux e seguir as instruções do site, conforme a imagem a seguir:

Instalação de Suporte ao Maven, Groovy, Gradle e Outras Linguagens

Agora, vamos instalar o suporte a outras linguagens de programação e frameworks essenciais para termos um ambiente de desenvolvimento abrangente. Habilitaremos o suporte a ferramentas para Java, C, C++, Kotlin, Python, além da linguagem Lua para scripts.

Para isso, vamos executar o seguinte comando:

apt install maven groovy valac lua5.4 gradle openjfx jython

Instalação do Suporte ao GStreamer

Nesta etapa, vamos instalar o suporte à reprodução de mídia dentro do WSL, de forma que seja possível utilizar o Google Chrome com um desempenho semelhante ao de uma versão nativa no Windows. Esse cenário é ideal, por exemplo, para testar uma aplicação PHP dentro do WSL.

Com o comando a seguir, teremos amplo suporte à reprodução de mídia, edição e processamento, streaming, codificação e decodificação. Para isso, basta executar o trecho abaixo no terminal como root:

apt-get install libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev libgstreamer-plugins-bad1.0-dev gstreamer1.0-plugins-base gstreamer1.0-plugins-good gstreamer1.0-plugins-bad gstreamer1.0-plugins-ugly gstreamer1.0-libav gstreamer1.0-tools gstreamer1.0-x gstreamer1.0-alsa gstreamer1.0-gl gstreamer1.0-gtk3 gstreamer1.0-qt5 gstreamer1.0-pulseaudio

Instalando o Google Chrome no WSL (Opcional)

Eu geralmente instalo um navegador web dentro do WSL. Embora as aplicações no WSL funcionem perfeitamente no Windows, graças ao parâmetro localhostForwarding=true que habilitamos no .wslconfig, ter um navegador dentro do WSL é uma boa prática, como uma precaução.

Para isso, vamos utilizar o wget para realizar o download do arquivo .deb neste link.

Após realizar o download do arquivo, vamos copiar o pacote .deb para dentro do nosso WSL utilizando o Windows Explorer.

Para isso, acesse o diretório onde você salvou o arquivo .deb.

Vamos clicar com o botão direito do mouse e selecionar a opção Copiar.

Agora, vamos acessar os diretórios do WSL pelo Windows Explorer.

Agora, vamos acessar a pasta /tmp dentro do WSL:

Agora, vamos colocar o arquivo .deb recém-baixado.

Com isso, vamos abrir o Windows Terminal e acessar o diretório /tmp via linha de comando:

Se pesquisarmos pelo conteúdo, encontraremos o arquivo .deb recém-copiado, utilizando o comando a seguir:

ls | grep google-chrome

Agora, vamos instalar o pacote com o comando a seguir, como root.

sudo dpkg -i google-chrome-stable_current_amd64.deb

Aguarde o processo de instalação finalizar e, em seguida, você poderá acessar o Google Chrome de duas formas. A primeira é via terminal, com o comando a seguir, como usuário normal (lembrando que ao fechar o terminal, o Google Chrome será encerrado):

A segunda opção é pelo Menu Iniciar, filtrando por Google Chrome (aparecerá uma versão com o ícone de um pinguim, junto ao logo). Dessa forma, ele funcionará até que o usuário finalize a sessão:

Importante: Quando abrir o Google Chrome pela primeira vez, ele perguntará se deseja torná-lo o navegador padrão do WSL. Fica a seu critério decidir. Também é possível instalar outros navegadores, como Firefox, Brave, entre outros, de acordo com a preferência do usuário.

Instalação e configuração do Oh-My-Zsh com plugins para terminal no usuário root

No Linux, existem diversos tipos de shell que podemos utilizar para potencializar a nossa produtividade. Entre os mais conhecidos, temos o Bash, presente na grande maioria das distribuições, o Z shell (Zsh) — que será o utilizado nesta configuração — e o FISH (Friendly Interactive Shell), que também é bastante popular. Embora existam muitas outras opções de shells, neste tutorial vamos nos concentrar na configuração do Oh-My-Zsh, uma ferramenta que vai incrementar o desempenho e a performance do Zsh, o shell que já instalamos no passo anterior, Instalando ferramentas essenciais.

Para saber mais sobre o Oh-My-Zsh, consulte o seguinte link.

Para instalar o Oh-My-Zsh, vamos rodar os seguintes comandos como root:

sudo su
zsh
cd
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Após rodar o comando acima, você perceberá que a estética do terminal será alterada.

Agora, vamos instalar alguns plugins que irão aumentar a nossa produtividade no terminal. Para isso, instalaremos os seguintes plugins:

zsh-autosuggestions: Responsável por sugerir comandos de forma inteligente enquanto você digita no terminal.
zsh-completions: Responsável por expandir as opções de autocompletar no Zsh, oferecendo sugestões para comandos, arquivos e argumentos que não são cobertos nativamente.
zsh-k: Responsável por melhorar a visualização e listagem de diretórios no Zsh, incluindo informações sobre pastas Git de forma mais legivel ao usuário.
zsh-fast-syntax-highlighting: Responsável por melhorar a legibilidade e a compreensão de códigos, comandos e scripts no terminal, aplicando destaques de sintaxe em tempo real, o que facilita a identificação de erros e a navegação entre diferentes elementos.
zsh-powerlevel10k: Um tema moderno, inspirado no Starship, projetado para ser utilizado no Oh-My-Zsh, oferecendo uma aparência limpa e funcional para o terminal.

Para realizamos a instalação vamos executar os comandos abaixo como usuário root:

Instalando zsh-autosuggestions:

git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

Instalando zsh-completions:

git clone https://github.com/zsh-users/zsh-completions ${ZSH_CUSTOM:-${ZSH:-~/.oh-my-zsh}/custom}/plugins/zsh-completions

Instalando zsh-k:

git clone https://github.com/supercrabtree/k $ZSH_CUSTOM/plugins/k

Instalando zsh-fast-syntax-highlighting:

git clone https://github.com/zdharma-continuum/fast-syntax-highlighting.git \  ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/plugins/fast-syntax-highlighting

Instalando powerlevel10k:

git clone --depth=1 https://github.com/romkatv/powerlevel10k.git "${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k"

Com os pacotes acima instalados, chegou o momento de configurarmos o arquivo .zshrc para garantir um visual agradável com o Powerlevel10k, além de habilitarmos as extensões recém-instaladas. Para isso, ainda como usuário root, vamos editar o arquivo .zshrc utilizando o editor de sua preferência. Neste tutorial, usaremos o vim.

Com o arquivo aberto, vamos localizar o trecho a seguir, que está logo no início do documento:

ZSH_THEME="robbyrussell"

Vamos alterar esta linha para o tema powerlevel10k, que instalamos na etapa anterior, deixando-a da seguinte forma:

ZSH_THEME="powerlevel10k/powerlevel10k"

Agora, vamos ativar os plugins que instalamos anteriormente. Para isso, localize o seguinte trecho:

plugins=(git)

E vamos acrescentar os plugins, deixando-os exatamente igual ao trecho a seguir:

plugins=(
  fast-syntax-highlighting
  git
  k
  zsh-autosuggestions
  zsh-completions
)

Realizadas as alterações acima, vamos salvar o nosso arquivo. No caso do vim, vamos apertar a tecla ESC e depois digitar a combinação :wq!.

Após retornarmos ao terminal, é a hora de carregar o arquivo de configuração que editamos anteriormente. Para isso, vamos executar o comando a seguir:

source .zshrc

Com isso, veremos uma tela para configurarmos o nosso tema do Powerlevel10K, semelhante à tela abaixo:

A seguir, estão os passos que eu utilizo para configurar o meu shell ZSH. Lembre-se de que você pode configurar conforme o seu gosto. Caso queira usar a mesma configuração que eu, basta seguir as opções abaixo:

1 - y
2-  y
3-  y
4 - 3
5 - y
6 - y
7 - 3
8 - 1
9 - 1
10 - 1
11 - 3
12 - 1
13 - 1
14 - 1
15 - 2
16 - 2
17 - y
18 - 1
19 - y

Se você seguiu a mesma configuração que eu utilizo, terá um terminal semelhante ao visual abaixo:

Instalação e configuração do Oh-My-Zsh com plugins para terminal no usuário comum

Agora, vamos realizar a instalação do Oh-My-Zsh e plugins para o nosso usuário comum, de forma que tenhamos um terminal mais robusto e produtivo para o nosso dia a dia. As etapas, em grande parte, serão semelhantes aos comandos que executamos para o usuário root na etapa anterior, porém teremos algumas particularidades, como a adição de alguns plugins extras, já que este será o usuário que utilizaremos no nosso dia a dia.

Para iniciar o processo de instalação, vamos executar o seguinte comando no terminal como usuário comum:

cd
zsh

Isso mudará o nosso shell de bash para zsh. Agora, vamos iniciar o processo de instalação do Oh-My-Zsh, como realizamos na etapa anterior. O único detalhe é que, ao apertar y para definir o zsh como shell padrão, ele pedirá a nossa senha de root.

Vamos instalar o Oh-My-Zsh com o comando a seguir:

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Agora, vamos instalar os plugins para termos uma maior produtividade no nosso terminal. A seguir, segue uma breve descrição dos plugins que vamos adicionar no nosso Zsh:

zsh-autosuggestions: Responsável por sugerir comandos de forma inteligente enquanto você digita no terminal.
zsh-completions: Responsável por expandir as opções de autocompletar no Zsh, oferecendo sugestões para comandos, arquivos e argumentos que não são cobertos nativamente.
zsh-k: Responsável por melhorar a visualização e listagem de diretórios no Zsh, incluindo informações sobre pastas Git de forma mais legivel ao usuário.
zsh-fast-syntax-highlighting: Responsável por melhorar a legibilidade e a compreensão de códigos, comandos e scripts no terminal, aplicando destaques de sintaxe em tempo real, o que facilita a identificação de erros e a navegação entre diferentes elementos.
zsh-powerlevel10k: Um tema moderno, inspirado no Starship, projetado para ser utilizado no Oh-My-Zsh, oferecendo uma aparência limpa e funcional para o terminal.
zsh-ask: Este plugin permite configurar uma integração com a API do ChatGPT, aumentando significativamente a produtividade. Para mais detalhes, consulte aqui.
zsh-histdb: Este plugin busca armazenar seu histórico em um banco de dados SQLite3, melhorando a gestão e o acesso ao histórico de comandos executados no seu terminal. Para mais detalhes, consulte aqui.
docker: Este plugin é responsável por adicionar alias e autocomplete para comandos, além de fazer o gerenciamento de containers Docker. Para mais detalhes, consulte aqui.
docker-compose: Este plugin funciona de maneira semelhante ao Docker, porém, desta vez, para o Docker Compose, aumentando a produtividade do usuário. Para mais detalhes, consulte aqui.
sudo: Este plugin adiciona o prefixo "sudo" ao pressionar "Esc", e, automaticamente, ele colocará o "sudo" no início do comando. Para mais detalhes, consulte aqui.
web-search: Este plugin adiciona suporte a buscadores como Google, Bing e Wiki para o terminal, permitindo realizar buscas rápidas sem a necessidade de um navegador web. Para mais detalhes, consulte aqui.

Para realizarmos a instalação dos plugins, vamos executar os comandos abaixo como usuário comum:

Instalando zsh-autosuggestions:

git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

Instalando zsh-completions:

git clone https://github.com/zsh-users/zsh-completions ${ZSH_CUSTOM:-${ZSH:-~/.oh-my-zsh}/custom}/plugins/zsh-completions

Instalando zsh-k:

git clone https://github.com/supercrabtree/k $ZSH_CUSTOM/plugins/k

Instalando zsh-fast-syntax-highlighting:

git clone https://github.com/zdharma-continuum/fast-syntax-highlighting.git \  ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/plugins/fast-syntax-highlighting

Instalando powerlevel10k:

git clone --depth=1 https://github.com/romkatv/powerlevel10k.git "${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k"

Instalando zsh-ask:

git clone https://github.com/Licheam/zsh-ask ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-ask

instalando zsh-histdb

git clone https://github.com/larkery/zsh-histdb $HOME/.oh-my-zsh/custom/plugins/zsh-histdb

Agora, com os pacotes acima instalados, chegou a hora de configurarmos o arquivo .zshrc para o nosso usuário comum. Para isso, vamos abrir o arquivo .zshrc com o seu editor de texto preferido. Neste tutorial, usaremos o Vim.

cd
vim .zshrc

Com o arquivo .zshrc aberto, chegou o momento de alterar o tema do nosso oh-my-zsh. Para isso, vamos localizar o trecho abaixo:

ZSH_THEME="robbyrussell"

Vamos alterar esta linha para o tema powerlevel10k, que instalamos na etapa anterior, deixando-a da seguinte forma:

ZSH_THEME="powerlevel10k/powerlevel10k"

Agora, vamos ativar os plugins que instalamos anteriormente. Para isso, localize o seguinte trecho:

plugins=(git)
E vamos acrescentar os plugins, deixando-os exatamente igual ao trecho a seguir:

plugins=(
  asdf
  copyfile
  dirhistory
  docker
  docker-compose
  fast-syntax-highlighting
  git
  jsontools
  kubectl
  k
  zsh-ask
  zsh-autosuggestions
  zsh-completions
  zsh-histdb
  sudo
  web-search
)

Realizadas as alterações acima, vamos salvar o nosso arquivo. No caso do vim, vamos apertar a tecla ESC e depois digitar a combinação :wq!.

Após retornarmos ao terminal, é a hora de carregar o arquivo de configuração que editamos anteriormente. Para isso, vamos executar o comando a seguir:

source .zshrc

Com isso, veremos uma tela para configurarmos o nosso tema do Powerlevel10K, semelhante à tela abaixo:

1 - y
2-  y
3-  y
4 - 3
5 - y
6 - y
7 - 3
8 - 1
9 - 1
10 - 1
11 - 3
12 - 1
13 - 1
14 - 1
15 - 2
16 - 2
17 - y
18 - 1
19 - y

Se você seguiu a mesma configuração que eu utilizo, terá um terminal semelhante ao visual abaixo:

Com isso, vamos ter o nosso oh-my-zsh configurado e pronto para trabalharmos com maior produtividade.

Criando estrutura de pasta do linux na home do usuario:

Como você pode ter notado, dentro do WSL não temos a árvore de diretórios padrão do Linux, ficando a cargo do usuário criar as pastas conforme a sua necessidade. Visando manter um ambiente semelhante ao do Linux, vamos criar a estrutura de arquivos de uma distribuição Linux na home do nosso usuário. Para isso, vamos executar o comando abaixo:

cd
xdg-user-dirs-update

Com isso, o seu diretório /home estará conforme a imagem abaixo:

Instalando o Webserver LAMP (Apache, MySQL e PHP)

Agora vamos instalar o LAMP, que é um acrônimo para Linux, Apache, MySQL e PHP, disponibilizando um ambiente completo dentro do WSL. Nessa etapa, vamos instalar:

Apache: Poderoso servidor web para hospedagem de aplicações.
MySQL: Banco de dados relacional bastante utilizado em ambientes produtivos.
PHP: Linguagem de programação fortemente utilizada para desenvolvimento web.

Importante: Caso queira seguir com um ambiente mais limpo, recomendo que pule para a etapa de instalar o Docker e Docker Compose e, após instalar o Docker, suba as stacks conforme o seu caso de uso.

Vamos seguir com a instalação dos pacotes para isso vamos rodar os comandos abaixo como root.

Instalando Apache: Para instalarmos o Apache, vamos executar os comandos abaixo:

sudo apt install apache2 ufw -y

Agora vamos liberar o acesso de entrada no Apache no nosso firewall UFW:

sudo ufw allow in "Apache Full"

Instalando o MySQL: Agora vamos iniciar o processo de instalação do banco de dados:

sudo apt install mysql-server -y

Após a instalação do mysql-server no Ubuntu, temos um bug em que o comando mysql_secure_installation não funciona corretamente. Para evitarmos esse tipo de problema, vamos primeiro alterar a senha do usuário root para que possamos prosseguir com a instalação:

Como root, execute o comando abaixo:

sudo mysql

Depois, rode a query a seguir para mudar a senha do usuário root do MySQL:

ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'sua-senha-aqui';

Após definir a senha do usuário root, vamos seguir o processo de instalação normal do MySQL. Para isso, vamos rodar o comando a seguir:

sudo mysql_secure_installation

Ao executar o comando, vamos ser direcionados para a tela de configuração do MySQL. Para isso, vamos realizar a configuração a seguir

Nessa primeira etapa, vamos apertar y para validar o componente de password:

Agora vamos selecionar a exigência mínima para a senha. Podemos selecionar a força da senha:

Agora, ele vai perguntar. Responda y para definir a senha do root (pode ser a mesma) ou coloque uma senha baseada nos critérios definidos anteriormente.
Após definir a senha, ele vai perguntar se você deseja seguir com a configuração do método de autenticação. Vamos responder y.

Vamos remover os usuários anônimos:

Vamos desativar o acesso remoto ao usuário root:

Vamos remover os bancos de dados de teste:

Por fim, vamos recarregar os privilégios:

Feita toda a configuração acima, chegou o momento de criarmos um usuário comum com permissão de root, evitando que fiquemos utilizando o usuário root para o nosso acesso no MySQL. Para isso, vamos rodar o comando abaixo para nos autenticar como root, o que será necessário para criar o nosso usuário local:

mysql -u root -p

Ele solicitará a sua senha de usuário root. Vamos informar a senha definida nos passos anteriores e rodar as instruções abaixo para criar um novo usuário, atentando-se para mudar os campos newuser e password.

Criando um novo usuário no MySQL:

CREATE USER 'newuser'@'localhost' IDENTIFIED BY 'password';

Concedendo permissão para todos os privilégios no usuário recém-criado.

GRANT ALL PRIVILEGES ON  *.*  TO 'newuser'@'localhost';

Agora, vamos recarregar todos os privilégios.

FLUSH PRIVILEGES;

Com o MySQL configurado, vamos realizar a instalação do PHP e do Composer no WSL. O primeiro passo é adicionar o repositório da versão mais recente do PHP. Nesse tutorial, vamos utilizar a versão 8.3.

Para isso, vamos seguir os passos abaixo:

Adicionando o repositório do PHP mais recente:

LC_ALL=C.UTF-8 sudo add-apt-repository ppa:ondrej/php

Vamos atualizar nossa lista de repositórios:

sudo apt update

Agora, vamos instalar as dependências para o PHP funcionar corretamente:

sudo apt install software-properties-common ca-certificates lsb-release apt-transport-https

Instalando o PHP 8.3 e todas as suas dependências

sudo apt-get install php8.3 php8.3-bcmath php8.3-bz2 php8.3-cgi php8.3-cli php8.3-common php8.3-curl php8.3-dba php8.3-dev php8.3-enchant php8.3-fpm php8.3-gd php8.3-gmp php8.3-imap php8.3-interbase php8.3-intl php8.3-ldap php8.3-mbstring php8.3-mysql php8.3-odbc php8.3-opcache php8.3-pgsql php8.3-phpdbg php8.3-pspell php8.3-readline php8.3-snmp php8.3-soap php8.3-sqlite3 php8.3-sybase php8.3-tidy php8.3-xml php8.3-xmlrpc php8.3-xsl php8.3-zip

Instalando dependências para o funcionamento do Compose:

sudo apt install php-cli unzip

Adicionando permissões para o PHP funcionar corretamente no Apache:

a2enmod proxy_fcgi setenvif
a2enconf php8.3-fpm

Reiniciando o serviço do Apache para refletir as alterações que realizamos:

systemctl restart apache2

Instalando o PHP Compose

cd /tmp
curl -sS https://getcomposer.org/installer -o /tmp/composer-setup.php
HASH=`curl -sS https://composer.github.io/installer.sig`
echo $HASH
php -r "if (hash_file('SHA384', '/tmp/composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
sudo php /tmp/composer-setup.php --install-dir=/usr/local/bin --filename=composer

Se tudo ocorreu bem, você verá uma tela semelhante à tela abaixo:

Instalando o NodeJS NPM e Yarn

Agora, vamos instalar os pacotes do NodeJS, NPM e Yarn. Apesar disso, mais à frente, vamos utilizar o ASDF (entraremos em mais detalhes em tópico futuro neste artigo) como uma garantia de ter o ambiente NodeJS, NPM e Yarn, pois já enfrentei problemas com o ASDF. No pior cenário, isso não impacta meu trabalho.

Importante: Esta etapa é opcional. Você pode utilizar somente o ASDF. Caso deseje, pode pular esta seção para Instalando o ASDF.

Para instalarmos os pacotes acima, vamos executar o comando a seguir:

sudo apt install nodejs npm yarn -y

Aguarde a instalação finalizar e, pronto, temos um ambiente para desenvolvimento Web usando NodeJS, NPM e Yarn.

Instalando o Ansible:

Agora, vamos instalar o Ansible, que é uma ferramenta de automação para gerenciar sistemas pessoais e servidores, onde, através de um arquivo .yaml, conseguimos passar um playbook que automatizará a instalação de pacotes e a configuração do nosso ambiente. É ideal para automatizar e padronizar servidores remotos.

Instalando o Ansible no Ubuntu:

sudo apt update
sudo add-apt-repository --yes --update ppa:ansible/ansible
sudo apt install ansible -y

Com o comando acima, vamos atualizar nossa lista de pacotes, adicionar o repositório oficial do Ansible e realizar a instalação do Ansible.

Instalando o Terraform Vault e Vagrant:

Agora, vamos instalar dois pacotes para gerenciar nossa infraestrutura. O primeiro deles é o Terraform, uma poderosíssima ferramenta de Infrastructure as Code (IaC) para provisionamento de ambientes em cloud, como AWS, Microsoft Azure, Google Cloud, entre outras. O segundo é o Vagrant, uma poderosíssima ferramenta para gerenciamento de ambientes virtualizados de desenvolvimento. Por fim, temos o Vault, que é um pacote para gerenciamento de secrets e criptografia baseada em identidade.

Para realizarmos a instalação, vamos executar os seguintes comandos como usuário root:

Fazendo o download da chave GPG do repositório da HashiCorp:

wget -O- https://apt.releases.hashicorp.com/gpg | \
gpg --dearmor | \
sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg > /dev/null

Adicionando o repositório da HashiCorp:

echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] \
https://apt.releases.hashicorp.com $(lsb_release -cs) main" | \
sudo tee /etc/apt/sources.list.d/hashicorp.list

Atualizando a lista de repositórios:

sudo apt update

Instalando Terraform, Vagrant e Vault:

sudo apt install terraform vagrant vault -y

Executados os comandos acima, teremos instalados os pacotes do Terraform, Vagrant e Vault, permitindo assim que tenhamos um leque maior de ferramentas de automação.

Instalando Banco de Dados Firebird, PostgreSQL, Memcached e Redis:

Agora, vamos instalar alguns outros bancos de dados adicionais, onde vamos instalar dois bancos de dados relacionais: o Firebird e o PostgreSQL; o Memcached, que é um sistema para armazenamento de chave-valor baseado em memória distribuída; e o Redis, que é um sistema de armazenamento chave-valor ideal para armazenamento de dados, muito utilizado para o armazenamento de tokens de sessão.

Importante: Não é necessário instalar esses pacotes como root. Caso prefira, ou tenha um hardware mais limitado, é recomendado utilizar o Docker para subir os serviços, somente quando for necessário.

Para isso, como usuário root, vamos rodar o comando a seguir:

sudo apt install postgresql postgresql-contrib postgresql-server-dev-16 redis-server libhiredis-dev memcached libmemcached-dev firebird-server

Caso queira habilitar os serviços como daemon do systemd, ou seja, sempre que abrir o WSL os bancos de dados iniciarem automaticamente, podemos rodar os comandos a seguir para habilitar cada serviço:

Habilitando o Firebird no systemd:

systemctl enable firebird-3.0

Habilitando o PostgreSQL no systemd:

systemctl enable postgresql

Habilitando o Memcached no systemd:

systemctl enable memcached

Habilitando o Redis no systemd:

systemctl enable redis-server

Com os comandos acima executados, ao iniciar o nosso WSL, automaticamente os serviços do Firebird, PostgreSQL, Memcached e Redis estarão em execução.

Instalando MongoDB Community:

Agora, vamos realizar a instalação de um poderosíssimo banco de dados NoSQL baseado em chave-valor e organizado por collections, que é o MongoDB. Esse banco é muito utilizado no ambiente corporativo, principalmente em cenários serverless.

Importante: Assim como os demais bancos de dados, você pode optar por subir o MongoDB como Docker, caso prefira ou seu hardware seja mais limitado.

Para instalarmos o MongoDB, vamos executar os comandos abaixo como usuário root:

Mudando para a pasta temporária e baixando a chave GPG do repositório do MongoDB 8.0 (última versão na data deste artigo):

curl -fsSL https://www.mongodb.org/static/pgp/server-8.0.asc | \
   sudo gpg -o /usr/share/keyrings/mongodb-server-8.0.gpg \
   --dearmor

Adicionando o repositório e definindo o caminho da chave GPG que baixamos anteriormente:

echo "deb [arch=amd64 signed-by=/usr/share/keyrings/mongodb-server-8.0.gpg ] http://repo.mongodb.org/apt/debian bookworm/mongodb-org/8.0 main" | sudo tee /etc/apt/sources.list.d/mongodb-org-8.0.list

Recarregando a lista de repositórios para obter os pacotes do MongoDB:

sudo apt-get update

Instalando o pacote do MongoDB Community Server:

sudo apt-get install -y mongodb-org

Com os comandos acima, teremos o MongoDB instalado e configurado no nosso WSL. Caso queira e tenha hardware disponível, você também pode habilitá-lo no systemd, de forma que, ao iniciar o WSL, o MongoDB Community Server já esteja em execução.

Para isso, vamos rodar o comando a seguir como usuário root:

systemctl enable mongod

Instalando MySQL Shell

Quando pensamos em ambiente de DevOps/SRE, uma ferramenta poderosíssima que precisamos ter em nosso ambiente é o MySQL Shell.

Essa ferramenta é responsável por disponibilizar um shell para o MySQL, de forma que consigamos, além de rodar queries, rodar scripts usando algumas linguagens de programação que nos auxiliem na validação de dados de tabelas, colunas, collations, além de nos trazer insights de pré-check para atualizações de versões do MySQL, o que acaba nos auxiliando no processo de atualizações em ambiente de cloud ou on-premises.

Para instalarmos, vamos executar o comando a seguir como root:

sudo apt install -y mysql-shell

Instalando Atlas Cli:

Agora, vamos realizar a instalação da ferramenta Atlas CLI, uma ferramenta destinada ao gerenciamento do serviço SaaS do MongoDB, conhecido como Mongo Atlas. O Mongo Atlas oferece uma interface web por meio da qual é possível criar projetos e clusters MongoDB, com a gestão compartilhada entre a equipe e o time do Atlas. A principal proposta do Atlas é fornecer um ambiente MongoDB que seja escalável e resiliente.

Vamos executar o comando abaixo com privilégios de usuário root:

sudo apt-get install -y mongodb-atlas

Instalando Docker:

Agora, vamos proceder com a instalação do Docker e Docker Compose, ferramentas essenciais para permitir a criação de ambientes containerizados com aplicações isoladas. Dessa forma, poderemos validar as aplicações que estamos desenvolvendo ou testar serviços disponíveis no Docker Hub.

Vamos executar o trecho abaixo para instalar o Docker com privilégios de usuário root para adicionar a chave do repositório do Docker:

sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

Agora, vamos executar o comando abaixo para adicionar o repositório do Docker, referenciando a chave previamente adicionada, ainda com privilégios de usuário root:

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Vamos atualizar nossa lista de repositórios para obter os pacotes do Docker, com privilégios de usuário root:

sudo apt-get update

Agora vamos instalar o Docker e o Docker Compose com o comando a seguir, , com privilégios de usuário root:

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-compose

Com os comandos acima, o Docker foi instalado em nosso sistema. No entanto, ao executar os comandos docker run ou docker-compose up, provavelmente receberemos um erro de "permission denied". Isso ocorre porque o grupo docker está atribuído apenas ao usuário root. Para resolver esse problema, vamos adicionar nosso usuário comum ao grupo docker, permitindo que os comandos do Docker sejam executados sem a necessidade de prefixar com sudo. Para isso, devemos executar o comando abaixo:

sudo usermod -aG docker $SEU-USUARIO

Caso possua um hardware mais robusto, recomendo fortemente habilitar o Docker como um serviço do systemd. Caso contrário, sempre que for utilizar o Docker, será necessário iniciar o serviço manualmente com o comando abaixo:

sudo systemctl start docker.service

Para configurar o Docker para iniciar automaticamente sempre que o WSL for iniciado, basta executar o comando a seguir com privilégios de root:

systemctl enable docker.service

Pronto! Com todos os comandos acima, teremos um ambiente com Docker totalmente configurado e pronto para criar ou rodar aplicações containerizadas.

Instalando o RustUP para Rust:

Agora, vamos instalar o RustUp para manter a versão do Rust e seus pacotes sempre atualizados para a última versão. Isso será fundamental mais à frente, quando formos instalar algumas extensões de terminal para o nosso ZSH.

Para isso como usuário normal vamos executar o comandos a seguir:

cd /tmp

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Vamos confirmar a instalação pressionando a letra y e, em seguida, selecionar a opção 1 para instalar e configurar o RustUp.

Após a instalação do RustUP, vamos adicionar a entrada do Rust no nosso terminal, para isso vamos editar o arquivo .zshrc com o vim e colar o trecho a seguir:

# Rust default settings
 export PATH=~/.cargo/bin:~/.local/bin:$PATH

Instalação de extensões de terminal com Cargo (Opcional):

Agora que temos o Cargo, Rust e RustUp configurados, chegou o momento de instalar algumas extensões para melhorar a estética e a usabilidade do nosso terminal. Para isso, vamos executar os comandos abaixo com o nosso usuário:

cargo install bat exa procs dust tokei ytop tealdeer grex rmesg zoxide delta

Ao executar o comando acima, nos depararemos com uma tela semelhante à seguinte:

Uma vez instaladas as ferramentas, precisaremos criar aliases para alguns pacotes que instalamos. Pessoalmente, gosto de usar três pacotes: bat, que é uma versão mais estética do cat; exa, que é uma versão do ls com suporte a ícones e visualmente mais atrativa; e ytop, uma alternativa mais bonita ao htop.

Para isso, vamos editar o nosso arquivo .zshrc com o editor de sua preferência. Neste tutorial, usaremos o vim. Para começar, execute o comando abaixo como usuário comum:

vim .zshrc

Em seguida, vamos localizar o trecho abaixo:

# Example aliases
# alias zshconfig="mate ~/.zshrc"
# alias ohmyzsh="mate ~/.oh-my-zsh"

e vamos adicionar as linhas abaixo:

alias ls="exa --icons"
alias cat="bat"
alias htop="ytop"

Pronto! Feito isso, você terá o seguinte resultado:

# Example aliases
# alias zshconfig="mate ~/.zshrc"
# alias ohmyzsh="mate ~/.oh-my-zsh"
alias ls="exa --icons"
alias cat="bat"
alias htop="ytop"

Agora, vamos explorar um pouco das ferramentas que instalamos com o Cargo:

Bat:

Exa:

ytop:

Instalando o ASDF

Agora, vamos instalar o pacote ASDF, um gestor de linguagens de programação que nos permitirá trabalhar com diversas linguagens de forma eficiente. Para isso, vamos fazer login como usuário root e executar os comandos abaixo.

O ASDF nos permite ter múltiplas versões de uma linguagem de programação instalada no sistema. Por exemplo, no caso do Node.js, podemos ter as versões 12, 14, 16 e 18. Isso facilita bastante, pois, ao invés de "poluirmos" o sistema com várias versões do Node.js, podemos instalar as versões conforme a necessidade, ou seja, de acordo com o projeto em que estamos trabalhando. E, caso não precise mais de uma versão, podemos removê-la sem comprometer o sistema.

Além disso, o ASDF possibilita a instalação de uma infinidade de linguagens de programação de maneira simplificada (consulte as linguagens suportadas aqui), tornando o ambiente multi-linguagens e mais robusto para estudos ou projetos nos quais vamos atuar.

Pessoalmente, gosto de instalar pacotes que não estão disponíveis nos repositórios do Ubuntu (ou seja, pacotes externos) em /opt. No entanto, você pode instalar onde preferir; a lógica é a mesma, bastando ajustar os caminhos e atribuir as permissões, se necessário.

Para instalar o ASDF em /opt, vamos seguir os comandos abaixo como usuário root:

Criando o diretório /opt/asdf para o binário do asdf e o diretório /opt/asdf/asdf-data para as linguagens de programação que vamos instalar.

cd /opt
sudo mkdir asdf
sudo mkdir -p /opt/asdf-data

Agora, vamos baixar o binário da última versão do ASDF disponível na data deste artigo:

cd /tmp
https://github.com/asdf-vm/asdf/releases/download/v0.16.5/asdf-v0.16.5-linux-amd64.tar.gz

Vamos extrair o arquivo tar.gz recém-baixado:

tar -xvzf asdf-v0.16.5-linux-amd64.tar.gz

Agora, teremos um arquivo binário chamado asdf. Vamos movê-lo para a pasta /opt/asdf com o comando abaixo:

sudo mv asdf /opt/asdf

Torne o binário executável com o comando a seguir:

sudo chmod +x /opt/asdf/asdf

Vamos alterar a propriedade da pasta e seus arquivos, definindo o nosso usuário como o proprietário.

sudo chown -R usuario:usuario /opt/asdf-data

Agora, vamos adicionar no .zshrc os caminhos para o binário do asdf e para a pasta onde vamos instalar as linguagens que utilizaremos. Para isso, vamos voltar para o diretório /home/usuario e editar o arquivo .zshrc com o editor de nossa preferência. Neste caso, utilizarei o vim.

vim .zshrc

E vamos adicionar o trecho abaixo:

# Asdf default settings
export PATH="/opt/asdf:$PATH"
export ASDF_DATA_DIR="/opt/asdf/asdf-data"
export PATH="${ASDF_DATA_DIR:-$HOME/.asdf}/shims:$PATH"

Feito isso, vamos recarregar a configuração do nosso .zshrc para que as alterações acima tenham efeito.

source .zshrc

Feito isso estamos com o ASDF configurado em nosso ambiente.

Instalando Linguagens de Programação no ASDF:

Como mencionado anteriormente, o ASDF suporta uma infinidade de linguagens de programação, que podem ser consultadas neste [link]. Como podemos ver abaixo, temos à disposição uma grande variedade de linguagens com as quais podemos trabalhar:

A seguir, vamos instalar o Node.js LTS para demonstrar como o processo de instalação com o ASDF é simples. Para isso, vamos executar os comandos abaixo como nosso usuário:

Adicionando o NodeJS:

asdf plugin add nodejs

Listando todas as versões do NodeJS:

asdf list all nodejs

Instalando o NodeJS 22.14.0:

asdf install nodejs 22.14.0

Setando o NodeJS 22.14.0 como versão padrão:

asdf set nodejs 22.14.0

Ao executarmos os comandos acima, será criado um arquivo chamado .tool-versions, que pode ser utilizado em dois cenários distintos:

.tool-versions em /home/usuario: Esta será a versão padrão assumida pelo ASDF, sendo usada em todo o sistema.
.tool-versions dentro de um projeto: Esta versão será aplicada apenas no escopo do projeto em que você está trabalhando. Por exemplo, se estiver atuando em um projeto legado em Node.js na versão 12, é possível limitar o uso dessa versão apenas dentro do projeto. Para isso, basta seguir o processo de instalação acima para a linguagem desejada ou seguir as instruções específicas para a linguagem com a qual você está trabalhando.

Para demais linguagens, basta seguir as recomendações dos mantenedores conforme a tecnologia necessária. Para verificar a lista de tecnologias compatíveis, basta clicar aqui.

Para criar um novo usuário no PostgreSQL, siga os passos abaixo como usuário root:

Acesse o banco de dados como superusuário com o usuário postgres, executando o seguinte comando:

sudo -u postgres psql

Agora, vamos criar o usuário e definir a senha para ele:

CREATE USER nome_do_usuario WITH PASSWORD 'senha';

Agora, vamos conceder permissões de superusuário ao usuário recém-criado:

ALTER USER nome_do_usuario WITH SUPERUSER CREATEDB CREATEROLE;
ALTER USER nome_do_usuario WITH REPLICATION BYPASSRLS;

Agora, vamos definir uma senha para o usuário postgres:

ALTER USER postgres WITH PASSWORD 'senha';

Vamos verificar se os usuários estão com as permissões corretas:

\du

Você verá uma tela semelhante à mostrada abaixo:

Agora, vamos sair do shell do postgres com o seguinte comando:

\q

Com os comandos acima executados, teremos criado um novo usuário com permissões de administrador, evitando assim a necessidade de utilizar o usuário postgres para gerenciar o banco de dados. Além disso, estaremos protegendo o usuário postgres com uma senha.

Instalando o Pulumi, outra ferramenta para IaC:

O Pulumi funciona de maneira semelhante ao Terraform para o provisionamento de infraestrutura em nuvem. No entanto, em vez de utilizar a linguagem HCL (usada no Terraform), o Pulumi permite que você utilize linguagens de programação como Go, Node.js e Python. Isso proporciona maior assertividade para aqueles que já estão familiarizados com essas linguagens, facilitando a criação de recursos em provedores de nuvem como AWS, Microsoft Azure, Google Cloud, entre outros (verifique a compatibilidade antes de utilizar).

Para realizar a instalação, execute o comando abaixo:

cd /tmp
curl -fsSL https://get.pulumi.com | sh

O comando acima realizará a instalação do Pulumi e adicionará seu binário automaticamente ao PATH no arquivo .zshrc.

Instalando a ferramenta de teste de estresse k6

Agora, vamos instalar o k6, uma ferramenta de teste de estresse amplamente utilizada em cenários corporativos. Essa ferramenta utiliza uma sintaxe simples baseada em JavaScript e permite a realização de testes de carga, além de integração com sistemas de observabilidade como Grafana, Datadog e New Relic. Com o k6, conseguimos verificar a escalabilidade e a resiliência das nossas aplicações.

Para instalar, vamos executar o seguinte comando:

sudo gpg -k
sudo gpg --no-default-keyring --keyring /usr/share/keyrings/k6-archive-keyring.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys C5AD17C747E3415A3642D57D77C6C491D6AC1D69
sudo echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" | sudo tee /etc/apt/sources.list.d/k6.list
sudo apt-get update
sudo apt-get install k6

Com o comando acima, o k6 será instalado no nosso ambiente. Para entender mais sobre o k6, é recomendado consultar a documentação oficial.

Instalando o Apache JMeter CLI

Semelhante ao k6, que instalamos na etapa anterior, o Apache JMeter também é uma ferramenta utilizada para realizar testes de carga e estresse em aplicações web. Ela é amplamente usada em ambientes corporativos. Pessoalmente, prefiro instalar ambas as ferramentas, pois haverá cenários em que o time de QA e desenvolvimento utilizará o JMeter em vez do k6. Ter um ambiente preparado para lidar com ambas as tecnologias é o ideal para um profissional de DevOps/SRE.

Vamos instalar o Apache JMeter 5.6.3 (última versão disponível na data deste artigo) executando os comandos abaixo:

Baixando o Apache Jmeter como usuário comum:

cd /tmp
wget https://dlcdn.apache.org//jmeter/binaries/apache-jmeter-5.6.3.zip

Agora, vamos extrair o arquivo ZIP que baixamos recentemente:

unzip apache-jmeter-5.6.3.zip

Agora, vamos mover a pasta recém-extraída para o diretório /opt, semelhante ao que fizemos com o asdf:

sudo mv apache-jmeter-5.6.3 /opt/

Agora, vamos alterar o proprietário da pasta JMeter para o nosso usuário:

sudo chown -R nome_do_usuario:nome_do_usuario /opt/apache-jmeter-5.6.3

Agora, vamos editar o nosso arquivo .zshrc com o editor de nossa preferência (usaremos o vim neste tutorial), adicionando o binário do Apache JMeter.

vim ~/.zshrc

Vamos adicionar o seguinte trecho:

# Jmeter default CLI
export PATH="/opt/apache-jmeter-5.6.3/bin:$PATH"

Com os comandos acima, teremos o JMeter configurado no nosso ambiente Ubuntu sob WSL.

Instalando o SDL 2 no Ubuntu

Agora, vamos instalar a biblioteca multimídia open-source no WSL, permitindo uma maior integração com as novas aplicações. Para isso, execute o comando abaixo como usuário root:

sudo apt install libsdl2-2.0-0 libsdl2-dev libsdl2-mixer-2.0-0 libsdl2-mixer-dev libsdl2-image-2.0-0 libsdl2-image-dev

Instalando lvim (Opcional)

Agora, vamos instalar a distribuição do Neovim chamada LunarVim. Ela transforma o nosso Neovim em uma IDE, semelhante ao VSCode. Para aqueles adeptos do terminal, isso proporciona uma maior produtividade no Vim.

Para realizar a instalação do LunarVim, precisaremos executar os comandos abaixo com o nosso usuário:

Vamos adicionar o repositório do Neovim (instável), uma exigência para o LunarVim:

sudo add-apt-repository ppa:neovim-ppa/unstable

Vamos atualizar a nossa lista de pacotes executando o comando abaixo:

sudo apt update && sudo apt dist-upgrade

Instalando as dependências necessárias para o LunarVim:

sudo apt install ripgrep fzf

Agora vamos fazer a instalação do tree-sitter, para isso vamos baixar o pacote do Github e compilar.

git clone https://github.com/tree-sitter/tree-sitter.git
cd tree-sitter
make
sudo make install

Após instalarmos todas as dependências necessárias, vamos instalar o LunarVim com o comando abaixo:

zsh <(curl -s https://raw.githubusercontent.com/lunarvim/lunarvim/master/utils/installer/install.sh)

Uma tela de instalação será exibida, conforme mostrado abaixo:

Com o processo de instalação concluído, vamos editar o nosso arquivo .zshrc com o editor de nossa preferência e adicionar o trecho abaixo na seção de aliases:

alias vim='lvim'

Ao executar o comando vim no terminal, nos depararemos com um Vim semelhante a uma IDE, com a estética abaixo. Caso queira personalizar o seu LunarVim, basta acessar a documentação oficial clicando aqui.

Instalando AWS CLI

Agora, vamos instalar o AWS CLI, que nos permitirá gerenciar ambientes AWS via linha de comando. Com ele, podemos utilizar ferramentas como Terraform, scripts ou até mesmo o CloudFormation, graças à integração que nos permite configurar nossas chaves pública e privada para realizar alterações, com base nas permissões configuradas.

Para instalar, vamos executar o comando abaixo:

cd /tmp
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
aws configure

Instalando Azure CLI

Semelhante ao AWS CLI, que configura o nosso ambiente WSL para gerenciar recursos na AWS, temos o Azure CLI. Ele instala as ferramentas necessárias para que possamos gerenciar nossos recursos na Microsoft Azure.

Para isso, vamos executar o comando abaixo como usuário root:

cd /tmp
sudo apt-get instal lsb-release

Vamos criar um diretório para armazenar a chave:

sudo mkdir -p /etc/apt/keyrings

Vamos baixar a chave do repositório do Microsoft Azure:

curl -sLS https://packages.microsoft.com/keys/microsoft.asc |
  gpg --dearmor | sudo tee /etc/apt/keyrings/microsoft.gpg > /dev/null

Agora, vamos alterar a permissão da chave da Microsoft que baixamos no comando anterior:

sudo chmod go+r /etc/apt/keyrings/microsoft.gpg

Agora, vamos adicionar o repositório do Microsoft Azure no Ubuntu com o comando abaixo:

AZ_DIST=$(lsb_release -cs)
echo "Types: deb
URIs: https://packages.microsoft.com/repos/azure-cli/
Suites: ${AZ_DIST}
Components: main
Architectures: $(dpkg --print-architecture)
Signed-by: /etc/apt/keyrings/microsoft.gpg" | sudo tee /etc/apt/sources.list.d/azure-cli.source

Agora, vamos atualizar nossa lista de repositórios:

sudo apt-get update

Agora, vamos instalar o azure-cli com o comando abaixo:

sudo apt-get install azure-cli

Após executarmos os comandos acima, estaremos aptos a trabalhar com o ambiente da Microsoft Azure.

Instalando Google CLI

Agora, vamos instalar o Google Cloud CLI, que nos permitirá gerenciar nossa infraestrutura e recursos no ambiente do Google Cloud. Para isso, vamos executar os comandos abaixo como usuário root:

Vamos baixar a chave do repositório do Google Cloud:

curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo gpg --dearmor -o /usr/share/keyrings/cloud.google.gpg

Agora, vamos adicionar o repositório do Google Cloud e referenciar a chave que baixamos anteriormente:

echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] https://packages.cloud.google.com/apt cloud-sdk main" | sudo tee -a /etc/apt/sources.list.d/google-cloud-sdk.list

Agora, vamos instalar o google-cloud-cli com o comando abaixo:

sudo apt-get update && sudo apt-get install google-cloud-cli

Instalando Minikube

Agora, vamos instalar a distribuição Kubernetes chamada de Minikube. Essa distribuição Kubernetes tem a facilidade de ser uma versão pequena, leve e customizada, de forma que consigamos validar nossos aplicativos em um único nó, sem a necessidade de ter uma instalação completa de um cluster Kubernetes e rodando sob um container Docker.

Observação: Para saber mais sobre o Minikube, basta clicar aqui.

Importante: A instalação do Minikube é opcional. Temos diversas distribuições Kubernetes e você pode optar por outras distribuições que melhor lhe atendam, como k3s, microk8s, rke, entre outras.

Para realizar a instalação, vamos primeiro baixar o arquivo .deb com o comando abaixo com o nosso usuário:

cd /tmp
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube_latest_amd64.deb

Agora vamos realizar a instalação do Minikube com o comando a seguir:

sudo dpkg -i minikube_latest_amd64.deb

Agora, vamos limitar a quantidade de memória que vamos utilizar no Minikube com o comando a seguir:

minikube config set memory valor

Agora, vamos limitar a quantidade de cpu que vamos utilizar no Minikube com o comando a seguir:

minikube config set cpus valor

Agora, vamos iniciar o serviço do Minikube com o comando a seguir:

minikube start

Colococando Minikube no SystemD (Opcional)

Se você tem um hardware mais potente, pode levar em consideração colocar o Minikube para iniciar juntamente com o SystemD. A principal vantagem dessa abordagem é que, ao iniciar o WSL, o Minikube já estará em execução, dispensando o usuário de ter que iniciar o Minikube toda vez que for trabalhar com Kubernetes.

Para habilitarmos o Minikube no SystemD, vamos executar os comandos abaixo como usuário root:

Vamos criar um arquivo service para o Minikube usando o editor de nossa preferência. Nesse tutorial, vamos usar o vim.

sudo vim /etc/systemd/system/minikube.service

Agora, vamos colar o trecho abaixo, atentando-se para mudar o nome de usuário e o grupo para o nome do seu usuário:

[Unit]
Description=Minikube Cluster
After=docker.service

[Service]
Type=oneshot
ExecStart=/usr/bin/minikube start
RemainAfterExit=true
ExecStop=/usr/bin/minikube stop
StandardOutput=journal
User=seu_usuario
Group=seu_usuario

[Install]
WantedBy=multi-user.target

Agora, será necessário recarregar o daemon do SystemD com o comando a seguir:

sudo systemctl daemon-reload

Agora, vamos habilitar o serviço do Minikube para iniciar sempre que abrirmos o WSL:

sudo systemctl enable minikube

Instalando o Kubectl

Agora vamos instalar o Kubectl que é uma ferramenta de linha de comando para gerenciamos cluster Kubernetes locais ou remotos crucial para profissionais de DevOps e SRE gerenciar cluster Kubernetes,

Observação: Para saber mais sobre o Kubectl, basta clicar aqui.

Para realizamos a instalação vamos executar o comando a seguir:

Baixando a chave GPG do repositório do kubectl:

curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.32/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

Vamos alterar a permissão para a chave recém-baixada com o comando a seguir:

sudo chmod 644 /etc/apt/keyrings/kubernetes-apt-keyring.gpg

Agora, vamos adicionar o repositório do kubectl e referenciar o caminho da chave baixada anteriormente:

echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.32/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

Agora, vamos alterar a permissão do repositório do kubectl com o comando a seguir:

sudo chmod 644 /etc/apt/sources.list.d/kubernetes.list

Agora, vamos atualizar a lista de pacotes para pegar o repositório e obter os arquivos do repositório do Kubernetes:

sudo apt-get update

E, por fim, vamos baixar e instalar o pacote do kubectl com o comando a seguir:

sudo apt-get install -y kubectl

Instalando o Helm

Agora, vamos instalar o Helm, um gerenciador de pacotes que visa automatizar e facilitar a implementação e manutenção dos nossos clusters Kubernetes, muito utilizado em cenários produtivos.

Observação: Para saber mais sobre o Helm, basta clicar aqui.

Para iniciar a instalação do Helm, vamos executar os comandos abaixo:

Baixando a chave do repositório do Helm:

curl https://baltocdn.com/helm/signing.asc | gpg --dearmor | sudo tee /usr/share/keyrings/helm.gpg > /dev/null

Agora, vamos adicionar o repositório do Helm e referenciar o caminho da chave baixada anteriormente:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/helm.gpg] https://baltocdn.com/helm/stable/debian/ all main" | sudo tee /etc/apt/sources.list.d/helm-stable-debian.list

`Agora, vamos atualizar a lista de pacotes para pegar o repositório e obter os arquivos do repositório do Helm:

`
sudo apt-get update

Agora, vamos realizar a instalação do Helm com o comando abaixo:

`
sudo apt-get install -y helm

Bônus: Gerando Backup do WSL

Caso deseje, você pode gerar um backup da configuração que realizamos no WSL, o que criará um backup compactado. Isso permitirá tanto replicar a nossa instalação em outros computadores, caso deseje, quanto armazená-lo em uma unidade de armazenamento, permitindo importar a instalação novamente sem a necessidade de configurar tudo do zero.

Para isso, vamos usar o PowerShell 7.5 como administrador:

Gerando Backup do WSL:

`
wsl --export {NomeDaDistribuição} backup.tar.gz

Importando Backup do WSL:

`
wsl --import {NomeDaDistribuição} {LocalDeInstalação} backup.tar.gz

Instalando o VScode e Integrando com o WSL:

Agora, vamos instalar o Visual Studio Code no nosso sistema Windows e realizar a integração do Visual Studio Code com o WSL, trazendo mais produtividade para o nosso fluxo de desenvolvimento.

Para isso, basta baixar o Visual Studio Code através deste link ou usar o comando abaixo no PowerShell como administrador com o comando a seguir:

`
winget install -e --id Microsoft.VisualStudioCode

Com o Visual Studio Code, vamos iniciar o aplicativo e instalar a extensão chamada Remote - WSL, conforme a imagem abaixo:

Com a extensão acima instalada, vamos fechar o Visual Studio Code e abrir o WSL com o usuário normal. Em seguida, execute o comando abaixo:

`
code .

Após concluir a instalação, você notará que estará utilizando o Visual Studio Code dentro do WSL. Basta observar no canto inferior esquerdo, onde aparecerá o nome da sua distribuição Linux.

Conclusão e Resultado Final

Se você seguiu os passos acima, terá um ambiente robusto e completo para aprender e também trabalhar com DevOps/SRE, pois instalamos diversos serviços que facilitam o nosso dia a dia, com ferramentas para desenvolvimento, automações, criação de scripts e gerenciamento de Kubernetes.

O seu WSL terá um terminal semelhante a este:

Built for developers, by developers.

Whether you're building a simple prototype or a business-critical product, Heroku's fully-managed platform gives you the simplest path to delivering apps quickly — using the tools and languages you already love!

Learn More