DEV Community: Wesley Gonçalves

PHP sem nada de Xampp e com muito Xdebug no Windows

Wesley Gonçalves — Sat, 08 Jun 2024 15:39:15 +0000

Uma coisa que já é sabida há um bom tempo é que NÃO precisamos usar o Xampp para montarmos um bom ambiente de desenvolvimento, mas voce pode argumentar que o próprio site oficial do PHP na Instalação no Windows recomenda fazer uso dele por ser mais pratico, concordo totalmente com essa afirmativa, mas o problema é que além de PHP são instalados outra ruma de tranqueiras que são desnecessárias. Caso queira entender o motivo dessas ferramentas serem desnecessárias minha sugestão é assistir o video do Vinícius Dias de nome: XAMPP: Por Que Este Não Deve Ser seu Ambiente de Desenvolvimento. Chega de conversa fiada e vamos para a configuração.

Índice

Instalando O PHP no Windows
Instalando o Xdebug
VScode e suas extensões
Usando o SQLite

Instalando O PHP no Windows

Para instalar o PHP no windows basta somente 3 passos, primeiro que vamos baixar os arquivos zipados no linK: PHP para windows, importante mencionar que talvez seja necessário instalar o Visual C++ Redistributable for Visual Studio, verifique antes no seu windows ele está instalado, caso contrário basta baixar neste link: Visual C++ Redistributable, instalação padrão do windows, faz next até aparecer o finish.

O próprio site explica as diferenças entre as versões disponíveis, para este exemplo vou usar o PHP 8.2 (8.2.19) com a versão VS16 x64 Thread Safe (2024-May-08 07:21:58), para a gente vamos somente baixar o arquivo .ZIP como mostrado na figura.

Feito isso, vamos agora descompactar a o zip, mas antes crie um diretório na raiz do disco C do windows, vai ficar assim "C:\php". depois da árdua tarefa descompactar um arquivo, agora entre na pasta e encontrará de cara os arquivos php.ini-development e php.ini-production , faça uma copia do arquivo php.ini-development e renomeia para ficar somente php.ini o resultado final vai ser como o da imagem.

Estamos quase lá, falta agora nossas variáveis de ambiente, pesquise no menu iniciar do windows por Editar as variáveis de ambiente.

Agora clicando em variáveis de ambiente, vamos ter a seguinte tela.

Edite a variável Path e nela coloque o caminho da pasta do php: "C:\php", seu PHP está instalado no windows, para verificar de fato se deu bom na instalação abra seu terminal e digite: php -v e o resultado é para ser.

Com isso você já pode fazer fazer seus programas com o PHP, mas aqui a gente quer colocar um ambiente de desenvolvimento arretado, então vamos configurar o gerenciador de pendencias do PHP o commposer e nossa ferramenta de debug o Xdebug.

Para instalar o composer basta fazer o baixar o executável e mais uma vez basta fazer next e depois finish. Se tudo estiver ocorrido como o desejado validamos rodando o comando.

composer -v

E o resultado deve ser esse.

Com isso temos nosso PHP e composer devidamente instalado, agora vamos para nossa ferramenta de depuração.

Instalando o Xdebug

Caso não conheça o essa ferramenta incrível, minha sugestão é fazer uma lida rápida na Documentação do Xdebug, aqui vou fazer a instalação e uma configuração básica que tenho usado no em meu ambiente local.

Primeiro vamos baixar a dll do Xdebug para windows, acessando o link, agora tenha atenção para que a versão selecionada seja compatível com a versão de PHP usada no Windows.

Selecionada a versão correta, descompacte e mude o nome para php_xdebug.dll, em seguida adicione a extensão em C:\php\ext. Feito isso temos a extensão pronta, mas ainda precisamos habilitar para uso, fazemos isso editando o arquivo php.ini.

Pesquise dentro do php,ini por zend_extension= , provavelmente você irá encontrar algo desse tipo.

;zend_extension=opcache

Duplique a linha e modifique para que fique agora assim.

;zend_extension=opcache
zend_extension=xdebug

Basicamente o que estamos fazendo é habilitar/ativar o uso da extensão para nosso PHP local, mas só isso não é suficiente, precisamos acionar algumas coisas para deixar o Xdebug zero bala para o desenvolvimento. Ainda no arquivo php.ini role até o final do arquivo e acrescente o seguinte bloco.

[Xdebug]
xdebug.mode=debug,develop //controla quais recursos do Xdebug estão habilitados
xdebug.client_host=localhost //Configura o host ao qual o Xdebug conecta ao iniciar uma conexão de depuração.
xdebug.start_with_request=trigger // depuração de etapas 
xdebug.idekey=VSCODE //chave IDE que o Xdebug deve passar para o cliente ou proxy
xdebug.client_port=9003  // A porta à qual o Xdebug tenta se conectar no host remoto
xdebug.var_display_max_children=128 //Controla a quantidade de filhos do array e as propriedades do objeto são mostradas quando as variáveis são exibidas com var_dump()
xdebug.filename_format=...%s%a // determina o formato com o qual o Xdebug renderiza nomes de arquivos em rastreamentos de pilha HTML

Essas são as configurações que julgo serem suficientes para quem tá começando, mas caso queira entrar mais a fundo leia a documentação das configurações do Xdebug.

Para saber de maneira bem simples se o Xdebug foi ativado corretamente é via comando, basta abrir o terminal e fazer.

php -i

O resultado será gigante, mas o mais importante é procurar pelo Xdebug, que deve aparecer assim.

Para finalizar essa parte, precisamos só de mais um detalhe, uma extensão para nosso navegador seja ele o Firefox ou Chrome, na extensão clique que opções e a tela apresentada será esta.

Pronto em IDE key deixe os parâmetros como na imagem Other e VSCODE, acredito que deva ter notado que esse é o mesmo valor que colocamos em nosso xdebug.idekey, agora lembre de deixar a extensão sempre ativada quando estiver depurando seu código PHP.

VScode e suas extensões

Para ser mais direto e não deixar o tutorial mais longo que o necessário, vai nas extensões do VSCODE e digita php, para inicio instala somente PHP Intelephense, PHP Debug e PHP IntelliSense.

Com tudo devidamente instalado vamos no menu lateral e clicamos no ícone de depuração ou simplesmente o comando (Ctrl + Shift + D) provavelmente você verá algo como demonstrado na imagem a seguir.

Basta agora clicar em create a launch.json file e escolha a opção PHP que o próprio VScode vai se virar para criar uma configuração para ti, aqui ele gerou isso aqui pra mim.

   "version": "0.2.0",
    "configurations": [
        {
            "name": "Listen for Xdebug",
            "type": "php",
            "request": "launch",
            "port": 9003
        },
        {
            "name": "Launch currently open script",
            "type": "php",
            "request": "launch",
            "program": "${file}",
            "cwd": "${fileDirname}",
            "port": 0,
            "runtimeArgs": [
                "-dxdebug.start_with_request=yes"
            ],
            "env": {
                "XDEBUG_MODE": "debug,develop",
                "XDEBUG_CONFIG": "client_port=${port}"
            }
        },
        {
            "name": "Launch Built-in web server",
            "type": "php",
            "request": "launch",
            "runtimeArgs": [
                "-dxdebug.mode=debug",
                "-dxdebug.start_with_request=yes",
                "-S",
                "localhost:0"
            ],
            "program": "",
            "cwd": "${workspaceRoot}",
            "port": 9003,
            "serverReadyAction": {
                "pattern": "Development Server \\(http://localhost:([0-9]+)\\) started",
                "uriFormat": "http://localhost:%s",
                "action": "openExternally"
            }
        }
    ]
}

Para nossas necessidades atuais, basta selecionar a opção Listen for Xdebug para iniciar o processo de depuração, vamos fazer assim, crie um diretório na raiz do sistema e em seguida um arquivo index.php, como mostrado na imagem.

O diretório vendor e os arquivos composer.json e composer.lock aparecem quando instalamos dependências em nosso projeto, mas para seu exemplo não ligue para eles.

Em seu terminal navegue até o diretório que onde o arquivo index.php está localizado e basta rodar o seguinte comando para inicializar o servidor do PHP.

php -S localhost:8080

O resultado será esse aqui.

No navegador acesse por http://localhost:8080 e o resultado esperado deve ser.

Nosso sistema está rodando perfeitamente bem e sem nada relacionado a XAMPP, viu nem foi tão difícil assim, agora para fechar de fato essa parte, vamos testar no Xdebug. Aqui eu coloquei um breackpoint na linha 2 em seguida inicializamos o debug do VCcode e damos um F5 na pagina http://localhost:8080

Se para ti apareceu uma imagem semelhante a que temos acima, podemos ter certeza que nosso ambiente com servidor local de PHP e ferramenta de depuração estão prontos para desenvolvimento.

Usando o SQLite

Para incio de conversa precisamos fazer a instalação do sqllite, acessando o link, selecione a terceira opção.

Semelhante a instalação do PHP, criamos um diretório na raiz do sistema de nome sqlite em seguida descompacte os arquivos nesta pasta e agora basta editar o PATH e apresentar a rota do diretório C:\sqlite. Para validar se está tudo funcionando bem basta rodar o comando.

sqlite3

Precisamos agora fazer um ajuste em nosso php.ini para suportar o sqlite, então edite o arquivo para que fique com as extensões habilitadas como demonstrado a seguir.

extension=pdo_sqlite
extension=sqlite3

Agora vamos criar um "projeto" usando para demonstrar o funcionamento do PHP com um banco de dados, fizemos uso do SQLite pelo simples fato de que ele cria somente um arquivo onde fica toda a estrutura necessária para nossas chamadas SQL.

Nosso index.php vai ficar assim.

require __DIR__ . '/../vendor/autoload.php';

use Database\Config;
use Database\SQLiteConnection;

try {
    $connection = new SQLiteConnection(Config::PATH_TO_SQLITE_FILE);
    $pdo = $connection->openConnect();
    echo "Conectado com sucesso ao banco de dados SQLite.";
} catch (\PDOException $e) {
    echo "Erro de conexão: " . $e->getMessage();
} catch (\Exception $e) {
    echo "Erro: " . $e->getMessage();
}

O arquivo config.php será responsável por registrar a localização do arquivo do banco.

namespace Database;

class Config {


    const PATH_TO_SQLITE_FILE =  __DIR__ . '\db\phpsqlite.db';
}

E por ultimo o SQLiteConnection.php fica responsável por estabelecer a conexão de fato com o SQlite.

namespace Database;

use PDOException;

class SQLiteConnection {

    private $pdo;

    private $pathToSQLiteFile;

    public function __construct($pathToSQLiteFile) {
        if (!file_exists($pathToSQLiteFile)) {
            throw new \Exception("Arquivo de banco de dados não encontrado: " . $pathToSQLiteFile);
        }
        $this->pdo = new \PDO("sqlite:" . $pathToSQLiteFile);
        $this->pathToSQLiteFile = $pathToSQLiteFile;
    }

    public function openConnect() {
        try{
            if($this->pdo==null){
              $this->pdo = new \PDO("sqlite:" . $this->pathToSQLiteFile,"","",array(
                    \PDO::ATTR_PERSISTENT => true
                ));
            }
            return $this->pdo;
        }catch(PDOException $e){

            print "Error in open DB:  ".$e->getMessage();
        }
    }
    public function getPDO() {
        return $this->pdo;
    }
}

Antes de testar, vamos criar o arquivo para nosso banco de dados, tá mais para um tamborete de dados, navegue até o diretório de seu projeto e execute o comando.

sqlite3 database/db/phpsqlite.db

Agora no shell do SQLite vamos criar uma tabela de exemplo e assim é criado nosso arquivo de banco de dados.

CREATE TABLE example (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL
);

em seguida rode o comando.

.exit

Antes de fazer o nosso teste de conexão com o banco precisamos fazer o mapeamento de nossos aquivos via composer, para isso basta criar o arquivo composer.json na raiz do projeto ele deve ficar assim

{
    "autoload": {
        "psr-4": {
            "App\\": "public/",
            "Database\\": "database/"
        }
    }
}

composer  dump-autoload

Se tudo estiver ocorrido como o esperado, teremos a saída

Generating autoload files
Generated autoload files

depois disso essa será a organização de seu diretório.

agora finalmente chegamos ao fim, navegue até o diretório "C:\project-php\public" e execute o comando.

php -S localhost:8080

em seu navegador o resultado deve ser este:

Agora, você tem um ambiente de desenvolvimento devidamente configurado, para uma leitura complementar ficar o link do PHP do jeito certo.

Configurando WSL2 com Intellij

Wesley Gonçalves — Tue, 26 Sep 2023 23:25:04 +0000

Neste breve tutorial faremos uma configuração para instalação da IDE Intellij no WSL2 usando o Ubuntu-20.04, caso nunca tenha feito a instalação desta distro no seu WSL2 minha sugestão é começar Configurando o WSL com o Ubuntu.

Depois de ter realizado a configuração mencionada estaremos prontos para dar inicio, importante também enfatizar que esse tutorial foi inspirado pelo video instalando o Intellij dentro do wsl2 do canal CodaRAM.

Índice

Instalando uma interface gráfica no WSL
Instalando a IDE pelo JetBrains Toolbox App
Instalando o JAVA e o Maven
- Java
- Maven
Configurando o JAVA e o Maven no Intellij

Instalando uma interface gráfica no WSL

Sim, meu camarada é possível instalar uma interface gráfica para seu WSL2, fazemos isto rodando o comando.

sudo apt install nautilus -y

Instalando a IDE pelo JetBrains Toolbox App

Basicamente vamos baixar o toolbox APP e fazer a instalação no WSL2, o interessante aqui é que você pode ter todas a ferramentas deles dentro do WSl, mas neste caso estamos focados no JAVA, com já citado a ferramenta vai ficar instalada dentro do WSL então baixe o arquivo da extensão .tar.gz usando sua interface do windows encontre o diretório da distro.

Dentro do diretório da distro jogue onde quiser o arquivo, lembre que depois de descompactado e instalado ele não terá mais utilidade.

sudo tar -xzf <nome-do-arquivo>.tar.gz -C /opt

Feito isso agora temos o arquivo descompactado na pasta /opt navegue até esta pasta e encontre o diretório com mesmo nome do arquivo descompactado.

cd /opt

cd <nome-do-arquivo>

Neste diretório roda o comando para iniciar a instalação de fato do tool box.

./jetbrains-toolbox

Se tudo estiver saindo como o esperado teremos a seguinte tela.

No meu caso já tenho instalado o Intellij IDEA Community, mas posso atualiza-lo ou instalar qualquer outras ferramentas. Feito isso, temos que fazer nossa IDE ficar acessível para o windows usando os seguintes comandos.

navegamos até o diretório e executamos um ls

  cd ~/.local/share/applications
  ls

O resultado é algo parecido com as linhas apresentadas abaixo.

jetbrains-idea-ce-566a045c.desktop  
jetbrains-toolbox.desktop

Agora executamos o comando:

sudo cp *.desktop /usr/share/applications

Se tudo estiver certo temos a seguinte imagem aparecendo no seu menu do windows, permitindo abrir o Intellij Community de dentro do WSL2

Instalando o JAVA e o Maven

Para instalar o JAVA e o Maven no Linux Ubuntu é simples, inicialmente vamos executar os seguintes comandos.

Java

Para atualizar o sistema

sudo apt update

Instalando o JRE(Java Runtime Environment)

sudo apt install default-jre

Verificando se a instalação está correta

java -version

A resposta deve ser algo como

openjdk version "11.0.20.1" 2023-08-24

OpenJDK Runtime Environment (build 11.0.20.1+1-post-Ubuntu-0ubuntu120.04)

OpenJDK 64-Bit Server VM (build 11.0.20.1+1-post-Ubuntu-0ubuntu120.04, mixed mode, sharing)

Pronto, de maneira semelhante temos que vamos instalar o JDK(Java Development Kit)

sudo apt install default-jdk

Verificando se a instalação está correta

javac -version

E sua resposta deve ser:

javac 11.0.20.1

Maven

Observe que para o Maven fazemos também 3 passos

sudo apt install maven

Verificando se a instalação está correta

mvn -version

E sua resposta deve ser:

Apache Maven 3.6.3
Maven home: /usr/share/maven
Java version: 11.0.20.1, vendor: Ubuntu, runtime: /usr/lib/jvm/java-11-openjdk-amd64
Default locale: en, platform encoding: UTF-8
OS name: "linux", version: "5.15.90.1-microsoft-standard-wsl2", arch: "amd64", family: "unix"

Configurando o JAVA e o Maven no Intellij

Temos IDE, Linguagem de programação e gerenciador de pacotes em pleno funcionamento o que nos falta agora é fazer Nossa IDE reconhecer a localização do Java e do repositório do Maven o .M2

Com sua IDE aberta digite o comando Ctrl + Alt + s para abrir as configurações, procure por Build, Execution, Development > Build Tools > Maven e preencha os campos com os seguintes valores.

Maven home path: /usr/share/maven

User settings... /home/<seuUsuario>/.m2/settings.xml

Local repository... /home/<seuUsuario>/.m2/repository

Para terminar procure por Build, Execution, Development > Build Tools > Maven > Runner e no campo do JRE coloque

JRE: /usr/lib/jvm/java-1.11.0-openjdk-amd64

OBS: Pode ser que quando você precisar instalar novos pacotes do Maven a IDE tenha algum problema e não deixe realizar o update, para esse caso verifique qual usuário é dono da pasta no diretório do usuário usando o comando:

cd ~
ls -la

Se o diretório .m2 estiver com o usuário root então mude para o seu pelo comando:

sudo chown -R seuUsuario:seuUsuario .m2

Agora sua IDE consegue atualizar sem problemas.

Configurando Alpine Linux, tmux e neovim no WSL2 - parte 1

Wesley Gonçalves — Thu, 08 Jun 2023 19:14:24 +0000

Configurando o WSL2 com Alpine Linux

Neste tutorial usaremos a Alpine Linux dentro do WSL2, caso nunca tenha configurado o wsl2 em sua maquina deixo esse outro tutorial Configurando o WSL com o Ubuntu 22.04 + ZSH para que tenha por onde começar, aqui vou considerar que já tenha WSL2 funcionando plenamente em sua maquina.

Escolhi essa distro por querer uma distro diferente da minha principal o Manjaro Linux, que também tenho um tutorial de instalação e experimentar o famoso neovim como ferramenta de desenvolvimento.

Índice

Configurando o WSL2 com Alpine Linux
Índice
Instalando o Alpine Linux no WSL2
- Instalando o básico
- Criando um usuário não root
Nerd Fonts
- powerlevel10k
- plugins zsh
- zsh-autosuggestions
- zsh-syntax-highlighting
Docker
- Iniciando o docker
- ALIAS

Instalando o Alpine Linux no WSL2

Importante lembar que por padrão o Alpine Linux não é suportado pelo WSL2, por isso usaremos o de um projeto da yuk7 que criou um modelo simples e fácil de ser seguido ela tem projetos para as distros:

Aqui deixo o link com a lista das distros que fazem parte deste projeto usando wsl2 diferentes da base do Linux Ubuntu.

Seguindo as recomendações do link basta baixar o arquivo descompactar onde achar melhor, eu fiz no diretório raiz. Agora dentro da pasta descompactada execute o terminal como Administrador do sistema e execute o seguinte comando

.\ Alpine.exe

Feito isso o Alpine Linux será instalado no WSL2, agora feche o terminal e abrindo novamente você verá o sistema instalado, quando tiver feito isso estará logado como root do sistema e daqui a pouco resolvemos isso.

Instalando o básico

Uma coisa interesante sobre o alpine é que ele vem sem nada praticamente, precisamos instalar tudo e vamos ao comando pra isso, mas antes vou deixar a lista de comandos do alpine para que possa entender como manipular o sistema.

apk add zsh curl wget git htop nano doas neofetch

Nesse pacote de instalações estamos colocando o zsh que será nosso shell padrão do sistema, mas antes disso vamos criar nosso usuário nào root do sistema.

Criando um usuário não root

Precisamos criar o usuário com sua respectiva senha, vamos precisar conceder para ele o uso de comandos de root e para isso temos que instalar e configurar sudo e fazemos isso pelo comando.

apk add sudo 
NEWUSER='<username>' 
adduser -g "${NEWUSER}" $NEWUSER 
echo "$NEWUSER ALL=(ALL) ALL" > /etc/sudoers.d/$NEWUSER && chmod 0440 /etc/sudoers.d/ $NEWUSER

agora adicionamos nosso usuário ao grupo wheel pelo comando

echo '%wheel ALL=(ALL) ALL' > /etc/sudoers.d/wheel 
adduser NEWUSER wheel

Legal, mas ainda não estamos usando o zsh e toda vez que entramos no sistema estamos como root. Para corrigir isso precisamos primeiro editar nosso arquivo passwd

nano etc/passwd

do resultado apresentado só é importante a primeira e ultima linha como exemplo:

root:x:0:0:root:/root:/bin/ash
.
.
username:x:1000:1000:wesleyotio:/home/username:/bin/ash

agora só mudamos de /ash pra /zsh e salvamos o arquivo, feche o terminal e abra novamente. O zsh estará em pleno funcionamento. Agora execute o comando:

whoami

se sua resposta for root é pelo fato de que o alpine ainda não está configurado para iniciar a partir de seu usuário criado, para corrigir isso feche o terminal e execute novamente a pasta descompactada do alpine linux como administrador e nela execute o seguinte comando passando o nome do seu usuário

.\ Alpine.exe config --default-user <username>

agora quando iniciamos o sistema o comando whoami deve apresentar o nome de seu usuário.

Nerd Fonts

Antes de deixar nosso terminal bonito como fizemos no Configurando o WSL com o Ubuntu 22.04 + ZSH vamos instalar uma fonte do tipo nerd fonts, aqui deixo os links da que tenho usado para você baixar e instalar em seu sistema.

Feito isso agora abra novamente o terminal e em configurações -> padrões -> fonts selecione MesloLGS NF .

powerlevel10k

Tudo isso foi necessário para agora instalar o powerlevel10k que é um tema para o shell ZSH e deixar nosso terminal mais bonito e performático quando somado aos plugins. Eu sugiro que use a instalação manual que tem certeza de funcionar.
Fazendo uso da instalação manual usamos o comando.

git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ~/powerlevel10k
echo 'source ~/powerlevel10k/powerlevel10k.zsh-theme' >>~/.zshrc

Feche o terminal e abra novamente, assim você inicia a configuração do tema, siga as instruções e customize seu terminal da forma que mais te agrada. Caso queira mudar o estilo apresentado basta usar o comando.

  p10k configure

e fazer o processo novamente.

plugins zsh

Bonito o terminal já está, mas precisamos deixar performático e para isso vamos usar os seguintes plugins:

zsh-autosuggestions
zsh-syntax-highlighting

zsh-autosuggestions

Esse plugin é responsável por usar nosso histórico de comandos para sugerir qual proximo comando você deseja usar e autocompleta o comado quando usamos TAB ou seta direita. Para instalar executamos.

 git clone https://github.com/zsh-users/zsh-autosuggestions ~/.zsh/zsh-autosuggestions

Agora adicionamos os caminho do plugin em nosso arquivo /.zshrc

source ~/.zsh/zsh-autosuggestions/zsh-autosuggestions.zsh

Feche e abar novamente o terminal para usar o plugin

zsh-syntax-highlighting

Esse plugin é responsável dar realce/cores nos comandos, diretórios e arquivos no sistema no terminal.

sudo git clone https://github.com/zsh-users/zsh-syntax-highlighting.git
echo "source ${(q-)PWD}/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh" >> ${ZDOTDIR:-$HOME}/.zshrc

Para ativar o plugin em nosso Shell executamos o comando.

 source ./zsh-syntax-highlighting/zsh-syntax-highlighting.zsh

Docker

Agora vamos pra instalação que deu mais trabalho para realizar, vale lembrar que estou usando WSL2 com docker nativo rodando na própria distro linux. Então caso seja usuário do docker desktop acho que este passo não seja necessário. Esses dois artigos aqui me ajudaram muito nessa configuração.

Inicialmente atualizamos o sistema pelo comando

sudo apk upgrade -U

agora instalamos o docker

sudo apk add docker

feito isso vamos adicionar nosso usuário ao grupo docker para não ser necessário usar sudo docker toda vez que quisermos usa-lo

sudo addgroup $USER docker

precisamos definir um ID para nosso grupo docker que deve ser um valor acima de 1000 e menor que 65534, para ver quais ids já estão atribuídos a grupos use o comando.

getent group | cut -d: -f3 | grep -E '^[0-9]{4}' | sort -g

escolhido o ID agora podemos atribuir ao grupo docker de duas maneiras usando o comando.

sudo sed -i -e 's/^\(docker:x\):[^:]\+/\1:<ID>/' /etc/group

ou caso tenha instalado o shadow

sudo apk add shadow
sudo groupmod -g <ID> docker

Pronto temos o docker instalado em sua distro

Iniciando o docker

No alpine Linux foi bem tenso até encontrar uma configuração que fizesse isso funcionar corretamente, foi aí que encontrei o comando que adiciona o serviço do docker a execução padrão

rc-update add docker default

Agora para iniciar o docker temos que fazer o comando

sudo openrc default

para finalizar a execução do docker usamos o mesmo comando do ubuntu

 sudo service docker stop

se desejar iniciar novamente usamos o mesmo comando do ubuntu também

 sudo service docker start

o problema é que para executar o serviço pela primeira vez somos obrigados a usar o sudo openrc default a solução para esse impasse é usar ALIAS

ALIAS

Alias são apelidos que damos aos nossos comando de terminal com objetivo de torna-los mais simples e para isso precisamos editar o nosso arquivo .zshrc ou criar um arquivo .zshrc_aliases em separado somente com seus alias. Vou optar pela segunda opção pois em uma nova instalação do sistema teremos somente que referenciar o arquivo novamente.

Iniciemos editando nosso arquivo .zshrc

sudo  nano ~/.zshrc

nesse arquivo vamos adicionar o caminho, caso exista, para nosso arquivo de aliases

if [ -f ~/.zshrc_aliases ]; then
      . ~/.zshrc_aliases
fi

agora vamos criar nosso aquivo de aliases e adicionar nossos apelidos

sudo nano ~/.zshrc_aliases

Meu arquivo ficou assim, defini docker-init para toda vez que iniciar os sistema e precisar ligar o docker

#Config for Docker
alias docker-init='sudo openrc default'
alias docker-start='sudo service docker start'
alias docker-stop='sudo service docker stop'

agora para garantir o funcionamento usamos o comando source para recarregar nossos arquivos

source ~/.zshrc_aliases
source ~/.zshrc

para realizar a testagem basta executar

docker-init
docker run --rm hello-world

Se sua saída obtiver o Hello from dorcker! sua configuração está completa. Na parte 2 realizaremos a configuração do Tmux e neovim

Xdebug em Docker usando VScode

Wesley Gonçalves — Tue, 02 May 2023 01:25:08 +0000

Configurando Xdebug em containers Docker

Realizar debugs em código PHP pode ser uma tarefa ardua muitas vezes, mas ferramentas como o Xdebug podem tornar esse trabalho mais fácil uma vez que permite realizar o monitoramento da aplicação durante o desenvolvimento diminuindo a propagação de erros para a produção.

Indice

DockerFile e docker-compose
VsCode
Logs

DockerFile e docker-compose

Inicialmente é importante entender a nossa estrutura dentro do diretório .docker, nele temos os arquivos e configuração do servidor web(NGIN-X), banco de dados(MySQL) e do PHP. Esses arquivos serão copiados para dentro dos containers da aplicação.
## PHP
Aqui temos a configuração necessária para habilitar o Xdebug no container.

    [xdebug]
    ; zend_extension=/usr/local/lib/php/extensions/no-debug-non-zts-20210902/xdebug.so //instala a extensão caso o docker não funcione
    xdebug.mode=debug // modo de execusão do xdebug
    xdebug.start_with_request=trigger // faz o rastreamento de função, depuração e coleta de estatísticas de lixo. 
    xdebug.idekey=VSCODE // id para identificar nossa aplicação   
    xdebug.client_host=host.docker.internal // conecta nosso host ao host do docker
    xdebug.log=/var/www/storage/logs/xdebug.log // salva os logs durante a execução 
    xdebug.client_port=9003 // porta usada para transmissão das informações

Como o parâmetro xdebug.start_with_request está como trigger ela precisa da extensão Xdebug helper no navegador para que toda Url acessada dispare o monitoramento do xdebug. Também é necessário configurar no Xdebug helper uma chave que identifica a IDE que estamos utilizando. Ao selecionar as preferências sua chave deve ser a mesma que está escrita em xdebug.idekey você encontrará a seguinte imagem.

Docker-compose

Em seu arquivo com docker-compose.yml garanta que o serviço que esteja rodando o PHP tenha essa configuração.

extra_hosts:
      - "host.docker.internal:host-gateway"

Isso dá a certeza que seu host do sistema tenha acesso ao que é processado nos containers, essas informações estarão disponíveis para consulta em sua IDE.

VsCode

Agora no VScode precisamos habilitar a extensão PHP Xdebug quando for executada pela primeira vez ela irá criar um diretório de nome .vscode e dentro dele um arquivo de nome launch.json é neste arquivo que é dado o caminho das pedras para o vscode acessar as informações/logs gerados pelo Xdebug

"configurations": [

   {
      "name": "Listen for Xdebug",
      "type":"php",
      "request": "launch",
      "hostname": "0.0.0.0", //aqui temos a garantia de estamos acessando o docker da aplicação
      "log": true,
      "port": 9003, // a mesma definida no xdebug.client_port
      "pathMappings": {
            "/var/www" : "${workspaceFolder}" //rota onde nosso projeto se encontra dentro do container  

      },
      "xdebugSettings": {
            "max_children": 10000,
            "max_data": 10000,
            "show_hidden": 1
      }
   }
]

Con toda essa estrutura montada agora temos que testar se nossa configuração funciona, para isso criamos um diretório de nome public com um arquivo ***index.php e dentro dele o seguinte código.

 phpinfo();exit;

Ao rodar seu projeto no local você terá todas as informações sobre o comportamento do xdebug como mostrado na imagem a seguir.

Se nenhuma mensagem de erro dentro de diagnostic log for apresentada então sua configuração de completa e agora pode se garantir debugando seu projeto.

Logs

Criamos também diretórios de nome storage/logs somente com o objetivo de armazenar todos os logs criados pelo xdebug durante o processo de debug.

Algumas referências

Configurando o WSL com o Ubuntu 22.04 + ZSH

Wesley Gonçalves — Sat, 18 Feb 2023 20:27:23 +0000

O WSL é uma excelente alternativa para desenvolvedores que querem possuir todas as vantagens do Windows e ainda manter toda a produtividade que o ambiente Linux pode oferecer.

Esta postagem é uma versão customizada do artigo da Fullcycle que está nesse link: Guia rápido do WSL2 + Docker.

Também vou deixar o aqui os videos do youtube e postagens que me ajudaram a fazer esta configuração.

Índice

Configurando o WSL com o Ubuntu 22.04 + ZSH
Índice
Instalando o WSL2
- Para Windows 11
- Para Windows 10
- Configuração de recursos de maquina no WSL
Escolhendo uma distro Linux
Usando docker nativo
Habilitando o VScode
ZSH
- Nerds Fonts
- powerlevel10k
- plugins zsh
- zsh-autosuggestions
- zsh-syntax-highlighting

Instalando o WSL2

Antes de iniciar a instalação do WSL2 propriamente dita acredito que valha muito a pena instalar antes o windows terminal por ser um emulador de terminal melhorar muito nossa produtividade alem de ser altamente customizável. Pode ser encontrado diretamente na Microsoft Store procurando por windows terminal, também será mostrado o windows terminal preview que é a versão beta que recebe as atualizações mais recentes.

Agora que temos o windows terminal instalado podemos executa-lo em modo administrador, de acordo com a documentação mais atualizada, você deve rodar o comando.

Para Windows 11

wsl --install

O processo pode ser um pouco demorado e por padrão no windows 11 a distro Ubuntu é instalada, para especificar qual distro você deseja instalar primeiro precisa listar as disponíveis usando o comando:

wsl --list --online

E o resultado apresentado no terminal será este:

 NAME               FRIENDLY NAME
Ubuntu             Ubuntu
Debian             Debian GNU/Linux
kali-linux         Kali Linux Rolling
SLES-12            SUSE Linux Enterprise Server v12
SLES-15            SUSE Linux Enterprise Server v15
Ubuntu-18.04       Ubuntu 18.04 LTS
Ubuntu-20.04       Ubuntu 20.04 LTS
Ubuntu-22.04       Ubuntu 22.04 LTS
OracleLinux_8_5    Oracle Linux 8.5
OracleLinux_7_9    Oracle Linux 7.9

Escolhida a distro executamos o comando com o nome igual ao apresentado na lista acima.

 wsl --install -d Ubuntu-22.04

Para Windows 10

Aqui as etapas mudam um pouco, inicialmente vamos rodar o seguinte comando para habilitar o WSL, sempre em modo administrador

 dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart

Em seguida habilitamos a virtualização

dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart

Em seguida reiniciamos o sistema.

Agora precisamos baixar o pacote de atualização do kernel do linux e executa-lo. Com a instalação concluída com sucesso vamos tornar a versão do WSL2 como a padrão.

wsl --set-default-version 2

Configuração de recursos de maquina no WSL

Em termos de recurso o WSL é um lobo feroz, podendo consumir por padrão os seguintes números.

Quase totalmente o processamento disponível
80% da memória RAM
25% do SWAP

Para limitar esse consumo basta criar o arquivo .wslconfig em sua pasta raiz do usuário C:\Users\nameuser como demostrado a seguir.

[wsl2]
memory=3GB
processors=4
swap=4GB

Escolhendo uma distro Linux

Abra a Microsoft store e escolha sua distro.

Selecione a que mais te agradar clique em instalar, nesse caso selecionaremos a 22.04 LTS

Terminada a instalação da distro ao inicia-la teremos a seguinte imagem solicitando a criação de um usuário para o sistema. Com isso temos certeza que nosso WSL2 está funcionando plenamente.

Com sua conta criada com sucesso está será sua visualização, agora oficialmente você é um usuário do Linux no Windows. Parabéns!!!

PS: Caso nenhuma das distro apresentadas seja do seu agrado é possível instalar qualquer distro, mas como o foco aqui é no Ubuntu deixo somente o link para quem quiser se aventurar. Importar qualquer distribuição do Linux a ser usada com o WSL

Usando docker nativo

Além de reduzir o consumo de recursos drasticamente em relação ao docker desktop temos o controle total dentro do Linux não dependendo de um terceiro. Neste link é explicado como fazer a instalação em outras distros Linux fora o Ubuntu.

Inicialmente temos que remover todas as versões antigas, mas isso é só mais uma garantia do que uma necessidade uma vez que estamos instalando o sistema

sudo apt-get remove docker docker-engine docker.io containerd runc

No meu caso a saída foi essa pois a distro já tinha docker e docker-engine instaladas.

Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
Package 'docker.io' is not installed, so not removed
E: Unable to locate package docker
E: Unable to locate package docker-engine

Agora faremos a atualização do sistema seguida da ativação dos pacotes com HTTPS.

sudo apt-get update
sudo apt-get install \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

Concluída essa etapa vamos habilitar o docker para uso no Ubuntu

sudo mkdir -m 0755 -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Para configurar o repositório usamos o comando.

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Rodamos a atualização mais uma vez.

sudo apt-get update

Estamos quase lá, só falta realizar a instalação do pacote de fato usando comando.

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

Deu certo! agora você possui o docker instalado, precisamos habilitar nosso usuário para a ferramenta.

sudo usermod -aG docker $USER

Agora ligamos o docker usando o comando

sudo service docker start

OBS: sempre use o comando acima para iniciar/ligar o docker no wsl.

E testamos usando o comando de hello world do docker

sudo docker run hello-world

Habilitando o VScode

Eu vou admitir que esteja usando o VScode, mas caso esteja usando outra IDE vou deixar o link do tutorial da fullcycle que explica como fazer isso, show! No VScode basta realizar a instalação do pacote de extensões Remote Development, feito isso você verá o ícone do pacote no canto inferior esquerdo do VScode, clicando lá essa será a imagem.

Selecione a segunda opção para selecionar em qual distro instalada no WSL deseja que o VScode seja usada e pronto agora temos a IDE funcionado dentro do Linux via WSL2. E agora no canto inferior esquerdo temos indicando nossa distro instalada como no exemplo da imagem abaixo.

OBS: Para abrir a IDE no WSL basta dar o comando

code .

E na primeira vez que fizer isso ele fara um download e instalação da versão mais recente, também é importante mencionar que algumas de suas extensões terão que ser instaladas novamente.

ZSH

Por padrão temos o bash como shell instalado no ubuntu, mas para caso queira listar todos os shells disponíveis basta usar o comando.

sudo cat /etc/shells

O resultado é uma saída como essa.

# /etc/shells: valid login shells
/bin/sh
/bin/bash
/usr/bin/bash
/bin/rbash
/usr/bin/rbash
/bin/dash
/usr/bin/dash
/usr/bin/tmux
/usr/bin/screen

Iniciamos atualizando o sistema

sudo apt update

Feito isso fazemos a instalação do zsh pelo comando

sudo apt install zsh -y

OBS: o “-y” no final do comando é para não ter confirmação antes da instalação.

Para verificar a versão instalada usamos o comando.

zsh --version

Antes de definir o zsh como shell padrão temos que saber onde o arquivo binário se encontra usando o comando.

whereis zsh

Essa é a saída apresentada.

zsh: /usr/bin/zsh /usr/lib/x86_64-linux-gnu/zsh /etc/zsh /usr/share/zsh /usr/share/man/man1/zsh.1.gz

Pronto agora que temos o caminho basta executar

sudo usermod -s /usr/bin/zsh $(whoami)

Feito isso, feche o terminal e abra novamente e para ter certeza que está usando o ZSH execute.

echo $SHELL

Sua saída será o caminho do binário do shell padrão, no nosso caso.

/usr/bin/zsh

Nerds Fonts

Antes de seguir com nossa configuração precisamos instalar uma fonte do tipo nerd fonts que nada mais são fonts que possuem ícones incorporados, então vamos fazer o download de uma delas.

Feito isso agora instale as fontes e feche e abra novamente o terminal e em configurações -> padrões -> fonts selecione MesloLGS NF. Nas configurações do vscode escreva terminal.integrated.fontFamily e selecione a mesma fonte.

O terminal integrado do VScode que roda no WSL não vai reconhecer essa font, pois a IDE está rodando no linux e a font está somente no windows, para corrigir isso vamos fazer assim.

Criamos a pasta onde nossa font vão ficar.

 sudo mkdir  /usr/share/fonts/meslolgsnf

Agora copiamos nossas fonts para este diretório, mas para localizar nossas fonts baixadas no windows a partir do wsl fazemos acesso ao diretório /mnt/c que nada mais é do que nosso disco C:/ visto a partir do Linux. Basta agora navegar pelos diretórios até onde fica os arquivos das fonts, no meu caso ficou assim.

  cd /mnt/c/Users/<nome_usuario>/Downloads

Agora copiamos cada uma das fonts pelo comando

   sudo cp MesloLGS\ NF\ Italic.ttf /usr/share/fonts/meslolgsnf

Tudo isso foi necessário para agora instalar o powerlevel10k que é um tema para o shell ZSH e deixar nosso terminal mais bonito e performático quando somado aos plugins.

powerlevel10k

Fazendo uso da instalação manual usamos o comando.

  git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ~/powerlevel10k
echo 'source ~/powerlevel10k/powerlevel10k.zsh-theme' >>~/.zshrc

  p10k configure

e fazer o processo novamente.

plugins zsh

Bonito o terminal já está, mas precisamos deixar performático, pra isso vamos usar os seguintes plugins:

zsh-autosuggestions
zsh-syntax-highlighting

zsh-autosuggestions

Esse plugin é responsável por usar nosso histórico de comandos para sugerir qual próximo comando você deseja usar e auto completa o comado quando usamos TAB ou seta direita. Para instalar executamos.

 git clone https://github.com/zsh-users/zsh-autosuggestions ~/.zsh/zsh-autosuggestions

Agora adicionamos os caminho do plugin em nosso arquivo /.zshrc

source ~/.zsh/zsh-autosuggestions/zsh-autosuggestions.zsh

Feche e abar novamente o terminal para usar o plugin

zsh-syntax-highlighting

Esse plugin é responsável dar realce/cores nos comandos, diretórios e arquivos no sistema no terminal.

sudo git clone https://github.com/zsh-users/zsh-syntax-highlighting.git
echo "source ${(q-)PWD}/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh" >> ${ZDOTDIR:-$HOME}/.zshrc

Para ativar o plugin em nosso Shell executamos o comando.

 source ./zsh-syntax-highlighting/zsh-syntax-highlighting.zsh

E é isso seu ambiente está totalmente pronto! Boa sorte!

Uma abordagem para o Laravel Horizon

Wesley Gonçalves — Fri, 20 Jan 2023 02:39:50 +0000

Se sua aplicação Laravel faz uso de filas e do redis, acrescentar o Laravel Horizon pode ser uma opção interessante para trazer mais performasse e melhorar o gerenciamento dos jobs processados em sua aplicação.

OBS: Nesta abordagem fizemos uso do Laravel 6.0 e Horizon 3.7.2

Dividir para conquistar

Ninguém melhor que você para saber quais filas possuem um maior fluxo de entrada e quais possuem maior processamento, mas caso não tenha essa informação isso é só mais um motivo para usar o horizon, uma vez que ele gera métricas que são apresentadas em um dashboard simples e intuitivo.

Para tirar o máximo de proveito do balanceamento do horizon é necessário agrupar suas filas da melhor forma possível, caso ainda não tenha entendido bem como esse balanceamento funciona sugiro que leia esse artigo do Zechariah Campbell que explica de maneira bem detalhada.

Acredito que o auto balanceamento seja o modelo ideal para sistemas em que as filas tem picos de processamento em certos momentos do dia, assim mais processos são destinados para a fila com mais jobs em espera afim de zera ou deixa o número de jobs em espera próximo aos das demais filas.

Por padrão nosso arquivo config/horizon.php o array de environments tem um formato semelhante ao da imagem a seguir.

Se por exemplo as filas books e images consomem muito tempo de processamento e possuem 500 jobs em espera e as demais filas estão zeradas, ambas terão mais processos para despacharem seus jobs. Em um dado momento a fila import, que consome pouco tempo de processamento, tem um pico e fica com 3000 jobs em espera, neste momento parte dos processos sao descolocados para import afim de reduzi-la o quanto antes.

O problema na situação é que o balanceamento tornará a execução das filas books e images mais lento ainda por ter que deslocar processos para a fila import. Para resolver isso devemos dividir nosso supervisor-1 em dois, um responsável por executar os jobs das filas com tempo de processamento e quantidade elementos em espera menor e outro com as filas de maior tempo de processamento e quantidades de jobs em espera, como mostrado na imagem a seguir.

Nesse novo modelo as filas default, mail e import terão pelo menos um processo cada e a soma de todos os processos em todas as filas é de no máximo quatro, aqui também definimos o timeout para estas filas que é de 240 segundos com tolerância de 3 tentativas antes de falha. Essa estrutura garante que o balanceamento irá distribuir os processos disponíveis, de acordo com a necessidade, somente as filas descritas.

As demais filas terão mais processos disponíveis com maior timeout, evitando que o balanceamento tire processos de quem já não tem tanto processamento e as filas tenham muitos jobs em estado espera comprometendo o funcionamento da aplicação.

Definindo o a conexão com o Redis

O arquivo queue.php é responsável por definir como o dever ser a conexão do banco de dados com as filas no Laravel, neste arquivo definimos como o Redis deve se conectar as filas monitoradas no Horizon, o arquivo terá o seguinte formato. Observe que no paramentro retry_after defini quanto tempo a conexão ficará aberta.

'connections' => [
    //outras conexões
    'redis' => [
            'driver' => 'redis',
            'connection' => 'default',
            'queue'  => 'default',
            'retry_after' => 600,
        ],
],

O poder das tags

De todas a vantagens apresentadas pelo uso do Laravel Horizon, para mim a melhor de todas é o uso de tags de monitoramento. Com elas podemos supervisionar a fila, o job e o model que foram executados permitindo saber qual teve sucesso ou falha, numero de execuções e a qual fila pertence aquele job.

Por padrão o Horizon atribui uma tag para cada job que recebe um model, por exemplo se temos a fila import que é responsável por adicionar novos livros ao sistema, para cada livro inserido na fila o cria a seguinte tag 'App/Book:id' onde id indica o índice do livro em sua tabela no banco de dados.

Essa comportamento tem seu valor, mas somente em sistemas onde toda fila recebe um model especifico, para casos mais complexos eu prefiro criar tags manualmente, pois assim é possível ter uma visão ampla do funcionamento das filas/jobs e encontrar falhas em um curto prazo.

Uma abordagem para tags

Para criar tags manualmente em cada job você deve criar uma função publica de nome tags que deve retornar um array de strings, isso mesmo um job pode possuir uma ou mais tags, tornando sua busca mais ampla.

Imagine que em um sistema de biblioteca exista um job de nome SendReturnAlert responsável por enviar um email de alerta pra que os usuários que tenham que devolver livros nos próximos 3 dias sua função construtora teria o seguinte formato.

public function __construct(int $userId, int $bookId) {

    $this->userId = $userId;
    $this->bookId = $bookId;
}

O padrão que uso no array de tags é colocar o nome do job como primeiro elemento seguido dos ids dos models associados e colocar nome da fila que job é processado por ultimo, para este exemplo teremos o seguinte resultado.

public function tags() {
    return ['SendReturnAlert','User:'. $this->userId,'Book:'. $this->bookId, 'default'];
}

A partir de agora dentro do Horizon podemos pesquisar jobs processados com exito ou não que tenham sua origem no job SendReturnAlert, no usuário, no livro ou na fila. Assim em caso de falha podemos identificar se problema tem origem na escrita do job, em algum dado do usuário, em alguma informação do livro ou na fila.

Usando commands

Em muitas situações precisamos reprocessar jobs falhados, na própria interface do laravel horizon é possível fazer a ação manualmente, o que não é muito viável, mas pode resolver casos muito pontuais. Uma abordagem um pouco mais pratica e de fácil implementação é criar um Command que acesse todos os jobs falhados e faça o reprocessamento.

Algo que não foi mencionado aqui e precisa ser explicado é quanto a persistência dos dados armazenado no horizon, no arquivo config/horizon.php quanto tempos ficará arquivado os jobs recentes, completados, falhados recentemente, falhados e monitorados. Temos a seguinte configuração padrão do sistema.

'trim' => [
    'recent' => 60,
    'completed' => 60,
    'recent_failed' => 10080,
    'failed' => 10080,
    'monitored' => 10080,
],

O número aqui representa a duração em minutos e pode ser customizado de acordo com a necessidade de sua aplicação, mas é importante que você saiba que quanto maior for esse valor, maior será o tamanho ocupado pelo disco do redis. Em casos estouro o horizon para de funcionar imediatamente comprometendo todo o funcionamento das filas e consequentemente da aplicação.

Com o command criado mudamos sua assinatura para receber como parâmetro opcional o nome do job que queremos reprocessar, assim quando executamos o command sem ele todos os jobs falhados serão reprocessados. Essa versão foi criada a partir do post do Kodeas

 protected $signature = 'horizon:retry-failed-jobs {jobName?}';

Em nossa função construtora recebemos JobRepository como parâmetro, que nada mais é que a interface criada pelo Laravel Horizon para acessar todas as informações dos jobs processados por Horizon, este é o resultado.

public function __construct(JobRepository $jobs) {
    parent::__construct();
    $this->jobs = $jobs;
}

Fazendo uso da interface obtemos o array de todos os jobs falhados e a partir daí podemos ter informações especificas de cada job como seu id, nome, fila que foi processado, data que foi falhado. Fica a seu critério escolher filtrar os jobs, aqui fiz preferencia por nome caso seja passado como parâmetro.

Também fazemos uso da classe RetryFailedJob para reprocessar o job falhado a partir de seu id e da função deleteFailed para remover o job falhado como demonstrado no código a seguir.

public function handle() {
    $jobName = $this->argument('jobName');

    $failedJobs = $this->jobs->getFailed();


    if($jobName != NULL) {
        foreach ($failedJobs as $failedJob) {

            if (preg_match("/$jobName/i", $failedJob->name) ) {

                $id = $failedJob->id;
                dispatch(new RetryFailedJob($id));
                $this->jobs->deleteFailed($id);
            } 
        }
    } else {
        foreach ($failedJobs as $failedJob) {

            $id = $failedJob->id;
            dispatch(new RetryFailedJob($id));
            $this->jobs->deleteFailed($id);        
        }

    }
}

Configurando o Manjaro Linux

Wesley Gonçalves — Wed, 12 Oct 2022 21:46:10 +0000

Guia de configuração para distro Manjaro

Atualmente estou utilizando esta distro e para auxiliar desenvolvedores, inclusive eu, na configuração deste ambiente e pra você que achou isso perdido na internet e não quer perder tempo segue o índice pra pular pro que realmente importa. 👇

Índice

Instalação do S.O
- Site oficial
- Xfce,KDE,Gnome...
- Usando o Rufus
- Instalando o manjaro
- Pos-instalação do manjaro
Conhecendo os gerenciadores de pacotes
- Pacman
- Yay
Configurando o terminal e o VScode
- Zsh
- Oh-my-zsh
- plugins
- Vscode
Extras

Instalação do S.O

Acessando o site oficial do manjaro você poderá escolher qual das interfaces gráficas do S.O deseja utilizar, para a maquina que configurei estou usando XFCE, mas o sistema possui tres oficiais XFCE,KDE e Gnome.

Se você preferir existem varias opções desenvolvidas pela própria comunidade escolha a que melhor te agrada.

Escolhida sua interface agora vamos baixar a ISO diretamente ou via torrent caso sua internet seja muito lenta. Download concluído é hora de usar um programa para deixar nosso pendrive bootável, se estiver usando Windows eu aconselho usar o rufus por ser muito simples e rápido.

Como o objetivo desse manual não é focar na instalação e configuração inicial do S.O vai aqui dois videos do canal Diolinux que mostra a instalação e apresentação inicial do sistema.

Gerenciadores de pacotes

Vou supor que tenha visto os videos acima e agora vou tentar explicar como funcionam os gerenciadores de pacotes do Manjaro.

Pacman

Aqui vou somente apresentar como é usado para esta configuração, mas vou deixar aqui o link para você ler e entender melhor o funcionamento deste gerenciador, segue alguns exemplos.

Para mostra a lista de opções.

 pacman --help

Temos como resultado estes comandos.

uso:  pacman <operação> [...]
operações:
    pacman {-h --help}
    pacman {-V --version}
    pacman {-D --database} <opções> <pacote(s)>
    pacman {-F --files}    [opções] [arquivo(s)]
    pacman {-Q --query}    [opções] [pacote(s)]
    pacman {-R --remove}   [opções] <pacote(s)>
    pacman {-S --sync}     [opções] [pacote(s)]
    pacman {-T --deptest}  [opções] [pacote(s)]
    pacman {-U --upgrade}  [opções] <arquivo(s)>

Para detalhar cada opção basta fazer como o exemplo.

 pacman -S --help

Instalando um pacote.

 pacman -S nome_do_pacote

Se quisermos a versão mais atualizada do discord este será o comando.

 pacman -Syu discord

Neste ponto vale a pena explicar o que cada flag realiza

-S: Instalar
-y: Baixa os pacotes novos do servidor
-u atualiza os pacotes instalados.

No caso este pacote já se encontra atualizado em sua versão mais recente e aqui é solicitado reinstalação, como mostrado na figura a seguir.

Yay

Até onde eu vi a principal diferença entre o pacman e Yay se deve ao fato de de yay conseguir fazer a instalação de pacotes oficiais da distro quanto de pacotes da comunidade chamados de AUR, mais uma vez segue o link do projeto e a seguir os passos.

 pacman -S --needed git base-devel

É uma boa usar a pasta /tmp somente para baixar o bin para instalação pois posteriormente esse arquivo sâo será mais usado.

 cd /tmp
 git clone https://aur.archlinux.org/yay.git

Agora entramos na pasta do projeto e executamos o comando de instalação

 cd yay
 makepkg -si

Com a instalação concluída pode usar mesma sintaxe do pacman que funciona de boas.

Configurando o terminal e o VScode

Agora chegamos na parte mais legal e que me deu mais trabalho até agora. A ideia é deixa nosso terminal mais "bonitinho" com algumas informações relevantes e bem performático. Para isso vamos começar instalando o zsh.

Primeiro verificamos qual o SHELL estamos usando no momento.

echo $SHELL

provavelmente essa será sua resposta

/usr/bin/bash

Isso indica que nosso SHELL padrão é o bash, agora vamos instalar o zsh usando pacman ou yay você que escolhe.

sudo yay -S zsh

Feito isso, voce pode nota que o zsh não é iniciado imediatamente para isso precisamos torna-lo nosso SHELL padrão, mas antes vamos listas todos os SHELLs instalados na maquina.

chsh -l

Teremos alguma resposta semelhante a esta.

/bin/sh
/bin/bash
/bin/zsh
/usr/bin/zsh
/usr/bin/git-shell

E por fim usamos o comando.

chsh -s caminho_do_shell_escolhido

Agora que temos o zsh instalado vamos deixa-lo "bonitinho", pra isso precisamos de fontes que suportem ícones. Eu uso a MesloLGS

Com as fontes baixadas agora vc deve criar um diretório com essa fonte no diretório de fontes do sistema.

sudo mkdir meslolgs /usr/share/fonts

Agora no diretório onde se encontram as fonts basta copiar para a pasta recém criada

cp nome_fonte /usr/share/fonts/meslolgs

OBS: Os emojis não são apresentados corretamente nesta distro, para corrigir isso basta executar o seguinte comando no terminal

yay -S noto-fonts-emoji

Verifique se a fonte está ativa procurando por ela em qualquer editor de texto, você provavelmente verá algo como a imagem a seguir.

Agora damos inicio a instalação do framework que gerencia as configurações do Zsh o famoso Oh-My-Zsh aqui também deixo o link de um dos artigos que me ajudaram a fazer essa configuração.

OBS: O comando a seguir só ira funcionar se antes você possui o git e o wget instalados, caso não tenha use estes scripts.

sudo yay -Syu
sudo yay -S git
sudo yay -S wget

Para verificar se tudo deu certo mesmo basta averiguar as versões dos pacotes instalados.

git --version
wget --version

Para realizar a instalação basta executar o script

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

Agora vamos a instalacao dos plugins que tornarão nosso zsh realmente poderoso.

zsh-z

Permite que consultemos rapidamente diretórios acessados com frequência ou recentemente.

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

zsh-autosuggestions

Tendo como base nosso historico de uso do terminal esse plugin sugere qual comando estamos querendo executar e com um seta direita ele escreve o comando.

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

zsh-syntax-highlighting

Torna o terminal interativo permitindo destaque aos comandos executados pelo Zsh enquanto eles são digitados

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

Agora com nossos plugins instalados precisamos ativa-los, para isso precisamos editar o arquivo de configuração do Oh-my-zsh.

nano ~/.zshrc

Basta adicionar o nome dos plugins instalados, salvar e reiniciar o terminal. O seu deve ficar assim.

plugins=(
  git

  zsh-z

  zsh-autosuggestions

  zsh-syntax-highlighting

  )

Para finalizarmos a instalação do terminal vamos instalar e configurar o powerlevel10k

git clone https://github.com/romkatv/powerlevel10k.git $ZSH_CUSTOM/themes/powerlevel10k

Editamos novamente arquivo de configuração do Oh-my-zsh.

nano ~/.zshrc

E alteramos o valor da linha ZSH_THEME

ZSH_THEME="powerlevel10k/powerlevel10k"

Ao reiniciarmos o terminal o powerlevl10k pede que você configure sua aparência, nesse momento se você não possuir nenhuma Nerd Fonts instalada os ícones não serão reconhecidos no sistema.
Quando desejar mudar novamente a aparência do tema execute o script.

 p10k configure

Agora seguimos para a instalação do VScode, vamos usar nesse caso novamente o o gerenciador de pacotes yay, pois o pacote usado pertence a comunidade do AUR do Arch linux a instalação é semelhante ao a do yay.

cd /tmp
git clone https://aur.archlinux.org/visual-studio-code-bin.git
cd visual-studio-code-bin
makepkg -si

Agora temos o VScode instalado, mas nosso terminal integrado está reconhecendo nossas fontes então precisamos configurar isso. Então em configurações digite terminal.fontfamily você verá a fonte usada no momento, basta mudar para nossa fonte baixada e seu ambiente está pronto.

Extras

A partir daqui segue as configurações/aplicações que fazem parte de minha rotina.

Docker

Aqui eu usei o pacman mas deixo o link pra quem quiser usar o yay.

Instalação

sudo pacman -S docker
sudo pacman -S docker-compose

Para inicializar ou desligar use

sudo systemctl start docker.service
sudo systemctl stop docker.service

Use esse comando para verificar o docker está ativo.

docker ps

Caso queria iniciar o docker junto com sua maquina sempre use.

sudo systemctl enable docker.service

OpenVPN

Este tópico foi criado para demonstrar um caso especifico onde a conexão com a VPN acontece, mas o usuário perde o acesso a internet.

Antes de iniciar, instale os softwares openvpn e NetworkManager-OpenVPN pelo pacman ou yay pelo comando

yay -S networkmanager-openvpn

yay -S openvpn

Pronto, a partir de agora vou considerar que possui um arquivo de configuração da vpn myvpn.ovpn junto de um usuário e senha.
Copie o arquivo de configuração para o diretório da mostrado pelo comando.

sudo cp /caminho/para/o/arquivo/myvpn.opvpn /etc/openvpn/

Agora edit o arquivo usando o nano

sudo nano /etc/openvpn/myvpn.opvpn

edit a linha que contêm auth-user-pass para ficar assim.

auth-user-pass /etc/openvpn/mycredentials.txt

em seguida crie o arquivo no diretório especificado no comando anterior e coloque seu usuário e senha

user
password

Pronto, agora use o seguinte comando para testar sua conexão

sudo openvpn /etc/openvpn/myconfig.opvpn

Feito isso observe se consegue ter conexão com a internet, se sim então seu arquivo de configuração está correto e você poderá fazer também na interface gráfica. Caso o acesso a internet não esteja funcionando observe se sua saída tem algo parecido como esse apresentado.

2023-03-26 00:37:20 [NEW-OPENVPN] Peer Connection Initiated with [AF_INET]10.10.10.10:1194
2023-03-26 00:37:24 Options error: Cannot set comp-lzo to 'yes', allow-compression is set to 'no'
2023-03-26 00:37:24 TUN/TAP device tun0 opened
2023-03-26 00:37:24 net_iface_mtu_set: mtu 1500 for tun0
2023-03-26 00:37:24 net_iface_up: set tun0 up
2023-03-26 00:37:24 net_addr_v4_add: 15.15.18.2/24 dev tun0
2023-03-26 00:37:24 Initialization Sequence Completed
2023-03-26 00:37:33 write to TUN/TAP : Invalid argument (fd=-1,code=22)
2023-03-26 00:37:43 write to TUN/TAP : Invalid argument (fd=-1,code=22)
2023-03-26 00:37:53 write to TUN/TAP : Invalid argument (fd=-1,code=22)

Para casos como mostrado acima o problema acontece pelo fato do servidor Openvpn está habilitado para permitir compressão, mas o seu cliente está configurado para desativar a compressão. Para corrigir esse problema basta editar seu arquivo myconfig.opvpn e adicionar a seguinte linha

comp-lzo yes //ou comp-lzo no caso seu servidor não tenha habilitado compressão

Agora repita o processo e a conexão estará funcionando corretamente.
Para realizar o mesmo processo pela interface gráfica basta fazer os seguintes passos:

Clique com o botão direito no ícone de sua rede ativa.
Navegue pelo menu Conexões VPN > Configurar VPN
Clique no ícone + para adicionar uma nova conexão
Selecione a opção Importar uma configuração de VPN salva
Selecione seu arquivo myconfig.opvpn
Adicione seu usuário e senha, salve e sua VPN está pronta para conexão no menu Conexões VPN