Este tutorial ensina os passos para montar seu HD externo ou pendrive no WSL para acessar ou alterar arquivos. Caso tenha um computador com sistema operacional Windows e precise acessar ou alterar informações em um HD/SSD externo (USB) ou Pendrive com partições de Linux (ext3, ext4, …) é possível utilizar o Windows WSL (Windows Subsystem for Linux).

Requisitos

Para executar este tutorial, temos como requisitos:

• Sistema Operacional Windows Instalado
• WSL instalado no Windows
• HD Externo, cartão SD, ou Pendrive com sistema de arquivos Linux (ext3, ext4, …).
• Acesso como Administrador no Windows PowerShell

Tutorial passo a passo para montar um hd externo ou pen drive no windows WSL (Windows Subsystem for Linux)

Passo 1: Conectar unidade de armazenamento externo no computador

Neste momento é importante conectar sua unidade de armazenamento HD Externo/Pendrive/Cartão SD no seu computador. É comum o windows não reconhcer o sistema de arquivos e oferecer para realizar formatação. Não formate a unidade de armazenamento, senão perderá os arquivos!

Passo 2: Executar o Windows Powershell como administrador

Encontre o aplicativo do Windows Power Shell, clique com o botão direito sobre o ícone e selecione a opção:

Executar como administrador / Run as administrator

Passo 3: Verificar se o Windows detectou a unidade de armazenamento

Dentro da janela do Powershell, precisamos verificar quais unidades ou dispositivos de armazenamento o windows detectou. Vamos utilizar o comando:

GET-CimInstance -query "SELECT * from Win32_DiskDrive"

Vamo ter como saída algo semelhante a:

DeviceID             Caption                 	Part.   Size   Model
--------             -------                 	-----   ----   -----
\\.\PHYSICALDRIVE0   Samsung SSD 980 PRO 2TB	4	2000   Samsung SSD 980 PRO 2TB
\\.\PHYSICALDRIVE1   Samsung SSD 850 EVO 500G	2	500    Samsung SSD 850 EVO 500

No exemplo da saída acima, precisamos identificar qual é o SSD principal do computador e qual é o HD/SSD externo que foi conectado. Como conheço as características do meu SSD Externo USB, sei que a unidade externa é o SSD de 500GB. Repare que a saída acima também mostra o número de partições de cada SSD, isso pode ser útil caso opte por disponibilizar apenas alguma partição no WSL, ao invés da unidade toda.

Passo 4: Disponibilizar a unidade/dispositivo no WSL

No caso deste exemplo, a unidade externa é identificada pelo DeviceID “\\.\PHYSICALDRIVE1“. Para disponibilizar essa unidade no WSL, vamos executar o comando:

wsl --mount \\.\PHYSICALDRIVE1 --bare

Passo 5: Identificar a unidade no WSL

Vamos agora para o terminal do Windows WSL. Vamos identificar o ponto de montagem da unidade utilizando o comando:

lsblk

O comando acima, vai nos trazer uma saída semelhante a:

NAME     MAJ:MIN  RM    SIZE  RO  TYPE  MOUNTPOINTS
sda        8:0     0  388.4M   1  disk
sdb        8:16    0      8G   0  disk  [SWAP]
sdc        8:32    0  465.8G   0  disk
 |--sdc1   8:33    0    256M   0  part
 |--sdc2   8:34    0  465.5G   0  part
sdd        8:32    0      1T   0  disk  /var/lib/docker
                                        /snap
                                        /mnt/wslg/distro
                                        /

Como tenho conhecimento que o SSD externo tem 500GB, a unidade que mais se assemelha a estas configurações é a sdc. Também sei que o SSD externo tem 2 partições, e essa informação também está presente, a unidade sdc possui as partições sdc1 e a sdc2.

Passo 6: Montar a partição desejada

Nesta etapa, tenho o desejo de montar a partição sdc1, que é a primeira partição da unidade. Então primeiro vou criar uma pasta chamada“hd-externo”, em seguida vou montar a partição nesta pasta, utilizando os comandos:

mkdir ~/hd-externo
sudo mount /dev/sdc1 ~/hd-externo

Passo 7: Acessar arquivos da partição

Com a partição montada na pasta “hd-externo“, basta entrar na pasta para ter acesso as informações presentes na partição:

cd ~/hd-externo
ls -lah

Passo 8: Desmontar a partição utilizada

Depois de realizar o acesso ou modificação dos arquivos presentes na partição, precisamos desmontar esta partição do sistema. Vamos utilizar o comando:

sudo umount ~/hd-externo

Passo 9 – Remover a unidade/dispositivo no WSL

Antes de remover a unidade de armazenamento externo do computador, precisamos remover ela do WSL. Vamos para o terminal do powershell, sendo necessário executar o comando:

wsl --unmount \\.\PHYSICALDRIVE1

Passo 10 – Confirmar se a unidade foi removida do WSL

No terminal do WSL, podemos confirmar se a unidade foi realmente removida do WSL e está disponível de volta no sistema Windows. Vamos utilizar novamente o comando:

lsblk

E vamos ter como saída, algo como:

NAME     MAJ:MIN  RM    SIZE  RO  TYPE  MOUNTPOINTS
sda        8:0     0  388.4M   1  disk
sdb        8:16    0      8G   0  disk  [SWAP]
sdd        8:32    0      1T   0  disk  /var/lib/docker
                                        /snap
                                        /mnt/wslg/distro
                                        /

Desta forma, confirmamos que a unidade de armazenamento externa foi removida.

Passo 11 – Ejetar a Unidade de armazenamento externa do computador

Realizado todos os passos anteriores, já podemos agora ejetar o HD/SSD externo ou pendrive do computador normalmente.

Extra – Desabilitando Overclock do Raspberry Pi após falha no boot

A principal motivação na criação deste tutorial é para realizar alterações no arquivo config.txt da partição de boot do raspberry pi. Desta forma, quando vou testar perfis de overclock que eventualmente não funcionam, é mais rápido ligar o SSD do Raspberry com uma gaveta USB no computador com o Windows e realizar as modificações. Se tem um problema semelhante, os passos deste tutorial vão te auxiliar nessas etapas.

Conclusão

Utilizar o Windows WSL pode ser muito útil, caso não tenha um computador com linux disponível para acessar informações em uma unidade externa. Ou caso precise realizar procedimentos reparadores na unidade de armazenamento do seu linux no seu computador com Windows.

Qualquer dúvida ou sugestão, basta informar nos comentários!

O post Tutorial como montar hd externo ou pendrive no Windows WSL apareceu primeiro em Vinicius Paes.

Criar um container com o software MySQLTuner integrado a uma base de dados, utilizando o docker compose.

Condições de contorno

Neste tutorial, vamos realizar teste em um container com a base de dados MariaDB (fork do mysql) em um sistema operacional linux em um processador ARM.

Passo a passo para utilizar o mysqltuner como um container com o docker compose

Passo 1: Conexão SSH

Conecte no seu servidor por SSH, por exemplo:

ssh vinicius@192.168.1.100

Passo 2: Criar diretórios para arquivos do container

Vamos criar um diretório dentro da pasta do usuário chamado docker, e depois uma pasta chamada MySQLTuner dentro desta pasta:

mkdir ~/docker
mkdir ~/docker/mysqltuner
cd ~/docker/mysqltuner

Passo 3: Criar o arquivo .env

O arquivo environment (.env) irá guardar as informações de conexão na base de dados. Vamos utilizar de exemplo a base de dados do container do moodle deste tutorial: container moodle

nano .env

Inserir as informações dentro do arquivo:

DOMAIN=cursos.viniciuspaes.com
HOST=moodledb
USER=root
PASS=senha_banco_dados
PORT=3306
MEM=8192

Lembrando que nas informações acima, o nome do HOST é o nome do nosso container do mariadb. Como estamos utilizando o exemplo do container que hospeda o moodle, o nome dele é moodledb (container da imagem do mariadb). A porta utilizada é a porta interna do container, que a padrão do mysql/mariadb é a 3306. A variável MEM, é relativa a memória ram disponível do HOST. A variável DOMAIN é utilizada para dar nome ao container, como estamos utilizando o exemplo do container do moodle, mantivemos o nome do subdomínio para ficar organizado dentro do portainer quando formos procurar pela stack.

Passo 4 – Criar a rede privada do mysqltuner

Para evitar abrir porta externa do container do mariadb, vamos ter que colocar o container do MySQLTuner na mesma rede do container do mariadb que queremos inspecionar. Primeiro, vamos criar então uma rede chamada MySQLTuner:

docker network create mysqltuner

Passo 5 – Editar o docker compose do seu container do mariadb

Se não tiver criado ainda um container do mariadb, basta criar. Se já tiver um container criado, basta adicionar a rede mysqltuner no container do mariadb. No exemplo abaixo destacamos apenas o update que realizamos no container do mariadb para adicionar a rede do mysqltuner e ativar o performance-schema:

  moodledb:
    image: mariadb:latest
    container_name: ${DOMAIN}_db
    command: '--default-authentication-plugin=mysql_native_password --performance-schema'
    volumes:
      - ./db_data:/var/lib/mysql
      - ./mariadb-conf/my.cnf:/root/.my.cnf
    restart: always
    env_file: .env
    environment:
      - MYSQL_USER=${MYSQL_USER}
      - MYSQL_DATABASE=${MYSQL_DB}
      - MYSQL_PASSWORD=${MYSQL_PASSWORD}
      - MYSQL_ROOT_PASSWORD=${MYSQL_PASSWORD}
      - MARIADB_CHARACTER_SET=utf8mb4
      - MARIADB_COLLATE=utf8mb4_unicode_ci
    networks:
      - default
      - mysqltuner

networks:
  default:
    name: rede_${DOMAIN}
  rede_proxy_reverso:
    external: true
  mysqltuner:
    external: true

No código acima, repare que mapeamos o arquivo my.cnf para acesso externo ao container. Desta forma, caso tenha o desejo de realizar modificações de performance nessa instância do mysql, basta editar o arquivo e adicioná-las.

Passo 6 – Criar o docker compose do container do mysqltuner

Vamos criar agora o docker compose do container do MySQLTuner:

nano docker-compose.yml

Inserir o conteúdo abaixo dentro do arquivo:

services:

  mysqltuner:
    container_name: ${DOMAIN}_mysqltuner
    build: .
    volumes:
     - ./projects:/srv/projects
    env_file:
      - .env
    networks:
      - mysqltuner
    stdin_open: true
    tty: true
    command: --host ${HOST} --port ${PORT} --user ${USER} --pass ${PASS} --forcemem ${MEM}

networks:
  mysqltuner:
    external: true

Passo 7 – Realizar download de arquivos necessários do MySQLTuner

Precisamos agora realizar o download dos arquivos necessários para o funcionamento do MySQLTuner:

wget https://raw.githubusercontent.com/major/MySQLTuner-perl/master/mysqltuner.pl
wget https://raw.githubusercontent.com/major/MySQLTuner-perl/master/vulnerabilities.csv
wget https://raw.githubusercontent.com/major/MySQLTuner-perl/master/basic_passwords.txt
wget https://raw.githubusercontent.com/major/MySQLTuner-perl/master/template_example.tpl

Passo 8 – Criar o arquivo Dockerfile

Vamos construir nosso próprio container do MySQLTuner, então precisamos criar um arquivo do tipo Dockerfile:

nano Dockerfile

Inserir o código abaixo dentro do arquivo:

FROM ubuntu:latest

ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt upgrade -y && apt-get install -yq --no-install-recommends \
    apt-utils \
    curl \
    wget \
    perl \
    perl-doc \
    mysql-client \
    libjson-perl \
    libtext-template-perl \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/* \
    && mkdir -p /results

RUN apt clean all

WORKDIR /

COPY ./mysqltuner.pl /mysqltuner.pl
COPY ./vulnerabilities.csv /vulnerabilities.txt
COPY ./basic_passwords.txt /basic_passwords.txt
COPY ./template_example.tpl /template.tpl

ENTRYPOINT [ "perl", "/mysqltuner.pl", "--passwordfile", "/basic_passwords.txt",\
             "--cvefile", "/vulnerabilities.txt", "--nosysstat", "--defaults-file", \
             "/defaults.cnf", "--dumpdir", "/results", "--outputfile", \
             "/results/mysqltuner.txt", "--template", "/template.tpl", \
             "--reportfile", "/results/mysqltuner.html" ]

CMD ["--verbose" ]

Passo 9 – Criar o container do mysqltuner

Agora é a última etapa! Para utilizar o docker compose para iniciar o container:

docker compose up -d

Se tudo correu bem e as configurações foram realizadas da forma correta, é possível inspecionar o log do container do MySQLTuner e verificar a saída do diagnóstico:

docker logs cursos.viniciuspaes.com_mysqltuner

No comando acima, você pode substituir o nome do container pelo seu ID de identificação. Primeiro utilize o comando:

docker ps

Agora anote o ID do container do mysqltuner, por exemplo:

CONTAINER ID   IMAGE             COMMAND                  CREATED             STATUS           NAMES
ab81292190a2   mariadb:latest    "docker-entrypoint.s…"   45 minutes ago      Up 45 minutes    cursos.viniciuspaes.com_db
jh370de553a5   mysqltuner        "perl /mysqltuner.pl…"   About an hour ago   Up 5 seconds     cursos.viniciuspaes.com_mysqltuner

No código acima, vemos que o ID do container do MySQLTuner é:

jh370de553a5

Podemos então acessar o log do container pelo comando:

docker logs jh370de553a5

Vamos ter como saída algo como:

-------- Recommendations ---------------------------------------------------------------------------
General recommendations:
    MySQL was started within the last 24 hours: recommendations may be inaccurate
    Reduce your overall MySQL memory footprint for system stability
    Dedicate this server to your database for highest performance.
    Be careful, increasing innodb_log_file_size / innodb_log_files_in_group means higher crash recovery mean time
Variables to adjust:
  *** MySQL's maximum memory usage is dangerously high ***
  *** Add RAM before increasing MySQL buffer variables ***
    table_definition_cache (600) > 792 or -1 (autosizing if supported)
    innodb_log_file_size should be (=32M) if possible, so InnoDB total log file size equals 25% of buffer pool size.
    innodb_log_buffer_size (> 16M)

Conclusão

O MySQLTuner é uma boa ferramenta para avaliar possibilidades de melhoria no seu setup de banco de dados. O tutorial descreve uma forma de criar um container funcional para o MySQLTuner, e os passos para configurar sua conexão ao banco de dados.

Qualquer dúvida ou sugestão, basta informar nos comentários!

O post Tutorial criar docker container do MySQLTuner apareceu primeiro em Vinicius Paes.

O objetivo deste tutorial é criar um container enxuto com a Ferramenta de Gerenciamento de Cursos Moodle. Este setup aborda a configuração de um domínio e suporte à conexão https (SSL). Este setup não utiliza o container oficial do moodle-hq, ao invés disso cria um ambiente mais enxuto e instala o Moodle do repositório oficial manualmente pelo Dockerfile.

Considerações

Alguns entusiastas do Moodle LMS (vide fórum de suporte do moodle) não recomendam utilizar o moodle em um container. O principal motivo levantando é que orquestrar o moodle em um container ocasiona um overhead de recursos do servidor, pois adiciona mais uma camada de processamento e complexidade. Esta justificativa pode parecer relevante para alguns casos onde os recursos são limitados e os cursos possuem altas demandas. Porém, se possuir uma infraestrutura de servidores corretamente dimensionadas (preferencialmente com interface web desacoplada do banco de dados), ou baixa demanda concorrente nos cursos, utilizar um container no docker é uma opção simples e eficaz.

Condições de contorno

Este tutorial foi testado tanto em ambiente x86/amd64 quando ARM64. Ou seja, você pode utilizar este setup tanto em um computador/servidor, quanto em um raspberry pi, por exemplo.

Requisitos

Alguns recursos são necessários para que você possa seguir este tutorial:

• Software docker e docker compose instalados e configurados
• Conexão internet para realização dos downloads necessários
• Capacidade de editar arquivos de configuração
• Capacidade de executar comandos no servidor: preferencialmente via conexão ssh, caso servidor remoto

Vamos fornecer passo a passo sobre quais arquivos precisam ser editados e como editar estes arquivos pela linha de comando.

Passo a passo em como criar um container docker enxuto para o gerenciador de cursos Moodle LMS

Passo 1 – Conexão no servidor

Caso tenha acesso físico ao servidor ou computador (com acesso com teclado/mouse/monitor), que vá instalar o moodle, não é necessário conexão SSH. Caso contrário, levando em consideração que seu servidor possua o IP: 192.168.1.100, será necessário realizar a conexão pelo prompt. Você também precisa saber qual seu usuário de conexão SSH e sua senha/certificado configurado. Para realizar a conexão, execute o comando:

ssh usuario@192.168.1.100

Passo 2 – Criar a pasta para o container

É interessante ter uma pasta chamada “docker” para guardar os arquivos de configuração e os volumes dos seus containers criados. Pensando na pasta home do seu usuário, vamos criar então:

mkdir ~/docker
mkdir ~/docker/moodle
cd ~/docker/moodle

Passo 3 – Criar arquivos de configuração

Neste setup não vamos utilizar a diretiva HTTP_X_FORWARDED_PROTO.  Então vamos configurar a imagem do container para acessar o certificado SSL externamente e habilitar suporte SSL dentro do container também, pela porta 443.

Os arquivos que precisam ser criados são:

• .env: este arquivo descreve valores para variáveis que vamos utilizar no arquivo de configuração do docker-compose.yml. Por exemplo: nome de usuário do banco, senha do banco de dados, domínio, etc.
• Dockerfile: arquivo que descreve como o container do moodle deve ser criado.
• docker-compose.yml: descreve o conjunto de containers devem ser criados e suas características.
• default-ssl.conf: arquivo que descreve a configuração do virtualhost para ter suporte ssl (porta 443).
• 000-default.conf: arquivo que descreve a configuração do virtualhost para acesso sem ssl (porta 80).
• create-moodle.sh: arquivo de shell que cria todos os arquivos acima, exceto o arquivo .env.

Na prática, vamos ter que criar apenas 2 arquivos, o arquivo .env e o arquivo create-moodle.sh.

Estamos dentro da pasta ~/docker/moodle, então já podemos criar o arquivo .env com o comando:

nano .env

Agora insira as informações:

MYSQL_USER=usuario_banco_dados
MYSQL_PASSWORD=senha_banco_dados
MYSQL_DB=nome_banco_dados
DOMAIN=cursos.viniciuspaes.com

No arquivo acima, estamos utilizando um subdomínio “cursos.viniciuspaes.com” como exemplo. Este nome de domínio (subdomínio) será atribuído também ao nome do container do moodle.

Vamos criar agora o arquivo create-moodle.sh com o comando:

nano create-moodle.sh

Agora cole o conteúdo abaixo dentro do arquivo:

Com o arquivo criado, é necessário conceder permissão de descrita:

sudo chmod +x create-moodle.sh

O arquivo create-moodle.sh irá criar todos os arquivos de configuração necessários (exceto .env), ira também verificar qual UID e GID do seu usuário e inserir essa informação no arquivo .env.

Para executar o arquivo, precisa utilizar o comando:

./create-moodle.sh

Ao executar esse comando, os arquivos abaixo serão criados:

• Dockerfile
• docker-compose.yml
• default-ssl.conf
• 000-default.conf

Passo 4 – Editar arquivo de configuração

Agora precisamos editar o arquivo docker-compose.yml e verificar se as configurações estão corretas.

Neste arquivo, as portas foram mapeadas da seguinte forma:

• Moodle: porta externa 8000 mapeada para porta interna 80
• Moodle: porta externa 8443 mapeada para porta interna 443
• Phpmyadmin: porta externa 8001 mapeada para porta interna 80

Então, com o IP de exemplo sendo 192.168.1.100, os serviços ficarão disponíveis:

http://192.168.1.100:8000
https://192.168.1.100:8443
http://192.168.1.100:8001

O nome do container do moodle irá receber o nome do domínio definido no arquivo .env. Caso queira um nome diferente, basta alterar. Caso não tenha um nome de domínio definido no arquivo .env, será inserido o nome localhost.

Ainda no arquivo docker-compose.yml, é necessário confirmar o caminho para seu certificado SSL, caso tenha um configurado. Você pode solicitar um certificado pelo container do Nginx Proxy Manager ou diretamente pelo letsencrypt, mas é necessário saber onde o certificado ficou salvo. No docker compose de exemplo, temos as 4 linhas:

- /home/vinicius/docker/nginxproxymanager/letsencrypt/live/npm-XX/fullchain.pem:/etc/apache2/ssl-certs/server.crt
- /home/vinicius/docker/nginxproxymanager/letsencrypt/live/npm-XX/privkey.pem:/etc/apache2/ssl-certs/server.key
# - /etc/letsencrypt/live/${DOMAIN}/fullchain.pem:/etc/apache2/ssl-certs/server.crt
# - /etc/letsencrypt/live/${DOMAIN}/privkey.pem:/etc/apache2/ssl-certs/server.key

As 2 primeiras linhas acima, são um exemplo do caminho do certificado gerado pelo Nginx Proxy Manager, revisar qual o caminho da sua instalação e realizar as modificações. Caso utilize um container do letsencrypt ou tenha o certbot instalado sem o docker, o caminho do certificado será algo semelhante as 2 últimas linhas acima. O caractere # no começo da linha serve para transforma ela em um comentário, desabilitando sua funcionalidade. Então caso utilize o padrão do container do letsencrypt, insira o caractere # nas duas primeiras linhas, para desabilitá-las e remova das 2 linhas de baixo. Ou mesmo apague as linhas que não for utilizar.

Passo 5 – Executar o docker compose e criar o container

Com as configurações descritas acima realizadas, precisamos agora executar o arquivo docker-compose.yml. Ao executar o mesmo, o container do Moodle será criado/construído, o que irá levar alguns minutos dependendo da velocidade da sua internet e poder de processamento. O container do mariadb e phpmyadmin estão “prontos” e só será realizado o download e execução. Para iniciar o funcionamento, execute então:

docker compose up -d

Como mencionado, o processo pode demorar alguns minutos (certamente vai demorar pelo menos uns 5 minutos).

Passo 6 – Conferir arquivos criados

Após a execução de todos os passos acima, os seguintes arquivos e diretórios devem estar presentes dentro da pasta:

• .env
• 000-default.conf
• Dockerfile
• create-moodle.sh
• db_data – diretório onde os arquivos do banco de dados ficam guardados
• default-ssl.conf
• docker-compose.yml
• logs – diretório onde os logs do apache ficam guardados
• moodle_data – diretório arquivos do moodle
• moodledata_data – diretório dos arquivos de cursos criados no moodle

Nesta etapa é interessante conferir se o container conseguiu realizar o download dos arquivos do Moodle e inserir na pasta moodle_data.

Execute o comando para verificar o conteúdo da pasta:

ls moodle_data

Se os arquivos foram copiados com sucesso, irá ter como resultado algo semelhante a:

CONTRIBUTING.md  blocks           course         help.php       my                   report
COPYING.txt      blog             customfield    help_ajax.php  notes                reportbuilder
Gruntfile.js     brokenfile.php   dataformat     index.php      npm-shrinkwrap.json  repository
INSTALL.txt      cache            draftfile.php  install        package.json         rss
README.md        calendar         editmode.php   install.php    payment              search
TRADEMARK.txt    cohort           enrol          iplookup       phpcs.xml.dist       security.txt
UPGRADING.md     comment          error          lang           phpunit.xml.dist     sms
admin            communication    favourites     lib            pix                  tag
ai               competency       file.php       local          plagiarism           theme
analytics        completion       files          login          pluginfile.php       tokenpluginfile.php
auth             composer.json    filter         media          portfolio            user
availability     composer.lock    githash.php    message        privacy              userpix
backup           config-dist.php  grade          mnet           question             version.php
badges           config.php       group          mod            r.php                webservice
behat.yml.dist   contentbank      h5p            moodlenet      rating

ATENÇÃO! Só realize esta etapa caso o diretório moodle_data estiver vazio, então realize o download manualmente:

cd moodle_data
wget https://download.moodle.org/download.php/direct/stable405/moodle-latest-405.tgz
tar -zxvf moodle-latest-405.tgz --strip-components=1
rm -R moodle-latest-405.tgz
cd ..
chmod 0755 moodle_data -R

Passo 7 – Configurar domínio

Caso tenha um domínio registrado, crie as entradas DNS do tipo A e CNAME para seu servidor.

Caso utilize o Nginx Proxy Manager, as informações necessárias são:

Domains Names: cursos.viniciuspaes.com
Scheme: https
Foward Hostname IP: cursos.viniciuspaes.com
Foward Port: 443

Na aba SSL solicite um certificado SSL e adicione o caminho do certificado corretamente no docker-compose.yml, caso ainda não tenha feito (como destacado no fim do passo 4). Como o Nginx Proxy Manager está na mesma rede do container do Moodle, utilizamos em “Foward Port” a porta interna (443) e no “Foward Hostname IP” utilizamos o nome do container (cursos.viniciuspaes.com), que por coincidência é o nome do domínio (subdomínio) utilizado para o website. Se não estiver utilizando o container na mesma rede do Nginx Proxy Manager, a configuração acima fica diferente. Sendo necessário configurar a porta externa (8443) e utilizar o IP do servidor no campo de Foward Hostname IP (192.168.1.100).

Passo 8 – Acessar moodle pela interface web e iniciar a instalação

Neste passo é interessante acessar o servidor pelo nome do domínio, ao invés do IP + porta. Caso tenha algum erro ao acessar pelo nome de domínio, revise os passos anteriores.

Para acessar a instalação do moodle, basta acessar o site pelo nome do domínio, neste exemplo:

https://cursos.viniciuspaes.com

Caso abra corretamente o site do moodle, você será encaminhado por alguns passos para configurar o idioma da instalação e credenciais do banco de dados.

A última etapa antes da instalação é um checklist de todas as dependências necessárias para o funcionamento do moodle. Neste tutorial, o Dockerfile está preparado para fornecer todas as dependências necessárias para a versão 4.05 do Moodle. Caso instale uma versão mais atual, é possível que apareça alguma necessidade nova.

ATENÇÃO! É comum que apareça a necessidade “UNICODE” na instalação, na página de checklist. Essa referência é diante o banco de dados e costuma ser super simples de arrumar. Caso apareça, basta executar os comandos abaixo:

cd ~/docker/moodle
cd moodle_data
nano config.php

Dentro do arquivo config.php, encontre a linha que começa com “‘dbcollation’ =>”, tenha certeza que ela fique da forma:

'dbcollation' => 'utf8mb4_unicode_ci',

Dê um refresh na página de instalação do Moodle e estará pronto para instalar.

Conclusão

A instalação do Moodle LMS não é algo trivial diante as dependências necessárias, porém este tutorial tenta minimizar todos estes esforços com um código em shell script para automatizar várias etapas. É interessante lembrar que há um container oficial do moodlq-hq, com um arquivo docker-compose para a configuração do moodle. Mas sinceramente, não gostei da documentação apresentada, tampouco da stack de containers que utilizam. Este tutorial visa simplificar ao máximo os passos, mantendo uma instalação enxuta e eficiente. Um upgrade interessante para este tutorial, seria habilitar a diretiva HTTP_X_FORWARDED_PROTO e minimizar o link de certificados SSL para dentro do container.

Qualquer dúvida ou sugestão, basta informas nos comentários!

O post Tutorial criar docker container moodle lms apareceu primeiro em Vinicius Paes.

Este tutorial tem como objetivo destacar os passos para criar um container WordPress com SSL utilizando um nome de domínio configurado no proxy reverso do container Nginx Proxy Manager.

• Forma mais simples de garantir suporte SSL ao container do wordpress, não é necessário realizar build para ativar porta 443 interna.
• Utilizando suporte a HTTP_X_FORWARDED_PROTO, o SSL configurado pelo proxy reverso é redirecionado para dentro do container do WordPress, mesmo que este só tenha a porta 80 habilitada.

Requisitos

• Se estiver utilizando um servidor caseiro (home lab) seu roteador precisa encaminhar (PORT FOWARD) as portas 80 (http) e 443 (https) para o seu servidor
• O firewall do seu servidor precisa aceitar acesso na porta 80 e 443 (normalmente são abertas)
• Garantir que não tenha outro serviço utilizando a porta 80 e 443, senão o container no NPM (Nginx Proxy Manager) não ficará funcional
  • Caso possua o apache instalado, basta executar:
    • sudo service apache2 stop
    • sudo update-rc.d apache2 disable
  • Caso possua o nginx instalado, basta executar:
    • sudo service nginx stop
    • sudo update-rc.d -f nginx disable
• Ter um nome de domínio configurado e apontado para seu servidor
  • Nesse tutorial vamos usar o nome de domínio site1.com.br como exemplo
• Ter software docker e docker compose instalados e configurados

Passo a passo para criar containers wordpress com suporte SSL através de proxy reverso do Nginx Proxy Manager

Passo 1: Criar pasta para guardar arquivos

mkdir ~/docker
mkdir ~/docker/nginxproxymanager
mkdir ~/docker/site1.com.br

Passo 2: Criar uma rede para todos os container que utilizarem o proxy reverso

Criar uma rede para os containers conseguirem conversar com o NPM:

docker network create rede_proxy_reverso

Passo 3: Criar arquivo docker compose para nginx proxy manager

cd ~/docker/nginxproxymanager
nano docker-compose.yml

Colar o conteúdo:

services:
  npm:
    image: 'jc21/nginx-proxy-manager:latest'
    container_name: nginx_proxy
    ports:
      - '80:80'
      - '8081:81'
      - '443:443'
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
    restart: unless-stopped
    networks:
      - rede_proxy_reverso
      - default

  db:
    image: mariadb:latest
    container_name: nginx_proxy_db
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_PASSWORD}
      MYSQL_DATABASE: ${MYSQL_DB}
      MYSQL_USER: ${MYSQL_USER}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}
    volumes:
      - ./db_data:/var/lib/mysql
    restart: unless-stopped
    networks:
      - default

networks:
  default:
    name: rede_npm
  rede_proxy_reverso:
    external: true

Passo 5: Criar arquivo .env para nginx proxy manager

cd ~/docker/nginxproxymanager
nano .env

Colar o conteúdo abaixo dentro do arquivo:

MYSQL_USER=nome_usuario_banco_npm
MYSQL_PASSWORD=senha_banco_dados_npm
MYSQL_DB=nome_banco_dados_npm
DOMAIN=nginx.proxy
USER=1000
GROUP=1000

Passo 6: Criar arquivo docker compose para site1.com.br que é um container wordpress

cd ~/docker/site1.com.br
nano docker-compose.yml

Agora precisamos colar o conteúdo abaixo dentro do arquivo:

services:

  db:
    image: mariadb:latest
    container_name: ${DOMAIN}_db
    command: '--default-authentication-plugin=mysql_native_password'
    volumes:
      - ./db_data:/var/lib/mysql
    restart: always
    env_file: .env
    environment:
      - MYSQL_USER=${MYSQL_USER}
      - MYSQL_DATABASE=${MYSQL_DB}
      - MYSQL_PASSWORD=${MYSQL_PASSWORD}
      - MYSQL_ROOT_PASSWORD=${MYSQL_PASSWORD}
    networks:
      - default

  site1.com.br:
    image: wordpress:latest
    container_name: ${DOMAIN}_web
    env_file:
      - .env
    depends_on:
      - db
    volumes:
      - ./public_html:/var/www/html/
      - ./logs:/var/log/apache2
      - /etc/localtime:/etc/localtime:ro
      - /etc/timezone:/etc/timezone:ro
    ports:
      - "9080:80"
    restart: always
    environment:
      - WORDPRESS_DB_HOST=db:3306
      - WORDPRESS_DB_USER=${MYSQL_USER}
      - WORDPRESS_DB_PASSWORD=${MYSQL_PASSWORD}
      - WORDPRESS_DB_NAME=${MYSQL_DB}
      - WORDPRESS_TABLE_PREFIX=${WP_PREFIX}
    extra_hosts:
      - "${DOMAIN}:127.0.1.1"
    entrypoint:
      - /bin/sh
      - -c
      - |
        usermod -u $${USER} www-data
        groupmod -g $${GROUP} www-data
        /usr/local/bin/docker-entrypoint.sh apache2-foreground
    networks:
      - rede_proxy_reverso
      - default

  phpmyadmin:
    container_name: ${DOMAIN}-phpmyadmin
    image: linuxserver/phpmyadmin
    env_file: .env
    environment:
      PMA_HOST: db #nome do container que proverá recursos de banco de dados, neste caso o container chama db
      PMA_PORT: 3306
      MYSQL_ROOT_PASSWORD: ${MYSQL_PASSWORD}
      UPLOAD_LIMIT: 64M
      MEMORY_LIMIT: 256M
      MAX_EXECUTION_TIME: 300
    ports:
      - "9081:80"
    networks:
      - default

networks:
  default:
    name: rede_${DOMAIN}
  rede_proxy_reverso:
    external: true

Passo 7: Criar arquivo .env para site1.com.br que é um container wordpress

Precisamos agora criar o arquivo .env para o container wordpress do domínio site1.com.br:

cd ~/docker/site1.com.br
nano .env

Cole o conteúdo abaixo dentro do arquivo:

MYSQL_USER=nome_usuario_banco_site1
MYSQL_PASSWORD=senha_banco_dados_site1
MYSQL_DB=nome_banco_dados_site1
DOMAIN=site1.com.br
WP_PREFIX=wpSITE1_
USER=1000
GROUP=1000

Passo 8: Iniciar os containers

Iniciar o container do Nginx Proxy Manager:

cd ~/docker/nginxproxymanager
docker compose up -d

Iniciar o container wordpress do site1.com.br:

cd ~/docker/site1.com.br
docker compose up -d

Passo 9: Testar funcionamento container wordpress

Configuramos o site1.com.br que é o container wordpress e responder solicitação pela porta 9080 do servidor. Levando em conta que nosso servidor está configurado com o IP 192.168.1.10,  vamos acessar o site com wordpress pelo browser:

http://192.168.1.10:9080

Se tentar acessar o a URL rapidamente, logo em seguida que criou o container, talvez receba mensagem de erro de conexão do banco de dados. O motivo é que o container do mysql demora um pouco para inicializar. Espere mais um pouco e tente acessar a URL novamente.

Se tudo ocorreu corretamente, vai aparecer a tela de configuração inicial do wordpress. Atenção! Não avance com a configuração, o ideal é realizar o processo já com o nome de domínio configurado.

Passo 10 – Configurar o Nginx Proxy Manager

Abra o navegador e digite o endereço do servidor juntamente com a porta. Neste exemplo nosso servidor está com endereço IP 192.168.1.10 e porta 8081. Então:

http://192.168.1.10:8081

Agora realize o primeiro login na plataforma:

Login: admin@example.com
Senha: changeme

Agora selecione a opção:

Proxy Hosts

Clique agora no botão:

Add Proxy Host

Vamos configurar agora o domínio site1.com.br. Em Domain Names, insira o texto:

site1.com.br

Em Scheme, escolha:

http

Em Foward Hostname / IP, escolha o IP do seu servidor (192.168.1.10), ou o IP de loopback (127.0.0.1) ou o nome do container que possui o wordpress instalado, neste caso:

site1.com.br

Em porta, vamos escolher a porta interna do container. Como temos uma rede dedicada para o proxy reverso (rede_proxy_reverso), o Nginx Proxy Manager consegue conversar pela rede interna compartilhada, não sendo nem mesmo necessário expor a porta do container. Caso não tenha a rede criada, ou vai utilizar o endereço IP, então precisa colocar a porta externa do container (9080). Então vamos escolher a porta:

80

Podemos também habilitar as opções:

Block Common Exploits
Websockets Support

Nesta mesma tela, temos alguma opções no menu superior:

Details | Custom locations | SSL | Advanced

Vamos solicitar o certificado SSL, então precisamos selecionar a aba:

SSL

Selecione agora a opção:

Request a new SSL Certificate with Let's Encrypt

Caminhe agora para a aba:

Advanced

Cole o seguinte texto:

proxy_set_header Host $host:$server_port;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;

Tudo pronto e configurado. Basta clicar no botão:

Save

Passo 11: Testar funcionamento

As principais configurações estão prontas. Acesse agora o nome de domínio escolhido pelo browser, no caso deste exemplo:

https://site1.com.br

Caso as configurações tenham sido realizadas corretamente, você irá se deparar com a tela de instalação do wordpress. Pode serguir com a instalação normalmente.

Passo 12: Resumo de configurações

Um breve resumo das configurações criadas:

Container Nginx Proxy Manager (NPM)

Portas expostas: 80, 443 e 8081
Porta da interface web do NPM: 8081

Container WordPress para o site1.com.br

Portas expostas: 9080 e 9081
Porta site wordpress: 9080
Porta interface phpmyadmin: 9081

IP de exemplo do servidor: 192.168.1.10

Para acessar a interface do NPM: http:192.168.1.10:8081
Para acessar o website pelo ip: http://192.168.1.10:9080
Para acessar a interface do Phpmyadmin: http://192.168.1.10:9081
Para acessar o website criado: https://site1.com.br

Conclusão

O setup do container do NPM + WordPress não é trivial, há pequenos detalhes diante a rede compartilhada entre o proxy reverso e o container do wordpress que influencia na porta a ser utilizada: usualmente pensamos na porta exposta no container, mas a forma mais segura é a porta interna. Utilizar o nome do container (site1.com.br) como “Foward Hostname” dentro do NPM também é um setup que utiliza as vantagens do DNS interno do docker para simplificar a comunicação entre containers. Estas configurações não são triviais para aqueles que estão começando a utilizar o docker e podem causar problemas no setup.

Qualquer dúvida ou sugestão no setup acima, basta entrar em contato pela área de comentários! Feedback é sempre bem vindo!

O post Tutorial container Nginx Proxy Manager e WordPress com SSL apareceu primeiro em Vinicius Paes.

Alterar o prefixo das tabelas do wordpress em um banco de dados já existente.

Requisitos

Ter um banco de dados funcional do wordpress onde deseja alterar o prefixo das tabelas no banco de dados.

Resumo

Os passos para alterar o prefixo de um banco de dados do wordpress já existente são:

1. Atualizar o arquivo wp-config.php e alterar a linha com o novo prefixo desejado: $table_prefix = ‘wp_‘;
2. Caso tenha o phpmyadmin instalado, selecione as tabelas e clique na opção: “Replace table prefix” ou “Substituir o prefixo de tabelas“.
3. Agora é necessário atualizar as referências cruzadas das tabelas do banco, alterar o prefixo anterior (wp_) para o novo (wpNOVO_). Execute as query SQL (podem ser feitas dentro do phpmyadmin também):
   • update wpNOVO_usermeta set meta_key = ‘wpNOVO_capabilities’ where meta_key = ‘wp_capabilities’;
   • update wpNOVO_usermeta set meta_key = ‘wpNOVO_user_level’ where meta_key = ‘wp_user_level’;
   • update wpNOVO_usermeta set meta_key = ‘wpNOVO_autosave_draft_ids’ where meta_key = ‘wp_autosave_draft_ids’;
   • update wpNOVO_options set option_name = ‘wpNOVO_user_roles’ where option_name = ‘wp_user_roles’;

Abaixo teremos um passo a passo descritivo de cada etapa.

Passo a passo de como alterar o prefixo do banco de dados do WordPress

Passo 1 – Inserir o novo prefixo no arquivo wp-config.php

Caso esteja no windows, basta abrir o arquivo wp-config.php no bloco de notas e alterar a linha:

$table_prefix = 'wp_';

Caso esteja realizando a atualização em linha de comando no linux ou mac os, caminhe até o diretório raiz da sua instalação do wordpress e edite o arquivo wp-config.php:

nano wp-config.php

Agora com o editor nano aberto, ande até encontrar a linha:

$table_prefix = 'wp_';

Esta linha indica que todas as tabelas do wordpress começam com o prefixo wp_.

Caso queira um prefixo novo chamado wpNOVO_, basta alterar essa linha para:

$table_prefix = 'wpNOVO_';

Passo 2 – Alterar o prefixo existente no banco de dados

O próximo passo é alterar manualmente o prefixo existente nas tabelas do banco de dados.

Opção 1: Alterar prefixos utilizando phpmyadmin

Caso tenha o phpmyadmin instalado, basta clicar no banco de dados para que as tabelas apareçam ao lado direito.

Agora clique em:

Marcar todos

Ao lado de Marcar todos, clique em:

Com marcados:

E finalmente selecione:

Substituir o prefixo de tabelas

Um modal irá abrir para você selecionar o prefixo antigo atual e o novo prefixo que deseja alterar. Do nosso exemplo o prefixo atual é o original:

wp_

O novo prefixo desejado vai ser:

wpNOVO_

Agora basta clicar em:

Continuar

Opção 2 – Alterar prefixos utilizando query SQL

Caso não tenha o phpmyadmin instalado, basta executar uma query SQL do tipo ALTER TABLE para cada tabela do banco de dados no wordpress. É muito comum que plugins criem tabelas adicionais no banco de dados do wordpress, mas para referência, as tabelas padrão de uma instalação do wordpress e suas respectivas alterações necessárias são:

ALTER TABLE `wp_commentmeta` RENAME `wpNOVO_commentmeta`;
ALTER TABLE `wp_comments` RENAME `wpNOVO_comments`;
ALTER TABLE `wp_links` RENAME `wpNOVO_links`;
ALTER TABLE `wp_options` RENAME `wpNOVO_options`;
ALTER TABLE `wp_postmeta` RENAME `wpNOVO_postmeta`;
ALTER TABLE `wp_posts` RENAME `wpNOVO_posts`;
ALTER TABLE `wp_termmeta` RENAME `wpNOVO_termmeta`;
ALTER TABLE `wp_terms` RENAME `wpNOVO_terms`;
ALTER TABLE `wp_term_relationships` RENAME `wpNOVO_term_relationships`;
ALTER TABLE `wp_term_taxonomy` RENAME `wpNOVO_term_taxonomy`;
ALTER TABLE `wp_usermeta` RENAME `wpNOVO_usermeta`;
ALTER TABLE `wp_users` RENAME `wpNOVO_users`;

A figura acima ilustra uma query SQL executada que tem o mesmo resultado do Passo 2 e Opcão 1 apresentado. Ela pode ser realizada também pelo console do mysql.

Passo 3 – Alterar referências entre tabelas existentes

Por fim, existem também referências entre as tabelas que precisam ser atualizadas. Geralmente apenas as tabelas user_meta e options possuem estas referências. Caso utilize plugins específicos com tais referências ou alguma versão mais nova do wordpress é bom ficar atento.

Caso utilize o phpmyadmin, e caso tenha clicado no banco de dados no menu da esquerda, as seguintes opções irão aparecer no menu superior:

Estrutura | SQL | Procurar | Consulta | Exportar | Importar | Operações | Rotinas | Eventos | Acionadores | Designer

Clique na opção do menu superior chamada:

SQL

Agora insira o seguinte código dentro do campo:

update wpNOVO_usermeta set meta_key = 'wpNOVO_capabilities' where meta_key = 'wp_capabilities';
update wpNOVO_usermeta set meta_key = 'wpNOVO_user_level' where meta_key = 'wp_user_level';
update wpNOVO_usermeta set meta_key = 'wpNOVO_autosave_draft_ids' where meta_key = 'wp_autosave_draft_ids';
update wpNOVO_options set option_name = 'wpNOVO_user_roles' where option_name = 'wp_user_roles';

Agora clique em:

Executar

A query SQL que inseriu irá ser executada e irá buscar as referências do prefixo antigo nas tabelas e realizar a atualização.

Caso não tenha o phpmyadmin, basta executar a query acima no console do mysql que terá o mesmo resultado.

Conclusão

A mudança do prefixo, das tabelas do wordpress, pode ser necessária em diversas ocasiões: aumentar segurança da instalação, ter várias instâncias do wordpress no mesmo banco, adequar a uma necessidade da organização, etc. O processo é simples e realizado em 3 etapas: atualizar o novo prefixo no wp-config.php, mudar o prefixo no banco e atualizar as referências entre tabelas.

O post Tutorial como mudar o prefixo das tabelas do wordpress apareceu primeiro em Vinicius Paes.

Criar um container utilizando docker para prover o serviço de conexão por ssh, com o open-ssh server, para prover acesso a websites configurados no servidor. Uma forma elegante de configurar o acesso de um usuário a diversos websites que este tem acesso e de forma organizada.

Requisitos

• Docker e docker compose instalado e configurado no servidor
• Pastas com arquivos de diferentes usuários que deseja organizar o acesso
  • Por exemplo: pastas de diversos websites que um webmaster tem privilégios de acesso
• Chave pública para acesso com certificado (opcional)
  • Possibilidade de acesso por nome de usuário/senha: menos seguro

Passo a passo para criar e configurar um container com open ssh server

Passo 1 – Criar pasta para configuração do container

mkdir ~/docker
mkdir ~/docker/openssh
cd ~/docker/openssh

Caso queira criar diversos containers com o openssh, pode criar pastas seguindo o modelo openssh-1, openssh2, …

Passo 2 – Criar o arquivo de configuração

Vamos então criar nosso arquivo docker-compose.yml:

nano docker-compose.yml

E agora copie o código abaixo dentro do arquivo:

services:
  openssh-server:
    image: lscr.io/linuxserver/openssh-server:latest
    container_name:  openssh_server
#    hostname: openssh_server
    environment:
      - PUID=1000							#Importante para não ter erro de permissão de escrita
      - PGID=1000							#Importante para não ter erro de permissão de escrita
      - TZ=America/Sao_Paulo
      - PUBLIC_KEY_FILE=/home/nomeusuario/.ssh/authorized_keys 		#opcional
#      - PUBLIC_KEY=suachavepublicaporextenso 				#opcional
#      - PUBLIC_KEY_DIR=/home/nomedousuario/apenas_chaves_publicas/ 	#opcional
#      - PUBLIC_KEY_URL=https://github.com/nomedousuario.keys 		#opcional
      - SUDO_ACCESS=false 						#opcional
      - PASSWORD_ACCESS=true 						#opcional
      - USER_NAME=nomedousuario 					#opcional
      - USER_PASSWORD=senhadousuario 					#opcional
#      - USER_PASSWORD_FILE=/home/nomedousuario/senhaemarquivo.txt 	#opcional
#      - LOG_STDOUT= 							#optional
    volumes:
      - /var/www/html/site1.com.br/public_html:/config/site1.com.br
      - /var/www/html/site2.com.br/public_html:/config/site2.com.br
    ports:
      - 2222:2222
    restart: unless-stopped

Passo 3 – Iniciando o container

Para iniciar o container, basta iniciar o comando:

docker compose up -d

Passo 4 – Credenciais de acesso

A forma mais simples de acessar é utilizando o software Filezilla, por possuir interface gráfica. Mas há quem prefere acessar diretamente pelo terminal também.

Do exemplo acima, as credenciais de acesso são:

host: sftp://192.168.1.100
Username: nomedousuario
Password: senhadousuario
Port: 2222

Lembrar de substituir o IP acima, pelo IP do seu servidor e não o IP do container. Se conectar pelo Filezilla, é necessário informar o prefixo sftp:// para que ele entenda que está realizando uma conexão por ssh.

Para conectar pelo terminal basta executar o comando e informar a senha:

ssh nomedousuario@192.168.1.100 -p 2222

Conclusão

A criação do container do OpenSSH server é bem simples, sendo possível escolher pela autenticação por chave pública ou usuário e senha. A conexão SSH é uma forma de acessar arquivos remotos de forma mais segura que o protocolo FTP. O setup acima é bem úteil também para organizar vários website ou pastas que podem ser acessar por determinado usuário.

O post Tutorial container docker open ssh server para acessar websites apareceu primeiro em Vinicius Paes.

• Aprender a ter suporte de envio de emails pelo WordPress utilizando um servidor de emails externo e autenticado
• Poder enviar email autenticado por uma caixa do gmail de forma simples ou outro servidor smtp
• Poder utilizar o plugin Contact form 7 em conjunto com envio de mensagens autenticadas por smtp
• Ter funcionalidade de envio de email pelo wordpress, mesmo que este esteja instalado em um container com docker

Requisitos para seguir o tutorial

• Saber encontrar os arquivos da sua instalação do wordpress
• Saber editar arquivos da sua instalação do wordpress
• Ter uma caixa de email criada (gmail ou outro provedor) e saber a senha
  • Caso utilize o gmail: criar uma senha de APP
    • É preciso ter autenticação em 2 etapas ativada na sua conta do gmail para a opção de criar senha de APP ficar disponível

Tutorial passo a passo para configurar envio de email autenticado pelo wordpress

Passo 1 – Configurar seu tema para suporte a envio de email por smtp

Acesse a pasta do seu tema atual do wordpress, por exemplo:

cd wp-content/themes/TEMAqueESTAusando/

Edite ou crie o arquivo functions.php dentro do seu tema atual:

nano funcions.php

Agora adicione o conteúdo:

add_action( 'phpmailer_init', 'send_smtp_email' );
function send_smtp_email( $phpmailer ) {
    $phpmailer->isSMTP();
    $phpmailer->Host       = SMTP_HOST;
    $phpmailer->SMTPAuth   = SMTP_AUTH;
    $phpmailer->Port       = SMTP_PORT;
    $phpmailer->SMTPSecure = SMTP_SECURE;
    $phpmailer->Username   = SMTP_USERNAME;
    $phpmailer->Password   = SMTP_PASSWORD;
    $phpmailer->From       = SMTP_FROM;
    $phpmailer->FromName   = SMTP_FROMNAME;
}

Lembrando que o código acima é da linguagem PHP, então precisa estar dentro das tags <?php e ?>.

Passo 2 – Configurar o wordpress para utilizar envio de email pelo servidor SMTP definido, ao invés do sendmail padrão

Agora é necessário editar o arquivo wp-config.php que está na base da instalação do wordpress.

nano wp-config.php

É necessário adicionar o conteúdo:

define( 'SMTP_HOST', 'smtp.gmail.com' );
define( 'SMTP_AUTH', true );
define( 'SMTP_PORT', '465' );
define( 'SMTP_SECURE', 'ssl' );
define( 'SMTP_USERNAME', 'seuemail@gmail.com' ); // Sua conta de email
define( 'SMTP_PASSWORD', 'suasenhatipoAPPpasswordgerada' ); // Sua senha de APP gerada no gmail (autenticação em 2 etapas precisa estar ativada para ter essa opção)
define( 'SMTP_FROM', 'seuemail@gmail.com' ); // Endereço de remetente, se quiser diferente do seu endereço de email
define( 'SMTP_FROMNAME', 'Nome Sobrenome' ); // Nome Remetente

Caso utilize seu próprio servidor de email, também é possível utilizá-lo. Basta realizar as modificações para sua caixa de email do seu servidor e o endereço smtp. Então, seguindo o exemplo do Tutorial para criar servidor de email, as configurações seriam muito semelhantes ao código abaixo:

define( 'SMTP_HOST', 'mail.seudominio.com.br' );
define( 'SMTP_AUTH', true );
define( 'SMTP_PORT', '465' );
define( 'SMTP_SECURE', 'ssl' );
define( 'SMTP_USERNAME', 'seuemail@seudominio.com.br' ); // Sua conta de email
define( 'SMTP_PASSWORD', 'suasenhatipoAPPpasswordgerada' ); // Sua senha da caixa de email
define( 'SMTP_FROM', 'seuemail@seudominio.com.br' ); // Endereço de remetente, se quiser diferente do seu endereço de email
define( 'SMTP_FROMNAME', 'Nome Sobrenome' ); // Nome Remetente

Conclusão

Esta é uma alternativa simples e objetiva para ter suporte a envio de emails autenticados com wordpress. Nativamente o wordpress irá tentar utilizar o método de envio de email padrão do servidor onde está configurado, usualmente o sendmail. Caso utilize seu wordpress em um container com docker, o envio autenticado é uma boa alternativa para garantir funcionalidades de envio de email, sem a necessidade de utilizar algum plugin mais complicado, como o WP MAIL SMTP.

O post Tutorial configurar WordPress para enviar email por SMTP apareceu primeiro em Vinicius Paes.

Criar um container com servidor de páginas apache2 para prover suporte a páginas html somente. Configurações específicas por .htaccess ou virtualhost também suportados. Container com suporte tanto para acesso http ou ssl (https://).

Requisitos

• Capacidade de criação de containers com Docker e suporte a docker compose.
• Conexão com internet para download da imagem do apache2 (httpd).

É possível configurar um domínio pra acesso ao seu container. Ou se preferir, pode acessá-lo diretamente pelo seu ip e porta definidos.

Como instalar imagem do httpd (apache2) com docker compose tendo suporte a certificado SSL

Passo 1: Criação de arquivos para configurar o container do wordpress

• .env – este arquivo irá conter informações sobre variáveis que podemos definir previamente, para serem utilizadas no arquivo de configuração do container. Neste exemplo, vamos configurar o nome de domínio que queremos vincular ao servidor de páginas httpd e container
• docker-compose – arquivo principal de definição das configurações do container.
• my-http.conf – arquivo de configuração do apache onde vamos definir o virtualhost para acesso http e https.

Nosso diretório base para o container será:

~/docker/website

Então vamos criar o diretório docker e website, caso ainda não estejam criados:

mkdir ~/docker
mkdir ~/docker/website

Agora vamos criar o arquivo .env:

nano ~/docker/website/.env

Precisamos colar o conteúdo:

DOMAIN=dev.viniciuspaes.com

Neste exemplo, vamos definir o domínio/subdomínio dev.viniciuspaes.com nesse container.

Vamos criar o arquivo do docker-compose.yml:

nano ~/docker/website/docker-compose.yml

Cole no seu conteúdo as informações abaixo:

services:
  apache:
    container_name: ${DOMAIN}_web
    image: httpd:latest
    env_file:
      - .env
    volumes:
      - ./my-httpd.conf:/usr/local/apache2/conf/httpd.conf
      - ./logs:/var/log/apache2
      - ./public_html:/usr/local/apache2/htdocs
      - /etc/letsencrypt/live/${DOMAIN}/fullchain.pem:/usr/local/apache2/conf/server.crt
      - /etc/letsencrypt/live/${DOMAIN}/privkey.pem:/usr/local/apache2/conf/server.key
      - /etc/localtime:/etc/localtime:ro
      - /etc/timezone:/etc/timezone:ro
    ports:
      - "8080:80"
      - "8081:443"
    restart: always

Por fim, precisamos fazer o download do arquivo httpd.conf do container do httpd:latest:

cd ~/docker/website
docker run --rm httpd:latest cat /usr/local/apache2/conf/httpd.conf > my-httpd.conf

Com o comando acima, será feito o download do arquivo httpd.conf de dentro do repositório do httpd e será renomeado para my-httpd.conf.

Passo 2: Editar o arquivo my-httpd.conf e configurar virtualhost

Vamos editar o arquivo my-httpd.conf:

nano my-httpd.conf

Agora é necessário remover o caractere # do começo das seguintes linhas:

#LoadModule socache_shmcb_module modules/mod_socache_shmcb.so
#LoadModule ssl_module modules/mod_ssl.so
#Include conf/extra/httpd-ssl.conf
#LoadModule rewrite_module modules/mod_rewrite.so

As linhas acima estão em sequência no arquivo, é necessário encontrá-las. Após editadas, devem ficar como:

LoadModule socache_shmcb_module modules/mod_socache_shmcb.so
LoadModule ssl_module modules/mod_ssl.so
Include conf/extra/httpd-ssl.conf
LoadModule rewrite_module modules/mod_rewrite.so

Ainda na edição do my-httpd.conf, precisamos configurar o virtualhost e inserir o conteúdo no fim do arquivo:

Passo 3: Confirmar caminho para certificado SSL

Neste tutorial estamos supondo que já possui um servidor de proxy reverso instalado e configurado e que o certificado SSL para o domínio que escolheu está presente no caminho:

/etc/letsencrypt/live/dev.viniciuspaes.com/fullchain.pem
/etc/letsencrypt/live/dev.viniciuspaes.com/privkey.pem

Caso não vá utilizar um domínio configurado em seu container, ou não vai precisar de acesso SSL, é só comentar essas linhas no docker-compose.yml e remover o virtual host para porta 443 (SSL).

Passo 4: Iniciar o Container

Para iniciar o container, vamos utilizar o docker compose, mas lembre-se que precisa estar na mesma pasta onde o arquivo está configurado:

cd ~/docker/website
docker compose up -d

Se todos os passos foram executados com sucesso, vamos ter o container configurado com as portas:

• 8080: para acesso http
• 8081: para acesso https (SSL)

Basta acessar seu domínio pela URL configurada:

dev.viniciuspaes.com

Ou se optou por não configurar um domínio e SSL, basta acessar pelo endereço IP do seu servidor. Exemplo de um servidor configurado na porta 192.168.1.100:

• http://192.168.1.100:8080
• https://192.168.1.100:8081

Conclusão

O processo para criação do container com suporte a páginas html pelo httpd (apache) é bem simples. O docker compose permite uma estrutura bem legível das configurações do container, permitindo parametrizações de acordo com as necessidades. Com este container, podemos servir páginas html de forma bem intuitiva, inserindo os arquivos na pasta public_html.

O post Tutorial container httpd apache com docker compose e suporte SSL apareceu primeiro em Vinicius Paes.

Este tutorial tem o objetivo ensinar um passo a passo de como instalar o wordpress como um container utilizando docker, com suporte a um nome de domínio e acesso por http e https. Por padrão o container do wordpress não vem com suporte SSL, vamos ensinar como realizar modificação no container com Dockerfile para habilitar a porta 443. Vamos abordar a utilização do apache como proxy reverso.

Este tutorial também aborda a possibilidade de instalar vários containers do wordpress para diversos sites e domínios distintos. Desta forma, é interessante ressaltar que o tutorial aborda como iniciar suporte SSL dentro do container, ao invés de apenas  habilitar a diretiva HTTP_X_FORWARDED_PROTO.

Caso queira configurar o wordpress sem realizar modificações com Dockerfile (build) de forma enxuta e objetiva com o Nginx Proxy Manager e a diretiva HTTP_X_FOWARDED_PROTO, utilize este tutorial:

• Tutorial container Nginx Proxy Manager e WordPress com SSL

Requisitos

• Software docker instalado e configurado no sistema operacional.
• Docker compose instalado e configurado.
• Conexão com internet para download da imagem do wordpress, mariadb (mysql), phpmyadmin, certificado SSL e proxy reverso (apache).
• Configuração DNS em seu domínio, direcionando para seu servidor.
  • Caso utilize um domínio local, editar o arquivo /etc/hosts em seu computador e adicioná-lo apropriadamente.
• Se utilizar um servidor caseiro, garantir que seu roteador está redirecionando as portas 80 e 443 para seu servidor.
• Garantir que seu firewall no servidor não está bloqueando as portas 80 e 443.

Observação

Como temos desejo de configurar um domínio em nossa instalação do wordpress, é comum utilizarmos um proxy reverso, para gerenciar uma solicitação pela porta 80 ou 443 e encaminhar para a porta correspondente que estará mapeada no container. Vamos abordar o arquivo de configuração de proxy reverso no apache (apache2).

Como instalar imagem do wordpress com docker compose tendo suporte a certificado SSL e nome de domínio

Passo 1: Configuração do Servidor de Páginas para proxy reverso

Precisamos preparar nosso ambiente de hospedagem para gerenciar as solicitações http/https e redirecionar para os containers que queremos criar. Caso já tenha o apache instalado em seu servidor, independente de ser em um container ou não, a etapa principal é configurar corretamente o arquivo de virtualhost do domínio com o proxy reverso.

Neste exemplo, vamos supor que queremos instalar o wordpress para o subdomínio dev.viniciuspaes.com. Mas poderia ser para qualquer domínio ou subdomínio que escolher.

Agora vamos definir quais as portas que este container wordpress irá utilizar. Para esse domínio, vamos utilizar a porta 9080 para acesso http, a porta 9081 para acesso com SSL (https) e porta 8082 para acesso a interface do phpmyadmin.

É necessário 2 arquivos de configuração instalados no apache: um para acesso http e outro para acesso https.

Para acesso http, vamos criar o arquivo dev.viniciuspaes.com.http.conf:

sudo nano /etc/apache2/sites-available/dev.viniciuspaes.com.http.conf

Agora cole o conteúdo abaixo dentro do arquivo. Lembre-se de alterar o nome de domínio e a porta que irá utilizar:

<VirtualHost *:80>
ServerName dev.viniciuspaes.com
ServerAdmin postmaster@viniciuspaes.com

ProxyPass / http://127.0.0.1:9080/
ProxyPassReverse / http://127.0.0.1:9080/
ProxyPreserveHost On
ErrorLog ${APACHE_LOG_DIR}/dev.viniciuspaes.com.error.log
CustomLog ${APACHE_LOG_DIR}/dev.viniciuspaes.com.access.log combined

## Redirecionar tráfego HTTP para HTTPS, habilitar somente após configurar certificado SSL
# RewriteEngine on
# RewriteCond %{SERVER_NAME} =dev.viniciuspaes.com
# RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [END,NE,R=permanent]
</VirtualHost>

No arquivo acima, escolhemos a porta 9080 para receber solicitações http no container que ainda vai ser criado.

Agora é necessário solicitar um certificado SSL do letsencrypt pelo certbot.
Caso seu certbot não esteja em um container basta seguir os passos deste tutorial:

• Solicitar certificado SSL com letsencrypt com apache

Ao solicitar o certificado as chaves serão salvas no caminho:

• /etc/letsencrypt/live/dev.viniciuspaes.com/fullchain.pem
• /etc/letsencrypt/live/dev.viniciuspaes.com/privkey.pem

Um arquivo de configuração para o apache também será criado com o nome:

• dev.viniciuspaes.com.http-le-ssl.conf

Vamos agora editar este arquivo para adicionar as informações do proxy reverso:

sudo nano /etc/apache2/sites-available/dev.viniciuspaes.com.http-le-ssl.conf

O conteúdo do arquivo deverá ficar como:

<IfModule mod_ssl.c>
<VirtualHost *:443>
ServerName dev.viniciuspaes.com

SSLProxyEngine on

<Proxy *>
Allow from all
</Proxy>

ProxyPreserveHost On
ProxyRequests Off

ProxyPass / https://127.0.0.1:9081/
ProxyPassReverse / https://127.0.0.1:9081/

ErrorLog ${APACHE_LOG_DIR}/dev.viniciuspaes.com.error.log
CustomLog ${APACHE_LOG_DIR}/dev.viniciuspaes.com.access.log combined

SSLCertificateFile /etc/letsencrypt/live/dev.viniciuspaes.com/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/dev.viniciuspaes.com/privkey.pem
Include /etc/letsencrypt/options-ssl-apache.conf

</VirtualHost>
</IfModule>

Lembrando que no arquivo acima escolhemos a porta 9081 no container, para receber solicitação https (SSL).

Passo 2: Criação de arquivos para configurar o container do wordpress

Vamos supor o desejo de manter todos os arquivos do containers organizados em uma pasta chamada docker, que pode estar dentro da nossa pasta pessoal. Vamos criar então uma pasta para nosso container do wordpress:

mkdir ~/docker/wordpress

Agora precisamos criar 5 arquivos:

• Dockerfile – este arquivo vai conter algumas tarefas que precisam ser utilizadas no momento de criação do container
• .env – este arquivo contém a definição de algumas variáveis importantes no processo de setup dos containers: nome de usuário, senha, nome de domínio, etc.
• 000-default.conf – é o arquivo de configuração que o servidor apache que vem dentro do container do wordpress deve utilizar para acesso http
• default-ssl.conf – semelhante ao arquivo 000-default.conf, porém com as configurações de acesso por ssl
• docker-compose.yml – arquivo de configuração dos containers a serem criados

Vamos caminhar até a pasta que criamos para guardar as informações deste container:

cd ~/docker/wordpress

Para criar o arquivo Dockerfile, usamos o comando:

nano Dockerfile

Dentro do arquivo vamos inserir o conteúdo:

#Definir a imagem do container a ser utilizado como base
FROM wordpress:latest

#Habilitar arquivo php.ini de produção caso existente na imagem
RUN mv "$PHP_INI_DIR/php.ini-production" "$PHP_INI_DIR/php.ini"

#Aumentar o post_max_size de 8MB para 64MB
RUN sed -i -e "s/post_max_size \= 8M/post_max_size \= 64M/g" "$PHP_INI_DIR/php.ini"

#Aumentar o upload_max_filesize de 2M para 60MB
RUN sed -i -e "s/upload_max_filesize \= 2M/upload_max_filesize \= 60M/g" "$PHP_INI_DIR/php.ini"

#Aumentar o tempo da sessão de 1440s para 86400s
RUN sed -i -e "s/session.gc_maxlifetime \= 1440/session.gc_maxlifetime \= 86400/g" "$PHP_INI_DIR/php.ini"

#Modificar o User ID e o Group ID do usuário www-data de dentro do container para seu usuário fora do container
RUN usermod -u 1000 www-data && groupmod -g 1000 www-data

#Copiar o arquivo defaul-ssl.conf que criamos para dentro do container
ADD default-ssl.conf /etc/apache2/sites-available/default-ssl.conf

Copiar o arquivo 000-default.conf que criamos, para dentro do container
ADD 000-default.conf /etc/apache2/sites-available/000-default.conf

#Habiliar o virtualhost definido em default-ssl.conf
RUN a2ensite default-ssl.conf

#Habilitar o virtualhost definido em 000-default.conf
RUN a2ensite 000-default.conf

#Caso sua imagem não tenha mysqli instalado (php:8.3-apache por exemplo), descomente o comando abaixo
#RUN docker-php-ext-install mysqli && docker-php-ext-enable mysqli

# Habilitar módulos rewrite, header, expires e ssl
RUN a2enmod rewrite && a2enmod headers && a2enmod expires && a2enmod ssl

#Adicionar o Servername do seu nome de domínio no arquivo apache2.conf
RUN echo "ServerName dev.viniciuspaes.com" >> /etc/apache2/apache2.conf

Vamos criar o segundo arquivo da lista:

nano .env

Vamos colar o conteúdo abaixo dentro do arquivo:

MYSQL_USER=nome_usuario_banco
MYSQL_PASSWORD=senha_do_banco_mudar
MYSQL_DB=nome_banco_dados
DOMAIN=dev.viniciuspaes.com
WP_PREFIX=wp_
USER=1000
GROUP=1000

Para o terceiro arquivo necessário, vamos criá-lo com o comando:

nano 000-default.conf

Seu conteúdo deve ser equivalente ao código abaixo:

<VirtualHost *:80>
       ServerAdmin webmaster@localhost
       DocumentRoot /var/www/html
       ErrorLog ${APACHE_LOG_DIR}/error.log
       CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Para o quarto arquivo necessário, vamos criar o arquivo de configuração para acesso https:
nano default-ssl.conf

Se conteúdo deve conter:

<IfModule mod_ssl.c>
        <VirtualHost _default_:443>
                ServerAdmin webmaster@localhost
                DocumentRoot /var/www/html
                Header always set Strict-Transport-Security "max-age=63072000; includeSubdomains;"
                Header append X-FRAME-OPTIONS "SAMEORIGIN"
                Header set X-Content-Type-Options nosniff
                Header set X-XSS-Protection "1; mode=block"
                Header always set Referrer-Policy "no-referrer"

                ErrorLog ${APACHE_LOG_DIR}/error.log
                CustomLog ${APACHE_LOG_DIR}/access.log combined

                SSLEngine on
                #SSLCertificateFile     /etc/apache2/ssl-certs/cert-filename.cert
                #SSLCertificateKeyFile  /etc/apache2/ssl-certs/cert-filenamekey.key

                SSLCertificateFile      /etc/apache2/ssl-certs/server.crt
                SSLCertificateKeyFile  /etc/apache2/ssl-certs/server.key

                <FilesMatch "\.(cgi|shtml|phtml|php)$">
                                SSLOptions +StdEnvVars
                </FilesMatch>

                <Directory /usr/lib/cgi-bin>
                                SSLOptions +StdEnvVars
                </Directory>

                BrowserMatch "MSIE [2-6]" \
                     nokeepalive ssl-unclean-shutdown \
                     downgrade-1.0 force-response-1.0
                
                BrowserMatch "MSIE [17-9]" ssl-unclean-shutdown
       </VirtualHost>
</IfModule>

Por fim, vamos criar o arquivo docker-compose.yml:

nano docker-compose.yml

Cole o código abaixo dentro do arquivo:

services:

  db:
    image: mariadb:latest
    container_name: ${DOMAIN}_db
    command: '--default-authentication-plugin=mysql_native_password'
    volumes:
      - ./db_data:/var/lib/mysql
    restart: always
    env_file: .env
    environment:
      - MYSQL_USER=${MYSQL_USER}
      - MYSQL_DATABASE=${MYSQL_DB}
      - MYSQL_PASSWORD=${MYSQL_PASSWORD}
      - MYSQL_ROOT_PASSWORD=${MYSQL_PASSWORD}
    networks:
      - default

  wordpress:
    container_name: ${DOMAIN}_web
    env_file:
      - .env
    depends_on:
      - db
    build: .
    volumes:
      - ./public_html:/var/www/html/
      - ./logs:/var/log/apache2
      - ./000-default.conf:/etc/apache2/sites-available/000-default.conf
      - ./default-ssl.conf:/etc/apache2/sites-available/default-ssl.conf
      - /etc/localtime:/etc/localtime:ro 
      - /etc/timezone:/etc/timezone:ro
      - /etc/letsencrypt/live/${DOMAIN}/fullchain.pem:/etc/apache2/ssl-certs/server.crt
      - /etc/letsencrypt/live/${DOMAIN}/privkey.pem:/etc/apache2/ssl-certs/server.key
    ports:
      - "9080:80"
      - "9081:443"
    restart: always
    environment:
      - WORDPRESS_DB_HOST=db:3306 #nome do container:porta que proverá recursos de banco de dados, neste caso o container chama db e a porta padrão é a 3306
      - WORDPRESS_DB_USER=${MYSQL_USER}
      - WORDPRESS_DB_PASSWORD=${MYSQL_PASSWORD}
      - WORDPRESS_DB_NAME=${MYSQL_DB}
      - WORDPRESS_TABLE_PREFIX=${WP_PREFIX}
    extra_hosts:
      - "${DOMAIN}:127.0.1.1"
    #user: ${USER}:${GROUP} #linha comentada, mas caso necessário configura UID e GID de permissão dos arquivos de acordo com definido no .env
    networks:
      - rede_proxy_reverso
      - default

  phpmyadmin:
    container_name: ${DOMAIN}-phpmyadmin
    image: linuxserver/phpmyadmin
    env_file: .env
    environment:
      PMA_HOST: db #nome do container que proverá recursos de banco de dados, neste caso o container chama db
      PMA_PORT: 3306
      MYSQL_ROOT_PASSWORD: ${MYSQL_PASSWORD}
    ports:
      - "9082:80"
    networks:
      - default

  networks:
    default:
      name: rede_${DOMAIN} #rede interna dessa stack, onde o phpmyadmin e o db ficam isolados da rede do proxy reverso, mas conseguem conversar com o wordpress
    rede_proxy_reverso:
      external: true

Passo 3: Confirmar caminho de certificados SSL gerados no Passo 1

Neste passo, é importante verificar qual a estratégia que utilizou para gerar o certificado SSL para seu domínio.

Se possui o certbot instalado no seu servidor, os certificados vão estar na pasta:

/etc/letsencrypt/live/nome_domínio/

Caso tenha utilizado um container somente para o certbot, ele costuma utilizar a pasta:

/etc/letsencrypt/live/nome_domínio/

Então é interessante verificar qual opção utilizou para gerar os certificados. Esta etapa é importante para atualizar o arquivo docker-compose.yml do passo anterior:

    volumes:
      - ./public_html:/var/www/html/
      - /etc/letsencrypt/live/${DOMAIN}/fullchain.pem:/etc/apache2/ssl-certs/server.crt
      - /etc/letsencrypt/live/${DOMAIN}/privkey.pem:/etc/apache2/ssl-certs/server.key

Observação! É possível que seus certificados estejam com o diretório criado com sufixo no nome, do tipo: -0001. Exemplo: /etc/letsencrypt/live/dev.viniciuspaes.com-0001/. Ficar atento a esta possibilidade, para definir o caminho correto para o domínio.

Passo 4: Confirmar criação entradas DNS

Neste exemplo vamos configurar um subdomínio para funcionar em um container com wordpress e com suporte SSL. Desta forma, em nossa registrar, precisamos ter uma entrada que converte um nome de domínio ou subdomínio para o ip do nosso servidor. Após criar a entrada, podemos verificar se a mesma está funcionar com o comando:

dig dev.viniciuspaes.com

Vamos ter como saída algo semelhante a:

; <<>> DiG Ubuntu <<>> dev.viniciuspaes.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 30
;; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
; COOKIE: 4f06f2012983012830129120398124d58fd5aac75eded21cf (good)
;; QUESTION SECTION:
;dev.viniciuspaes.com. IN A

;; ANSWER SECTION:
dev.viniciuspaes.com. 120 IN A 172.67.148.152

Na saída do comando dig acima, podemos ver que exista uma entrada DNS do tipo A configurada, direcionando o nome do subdomínio para o IP do servidor.

Passo 5: Executar o container

Com os passos anteriores configurados corretamente, podemos iniciar nosso container wordpress com suporte tanto http, quanto SSL. Vamos caminhar novamente para a pasta onde está o arquivo docker compose:

cd ~/docker/wordpress

Vamos executar o container com o comando:

docker compose up -d

Lembrete sobre as portas utilizadas:

• Acesso website http: porta 9080
• Acesso website https: porta 9081
• Acesso interface phpmyadmin: porta 9082

Passo 6: Acessar website wordpress pelo nome de domínio

Com o docker-compose.yml executado, é possível verificar se os containers do wordpress, mariadb (mysql) e phpmyadmin estão funcionando corretamente com o comando:

docker ps

Como saída do comando acima, vamos ter algo semelhante ao texto abaixo:

CONTAINER ID   IMAGE            COMMAND                  CREATED          STATUS          PORTS                                 NAMES
e2yf533e       dev-wordpress    "docker-entrypoint.s…"   22 seconds ago   Up 20 seconds   9080->80/tcp, 9081->443/tcp,          dev.viniciuspaes.com_web
47g5b597       mariadb:latest   "docker-entrypoint.s…"   23 seconds ago   Up 21 seconds   3306/tcp                              dev.viniciuspaes.com_db
224907aa       phpmyadmin       "/init"                  23 seconds ago   Up 21 seconds   443/tcp, 9082->80/tcp, 9082->80/tcp   dev.viniciuspaes.com-phpmyadmin

Se na saída acima, na coluna de STATUS não receber nenhum tipo de erro. Aparentemente os containers estão funcionais.
Abra agora o seu browser de internet e acesse o nome de domínio que atribuiu ao container. No caso desse exemplo, vamos acessar:

https://dev.viniciuspaes.com

Atenção, o container do banco de dados demora alguns segundos a mais para iniciar e ficar funcional, comparado ao container do wordpress. Se acessar rapidamente a url do seu nome de domínio, é comum receber o erro de conexão de banco de dados do wordpress. Só aguardar alguns segundos e recarregar a página.

Conclusão

Existem diversas abordagens para configurar o wodpress em formato de container no docker. O container padrão do wordpress vem com o servidor de páginas apache instalado, porém somente com a porta 80 configurada. Este tutorial abordou uma forma de ativar o virtualhost para ssl no container padrão do wordpress e definiu as configurações necessárias para correto funcionamento.

O post Tutorial container wordpress com docker compose e suporte SSL e Apache apareceu primeiro em Vinicius Paes.

Instalar imagem do homer em formato de container com o docker. O Homer é uma dashboard estática muito famosa para utilização em servidores em homelab.

Requisitos

1. Software docker instalado e configurado no sistema operacional
2. Docker compose instalado e configurado
3. Conexão com internet para download da imagem do homer dashboard.

Como instalar imagem do homer com docker

Passo 1: Ter uma pasta dedicada para gerenciar os containers

Caso esteja configurando em linha de comando no linux:

mkdir ~/docker
cd ~/docker

Passo 2: Criar uma pasta para armazenar os arquivo de configuração do homer

mkdir ~/docker/homer

Passo 3: Descobrindo o UID e o GID do seu usuário no linux

No terminal utilize o comando para descobrir o UID (user ID):

id -u

Para descobrir o GID (group ID):

id -g

No meu exemplo, meu UID e GID tiveram como resultado o número 1000.

Passo 4: Criar o arquivo de docker compose para o homer

Agora precisamos criar o arquivo docker-compose.yml dentro da pasta ~/docker/filebrowser com o editor de texto conhecido como nano.

nano ~/docker/homer/docker-compose.yml

Dentro do docker-compose.yml é necessário inserir o conteúdo abaixo:

---
version: "2"
services:
  homer:
    image: b4bz/homer
    container_name: homer
    volumes:
      - ~/docker/homer/data:/www/assets
    ports:
      - 8080:8080
    environment:
      - UID=1000
      - GID=1000
    restart: unless-stopped

Após inserir os dados acima dentro do arquivo docker-compose.yml pelo nano, lembre-se de salvar o arquivo e sair do editor.

Passo 5: Inicializar o container

Caso a imagem do container não esteja disponível (possivelmente não estará) o docker fará o download automaticamente.
Para iniciar a imagem do container com o docker compose, utilize o comando:

cd ~/docker/homer
docker compose up -d

Caso esteja utilizando o homer em seu próprio computador, é possível acessá-lo pelo browser, pela url:

http://localhost:porta

Ou se estiver utilizando o mesmo em algum computador remoto ou servidor, basta acessar pelo ip:porta, exemplo:

http://192.168.1.70:8080

Caso já tenha algum serviço funcionando na porta 8080, é necessário editar o arquivo docker-compose.yml e alterar o mapeamento de portas, exemplo:

    ports:
      - 8085:8080

Desta forma a dashboard do homer ficará disponível na porta 8085.

Passo 6: Customização da dashboard

Após a inicialização do container, terá uma dashboard com dados padrão recém criada.

Para customizar sua dashboard, edite o arquivo:

~/docker/homer/data/config.yml

Se atente que o arquivo é no formato yaml (.yml) e a identação é fundamental. Se não estiver familiarizado em como editar o arquivo, basta seguir o padrão já existente. Lembre-se de ter um backup do arquivo original de config, caso necessite reverter as mudanças.

É possível encontrar diversos ícones para a dashboard em 2 excelentes repositórios no github:

• Homer Icons
• Dashboard Icons

Conclusão

A instalação do container de dashboard do homer é super fácil. Fique atento a qual porta deseja que a mesma funcione, para evitar conflitos com outros serviços.

Para demais comandos utilizando o docker em linha de comando, acesse o artigo: https://viniciuspaes.com/raspberry-pi/tutorial-como-instalar-docker-raspberry-pi/

O post Tutorial instalar homer com docker compose apareceu primeiro em Vinicius Paes.

Instalar imagem do portainer em formato de container com o docker, utilizando o docker compose.

Requisitos

1. Software docker instalado e configurado no sistema operacional
2. Docker compose instalado e configurado
3. Conexão com internet para download da imagem do portainer

Como instalar imagem do portainer com docker

Passo 1: Ter uma pasta dedicada para gerenciar os containers

Se estiver configurando o container em linha de comando, é interessante ter uma pasta para organizar os arquivos das imagens, como pasta de configuração, arquivo de texto da configuração do docker compose, etc.

mkdir ~/docker
cd ~/docker

Passo 2: Criar uma pasta para armazenar os arquivo de configuração do portainer

mkdir ~/docker/portainer

Passo 3: Criar o arquivo de docker compose para o portainer

Agora precisamos criar o arquivo docker-compose.yml dentro da pasta ~/docker/portainer com o editor de texto conhecido como nano.

nano ~/docker/portainer/docker-compose.yml

Dentro do docker-compose.yml é necessário inserir o conteúdo abaixo:

services:
  portainer:
    image: portainer/portainer-ce:latest
    container_name: portainer
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./portainer-data:/data                             #Pasta onde os arquivos de configuração serão disponíveis no ambiente de host ~/docker/portainer/portainer-data/
    ports:
      - 9000:9000

Após inserir os dados acima dentro do arquivo docker-compose.yml pelo nano, lembre-se de salvar o arquivo e sair do editor.

Passo 4: Inicializar o container

Caso a imagem do container não esteja disponível (possivelmente não estará) o docker fará o download automaticamente.
Para iniciar a imagem do container com o docker compose, utilize o comando:

cd ~/docker/portainer
docker compose up -d

Caso esteja utilizando o portainer em seu próprio computador, é possível acessá-lo pelo browser, pela url:

http://localhost:porta

Ou se estiver utilizando o mesmo em algum computador remoto ou servidor, basta acessar pelo ip:porta, exemplo:

http://192.168.1.70:9000

Caso já tenha algum serviço funcionando na porta 9000, é necessário editar o arquivo docker-compose.yml e alterar o mapeamento de portas, exemplo:

    ports:
      - 9090:9000

Desta forma o serviço do filebrowser ficará disponível na porta 9090.

Após primeiro acesso web ao portainer, será necessário criar as credenciais de acesso com usuário e senha. Lembre de guardar as credenciais em um local seguro.

Conclusão

A instalação do portainer com docker é extremamente simples. O docker compose auxilia no setup do container por já ter uma receita de bolo das configurações desejadas.

Para demais comandos utilizando o docker em linha de comando, acesse o artigo: https://viniciuspaes.com/raspberry-pi/tutorial-como-instalar-docker-raspberry-pi/

O post Tutorial instalar portainer com docker compose apareceu primeiro em Vinicius Paes.

Instalar imagem do filebrowser em formato de container com o docker. Neste exemplo vamos instalar em um ambiente linux, mas o setup é o mesmo para o windows.

Requisitos

1. Software docker instalado e configurado no sistema operacional
2. Docker compose instalado e configurado
3. Conexão com internet para que seja possível realizar o download da imagem do filebrowser

Como instalar imagem do filebrowser com docker

Passo 1: Ter uma pasta dedicada para gerenciar os containers

Caso esteja configurando em linha de comando no linux:

mkdir ~/docker
cd ~/docker

Passo 2: Criar uma pasta para armazenar os arquivo de configuração do filebrowser

mkdir ~/docker/filebrowser

Passo 3: Criar arquivos de configuração em branco do filebrowser

Na primeira execução/instalação do filebrowser, é necessário criar os arquivos de configuração em branco, para evitar problemas do container criar os mesmos como diretório.

Dentro da pasta ~/docker/filebrowser vamos criar a pasta config/ para armazenar os arquivos de configuração (que inicialmente vão estar em branco):

mkdir ~/docker/filebrowser/config
touch ~/docker/filebrowser/config/filebrowser.db
touch ~/docker/filebrowser/config/filebrowser.json

Passo 4: Descobrindo o UID e o GID do seu usuário no linux

No terminal utilize o comando para descobrir o UID (user ID):

id -u

Para descobrir o GID (group ID):

id -g

No meu exemplo, meu UID e GID tiveram como resultado o número 1000.

Passo 5: Definindo corretamente o proprietário dos arquivos de configuração do filebrowser

É necessário que os arquivos filebrowser.db e filebrowser.json tenham como proprietário o usuário e o grupo de usuário corretos, no meu caso:

sudo chown vinicius:vinicius ~/docker/filebrowser/config/filebrowser.*

É possível também utilizar o UID e o GID no lugar dos nomes do usuário e grupo de usuário acima, ou seja, 1000:1000 (ao invés de vinicius:vinicius).

Passo 6: Criar o arquivo de docker compose para o filebrowser

Agora precisamos criar o arquivo docker-compose.yml dentro da pasta ~/docker/filebrowser com o editor de texto conhecido como nano.

nano ~/docker/filebrowser/docker-compose.yml

Dentro do docker-compose.yml é necessário inserir o conteúdo abaixo:

---
version: "2"
services:
  filebrowser:
    image: filebrowser/filebrowser
    container_name: filebrowser
    volumes:
      - /home/vinicius:/srv                                                            #Pasta onde deseja que os arquivos sejam acessados pelo filebrowser
      - /home/vinicius/docker/filebrowser/config/filebrowser.db:/database.db
      - /home/vinicius/docker/filebrowser/config/filebrowser.json:/filebrowser.json
    ports:
      - 80:80                                                                          #Mapeamento porta externa (servidor) : Porta interna (container)
    user: 1000:1000                                                                    #(Id do usuário) UID:GID (Id do grupo do usuário)
    restart: unless-stopped

Após inserir os dados acima dentro do arquivo docker-compose.yml pelo nano, lembre-se de salvar o arquivo e sair do editor.

Passo 7: Inicializar o container

Caso a imagem do container não esteja disponível (possivelmente não estará) o docker fará o download automaticamente.
Para iniciar a imagem do container com o docker compose, utilize o comando:

cd ~/docker/filebrowser
docker compose up -d

Caso esteja utilizando o filebrowser em seu próprio computador, é possível acessá-lo pelo browser, pela url:

http://localhost:porta

Ou se estiver utilizando o mesmo em algum computador remoto ou servidor, basta acessar pelo ip:porta, exemplo:

http://192.168.1.70:80

Caso já tenha algum serviço funcionando na porta 80, é necessário editar o arquivo docker-compose.yml e alterar o mapeamento de portas, exemplo:

    ports:
      - 8077:80

Desta forma o serviço do filebrowser ficará disponível na porta 8077.

Conclusão

Instalar o container do filebrowser é bastante simples. Necesário ter cuidado apenas na primeira vez que inicializar o container, pois é necessário ter os arquivos de configuração criados previamente, senão o container irá criar os mesmos como diretórios e causará erros de execução.

Para demais comandos utilizando o docker em linha de comando, acesse o artigo: https://viniciuspaes.com/raspberry-pi/tutorial-como-instalar-docker-raspberry-pi/

O post Tutorial instalar filebrowser com docker compose apareceu primeiro em Vinicius Paes.

• Habilitar porta 465 para envio de email SMTPS no Postfix, para o sistema ficar compatível com o novo Outlook (cliente de email)

Passo a para para habilitar porta 465 no postfix para ser compatível com Outlook

Caso tenha chego aqui pelo post de Configurar um Servidor de Email Completo no Ubuntu, com a atualização do aplicativo “Email” do Windows para Outlook, há problemas de autenticação e configuração para envio de emails. Este problema é mais evidente no Outlook, que só aceita enviar emails pela porta 465. Há outros clientes de email que podem ter a mesma característica.

Passo 1 – Conexão SSH no servidor de emails

Conecte no seu servidor por SSH, exemplo:

ssh usuario@ip

Ou caso utilize uma chave (padrão caso seu servidor esteja na Amazon AWS):

ssh -i chave.pem usuario@IP

Passo 2 – Editar configuração Postfix

Para adicionar envio de emails também pela porta 465, precisamos primeiramente habilitar a opção no postfix. Desta forma, é necessário alterar o arquivo master.cf:

sudo nano /etc/postfix/master.cf

Após o arquivo aberto, precisamos inserir o conteúdo abaixo no fim do arquivo:

smtps     inet  n       -       y       -       -       smtpd
  -o syslog_name=postfix/smtps
  -o smtpd_tls_wrappermode=yes
  -o smtpd_sasl_auth_enable=yes
  -o smtpd_relay_restrictions=permit_sasl_authenticated,reject
  -o smtpd_recipient_restrictions=permit_mynetworks,permit_sasl_authenticated,reject
  -o smtpd_sasl_type=dovecot
  -o smtpd_sasl_path=private/auth

Após inserir o conteúdo, salve o arquivo antes de fechar o editor nano.

Passo 3 – Reiniciar Postfix

Para que as modificações realizadas fiquem persistentes, há necessidade de reiniciar o postfix. Execute então o comando abaixo:

sudo service postfix restart

Passo 4 – Abrir porta 465 no firewall

Caso tenha firewall UFW instalado e configurado, ou utilize o IPTABLES para bloquear portas no servidor, é necessário garantir acesso ao tráfego na porta 465.

IPTABLES

Para habilitar o tráfego da porta 465 pelo IPTABLES, utilize o comando:

sudo iptables -A INPUT -p tcp --dport 465 -j ACCEPT

UFW

Caso tenha o UFW configurado, execute o comando:

sudo ufw allow 465/tcp

Passo 5 – Abrir porta 465 em provedor ou cloud

Caso utilize alguma empresa de Cloud para hospedar seu servidor de email, é necessário acessar a interface da mesma e verificar a possibilidade de abrir a porta 465. Da mesma forma, caso hospede o servidor em seu provedor ou localmente, é necessário habilitar a comunicação da porta 465 no roteador.

Conclusão

Caso tenha seguido os passos do tutorial corretamente, seu postfix já está habilitado a enviar emails autenticados também pela porta 465. Alguns clientes de email precisam desta configuração para conseguirem enviar emails corretamente.

O post Servidor de Email Ubuntu: habilitar porta 465 SMTP para Outlook apareceu primeiro em Vinicius Paes.

Caso esteja migrando um servidor, sendo necessário também migrar os certificados SSL do letsencrypt (certbot), é possível seguir este tutorial para executar as tarefas necessárias.
Desta forma temos 2 servidores em questão:

• Servidor ANTIGO
• Servidor NOVO

Resumo de como migrar certificado SSL entre servidores

Resumindo os passos necessários:

1. Tenha o certbot instalado em ambos os servidores
2. Conecte no servidor antigo por SSH
3. Utilize o RSYNC para sincronizar as pastas do servidor antigo com o novo (faça backup de tudo antes para evitar que arquivos sejam sobreescritos)
   1. sudo rsync -avz /etc/letsencrypt/archive/       root@ipservidornovo:/etc/letsencrypt/archive/
   2. sudo rsync -avz –links /etc/letsencrypt/live/ root@ipservidornovo:/etc/letsencrypt/live/
   3. sudo rsync -avz /etc/letsencrypt/renewal/      root@ipservidornovo:/etc/letsencrypt/renewal/
4. No servidor novo, testar se os links lógicos foram preservados:
   1. sudo certbot update_symlinks
5. Testar se migração foi realizada com sucesso:
   1. sudo letsencrypt renew –dry-run
6. Migração concluída

Passo a passo para migrar certificados SSL de um servidor antigo para um novo

Passo 1 – Preparar o servidor novo para receber os certificados (instalar certbot)

Abra um terminal ou utilize um software (putty) para conectar no Servidor NOVO para instalar o certbot:

ssh usuario@ipservidornovo

Agora siga os passos descritos nesta URL pra instalar o certbot:

https://certbot.eff.org/

Caso já tenha o certbot instalado no novo servidor, interessante realizar um backup dos certificados para evitar que sejam sobreescritos pelo rsync no próximo passo.

Passo 2 – Enviar os arquivos dos certificados para o novo servidor

Passo 2 – Opção 1 – Migrar os arquivos com RSYNC

Abra uma nova janela do terminal ou utilize um software (putty) e conecte no Servidor ANTIGO por ssh:

ssh usuario@ipservidorantigo

Caso tenha possibilidade de conexão no Servidor NOVO por ssh à partir do Servidor ANTIGO, é possível utilizar RSYNC (Atenção! Estas pastas são propriedades do usuário root, então para ter permissão de sincronizar, é necessário se conectar com usuário root, ou migrar para umas pasta temporária no novo servidor e depois mover os arquivos):

sudo rsync -avz         /etc/letsencrypt/archive/  usuario@ipservidornovo:/etc/letsencrypt/archive/
sudo rsync -avz --links /etc/letsencrypt/live/     usuario@ipservidornovo:/etc/letsencrypt/live/
sudo rsync -avz         /etc/letsencrypt/renewal/  usuario@ipservidornovo:/etc/letsencrypt/renewal/

Vá para o terminal do Servidor NOVO que abriu, ou para a aba de conexão do Putty relacionada ao Servidor NOVO.
Agora execute o comando para verificar que os links simbólicos da pasta /etc/letsencrypt/live/ foram migrados corretamente:

sudo certbot update_symlinks

Se tudo ocorreu corretamente, pode executar o certbot e testar reinstalar o certificado:
Caso utilize nginx:

sudo certbot --nginx

Caso utilize apache:

sudo certbot --apache

Tudo Pronto! Certificados Migrados com Sucesso!

Passo 2 – Opção 2 – Migrar os arquivos com SCP

Caso não tenha possibilidade de conexão por SSH de um servidor para o outro com permissão root e não quer utilizar uma pasta temporária, é possível compactar os arquivos e enviar para o outro servidor:
Vá para sua pasta home:

cd ~

Agora execute o comando para criar um arquivo compactado dos certificados:

sudo tar -chvzf letsencrypt-files.tar.gz /etc/letsencrypt/archive/ /etc/letsencrypt/renewal/

Agora é preciso enviar o arquivo para o Servidor NOVO.
Caso possa conectar no servidor novo por SSH à partir do Servidor ANTIGO com um usuário sem permissão root, é possível utilizar o comando scp:

scp letsencrypt-files.tar.gz usuario@ipservidornovo:

No comando acima, o arquivo vai ser transferido para a pasta home do seu usuário, como exemplo: /home/usuario/

Se preferir, é possível realizar o download do arquivo criado para seu computador pessoal. Abra um terminal em seu computador e utilize o comando:
Caso utilize windows:

scp usuario@ipservidorantigo:/home/usuario/letsencrypt-files.tar.gz "%userprofile%/Downloads"

Se estiver utilizando Mac ou Linux:

scp usuario@ipservidorantigo:/home/usuario/letsencrypt-files.tar.gz ~/Downloads

Com o arquivo letsencrypt-files.tar.gz já disponível no Servidor NOVO, é necessário descompactar o mesmo e mover os certificados para a pasta /etc/letsecrypt. No comando abaixo vamos levar em consideração que o arquivo compactado está presente na pasta home do usuário.

sudo tar -xvf ~/letsencrypt-files.tar.gz

Agora copie os arquivos dos certificados que gostaria de instalar no novo servidor:

sudo cp ~/etc/letsencrypt/archive/ /etc/letsencrypt/archive/ -R
sudo cp ~/etc/letsencrypt/renewal/ /etc/letsencrypt/renewal/ -R

Necessário agora recriar os links lógicos para a pasta “live” de cada domínio:

sudo ln -s /etc/letsencrypt/archive/domonio1.com.br/cert1.pem      /etc/letsencrypt/live/domonio1.com.br/cert.pem
sudo ln -s /etc/letsencrypt/archive/domonio1.com.br/chain1.pem     /etc/letsencrypt/live/domonio1.com.br/chain.pem
sudo ln -s /etc/letsencrypt/archive/domonio1.com.br/fullchain1.pem /etc/letsencrypt/live/domonio1.com.br/fullchain.pem
sudo ln -s /etc/letsencrypt/archive/domonio1.com.br/privkey1.pem   /etc/letsencrypt/live/domonio1.com.br/privkey.pem

Atenção! Lembrando que a pasta /archive/dominio1.com.br/ pode conter várias versões dos certificados, cert.pem, cert1.pem, cert2.pem; chain.pem, chain1.pem, chain2.pem, etc. Escolher a mesma versão utilizada no Servidor ANTIGO.

Agora verifique se os links lógicos foram criados corretamente, senão, revise os passos anteriores:

sudo certbot update_symlinks

Lembrando que é comum receber erro nos links lógicos (symlinks), como o erro abaixo:

Renewal configuration file /etc/letsencrypt/renewal/dominio1.com.br.conf is broken.
The error was: expected /etc/letsencrypt/live/dominio1.com.br/cert.pem to be a symlink
Skipping.

Caso receba a mensagem de erro acima, é necessário repetir o passo anterior (sudo ln -s …)  e verificar se criou os links lógicos corretamente.

Se tudo ocorreu corretamente, pode executar o certbot e testar reinstalar o certificado:
Caso utilize nginx:

sudo certbot --nginx

Caso utilize apache:

sudo certbot --apache

Caso não receba nenhuma mensagem de erro, os certificados foram migrados com sucesso.

Conclusão

O processo de migração dos certificados do certbot (letsencrypt) é bastante simples. Basta saber quais os arquivos necessários e ter certeza que a estrutura de links lógicos (symlinks) foi preservada na migração.
Caso tenha alguma dúvida ou sugestão, basta informar nos comentários!

O post Tutorial como migrar certificados SSL letsencrypt de um servidor antigo para o novo apareceu primeiro em Vinicius Paes.

Introdução

A Raspberry Pi Foundation lança o quinto modelo da sua linha de mini computadores de placa única. O Raspberry Pi 5 segue as mesmas especificações de tamanho, tendo sua largura e comprimento semelhantes à de um cartão de crédito.

Em uma análise superficial, os upgrades mais aparentes são referentes ao processador e suporte PCI-e.

De acordo com a fundação, o novo processador possui velocidade entre 2 ou 3x mais veloz que o modelo anterior (Raspberry Pi 4), e o clock base do novo processador é de 2,4 Ghz.

O segundo destaque é o suporte ao PCI-e 2.0 x1, mas que diferente dos seus concorrentes, precisa de um HAT (Hardware Attached on Top) específico para a conexão.

Especificações Técnicas do Raspberry Pi 5

O Raspberry Pi 5 conta com diversos upgrades de hardware, mas nada muito expressivo diante o modelo 4 e seus concorrentes. Abaixo segue a especificação técnica do novo modelo:

• Processador: Broadcom BCM2712 com clock de 2.4GHz, 4 núcleos (quad-core) e 64-bits, da linha Arm Cortex-A76
  • Possui extensões de criptografia, Memória Cache L2 de 512KB por cada núclo e 2MB de memória cache L3 compartilhada
• Placa de Vídeo (GPU): Modelo VideoCore VII, com suporte OpenGL ES 3.1, Vulkan 1.2
• Saída vídeo: 2 Saídas micro HDMI com suporte a 4K e 60 frames com suporte HDR e suporte a decodificação HEVC
• Memória RAM: Utiliza memória ram de baixo consumo energético LP-DDR4 X-4267 SDRAM. É possível adquirir o Raspberry Pi 5 com 4 ou 8GB de RAM.
• Conexão Wi-fi: Modelo Dual-band 802.11ac (wifi-5)
• Conexão Bluetooth: 5.0 (modelo de baixo consumo BLE)
• Armazenamento: Slot para cartão microSD, agora com suporte ao modo SDR104 de alta velocidade
• Conexão USB:
  • 2 portas × USB 3.0, suporte para largura de banda simultânea de 5Gbps
  • 2 portas × USB 2.0, para conexão de periféricos
• Conexão Ethernet cabeada: Modelo Gigabit, com suporte Power Over Ethernet+ (mas precisa de um HAT PoE)
• Interface MIPI: Suporte para 2 câmeras/dispositivos em largura de banda de 4-lanes (o dobro, comparado com o Raspberry Pi 4)
• Interface PCIe 2.0 x1: permite conexão de periféricos, placas gráficas ou unidades de armazenamento (mas precisa de um HAT específico para esta finalidade)
• Fonte de Alimentação: o modelo continua sendo alimentado por fonte de alimentação de 5V, mas necessita de uma corrente de 5 amperes. A conexão é USB-C, e agora possui suporte ao Power Delivery
• GPIO: Continua com o mesmo suporte padrão do header de 40 pinos do Raspberry Pi
• RTC: Suporte para Real-time clock (RTC), mas precisa de alimentação de uma bateria externa
• Botão: Botão de liga e desliga
• Ventoinha: suporte para ventoinhas PWM com conector dedicado (4 pinos) na placa mãe

Preço do Raspberry Pi 5

Os novos modelos do Raspberry Pi 5 tiveram um aumento diante o modelo anterior, os novos valores são:

• Raspberry Pi 5 com 4GB de ram: U$60 dólares
• Raspberry Pi 5 com 8GB de ram: U$80 dólares

Ao observar os novos preços acima, notamos um aumento de U$5 dólares diante os modelos com a mesma configuração de RAM do Raspberry Pi 4.

Lançamento do Raspberry Pi 5

De acordo com a fundação mantenedora do Raspberry Pi o lançamento do Raspberry Pi 5 será em outubro de 2023. Caso tenha interesse no novo modelo, já é possível comprar em pré venda nos principais fornecedores internacionais.

• Pi Hut
• Parallax
• Pimorini
• Cytron.io

Considerações sobre o novo Raspberry Pi 5

De forma geral, um problema comum no Raspberry Pi, é o IO. No modelo 5, o upgrade para suporte ao modo SDR104 é interessante, porém de forma geral não garante desempenho e confiabilidade satisfatórios para armazenamento de longo prazo. O suporte para PCI-e 2.0 x1 é interessante, mas a banda de transferência também fica limitada a algo próximo a 500MB/s, então não temos grandes vantagens, comparadas a utilização de um SSD na porta USB 3.0.

Se compararmos os principais concorrentes do Raspberry Pi, é possível notar que já possuem suporte a unidade de armazenamento NVME nativamente, com o slot soldado na placa mãe. Acredito que a Pi Foundation segurou um pouco os upgrades nesta geração, como o RPi 5 chegou no fim do baile em 2023, esperava um hardware igual ou superior aos concorrentes.

O Raspberry ainda tem muitas vantagens diante os produtos concorrentes, mas a principal ainda é diante a comunidade de desenvolvedores em torno do Raspberry. Já tive produtos dos concorrentes, e me decepcionei pela falta de suporte ao longo do tempo. A pergunta é até que ponto a Raspberry vai conseguir segurar o pé no freio nos upgrades e se manter na liderança, a medida que as outras marcas vão desenvolvendo sua base de suporte e investindo pesado em hardware.

E você, o que achou do Raspberry Pi 5? Uma grande evolução diante o modelo anterior? Eu particularmente não vejo nenhuma grande vantagem para realizar um tech refresh no meu Raspberry Pi 4. Mas vamos aguardar os testes de benchmark.

O post Raspberry Pi 5 apareceu primeiro em Vinicius Paes.

As ferramentas de Inteligência Artificial são de grande valia no processo de restauração e colorização de fotografias antigas digitalizadas. Muitas vezes o processo de restauração era demorado, pois era necessário utilizar ferramentas de edição como o photoshop para manualmente ir corrigindo defeitos da fotografia e ajustando características da imagem.

As ferramentas de IA ainda não são perfeitas, principalmente se a foto possuir defeitos e ou desgastes do tempo. Porém, os resultados são bem satisfatórios. Nesta postagem, reuni as principais ferramentas de AI que ofertam recursos de colorização ou restauração de imagens. Fiz um teste com uma fotografia de um familiar e fiquei impressionado com o ganho de nitidez e profundidade em alguns testes. O melhor resultado que obtive foi corrigindo os defeitos da imagem com o photoshop e depois utilizando as ferramentas de Inteligência Artificial para ajustar os demais parâmetros.

Para fins de comparação, os testes que realizei foram em uma imagem 3×4 do meu avô. Segue a imagem original ao lado da edição manual que fiz no photoshop:

Lista de Ferramentas de Inteligência Artificial para restaurar e colorir fotos antigas

A seguir a lista de ferramentas de IA para restaurar fotografias, lembrando que nem todas são gratuitas, mas é possível realizar um teste grátis com funções básicas, ou gerar uma foto com marca dágua.

Hotpot.ai

A Hotpot oferta diversas ferramentas em seu website, mas como o nosso objetivo é restaurar e colorir as fotos, as principais são:

• Restauração de foto
• Colorir foto antiga

Com o Hotpot não obtive resultados extraordinários com a fotografia, tive nitidez mais no rosto, porém as roupas e o fundo ficaram com muitos ruídos e algumas vezes com pouca nitidez. Sobre a etapa de colorir as fotos, elas mantinham aquele efeito de quadros antigos, que eram pintados a mão. Porém a ferramenta deixou gerar as imagens de forma gratuita.

Abaixo segue algumas comparações da utilização do Hotpot.ai com efeito de restauração com IA na foto original e na foto com photoshop:

Como mencionei, o resultado da aplicação de IA na foto previamente editada com photoshop foi excelente. É possível verificar que a imagem ganhou mais nitidez e os ajustes de contraste geram um efeito de profundidade. Resultado fantástico.

Utilizando as opções de colorização do Hotpot.ai, obtive os seguintes resultados:

Das imagens acima, o melhor resultado que obtive foi com a opção de colorização com 15 fatores. Mas ao olhar as imagens, é possível notar alguns detalhes no queixo, mas estes problemas foram oriundos do software de compressão das imagens para web. Fiz essa compressão para postar a imagem aqui no website. Se conseguiu um resultado melhor com outra opção de fator de cor, me conta aí nos comentários!

VanceAI.com

Com a ferramenta de IA da VanceAI foi possível realizar modificações na foto diretamente pela página web. Sendo possível ajustar características de cor, contraste, nitidez, cortar a imagem, girar, etc. A capacidade de correção de defeitos da imagem é boa, achei melhor que a do Hotpot, que parecia utilizar um “blur” nos defeitos e suas proximidades.

O que mais me impressionou foi a nitidez do rosto das pessoas na foto e a textura de pele utilizada que superou e muito minhas expectativas. Porém alguns defeitos da fotografia a IA não conseguiu corrigir corretamente e algumas dobras do pescoço ficaram com riscos. Mas se fosse levar em conta somente o rosto, de longe foi a melhor ferramentas que utilizei. A desvantagem que a imagem gerada de forma gratuita possui marca dágua.

Quando removi os maiores defeitos da imagem com o photoshop e utilizei novamente a ferramenta, os resultados foram fantásticos. Basta acessar o link abaixo para ter acesso a ferramenta:

• Restauração e colorização de fotografias

ImageColorizer.com

A Imagecolorizer possui diversas ferramentas presentes em seu website, diferente da VanceAI que possui tudo integrado, na Imagecolorizer é necessário realizar cada etapa por vez. No teste que realizei, peguei a foto original e solicitei o serviço de Reparação (AI Repair), o resultado foi bem abaixo do esperado. Os campos que possuem dobra da fotografia ficaram borrados ao invés de corrigidos igual a Vance realizou.

Optei por utilizar a foto que eu mesmo fiz as correções e reparos na fotografia e apliquei o serviço de “Retouch”, aumentando a nitidez, o resultado ficou fantástico, o melhor que consegui de todas as ferramentas.

Por fim, optei em colorir a imagem que realizei o retouch. O resultado ficou bem abaixo do esperado. Na questão de colorir, a VanceAI ainda é superior. Até mesmo o Hotpot teve um resultado melhor que a imagecolorizer. As ferramentas que utilizei da ImageColorizer foram:

• AI Repair
• AI Retouch (a melhor solução de todas)
• AI Colorize (resultado pouco satisfatório para o teste que realizei)

Remini.AI

O Remini.AI possui uma solução all-in-one para restaurar e colorir as imagens. No teste que realizei os resultados foram fantásticos. De longe a melhor solução para nitidez e detalhes nos rostos da imagem e correção de contraste em regiões de contorno. A adição de profundidade na foto também é espetacular. A única desvantagem a opção gratuita apenas ofertas imagens com marca dágua.

É possível acessar a ferramenta pelo link:

• Restauração e colorização de fotos

A imagem acima não faz jus ao resultado. A foto ajustada com IA possui uma resolução muito maior e excelente nitidez. Antes de realizar um veredicto sobre a foto acima, lembre-se que a mesma teve resolução diminuída e foi comprimida para padrão web. Uma dica, se utilizar o aplicativo de celular da Remini é possível exportar a foto sem marca dágua.

ImgKits.com

O ImgKits.com também oferta diversos serviços de manipulação de imagens. Porém nem todas as opções são grátis, fiz testes com as opções de unblur, repair e colorização:

• Imgkits.com
• Ferramenta unblur e colorização do Imgkits.com
• Ferramenta de remoção de defeitos na imagem do Imgkits.com

De todas as ferramentas de IA listadas o ImgKits é a que tive resultados menos otimizados:

• Utilizando uma imagem que já tinha restaurado (photoshop), não notei nenhum ganho expressivo, porém notei algumas correções de contraste em regiões de contorno, mas quase imperceptíveis. Em seguida optei por colorir a imagem, para ver se há algum ganho no processo ao utilizar uma imagem já restaurada. Novamente o resultado foi pífio.

Porém, me surpreendi com o processo de restauração de imagem, você precisa indicar manualmente onde gostaria de realizar correções e o resultado é fantástico. De todas as ferramentas foi a que garantiu o melhor resultado nas correções de defeitos, realmente funciona! Somente as bordas da imagem que a ferramenta teve dificuldade de corrigir, então mantive o aspecto original.

Na primeira vez que utilizei o Imgkits.com tive uma impressão ruim no geral, mas entendi que cada fotografia precisa de ajustes diferentes. Como o imgkits deixa você livre pra escolher quais correções deseja utilizar, diferente das IA que já fazem a análise geral e correção, o resultado final depende muito do seu discernimento sobre qual ferramenta deve utilizar dentro do site.

Abaixo temos 3 sequências de comparação de imagens:

1. Não gostei da ferramenta de unblur, porém quando comprimi a imagem para postar aqui no site, o resultado ficou satisfatório. Mas as outras opções de IA são melhores.
2. É aqui que o Imgkits brilha! Para remoção de feitos ela ganhou de todas as ferramentas.
3. Processo de aplicação de cor deixou a desejar.

Conclusões

Analisando as ferramentas disponíveis, cheguei a algumas conclusões sobre o processo de restauração de fotografias utilizando IA. No meu caso específico, restaurando uma imagem 3×4, o setup ideal foi:

Para a imagem original cheia de defeitos, segue os passos:

1. Imgkits.com: Remover os defeitos da imagem, como riscos, dobra da fotografias, etc.
2. Imgkits.com: Remover o fundo da imagem (esta etapa faz sentido em imagens como a de foto 3×4, que o fundo pode gerar ruídos)
3. ImageColorizer ou Remini.AI ou Vance.AI (empate técnico): Ajustar constraste, brilho, nitidez etc. Se utilizar a Remini.AI no app do celular gera a imagem sem marca dágua.
4. Hotpot.AI: Colorização na escala 15F. Se remover o fundo no passo 2, o resultado de cor fica muito bom.

Para uma imagem sem defeitos, mas antiga, segue os passos:

• ImageColorizer ou Remini.AI ou Vance.AI (lembrando que a Remini.AI insere características de barba e bigode nas fotos para dar sensação de detalhes no rosto, mas não estão presentes naturalmente)
• Hotpot.AI: Colorização na escala 15F. Lembrando que fiz o teste com foto 3X4, se sua foto for em outro estilo, é necessário pesquisar qual o resultado mais satisfatório.

Conseguiu resultados diferentes utilizando estas ferramentas? Conhece outras ferramentas de IA para restauração de fotos? Conta aí nos comentários!

O post Como restaurar e colorir fotos antigas com Inteligência Artificial (IA) apareceu primeiro em Vinicius Paes.

• Instalar suporte .NET Framework no Linux, com o Mono
• Criar servidor de Terraria no Raspberry Pi

Considerações Iniciais

Neste tutorial vamos levar em conta que já formatou um cartão de memória ou unidade de armazenamento USB no seu raspberry Pi com o Raspberry Pi Imager. No momento da formatação e escolha do sistema operacional (Raspberry Pi OS ou Ubuntu) você já habilitou suporte a conexão SSH e conexão wifi, caso não vá utilizar conexão de internet por cabo no Raspberry.

Passo a passo para criar servidor de Terraria no Raspberry Pi

Passo 1 – Conexão SSH

Como comentamos, já vamos considerar que instalou a imagem do Sistema Operacional no Raspberry com suporte a conexão SSH. Desta forma, levando em conta o usuário viniciuspaes e o IP sendo 192.168.1.55, vamos realizar o login com o comando:

ssh viniciuspaes@192.168.1.55

Passo 2 – Update e Upgrade de softwares

Vamos ter certeza que estamos com o sistema operacional e os softwares na versão mais atualizada. Vamos então executar o comando:

sudo apt update && sudo apt upgrade

Passo 3 – Download e instalação da versão mais atualizada do Mono

Terraria utiliza o .NET Framework para funcionar, como estamos utilizando o sistema operacional Linux, precisamos então utilizar o software Mono. Nesta etapa precisamos acessar o site do Mono pelo link:

• Página de Download da versão atualizada do Mono (.NET Framework para Linux)

Nesta tela temos 3 opções de sistema operacional:

• Ubuntu
• Debian
• Raspbian

Neste exemplo, meu raspberry está com o Ubuntu instalado, mas caso você esteja utilizando o Debian ou Raspbian, só clicar na aba deles na página do Mono para verificar os comandos de instalação.

Seguindo as instruções da página do Mono para o Ubuntu, para realizar a instalação do Mono, precisamos executar os comandos (execute 1 linha por vez no terminal):

sudo apt install ca-certificates gnupg
sudo gpg --homedir /tmp --no-default-keyring --keyring /usr/share/keyrings/mono-official-archive-keyring.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF
echo "deb [signed-by=/usr/share/keyrings/mono-official-archive-keyring.gpg] https://download.mono-project.com/repo/ubuntu stable-focal main" | sudo tee /etc/apt/sources.list.d/mono-official-stable.list
sudo apt update

Vamos precisar do pacote do Mono completo, então para realizar a instalação, precisamos executar o comando:

sudo apt install mono-complete

Passo 4 – Download da versão mais atualizada do Servidor de Terraria Oficial

Para realizar o download da última versão do Servidor de Terraria, primeiro vá até a página oficial do jogo:

Terraria.org

Navegue até o rodapé da página e procure pelo link:

PC Dedicated Server

Copie o link de download para que possa realizar o download diretamente no servidor.

Alternativamente, segue uma lista dos arquivos para download:

• Terraria Server 1.4.4.9
• Terraria Server 1.4.4.8.1
• Terraria Server 1.4.4.8
• Terraria Server 1.4.4.7
• Terraria Server 1.4.4.6
• Terraria Server 1.4.4.5
• Terraria Server 1.4.4.4
• Terraria Server 1.4.4.3
• Terraria Server 1.4.4.2
• Terraria Server 1.4.4.1
• Terraria Server 1.4.4
• Terraria Server 1.4.3.6
• Terraria Server 1.4.3.5
• Terraria Server 1.4.3.4
• Terraria Server 1.4.3.3
• Terraria Server 1.4.3.2
• Terraria Server 1.4.3.1
• Terraria Server 1.4.3
• Terraria Server 1.4.2.3

Neste exemplo, a última versão disponível é a 1.4.4.9. Para navegar até a pasta do seu usário, utilize o comando:

cd ~

Para realizar o download do arquivo diretamente no servidor, utilizar o comando:

wget https://terraria.org/api/download/pc-dedicated-server/terraria-server-1449.zip

Repare então que vamos ter o arquivo no formato terraria-server-XXXX.zip na nossa pasta pessoal do usuário.

Passo 5 – Descompactar arquivo de Servidor do Terraria

Para descomprimir/descompactar o arquivo que acabamos de realizar o download, precisamos ter o software zip/unzip instalado. Desta forma, vamos utilizar o comando:

sudo apt install zip unzip

Para descomprimir o arquivo .zip do servidor, utilize o comando:

unzip terraria-server-1449.zip

Para renomear a pasta da versão do terraria (1449) para terraria-server, utilize o comando:

mv 1449 terraria-server

Passo 6 – Primeira tentativa de execução do servidor de Terraria

Agora os arquivos do servidor do terraria estão disponíveis dentro da sua pasta de usuário. A pasta do servidor possui 3 opções de sistema operacional:

• Linux
• Windows
• Mac Os

Vamos acessar agora os arquivos do servidor de terraria disponíveis para linux (executar 1 linha de cada vez):

cd ~
cd terraria-server
cd Linux

Para realizar a primeira tentativa de execução do servidor, vamos executar o comando:

mono --server --gc=sgen -O=all ./TerrariaServer.exe

É comum receber erros na primeira execução, como exemplo:

Your mono runtime and class libraries are out of sync.

Caso receba este erro, basta remover alguns arquivos (execute uma linha de cada vez):

rm monoconfig
rm mscorlib.dll
rm System*
rm Mono*

Passo 7 – Execução do servidor de Terraria

Se realizou todos os passos corretamente, agora o Raspberry Pi está apto a executar o servidor de Terraria. Execute então novamente o comando:

mono --server --gc=sgen -O=all ./TerrariaServer.exe

Você pode adicionar um mundo que já possua no seu servidor do Raspberry. Os arquivos do seu mundo devem ficar dentro da pasta:

~/.local/share/Terraria/Worlds

Passo 8 – Criando um novo mundo e habilitando o mesmo no servidor

Após executar o comando do passo anterior, você terá a opção de criar um novo mundo ou carregar um mundo existente, caso este esteja presente na pasta apropriada.

Caso opte por criar um novo mundo, as etapas são:

• Tamanho do mapa (pequeno, médio ou grande). Um mapa grande vai demorar bastante para ser criado, tenha certeza também que seu Raspberry tenha uma boa dissipação de calor nessa etapa. É comum acontecer erros na criação de mapas grandes por este motivo.
• Dificuldade: Classic, Expert, Master e Journey.
• Maldição do mundo: Corrupt ou Crimson
• Nome para o novo mundo
• Semente: é utilizada como variável para definir um mundo aleatório. Se tiver algum mapa que já gerou no passado, pode aproveitar a mesma semente e gerar novamente.

Após criar um novo mundo, é possível selecioná-lo para execução no servidor. Em seguida deverá definir as opções:

• Número máximo de jogadores conectados.
• Porta de conexão do servidor, o padrão é a porta 7777.

Neste exemplo então, para se conectar no servidor de terraria local, foi necessário apenas escolher o IP e a porta.

Caso queira deixar o servidor disponível externamente, você precisa abrir a porta 7777 no seu roteador e direcionar o tráfego para o IP do Raspberry Pi. Depois anote o seu IP público (IP externo de internet) e passe para que seus amigos possam se conectar.

Considerações Finais

O servidor de Terraria é bem leve, nos testes que realizei o Raspberry raramente passava de 1GB de ram, mesmo durante o processo de criação de um novo mundo. Não tive oportunidade de testar com muitos jogadores, mas com certeza é bem mais leve que o servidor de Minecraft e o Raspberry não terá grandes problemas de execução.

O post Tutorial como criar servidor de Terraria no Raspberry Pi apareceu primeiro em Vinicius Paes.

Passo a passo ensinando como criar um servidor de Minecraft no Raspberry Pi.

Requisitos mínimos

• Raspberry Pi 3
• Fonte alimentação 2,5A
• Cartão SD Class 10 – 16GB

Requisitos Recomendados

• Raspberry Pi 4 – 4GB
• Fonte alimentação 3A – 5,1V (evitar undervoltage)
• SSD USB 3.0 – 32GB
• Overclock para 2,2Ghz
• Cooler com ventoinha

Considerações Iniciais

Apesar do Minecraft ser um jogo aparentemente simples em questões gráficas, ele demanda bastante processamento em algumas ocasiões, que pode levar o Raspberry a trabalhar em seu limite. É comum então que receba mensagens como:

Can't keep up! Is the server overloaded? Running 2171ms or 43 ticks behind

Nos testes que realizei, mesmo recebendo eventualmente mensagens de atraso no servidor, não constatei nenhum problema na jogabilidade. Realizei overclock no limite do meu Raspberry (não consegui chegar nos prometidos 2,3Ghz), mas mesmo com 2250 Mhz as mensagens continuavam a aparecer, mas não eram frequentes. Acompanhei o servidor com uma janela rodando o htop e depois do jogo iniciado, não vi nenhum núcleo passando de 70% em nenhum momento. Memória ram também não pareceu ser um problema, o garbage collector parece funcionar de forma satisfatória. Rodei o servidor com 3, 4 e 7GB de ram e não senti diferença em desempenho. Provavelmente somente com um número maior de jogadores conectados seria possível realizar um teste mais aprofundado.

Passo a passo como criar um servidor de Minecraft

Passo 1 – Conectar no servidor

Neste exemplo, tenho o Raspberry Pi configurado com o IP 192.168.1.55 e o usuário principal é o viniciuspaes. Então para realizar o login por ssh, utilizo o seguinte comando pelo terminal:

ssh viniciuspaes@192.168.1.55

Passo 2 – Verificar versões do OpenJDK disponíveis

O servidor do Minecraft funciona com a tecnologia/linguagem de programação JAVA. Então precisamos do Java JDK e JRE disponíveis no raspberry. É uma boa prática sempre instalar a última versão disponível. Você pode verificar as versões disponíveis com o comando:

sudo apt-cache search openjdk

Nesta busca pelos pacote do OpenJDK, verificamos que a versão 19 está disponível.

Passo 3 – Instalar OpenJDK (JDK e JRE)

No passo anterior vimos que a versão 19 está disponível e como mencionamos, precisamos tanto do JDK quanto do JRE. Então vamos instalar estes pacotes com o comando:

sudo apt install openjdk-19-jdk openjdk-19-jre

Na minha instalação, o download dos softwares ficou próximo de 673MB.

Passo 4 – Download do executável .jar do Minecraft Server

Neste passo precisamos já preparar o local onde queremos guardar os arquivos do servidor de Minecraft. De forma simples, vou criar um diretório dentro da minha pasta de usuário mesmo, você também pode fazer o mesmo com os comandos:

Para caminhar para sua pasta de usuário:

cd ~

Para criar uma pasta para o servidor:

mkdir minecraft-server

Para entrar dentro da pasta do Minecraft

cd minecraft-server

Agora precisamos ir no site do desenvolvedor do minecraft e realizar o Download do arquivo executável do servidor. Então precisamos abrir a seguinte URL no browser:

• Página Oficial de Download do executável do Servidor de Minecraft

Agora você precisa somente copiar o link de download para o clipboard (copy link address). Agora no sua janela de terminal, utilize o comando wget seguida do link de download, para realizar o download direto na pasta que já criamos. Dependendo do terminal que estiver utilizando você pode utilizar o control+v para colar o link de download (linux e mac), ou o botão direito do mouse (windows). Neste exemplo o link que utilizamos foi:

wget https://piston-data.mojang.com/v1/objects/84194a2f286ef7c14ed7ce0090dba59902951553/server.jar

Passo 5 – Aceitar arquivo EULA

Antes do servidor poder ser executado corretamente, precisamos aceitar o End User License Agreement (EULA). Precisamos então rodar a primeira vez o servidor, para que o mesmo faça o download de todas as dependências e do arquivo de EULA. No comando abaixo vamos executar o servidor, repare nos prefixo “-Xmx” e “-Xms” eles definem a quantidade de memória ram que o servidor poderá utilizar. Uma boa prática é rodar o htop, ver a quantidade de memória ram que está utilizando e ver o quanto que poderia deixar disponível para o servidor.

Se o seu Raspberry tiver bastante memória ram, a regra geral é deixar 1Gb pro sistema operacional e o restante para o minecraft. Então se tiver utilizando um Raspberry com 4Gb de ram, utilize 3GB para o servidor. Neste exemplo estou com um Raspberry de 8Gb, então vou alocar 6Gb para o servidor, pois está de bom tamanho:

java -Xmx6G e -Xms6G -jar server.jar

Irá aparecer uma mensagem de erro para ecitar o EULA. Então vamos utilizar o nano para editar o arquivo:

nano eula.txt

No arquivo temos:

eula=false

Precisamos alterar para:

eula=true

Aperta control+o para salvar as modificações e control+x para sair do editor nano.

Passo 6 – Executar o servidor de Minecraft

A configuração básica está pronta. Caso não tenha o desejo de instalar nenhum mod adicional ou otimização com o Fabric ou Lithium, basta executar o servidor. Como estamos com um servidor headless, podemos utilizar a opção nogui também. Lembre de alterar os campos “-Xmx” e “-Xms” para a quantidade de memória RAM que você tem disponível.

java -Xmx6G e -Xms6G -jar server.jar nogui

Tudo pronto, servidor ativo e funcional.

Passo 7 – Testar Servidor

Para testar o servidor, utilizei o aplicativo do Xbox do Windows, e executei o Minecraft Launcher.

Selecionei a opção de um jogo multiplayer.

Em seguida escolhi a opção de adicionar um servidor (Add Server)

Deixei o nome padrão para o servidor “Minecraft Server”

E na opção de IP, inseri o IP do meu Raspberry Pi “192.168.1.55”.

Tudo Pronto, agora é só clicar no servidor e selecionar join.

O post Tutorial como criar servidor de Minecraft no Raspberry Pi apareceu primeiro em Vinicius Paes.

Em alguns casos específicos, definir um IP estático para seu computador ou servidor pode ser necessário para facilitar o acesso ao mesmo e garantir maior controle do seu equipamento pela rede.

Caso tenha um servidor local em sua residência, mapear portas abertas do seu roteador para o IP fixo do seu servidor local pode também ser necessário. Uma alternativa de definir o IP estático manualmente, é definir um IP estático por DHCP (static leases), baseado no MAC Address da placa de rede do seu servidor. Mas neste artigo, vamos abordar somente a configuração manual de IP estático configurado no Ubuntu Server. As configurações serão realizadas por linha de comando (CLI).

Como funciona o IP estático e o DHCP?

No DHCP (Dynamic Host Configuration Protocol), o seu computador (ou servidor) envia uma solicitação por broadcast na rede em que está conectado, solicitando configurações para sua placa de rede. Caso você tenha um servidor de DHCP instalado na sua rede, ou mesmo, caso seu roteador oferte serviço de DHCP, ao receber a solicitação de broadcast do computador, ele então responde a solicitação enviandos os dados de configuração (IP, máscara de subrede, servidor dns, gateway, etc).

Caso opte por utilizar a configuração manual, ou IP estático, você mesmo precisa saber quais as configurações da sua rede, e atribuir um IP estático para os computadores. Então temos 2 formas comuns de configuração: a forma estática e dinâmica.

Uma terceira forma que une vantagens dos 2 métodos é o IP estático fornecido dinamicamente. Basicamente você configura seu servidor DHCP para sempre fornecer o mesmo IP para um determinado computador.

Passo a passo para configurar IP estático no Ubuntu com Netplan

Passo 1: Conexão com servidor

Caso esteja conectado fisicamente ao servidor, basta pular para a próxima etapa. Caso esteja com um setup “headless” coencte no servidor por uma conexão ssh. Neste exemplo nosso servidor possui o IP  192.168.1.55 e o nosso nome de usuário é “viniciuspaes”, então o comando fica:

ssh viniciuspaes@192.168.1.55

Passo 2: Verificar o nome da nossa interface de rede

A interface pode receber nomes distintos durante o processo de instalação do sistema operacional. Desta forma, para configurar nosso IP estático, precisamos saber para qual interface queremos realizar o processo. Alguns nomes comuns: eth0, eth1, enp0s10, wlan, …

Para listar nossas interfaces, vamos utilizando o comando:

ip -brief address show

No meu exemplo, tenho 4 interfaces de rede configuradas:

• lo: identifica a interface de loop interno
• eth0: é a minha interface de rede por cabo
• wlan0: é a minha placa de rede wifi
• docker0: é a minha interface de rede de bridge interna do docker

Neste exemplo, vou configurar meu IP estático na minha placa de rede cabeada, que no caso será a eth0.

Passo 3 – Criar arquivo de configuração de rede

Vamos criar então nosso arquivo de configuração para o IP estático, vamos utilizar o editor nano no processo:

sudo nano /etc/netplan/01-network-manager-all.yaml

O arquivo de configuração utiliza o formato .yaml, então tome cuidado com o espaçamento/identação. No arquivo abaixo, vou definir as configurações para:

• Nome da Interface: eth0
• IP Estático: 192.168.1.55
• Máscara da subrede: /24 (24 bits traduz para: 255.255.255.0)
• Gateway (endereço do roteador): 192.168.1.1
• DNS (utilizo os do google): 8.8.8.8 e 8.8.4.4

O arquivo fica então com o formato:

Passo 4 – Ativar novo arquivo de configuração

Há duas formas de ativar o arquivo de configuração, podemos primeiro testar o mesmo para ativação com o comando:

sudo netplan try

Ou podemos aplicar as modificações diretamente:

sudo netplan apply

Para ver se a alteração ficou persistente utilize o comando (substitua eth0 pela sua interface):

ip addr show eth0

Passo 5 – Verificar conflitos

Caso tenha qualquer problema na configuração do IP do seu servidor, verifique se não há outros arquivos presentes na pasta /etc/netplan. Por padrão há o arquivo configurado com DHCP. Caso agora sua interface tenha 2 endereços IP, tente desabilitar o arquivo antigo de configuração e aplique novamente as modificações com sudo netplan apply.

Conclusão

O setup do IP estático no Ubuntu Server é bem simples. Caso o usuário saiba as configurações de sua rede, basta editar o arquivo de configuração e aplicar as modificações.

Caso tenha alguma dúvida ou dificuldade no processo, basta informar nos comentários!

O post Tutorial como definir IP estático no Ubuntu Server com netplan apareceu primeiro em Vinicius Paes.

• Entender o que é o software Docker e sua proposta
• Prover os passos necessários para instalar o Docker no Raspberry Pi

Setup

Para que seja possível seguir este tutorial, é necessário que tenha os itens disponíveis:

• Raspberry Pi
• Fonte de alimentação dimensionada com corrente mínima para seu Raspberry Pi
• Unidade de armazenamento: cartão SD, pen drive, disco rígido USB ou SSD USB.
• Conexão com internet (wi-fi ou cabeada)

O que é o software Docker?

O Docker é também uma plataforma que facilita a criação, implantação e execução de aplicativos em containers. Um container é um encapsulamento leve e independente que pode conter todo o código e as bibliotecas necessárias para executar um aplicativo, incluindo o próprio aplicativo. Desta forma, o Docker permite empacotar um aplicativo juntamente com suas dependências em um container, garantindo que ele funcione consistentemente em outros ambientes, seja em um ambiente de desenvolvimento, teste ou produção. É interessante destacar que um container pode não funcionar em todos os ambientes, é necessário verificar a compatibilidade do software encapsulado com arquitetura x86 e arm, porém há formas de emular a compatibilidade.

Aqui estão algumas características e conceitos-chave relacionados ao Docker:

1. Containers: Os containers são unidades isoladas que incluem o aplicativo, suas bibliotecas e dependências, tornando-os portáteis e independentes do ambiente em que são executados. Eles são mais leves que máquinas virtuais e compartilham o kernel do sistema operacional com o host, o que os torna mais eficientes.
2. Imagens: As imagens do Docker são modelos somente leitura que contêm instruções para criar um container. Você pode pensar nelas como um plano de construção para um container. Imagens podem ser compartilhadas e versionadas, o que facilita a colaboração e a implantação consistente de aplicativos.
3. Dockerfile: Um Dockerfile é um arquivo de configuração que define como uma imagem do Docker deve ser construída. Ele especifica quais bibliotecas e dependências devem ser instaladas no container e como o aplicativo deve ser configurado.
4. Orquestração: O Docker pode ser usado em conjunto com ferramentas de orquestração, como o Kubernetes, para gerenciar a implantação e o dimensionamento de aplicativos em containers em ambientes de produção. Essas ferramentas permitem que você automatize tarefas como balanceamento de carga, escalabilidade automática e recuperação de falhas.
5. Docker Hub: É um repositório público de imagens do Docker, onde você pode encontrar imagens prontas para uso em uma ampla variedade de aplicativos e serviços.
6. Isolamento: Os contêineres Docker fornecem um alto grau de isolamento entre aplicativos, o que significa que eles não interferem uns nos outros e não afetam o sistema host.
7. Portabilidade: Como os containers encapsulam todas as dependências necessárias, eles são altamente portáteis. Você pode criar um container em um ambiente de desenvolvimento e executá-lo em qualquer lugar que tenha o Docker instalado.

Em resumo, o Docker simplifica o processo de desenvolvimento, implantação e gerenciamento de aplicativos, tornando-os mais eficientes, escaláveis e consistentes em diferentes ambientes. É amplamente utilizado na indústria de desenvolvimento de software para criar e distribuir aplicativos de forma confiável e rápida.

Passo a passo de como instalar o Docker no Raspberry Pi

Passo 1 – Conexão no raspberry

Caso esteja utilizando seu Raspberry de forma “headless”, basta conectar ao mesmo por SSH. É necessário saber o endereço IP do seu Raspberry, neste exemplo vamos adotar o usuário de login como “viniciuspaes” e o IP sendo 192.168.1.100:

ssh viniciuspaes@192.168.1.100

Passo 2 – Atualização de software do Raspberry

Utilize o comando abaixo para realizar update da lista de pacotes que podem ser atualizados e em seguida realizar o upgrade destes:

sudo apt update && sudo apt upgrade

Passo 3 – Remover softwares que podem gerar conflitos

Caso tenha instalado o docker anteriormente pelo gerenciador de pacotes apt, é possível que cause conflitos de instalação. O recomendado é instalar diretamente pelo repositório oficial do Docker, para ter acesso as versões mais atuais. Com o comando abaixo, vamos procurar por diversos pacotes relacionados ao docker e solicitar a remoção, caso estejam instalados pelo apt:

for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do sudo apt-get remove $pkg; done

Passo 4 – Download do script oficial de instalação do Docker e execução

Neste passo, vamos utilizar o Curl para realizar o download do script de instalação do Docker:

curl -fsSL https://get.docker.com -o get-docker.sh

Agora precisamos executar o script com o comando:

sudo sh get-docker.sh

Passo 5 – Adicionar usuário não privilegiado para ter permissão de execução do Docker.

Neste exemplo, vou utilizar o usuário viniciuspaes, adicionando o mesmo no grupo do Docker, desta forma este usuário poderá executar o docker e gerenciar os containers.

sudo usermod -aG docker viniciuspaes

Passo 6 – Reiniciar Conexão ao Raspberry

Uma etapa necessária é realizar o logout e posterior login no seu raspberry, para que as modificações de permissão do grupo do seu usuário tenham efeito. Caso tenha formatado o seu raspberry do zero para seguir este tutorial, provavelmente o sistema operacional também deve pedir para que realize a reinicialização. Então é recomendado que utilize o comando para reiniciar o raspberry pi:

sudo reboot now

Passo 7 – Nova conexão e verificar versão do Docker instalado

Realize novamente a conexão SSH ao seu raspberry após a reinicialização, caso esteja com um setup “headless”. Agora podemos ver a versão do Docker instalado com o comando:

docker version

Passo 8 – Testar instalação do docker com execução da imagem de hello-world

Para finalizar a instalação do Docker é interessante testar a mesma executando a imagem de hello-world. Vamos então utilizar o comando:

docker run hello-world

Tudo certo! Caso tenha sucesso na execução da imagem de hello-world o docker foi instalado e configurado corretamente. Caso tenha algum erro, interessante verificar se seu usuário tem privilégio de execução do Docker, igual configuramos no passo 5. Se ainda tiver dúvidas, você pode testar a execução do Docker com o comando “sudo”, para ter certeza que não é um problema de privilégio de execução.

Lista de comandos úteis para utilização do Docker

Fazer o download de uma imagem de um container

Você pode buscar por imagens prontas diretamente no site do docker hub. No exemplo do comando abaixo, vamos realizar somente o download da imagem oficial do nginx:

docker pull nginx

Criar um container a partir de uma imagem

O comando docker run permite iniciar um container a partir de uma imagem. No exemplo do comando abaixo, vamos criar um container que contém a instalação do servidor de páginas nginx:

docker run nginx

Ao executar o comando, caso o docker não encontre a imagem localmente, ele irá buscar a mesma diretamente no docker hub e irá criar o container. Mas caso já tenha feito o download da imagem com o comando docker pull, o container é criado mais rapidamente, pois não precisa realizar o download da mesma.

O problema do comando acima, é que o terminal fica bloqueado na execução. Como opção, podemos passar por referência o prefixo -d, para que o container fique em funcionamento em segundo plano.

docker run -d nginx

O problema do comando acima é que não mapeamos a porta de execução do container. Como o nginx pode funcionar como um servidor de páginas, para que seja possível testar o funcionamento, é interessante que a porta http seja mapeada para o host. Podemos então mapear a porta do host para o container com o prefixo -p [portaHost]:[portaContainer]. Neste exemplo, vamos mapear a porta 8080 do host para ser redirecionada para a porta 80 do Container:

docker run -d -p 8080:80 nginx

Verificar os containers em funcionamento

Para verificar quais container estão ativos, podemos utilizar o comando:

docker ps

Neste exemplo, verificamos 2 containers sendo executados. Ambos os containers utilizam a imagem oficial do nginx:

CONTAINER ID IMAGE COMMAND                CREATED       STATUS       PORTS                                 NAMES
58a23436fc0e nginx "/docker-entrypoint.…" 4 minutes ago Up 4 minutes 0.0.0.0:8080->80/tcp, :::8080->80/tcp festive_cori
c46cd9b051a9 nginx "/docker-entrypoint.…" 7 minutes ago Up 7 minutes 80/tcp                                pensive_carson

Parar e remover um container

Vamos remover o container da imagem do nginx que esquecemos de mapear a porta externa do host. Olhando a saída do Docker ps, temos o ID do container que queremos remover. Neste caso o ID é:

c46cd9b051a9

Não é possível remover um container que está em funcionamento, então primeiro precisamos parar o container com o comando:

docker stop c46cd9b051a9

Em seguida podemos proseguir com a remoção do container:

docker rm c46cd9b051a9

Entrar dentro de um container e executar comandos

Caso precise entrar dentro do container que possui ID “58a23436fc0e” para executar algum comando:

docker exec -it 58a23436fc0e /bin/bash

No comando acima, executamos o bash dentro do container. Se o comando acima não funcionar, é possível que a imagem que esteja utilizando não ter o bash. Para sair do container, lembre-se de digitar “exit”.

Listar as imagens de containers que já fez download

Caso queira verificar quais imagens de containers já fez download e estão disponíveis em seu computador, utilize o comando:

docker images

REPOSITORY  TAG    IMAGE ID     CREATED      SIZE
nginx       latest 91582cfffc2d 38 hours ago 192MB
hello-world latest b038788ddb22 4 months ago 9.14kB

Considerações Finais

A instalação do Docker no Raspberry Pi é bem simples e pode ser realizada com poucos passos. É um excelente setup para começar a aprender a utilizar o docker e gerenciar aplicativos ou projetos pessoais na sua rede local. Os principais comandos de utilização do Docker também foram listados

Caso tenha dúvidas sobre a instalação ou execução do Docker, basta escrever aí nos comentários!

O post Tutorial como instalar Docker no Raspberry Pi apareceu primeiro em Vinicius Paes.

Venho realizando testes com as melhores formas de realizar o boot no Raspberry Pi. Desde cartões SD de alto desempenho; SSD externo, ligado por USB e também memória eMMC (RPi 4 Compute Module).

Aproveitei a recente redução de preços de SSD SATA, e atualmente, é a melhor opção custo benefício para o Raspberry Pi 4. Como o Raspberry ainda possui muitas restrições de I/O, um SSD SATA atende as necessidades muito bem. Lembrando que a melhor performance ainda continua sendo um SSD Nvme.

Caso esteja utilizando um SSD, independente se for SATA ou NVME, é interessante saber que é possível otimizar a vida útil do mesmo habilitando a funcionalidade do “TRIM” no linux.

Tive sucesso em habilitar o TRIM no meu Raspberry Pi 4. No meu setup utilizei um adaptador USB-SATA da UGREEN e um SSD Samsung EVO 850 de 500GB.

Objetivos

• Saber o que é o TRIM, e suas vantagens
• Entender o risco de tentar habilitar o TRIM em uma unidade que não ofereça suporte e causar danos irreversíveis no seu SSD
• Passo a passo para habilitar o TRIM no raspberry pi em uma unidade de armazenamento que ofereça suporte

Aviso! Este tutorial pode causar danos na sua unidade. Continue por rua conta e risco!

O que é o TRIM?

O termo “TRIM” é referente a uma operação que é realizada em dispositivos de armazenamento de estado sólido, como discos SSD e cartões de memória (SD). O TRIM é uma parte crucial para garantir um desempenho eficiente e uma vida útil prolongada desses dispositivos.

Especificamente, o TRIM é uma operação/comando para a interface ATA. Imagine você utilizando normalmente as informações em sua unidade de armazenamento: copiando novos arquivos e deletando arquivos antigos. Quando realiza estas operações, e diante a estrutura do SSD, é necessário que a unidade garanta que as informações “apagadas” sejam devidamente removidas e que haja espaço disponível para novas informações a serem gravadas. Desta forma, é a funcionalidade do TRIM informar ao seu SSD sobre quais dados podem ser apagados. Pode parecer intuitivo este processo, mas ele depende de suporte tanto do Sistema Operacional, quanto da unidade de armazenamento.

Qual a vantagem do TRIM?

De forma sucinta: o SSD sabe de antemão quais dados foram “removidos” e pode marcar os mesmos como “inválidos”, ou seja, ele não precisa remover os dados naquele momento, pode apenas marcar estes dados para serem apagados em um momento mais ocioso da unidade de armazenamento. Permite que o SSD gerencie de forma mais otimizada os dados, evitando também problemas de “write amplification”, que é uma particularidade da memória flash, pois os blocos/páginas precisam ser apagados antes de serem escritos.

Para fazer mais sentido, imagine que o SSD não saiba de antemão quais dados foram “apagados” pelo usuário. E no momento de escrita de novos arquivos, recebe também a notificação de que precisa sobrescrever certos blocos/páginas para que seja possível gravar todas as novas informações. Mas a memória flash precisa ser apagada, para que nova informação seja gravada, então a característica de sobrescrever nada mais é que um overhead de apagar e depois inserir novas informações: gerando múltiplas operações de leitura e escrita. Como o controlador precisa também trabalhar mais em curtos espaços de tempo, quando há estas operações, também é gerado mais calor. Todo este processo pode acarretar em problemas de desempenho e diminuir a vida útil da unidade.

Lembrando que o TRIM pode receber outros nomes ou agir de formas diferentes em outras interfaces ou diferentes sistemas operacionais. Mas de forma resumida, utilizamos o termo TRIM para exemplificar este processo de gestão ativa do sistema de arquivos. O TRIM trabalha com o Garbage Collector auxiliando no processo de organização, limpeza e otimização do SSD. Um ponto importante, o TRIM é opcional, os SSD também operam normalmente mesmo que o sistema operacional não ofereça suporte.

Mas um aviso! Talvez sua unidade de armazenamento não tenha suporte ao TRIM. Tentar ativar o mesmo para uma unidade que não tenha suporte pode causar problemas irreversíveis. Tornando a unidade “somente leitura” ou mesmo transformando em um peso de papel.

Passo a passo para habilitar suporte ao TRIM no Raspberry Pi

Passo 1 – Condições de Contorno

Para executar este tutorial, é necessário que você tenha um SSD configurado em seu Raspberry Pi. O caso ideal é que você já esteja com o SSD configurado e seu boot é realizado diretamente nele. É interessante não ter outras unidades de armazenamento configuradas, pois pode se confundir durante o processo e tentar habilitar o TRIM em outra unidade, causando problemas.

Como mencionei inicialmente, no meu setup, utilizei:

• Adaptador USB-SATA da UGREEN
• SSD SATA 500GB 850 EVO da Samsung

Caso utilize outro equipamento, verificar se estes possuem suporte ao TRIM, para não danificar a unidade de armazenamento.

Passo 2 – Riscos

Estou sendo repetitivo, mas é por uma boa causa. Ficaria muito chateado se seguissem este tutorial e o mesmo causasse qualquer tipo de problema em seu equipamento. Então por favor, se não possuem certeza caso seu equipamento tem suporte ao TRIM, não sigam o tutorial. Existem alguns passos para tentar verificar se o TRIM é suportado, mas não são 100% garantidos. Lembrem que tanto o adaptador USB-SATA, quanto o SSD precisam ter suporte. Se utilizam um SSD USB externo (all-in-one), cuidado em dobro.

Mesmo que utilizem o mesmo equipamento que utilizei, lembrem-se que as empresas podem realizar upgrades e mudanças no equipamento ao longo do tempo e mesmo assim manter o mesmo nome e modelo. Nunca é 100% garantido.

Passo 3 – Verificar se o TRIM já está sendo utilizado

No linux, podemos executar o comando abaixo para verificar se o TRIM está ativado e sendo utilizado:

sudo fstrim -v /

Se receber a mensagem “fstrim: /: the discard operation is not supported” como mostrado na imagem abaixo, então o TRIM não está habilitado.

Agora vamos verificar como o SSD USB está sendo montado na unidade:

sudo fdisk -l

Na imagem abaixo, podemos verificar que meu SSD está montado como /dev/sda. Minha partição de boot é o /dev/sda1 e a minha partição do sistema de arquivos está em /dev/sda2.

Uma outra forma de verificar se o TRIM está habilitado no meu SSD, é verificar o valor da variável “DISK-MAX” do comando abaixo:

lsblk -D

No meu caso, tenho as partições do meu SSD com o valor “0B”, que indica que o TRIM não está ativado.

Lembrando que nesta etapa, estamos apenas verificando se o TRIM já está ativado e funcional. Como verificado nos passos acima, não há nenhuma evidência que o TRIM esteja ativado, mas isso não significa que o mesmo não esteja disponível. Dependendo do sistema operacional, o TRIM não vem configurado e ativado por padrão. Nos próximos passos, vamos verificar se meu Adaptador USB-SATA da UGREEN tem suporte ao TRIM com meu SSD.

Passo 4 – Verificar se o dispositivo possui suporte ao TRIM

Para esta etapa, vamos precisar de 2 softwares:

• sg3-utils
• lsscsi

Caso já não tenha eles instalados, instalar pelo apt:

sudo apt install sg3-utils lsscsi

Agora vamos precisar verificar o valor das variáveis:

• Maximum unmap LBA count
• Unmap command supported (LBPU)

Para verificar o valor da variável “Maximum unmap LBA count“, utilize o comando:

sudo sg_vpd -p bl /dev/sda

Na imagem abaixo, é possível observar que no meu caso, o valor é:

Maximum unmap LBA count: 4194240

Para verificar o valor da variável “Unmap command supported (LBPU)“, vamos utilizar o comando:

sudo sg_vpd -p lbpv /dev/sda

Na imagem abaixo, é possível observar que no meu setup, as saídas:

Unmap command supported (LBPU): 1

O que estas informações das variáveis querem dizer? Bom, caso o valor de “Maximum unmap LBA count” seja maior que ZERO. E caso o valor da variável “Unmap command supported (LBPU)” seja exatamente igual a 1. Então há evidências que seu setup (Adaptador USB/SATA + SSD) tenha suporte ao TRIM.

Então, no meu caso:

• Maximum unmap LBA count: 4194240 (maior que zero!)
• Unmap command supported (LBPU): 1 (igual a 1!)

Nesta etapa então, verifiquei que há evidências sobre o suporte ao TRIM no meu setup. Assumi o risco pessoal de tentar habilitar o TRIM, sabendo das consequências negativas caso não tenha suporte.

Passo 5 – Habilitando o TRIM no SSD externo no Raspberry Pi

Para habilitar o TRIM primeiro precisamos verificar o modo de provisionamento atualmente ativo. Precisamos então verificar o conteúdo do arquivo de provisionamento. Execute o comando abaixo:

find /sys/ -name provisioning_mode -exec grep -H . {} + | sort

Ao executar o comando, é feito uma busca pelo arquivo de provisionamento e seu conteúdo. No meu caso, a saída que recebi menciona que o método de provisionamento atual é “full”:

/sys/devices/platform/scb/fd500000.pcie/pci0000:00/0000:00:00.0/0000:01:00.0/usb2/2-2/2-2:1.0/host0/target0:0:0/0:0:0:0/scsi_disk/0:0:0:0/provisioning_mode:full

Como só tenho um SSD configurado, só recebi a saída em 1 linha. Caso tenha mais de uma unidade de armazenamento configurada, será necessário confirmar qual linha do exemplo acima é referente a qual unidade.

Caso tenha mais de uma saída, é possível identificar qual linha do exemplo acima é referente a cada unidade. Execute o comando abaixo:

sudo lsscsi

No meu caso, o comando acima resultou em:

[0:0:0:0]	disk	Samsung SSD 850 EVO 500G	0	/dev/sda

Na saída do comando é possível verificar um identificador do disco “[0:0:0:0]” referente ao SSD. Vimos no começo do tutorial, que o SSD está configurado em /dev/sda. Se repararmos na saída do comando para verificar o método de provisionamento, vemos que o meu SSD, identificado como “[0:0:0:0]“, tem parte do caminho com o identificador:

"[...]scsi_disk/[0:0:0:0]/provisioning_mode:full"

Confirmado qual o caminho do arquivo de provisionamento do SSD, agora precisamos alterar o método de provisionamento de “full” para “unmap”.

Quando executei o comando “find /sys/ -name provisioning_mode -exec grep -H . {} + | sort” tive como resposta o caminho do arquivo sendo (:full é o conteúdo do arquivo e não faz parte do caminho):

/sys/devices/platform/scb/fd500000.pcie/pci0000:00/0000:00:00.0/0000:01:00.0/usb2/2-2/2-2:1.0/host0/target0:0:0/0:0:0:0/scsi_disk/0:0:0:0/provisioning_mode

Para verificar o conteúdo deste arquivo, executo o comando:

cat /sys/devices/platform/scb/fd500000.pcie/pci0000:00/0000:00:00.0/0000:01:00.0/usb2/2-2/2-2:1.0/host0/target0:0:0/0:0:0:0/scsi_disk/0:0:0:0/provisioning_mode

Confirmando então, ele contém a string “full“, que precisamos alterar.

Preciso alterar o arquivo e substituir o seu conteúdo de full para unmap. Para isso, primeiro mude para usuário root:

sudo su

Agora execute o comando:

echo unmap > /sys/devices/platform/scb/fd500000.pcie/pci0000:00/0000:00:00.0/0000:01:00.0/usb2/2-2/2-2:1.0/host0/target0:0:0/0:0:0:0/scsi_disk/0:0:0:0/provisioning_mode

Agora se verificar o conteúdo do arquivo, vai ver que o mesmo foi atualizado para “unmap”:

cat /sys/devices/platform/scb/fd500000.pcie/pci0000:00/0000:00:00.0/0000:01:00.0/usb2/2-2/2-2:1.0/host0/target0:0:0/0:0:0:0/scsi_disk/0:0:0:0/provisioning_mode

Agora é necessário calcular o valor para ser inserido na variável “discard_max_bytes”. Para seu cálculo vamos precisar das variáveis:

• Maximum unmap LBA count
• Logical block length

O valor de Maximum unmap LBA count é obtido executando o comando:

sudo sg_vpd -p bl /dev/sda

O valor de Logical block length pode ser obtido com o comando:

sudo sg_readcap -l /dev/sda

Lembrando que ambos os comandos acima, /dev/sda é onde meu SSD está montado na unidade. Se o seu estiver com outro caminho, lembre-se de atualizar os comandos acima.

Neste setup, consegui os seguintes valores:

Maximum unmap LBA count = 4194240
Logical block length = 512 bytes

A fórmula para a variável “discard_max_bytes” é:

discard_max_bytes = "Maximum unmap LBA count" * "Logical block length"
discard_max_bytes = 4194240 * 512
discard_max_bytes = 2147450880

Caso faça as contas e consiga valores diferentes, não tem problema. Estes valores podem variar dependendo do seu setup.

Caso não esteja em modo super usuário, é necessário para alterar o arquivo.

sudo su

Execute o comando para atualizar o valor de discard_max_bytes:

echo 2147450880 > /sys/block/sda/queue/discard_max_bytes

Vamos agora confirmar se o TRIM foi habilitado executando o comando:

sudo fstrim -v /

Passo 6 – Ativando persistência no TRIM

É necessário ativar persistência no TRIM, pois senão, caso reinicie o Raspberry, as modificações não serão mantidas.

A primeira etapa é identificar o seu SSD externo. No meu caso, é identificar meu adaptador SATA/USB. É necessário identificar 2 características:

• idVendor
• idProduct

Vamos executar o comando “lsusb” para identificar os dispositivos conectados na USB:

lsusb

Ao executar o inspecionar a saída, verifiquei que a seguinte linha era referente ao meu adaptador SATA/USB:

Bus 002 Device 002: ID 174c:1153 ASMedia Technology Inc. ASM1153 SATA 3Gb/s bridge

Da linha acima, temos os valores:

• 174c = idVendor
• 1153 = idProduct

A segunda etapa então é adicionar uma regra no udev pra configuração automática do TRIM. Para isto, vamos criar e editar o arquivo com o nano:

sudo nano /etc/udev/rules.d/10-trim.rules

Agora é necessário inserir a linha abaixo dentro do nano, mas você precisa alterar o campo idVendor e idProduct com os dados do seu dispositivo. No meu caso, ficou:

ACTION=="add|change", ATTRS{idVendor}=="174c", ATTRS{idProduct}=="1153", SUBSYSTEM=="scsi_disk", ATTR{provisioning_mode}="unmap"

Passo 7 – Automatizando o processo de execução do TRIM

Por padrão, após configurar e habilitar o TRIM em sua unidade de armazenamento, ele não é executado automaticamente. Então é preciso avisar o sistema operacional para que se encarregue deste processo. Senão, terá que chamar a função fstrim manualmente, toda hora que desejar realizar o trim.

Desta forma, para deixar o sistema operacional encarregado para gerenciar o trim, execute o comando:

sudo systemctl enable fstrim.timer

Tudo certo! Para testar se tudo ocorreu bem, reinicie o Raspberry e execute o comando:

sudo fstrim -v /

Caso seu dispositivo tenha suporte ao TRIM e tenha sido configurado corretamente, o TRIM está habilitado e funcional!

Conclusão

Neste tutorial foi possível verificar os passos para habilitar o TRIM utilizando um SSD externo no Raspberry Pi. O processo envolve poucas etapas, mas possui pequenos detalhes para identificação dos dispositivos que podem aumentar o tempo de implementação do tutorial. Caso possua um dispositivo que forneça suporte, o TRIM é uma excelente alternativa para aumentar a vida útil de unidades de armazenamento de estado sólido, como SSD e cartões de memória (SD).

Qualquer dúvida ou sugestão, basta informar nos comentários!

O post Como habilitar TRIM com SSD USB no Raspberry Pi apareceu primeiro em Vinicius Paes.

O objetivo principal deste tutorial é uma forma de não inicializar (desabilitar) o wifi e/ou bluetooth do raspberry pi durante o boot. É muito útil para economia de energia durante um setup que não necessita destes recursos no raspberry pi, ou caso seja neurótico com emissão de rádio frequência perto de você.

Condições de contorno

Este setup foi testado no Ubuntu Server 22.04, mas também é funcional na versão 20.10. Neste exemplo, testei o procedimento no Raspberry Pi 4, mas verifiquei que também é funcional na versão do RPi 3. Lembrando que nesta versão, utilizo o ubuntu server na versão minimal, ou seja, somente por interface de linha de comando.

Passo a passo para desligar wifi e/ou bluetooth no Raspberry Pi

Acesso ou Conexão com o Raspberry Pi

1. Caso esteja utilizando o Raspberry com teclado, mouse e monitor: faça login com seu usuário e senha.
2. Se o seu setup é “headless”, faça conexão no seu RPi por ssh (o nome de usuário padrão é pi, caso não tenha definido um usuário diferente). Substituir o IP abaixo pelo endereço IP do seu Raspberry.
   Exemplo:

   ssh pi@192.168.1.99

Editar arquivo de configuração no RPi

• Se estiver utilizando o RPi 3B ou 3B+, edite o arquivo:

  sudo nano /boot/firmware/config.txt

• Se estiver utilizando o RPi 4, o arquivo que precisa ser alterado é diferente:

  sudo nano /boot/firmware/usercfg.txt

Para desabilitar o wifi, insira a linha no arquivo que está aberto para edição:

dtoverlay=disable-wifi

Para desabilitar o bluetooth, insira a linha:

dtoverlay=disable-bt

Caso tenha o desejo de desabilitar tanto o Wifi, quanto o bluetooth, o arquivo editado precisa conter ambas as linhas, como exemplo:

dtoverlay=disable-wifi
dtoverlay=disable-bt

Agora salve o arquivo e saia do editor nano.

Reiniciar o Raspberry Pi

Para reiniciar o RPi e verificar que o Wifi e/ou o Bluetooth foram desabilitados, execute o comando:

sudo reboot now

O post Tutorial desabilitar Wifi ou Bluetooth no Raspberry Pi com Ubuntu Server apareceu primeiro em Vinicius Paes.

O principal objetivo é comparar se o download de um arquivo realizado pela internet manteve as características originais do mesmo, ou seja, o arquivo não foi corrompido. Este processo é bastante útil quando é necessário realizar alguma instalação de software sensível, como por exemplo, upgrade de firmware de equipamentos. Evitando problemas de “softbrick” causado por arquivo corrompido. Para realizar este procedimento de comparação, podemos utilizar as funções:

• Hash MD5
• Hash SHA1
• Hash SHA256

O que é o Hash e/ou Checksum?

Um hash de arquivo, também conhecido como checksum, é uma sequência alfanumérica única e fixa gerada por meio de um algoritmo de hash a partir dos dados de um arquivo. Esse valor de hash é uma representação única do conteúdo do arquivo, e mesmo uma pequena alteração nos dados resultaria em um hash completamente diferente. Essa propriedade torna os hashes úteis para uma variedade de finalidades, incluindo segurança, integridade de dados e verificação de autenticidade.

Como verificar o Hash (Checksum) de um arquivo utilizando o sistema operacional Windows?

Quando for realizar o download do arquivo na internet, é comum que o site que oferta o arquivo, também mostre o checksum do mesmo para diferentes tipos de funções de hash.

No Sistema Operacional Windows, a forma mais simples de verificar o hash de um arquivo é através do prompt de comando, utilizando a função certutil e passando o prefixo de hashfile.

Então, o primeiro passo é abrir o prompt de comando. Por padrão, ao abrir o prompt de comando, você estará na pasta: C:\Users\NomeUsuario\

Levando em conta que nosso arquivo está dentro da pasta de Download, vamos caminhar até a pasta, utilizando o comando:

cd Downloads

Neste exemplo, o arquivo que queremos verificar o checksum, tem o nome:

arquivo_de_exemplo.img

Lembrando que o arquivo pode ter qualquer nome e qualquer extensão.

Como verificar o hash com md5 no windows

Para verificar o hash do arquivo “arquivo_de_exemplo.img” utilizando a função md5, digite o comando no prompt de comando:

certutil -hashfile arquivo_de_exemplo.img md5

Como verificar o hash SHA1 no windows

Seguindo o mesmo padrão para o hash md5, para utilização a função SHA1, basta utiliza o comando abaixo:

certutil -hashfile arquivo_de_exemplo.img sha1

Como verificar o checksum com função hash SHA256 no windows

Assim como realizado para os hash’s MD5 e SHA1, basta incluir qual função de Hash gostaria de utilizar, como exemplo, para o SHA256 basta utilizar o comando:

certutil -hashfile arquivo_de_exemplo.img sha256

Como verificar o Hash (Checksum) de um arquivo no Mac OS ou Linux?

O procedimento é bastante similar com o que é feito no Windows, a diferença que no Mac OS e no Linux, precisamos utilizar o aplicativo terminal, ao invés do prompt de comando. Neste exemplo vamos utilizar a função openssl, que é nativa no Mac e no Linux.

Primeiramente, vamos executar o aplicativo terminal. Após aberto, você estará na pasta pessoal do seu usuário. Vamos supor que o arquivo que você realizou o download e gostaria de verificar o checksum está na pasta Downloads, então precisamos executar o seguinte comando no terminal:

cd Downloads

Vamos imaginar que o arquivo tenha o nome de “arquivo_de_exemplo.img”. Importante ressaltar que o arquivo pode ter qualquer nome e possuir qualquer tipo de extensão. E arquivos muito grandes vão demorar mais tempo para ser calculado o hash.

Como verificar o hash com md5 no Mac OS ou Linux

No Linux e Mac OS o método mais fácil para verificar o checksum de um arquivo é utilizando a função openssl. No exemplo abaixo, temos o comando para verificar o hash md5 do arquivo de exemplo:

openssl md5 arquivo_de_exemplo.img

Como verificar o hash SHA1 no Mac OS e Linux

A função utilizada para o hash sha1 é a mesma do md5, o que muda é o parâmetro de qual função de hash vamos utilizar. Segue o exemplo para verificar o checksum sha1 de um arquivo:

openssl sha1 arquivo_de_exemplo.img

Como verificar o checksum com função hash SHA256 no Linux e Mac OS

Da mesma forma dos exemplos anteriores, o comando abaixo gera o checksum do arquivo de exemplo para a função hash sha256. Lembrar de alterar o “arquivo_de_exemplo.img”, pelo nome do arquivo que gostaria de calcular o hash.

openssl sha256 arquivo_de_exemplo.img

Conclusão

O processo de realizar o checksum através de função hash é bem simples. Utilizar as funções nativas do sistema operacional garantem bastante agilidade no processo, pois não é necessário instalar nenhum software. Lembrando que após gerar o hash do arquivo, basta comparar com o hash fornecido pelo website, para que seja possível comparar os resultados. Caso obtenha um hash diferente, tente realizar o download novamente e confirmar que está testando o arquivo correto.

Se tiver qualquer dúvida ou sugestão, basta informar nos comentários!

O post Tutorial como verificar o Hash / Checksum de um arquivo no Mac, Linux ou Windows apareceu primeiro em Vinicius Paes.

Objetivos

• Entender o que é e para que serve o Google Analytics
• Aprender a criar uma conta no Google Analytics
• Tutorial passo a passo ensinando a configurar um domínio com código de rastreio para gerar relatórios no Google Analytics

O que é o Google Analytics?

O Google Analytics (GA) é uma plataforma que funciona como um serviço de coleta de dados de websites e aplicativos móveis para criar relatórios, provendo transformar dados em respostas úteis para seu negócio. Ou seja, você instala um código javascript (GA4 atualmente) do Google no seu website ou aplicativo e este código vai monitorar todos os acessos dos usuários. Desta forma, você poderá verificar estas informações em sua página pessoal no analytics.

O Google Analytics é muito útil, principalmente para identificar o perfil dos usuários que acessam seu website. É possível verificar os conteúdos mais buscados, os conteúdos que precisam de manutenção (baixa retenção), a origem do tráfego (mídias sociais, busca google, campanha paga, etc) entre outros.

Caso seu website possua propagandas (banners) do Adsense, é também possível gerar relatórios das páginas que mais convertem acesso de usuários por impressão de banners ou cliques.

Agora, se possui um site de e-commerce ou de serviços, é possível criar filtros no Google Analytics para verificar também quais produtos e serviços convertem mais em vendas por volume de acesso. É possível também verificar, caso possua campanhas pagas do Adwords, qual o comportamento do ROI.

O Google Analytics também permite verificar as palavras-chave (keywords) veiculadas nas pesquisas que o destino final do usuário foi o acesso ao seu website. Estas métricas, juntamente com informações provenientes do google insights são ferramentas muito úteis para maximizar a experiência do usuário em seu website e focar no aumento de tráfego.

Tutorial passo a passo ensinando a configurar um domínio com código de rastreio para gerar relatórios no Google Analytics

Um pequeno resumo sobre como utilizar o Google Analytics e configurar o mesmo em seu site:

1. Faça login em sua conta do Google
2. Se cadastre no Google Analytics, acessando a URL: https://analytics.google.com
3. Configure sua conta, inserindo um domínio (ou app móvel) e qual objetivo para geração de relatórios (site tem foco em serviços, e-commerce, propagandas, etc)
4. Verifique o código de rastreio (javascript) gerado na sua conta:
   • Caso utilize wordpress, é possível utilizar plugins para inserir o código de rastreio em seu site
   • Outra opção é editar os arquivos html do seu site e inserir o código de rastreio (tag) manualmente
5. Aguarde até 48h até que o Google Analytics comece a receber dados de visitantes do seu site e apresentar nos relatórios

A seguir temos os passos descritos de forma mais detalhada, com imagens para auxiliar no processo.

Passo 1: Realizar login na conta do Google ou criar uma conta, caso ainda não tenha

O primeiro passo para utilizar o google analytics é acessar a página oficial da plataforma:

https://analytics.google.com

Para que seja possível utilizar esta ferramenta é necessário ter uma conta do Google para iniciar o setup. Caso você tenha uma conta de email no gmail, você já tem uma conta do Google. Sendo necessário então realizar o login:

Passo 2 – Iniciar o cadastro no Google Analytics

Após realizar o login, será direcionado para a página inicial do Google Analytics. Se não tiver cadastro no Google Analytics ainda, será necessário clicar no botão:

Começar a usar

Passo 3 – Primeira etapa de cadastro – criando uma conta no GA

Agora temos que realizar o cadastro na ferramenta. São 5 etapas simples onde fornecemos alguns dados básicos sobre como desejamos utilizar a ferramenta e para qual website ou aplicativo queremos vincular um código de rastreio.

Na primeira etapa, precisamos definir um nome para a conta. Como esta conta vai ser minha principal, vou escolher o nome de:

Conta Principal

Nesta página também há opções que podemos marcar nos checkbox, para compartilhamento de dados com o Google Analytics, e outras opções de suporte. Marque de acordo com suas necessidades.

Após preencher a informações, clique em:

Próxima

Passo 4 – Criando uma propriedade – incluindo um domínio para gerar relatórios

A próxima etapa é sobre criar uma propriedade. Basicamente, no caso deste exemplo, a propriedade será o Google Analytics vinculado em meu site pessoal, o viniciuspaes.com. Como estou no Brasil, defini meu fuso horário como GMT +3, com horário de São Paulo. Mas deixei selecionado a moeda como Dólar americano.

Após selecionar as configurações, clique em:

Próximo

Passo 4 – Detalhes sobre sua equipe

Nesta terceira etapa da página de cadastro, precisamos definir alguns dados sobre a empresa. Se você trabalha sozinho, ou é um blog pessoal, não tem problema. Basta selecionar o número de pessoas que trabalham junto com você.

No meu caso, como é um blog pessoal e trabalho sozinho, selecionei:

Pequena: 1 a 10 funcionários

Passo 5 – Objetivo para utilizar os relatórios do Google Analytics

Agora precisamos selecionar quais nossos objetivos utilizando o Google Analytics. Selecione as opções que mais façam sentido para seu website. Estas opções ajudam o Google Analytics a definir mais ou menos a sua expectativa para a geração dos relatórios e pode fazer sugestões relacionadas.

Após definir as opções que mais e enquadram em seu perfil, clique em:

Criar

Passo 6 – Verificar os termos e serviços para utilização da ferramenta

Antes da sua conta ser criada, será necessário aceitar os termos de serviços do Google Analytics. Caso concorde com todos os itens do termo, clique no botão:

Aceito

Passo 7 – Definir as configurações para Coleta de Dados

Agora estamos na última etapa, na configuração de coleta de dados. Neste exemplo, estou configurando o Google Analytics em um website, então vou clicar na opção:

Web

Caso queira utilizar o GA em um aplicativo, basta selecionar a opção apropriada.

Passo 8 – Coleta de Dados / Configurar fluxo de dados

Ao clicar no botão de “Web”, automaticamente uma aba lateral será aberta, para configurar o fluxo de dados. Neste exemplo eu configurei meu site com “https://” (pois tenho certificado SSL/TLS no meu domínio) e inseri a url:

viniciuspaes.com

Em seguida, para identificar este fluxo, inseri que seria relevante o meu blog pessoal, ou seja:

Vinicius Paes

Após preencher os dados acima, basta clicar no botão:

Criar fluxo

Passo 9 – Coleta de Dados / Configurar fluxo de dados / Métrica Otimizada

Após clicar no botão “Criar fluxo” uma outra aba de métrica otimizada vai abrir. Basta selecionar as opções que fazem sentido para você. Eu mantive todas as opções marcadas, que é o padrão.

Após selecionar as opções, clique em:

Salvar

Passo 10 – Coleta de Dados / Configurar fluxo de dados / Métrica Otimizada / Detalhes do fluxo da Web

Por fim, será encaminhado para a aba de resumo dos detalhes do fluxo web configurado.

Basta clicar no “X” no canto superior esquerdo e fechar a aba.

Passo 11 – Etapa 5 do cadastro concluída – Coleta de Dados Configurada

Agora você estará de volta na página de “Começar a Coletar Dados”. Porém, com a configuração realizada.

Para continuar, clique no botão:

Avançar

Passo 12 – Configuração inicial / cadastro realizado – Coleta de dados pendente – precisa inserir código de rastreio no site

As 5 etapas iniciais de cadastro foram criadas com sucesso. Clique no botão:

Ir para a página inicial

Só um lembrete, nesta configuração inicial ainda não vinculamos o código de rastreio em nosso site. Então os dados não vão aparecer ainda. Vamos realizar esta etapa de adicionar uma “tag” do GA4 no site nos próximos passos.

Passo 13 – Configurar quais comunicados por email gostaria de receber

Na primeira vez que realizar o login no Google Analytics, um modal irá aparecer com as opções de notificação que gostaria de receber por email. Marque as opções que melhor atende suas necessidades e clique no botão:

Salvar

Passo 14 – Primeiro acesso a Dashboard do Google Analytics

Agora finalmente está na página principal após login no Google Analytics. Esta página também é conhecida como dashboard. Como só temos 1 único domínio configurado, estamos na dashboard deste domínio. No menu superior é possível observar:

Todas as contas > Conta Principal - viniciuspaes.com

Como mencionado, algumas configurações iniciais já foram realizadas. Mas precisamos agora “instalar” o código javascript de rastreio do Google Analytics (GA4) em nosso website.  Este código também é conhecido como tag.

Na página de dashboard, tem um aviso que nenhum dado ainda foi recebido pelo seu site, para verificar se possui uma tag instalada. Mas é exatamente isso mesmo, acabamos de criar a conta e não instalamos o código de rastreio ainda. Então precisamos clicar no botão:

Ver instruções para inclusão de tag

Passo 15 (1) – Instruções de instalação do código de rastreio (tag) utilizando plugins

Nesta página, temos 2 opções para instalação do código de rastreio do analytics:

1. Caso esteja utilizando WordPress em seu domínio ou outro gerenciador de conteúdo compatível, é possível instalar o código de rastreio através de plugins
2. Instalação do código de rastreio manualmente

Se tiver acesso aos arquivos de instalação do seu website, o recomendado é instalar manualmente o código. Pois muitas vezes os plugins tem um gasto muito maior de I/O no servidor. Se não tiver acesso para alterar os arquivos do seu site, ou não tiver o conhecimento para realizar o procedimento, uma opção é utilizar um plugin.

O próprio Google Analytics indica 3 sugestões de plugin para o wordpress:

• MonsterInsights plugin
• Site kit plugin
• WooCommerce plugin

Passo 15 (2) – Instruções de instalação do código de rastreio (tag) manualmente (editando arquivo do site)

Se optar por instalar manualmente o código de rastreio, lembre-se que o mesmo precisa estar presente em todas as páginas do seu site. Caso utilize um gerenciador de conteúdo (WordPress, Joomla, etc) é possível editar apenas 1 arquivo do seu template, adicionando o código, pois o mesmo é utilizado em todas as páginas. No wordpress o arquivo dentro da sua pasta de template chamado “header.php” tem esta função. Particularmente gosto de inserir o código de rastreio dentro das tags <head> … </head> para garantir que o código seja executado logo no início da abertura da página.

No exemplo da imagem abaixo, é possível verificar o código de rastreio que precisa ser adicionado e na tela seguinte a edição do arquivo de header do site e inserção do código de rastreio:

Passo 16 – Instalação e configuração concluída – só aguardar os dados!

Tudo pronto! Ao seguir este tutorial foi possível verificar os passos para se cadastrar no Google Analytics e configurar um domínio para que seja analisado. O GA informa que os dados de rastreio podem demorar até 48h para começarem a aparecer, então agora é ter paciência para acessar os dados de relatórios disponíveis.

Conclusões

O cadastro, configuração e instalação (rastreio) do Google Analytics é bastante simples. Algumas configurações iniciais de fluxo de informação podem ser um pouco complicadas na primeira vez que se depara com elas. Mas o verdadeiro desafio é depois de pronto. O Google Analytics fornece muitas informações, sendo possível criação de filtros e telas de relatórios personalizadas para atender a sua demanda. Mas é importante realizar o cadastro do seu site ou app o mais rápido possível e já deixar o GA coletando os dados, toda informação é valiosa!

Se seguiram este tutorial até aqui, tudo correu bem! Caso tenham alguma dúvida ou sugestão, basta informar nos comentários. Farei o possível para responder!

O post Tutorial como criar conta no Google Analytics apareceu primeiro em Vinicius Paes.

• Aprender a adicionar acesso a um novo usuário a uma conta ou propriedade no Google Analytics
• Passo a passo para alterar permissão de acesso de um usuário existente no GA
• Como deletar acesso de usuário a uma conta ou propriedade (website) no Analytics

Introdução

Na gestão de acompanhamento e análise de crescimento de um website é importante ter uma equipe capacitada para gerenciar todas as atribuições existentes. É muito mais eficiente termos profissionais dedicados em cada área, do que apenas um funcionário dedicado a todas as análises e geração de relatórios. Para garantir de forma otimizada o acesso de todos os usuários desta equipe, podemos adicionar diferentes níveis de acesso ao Google Analytics e a cada website (propriedade) configurado na plataforma.

Lembrando que por motivos de segurança, essa gestão de acessos é importante também para garantir que apenas usuários administradores tenham permissão de excluir contas. Desta forma, é possível definir permissões somente leitura para determinados colaboradores, além de garantir permissões de customização dos relatórios para usuários editores. É possível garantir acesso de visualização para terceiros (agências de web marketing), entre outros.

No geral, há um conjunto de permissões (papéis) disponíveis na gestão de acesso de usuários no Google Analytics, sendo elas:

• Administrador
• Editor
• Profissional de Marketing
• Analista
• Leitor
• Nenhum

Além destes papéis, é possível também restringir dados sensíveis sobre o website, como as métricas de custo (adwords) e receita (adsense), caso seu Google Analytics tenha esses serviços vinculados.

Passo a passo de como criar novo usuário com acesso no Google Analytics

Caso queira criar um novo usuário para ter acesso a um website do seu Google Analytics, os passos são bem simples. De forma geral, em resumo, podemos destacar as etapas sendo como:

1. Realizar login na sua conta do Google Analytics
2. Acessar a página de Administrador (ícone de engrenagem)
3. Selecionar o tipo de acesso que deseja adicionar:
   • Criar um novo acesso a conta (todos os websites)
   • Criar um novo acesso a propriedade (apenas 1 site ou conjunto de sites da propriedade)
4. Clicar no botão de “+” para adicionar acesso para um novo usuário (opção: adicionar usuários)
5. Inserir email do novo usuário e permissões
6. Tudo pronto! Acesso para novo usuário criado

Abaixo é possível conferir o passo a passo de maneira explicativa, acompanhando cada passo por imagens.

Passo 1 – Acessar página de administração

Após realizar login no Google Analytics, é preciso localizar o ícone de engrenagem que é correspondente ao link para a páginas de administrador do Google Analytics. Usualmente este link fica disponível no canto inferior esquerdo da página principal do analytics, e faz parte do menu lateral.

Passo 2 – Selecionar opção Gerenciamento de acesso à conta ou propriedade

Agora estamos na página principal do administrador da conta. Temos diversas opções nesta página, mas nosso objetivo é gerenciar acessos. Desta forma, temos 2 opções:

1. Gerenciar acesso à conta (engloba todos os websites configurados nesta conta)
2. Gerenciar acesso a propriedade (cada propriedade engloba usualmente 1 website, ou um conjunto de websites)

Escolha a opção que faça mais sentido para suas necessidades. Usualmente garantimos acesso à propriedade, para que uma equipe ou empresa terceirizada cuide de um determinado website.

Passo 3 – Clicar no botão “+” para habilitar opções de criação de novo usuário com acesso ao GA

Agora estamos na tela que gerenciar os acessos. No canto superior direito temos um ícone com o símbolo de “+”. Ao clicar no botão, selecione a opção:

Adicionar usuários

Passo 4 – Inserir dados pessoais do novo usuário, junto com seu papel e restrição

Agora você estará na tela para configurar o acesso de novos usuários. Adicione o endereço de email de todos os usuários que deseja gerenciar o acesso. Em seguida, é necessário gerenciar os papéis (permissões) que estes novos usuários vão ter.

Caso tenha configurado o Adwords ou Adsense em sua conta do Google Analytics, será possível garantir permissão de acesso a estas métricas ou não.

Ao terminar de configurar o acesso dos novos usuários, clique no botão:

Adicionar

Tudo Pronto! Acesso a um novo usuário configurado com sucesso!

Editar papel e permissão de acesso usuário Google Analytics

Passo 1 – Vá para a página de administração

A opção de edição de acesso de usuários também se encontra dentro da página de Administrador. Sendo necessária acessá-la.

Passo 2 – Opção de Gerenciamento de acesso à conta ou propriedade

Caso deseja alterar a permissão de acesso de um usuário com acesso à conta, selecione:

Gerenciamento de acesso à conta

Ou, caso tenha o desejo de alterar o acesso de um usuário a uma propriedade, selecione:

Gerenciamento de acesso à propriedade

Passo 3 – Encontre o usuário que deseja realizar alteração de nível de acesso

Selecione o ícone “…” para abrir a opção:

Ver os detalhes da conta do usuário

Passo 4 – Edite o nível de acesso do usuário no Google Analytics

Agora selecione o ícone de edição (lápis) para editar a permissão de acesso do usuário.

Deletar acesso de usuário no Google Analytics

Assim como na opção de criação e alteração da permissão de acesso de usuários no Google Analytics, precisamos caminhar até a página de gerenciamento de acesso (propriedade ou conta).

Encontre o usuário que queira excluir (remover) o acesso e selecione a opção:

Remover acesso

Conclusão

Neste passo a passo cobrimos 3 opções possíveis na gestão de acesso no Google Analytics: criar, alterar e remover. Os passos são bem simples e intuitivos. Caso tenha alguma sugestão ou dúvida, basta informar nos comentários!

O post Como adicionar, alterar e excluir o acesso de usuários no Google Analytics apareceu primeiro em Vinicius Paes.

Make automatic connections on gitlab or github with git pull, git push, git clone using SSH protocol without needing to enter credentials (password). Also useful for using a webhook that updates the software on the server whenever there is a commit on the master/main branch.

Project Requirements

1. Terminal / Command Prompt access (command line)
2. A Gitlab or GitHub account

How to create SSH key for automatic authentication in github or gitlab?

Basically the steps are very simple, whether for windows, mac or linux:

1. Open terminal (linux and mac) or command prompt (windows)
2. To create SSH key with RSA encryption, use the command: ssh-keygen -t rsa -b 4096 -C “myemail@email-example.com“
3. You will be asked 3 questions: where to save the SSH key pair, passphrase to access the key (optional), and to confirm the entered passphrase
4. To access the content of the created public SSH key:
   • On linux or mac, use the command: cat ~/.ssh/id_rsa.pub
   • On windows: type “%userprofile%\.ssh\id_rsa.pub”
5. Copy the created public ssh key text (id_rsa.pub) and install/configure (paste the key text) in the github or gitlab ssh key configuration field
6. Do not let anyone access your private ssh key (id_rsa) and keep it safe at all times

Below we will explain in detail the step by step and the how to create ssh key pair, with images and explanatory text.

Step 1: Open command prompt or terminal application with desired user

The first step is to open the command prompt if you are using Windows Operating System or the Terminal if you are using the Mac OS or Linux.

Make sure you are using the correct user that you want to authenticate (for creating the SSH key pair). Remember to avoid using the root user (if you use Linux).

Step 2: Create a new ssh key pair

With the prompt or terminal open, let’s use the ssh-keygen command to generate a key pair with 4096-bit RSA encryption and insert, together with the key, a text string informing the e-mail linked to the key (using the same e-mail address that you use in your githu, gitlab or bitbucket account is a good practice):

ssh-keygen -t rsa -b 4096 -C "myemail@email-example.com"

After running the command, three questions will be prompted:

1. The first is where you would like to save the created key. It is recommended to save in the default folder (leave it blank and press ENTER).
2. The second question is related to creating a password (passphrase) to access the key.
3. The third question is to confirm the chosen password.

Regarding the first question after running ssh-keygen: Select the location where you want to save the ssh key. If you press enter (without writing anything), it will be saved in your home folder, which can be:

On Windows:

C:\Users\yourusername\.ssh\id_rsa.pub or "%userprofile%\.ssh\id_rsa.pub"

On Linux and MAC OS, the path is:

~/.ssh/id_rsa.pub

Regarding the second question: – So, do I need to setup a password/passphrase to access the ssh key or not? It is interesting to take into account some points:

• If you are strict about storing your keys securely, and don’t want to have to type your password every time you connect or commit, then it’s better not to set a password.
  If security is an extremely important variable, especially if you work with production servers, or private repositories with sensitive information, for security reasons, it is recommended that you configure a password/passphrase.

Use case example:

• If you create your keypair without a linked password, the process of connecting to your server or repository is very quick, as there is no longer any need to enter login and password credentials. Its use is also very common in automated processes, if you have a cron job configured that needs to make an ssh connection.
• Adding a password to your key can provide an extra layer of security. The reason is that if a hacker manages to access your key pair, he will not be able to connect directly to your server or repository; it will still need the password.

The third question is related to confirmation of the chosen password.

A fingerprint of your computer/server (key fingerprint) will then be generated.

Step 3: Paste the public SSH key to your GitHub or Gitlab account

In order to setup your SSH key on Gitlab, Github or Bitbucket, you need to access the content of the id_rsa.pub file (which is your public key). The bellow command will show your generated public key on the screen:

On Linux and MAC OS, the command is:

cat ~/.ssh/id_rsa.pub

On Windows:

type "%userprofile%\.ssh\id_rsa.pub"

The beginning of the key must start with ssh-rsa and end with your chosen email address. Now select you public key text and copy to the clipboard.

Step 4: Configure Github and Gitlab

In the previous step we copied the contents of the id_rsa.pub file to the clipboard. In order to configure our SSH key authenticated access on Gitlab or Github, we need to “install”/configure this public ssh key on the platform.

If you want to use a key in the ed25519 standard or instead of RSA, just generate it with the steps below:

ed25519 algorithm

An alternative to SSH key creation is to use the ed25519 encryption algorithm instead of RSA. To create the key pair with this algorithm, use the command:

ssh-keygen -t ed25519 -C "my-email@email-example.com"

The path to the public key is the same, but now it has the name linked to the algorithm:
On Linux and Mac OS:

~/.ssh/id_ed25519.pub

On Windows:

C:\Users\yourusername\.ssh\id_ed25519.pub or "%userprofile%\.ssh\id_ed25519.pub"

To view the contents of the public SSH key, use the command:

If you are using Linux or Mac OS:

cat ~/.ssh/id_ed25519.pub

Now if you are using Windows, use the command:

type "%userprofile%\.ssh\id_ed25519.pub"

If you have any questions or suggestions, write them in the comments! I will do my best to answer!

Step by step on how to configure SSH key in Gitlab

Create a new repository in gitlab

In this example, we will first show you how to create a new project, or new repository. On the Gitlab home screen, (after logging in), click on the option:

Create a project

Then choose the type of project you want to create. In this example we are going to create a blank repository, so let’s choose:

Create a blank project

Now we are on the new repository configuration screen. In this example we will choose the name “repo-gitlab“, in reference to a repository that we will configure in gitlab. The project slug is how the name of your project will appear in the url of the page, it is automatically generated according to the chosen name, but it is possible to change it. We’re not going to set up a deployment, so check:

No deployment planned

This repository will be private, so only the owner of the repository and whoever he grants access will be able to see its contents. We are already going to configure the repository with a README file automatically, because this way we can already make a clone on our computer and test it.

When everything is ready, click on the button:

Create project

In this example, we have the project/repository created as in the image below:

Add SSH key to gitlab

One of the most important parts of configuring your repository’s integration into your development environment is configuring your public SSH key so that you can speed up the commit process. SSH key settings are within your personal profile menu. So first we need to click on our photo icon, as in the image below:

Now choose the option:

Edit profile

Now we are inside our profile page. Notice that now the options in the left menu are different. Let’s choose the option:

SSH Keys

We are now on the public SSH key configuration screen. Copy your generated key (content of id_rsa.pub) on your personal computer and paste it in the text field, as shown in the image below. Then click on:

Add Key

All done! New public key configured successfully! You will have a confirmation image and a summary of your key data, as shown in the image below:

Step by step on how to configure SSH key on Github

As we showed in the example above, the process to add an SSH key in github is very similar to what was done in gitlab.
If you already have a repository created, you can also try cloning it on your personal computer to perform commit tests.

Add SSH key to gitlab

The process to add your public ssh key on github is super simple. The first step is to click on your profile picture in the upper right corner. When clicked, the menu will appear.

In the menu, select the option:

Settings

In the settings page, select the bellow option available in the left menu bar:

SSH and GPG keys

Now just look for the “SSH Keys” session and click on the green button:

New SSH Key

Now choose a title for your key, which is basically a name, so you can remember the purpose or origin of that key. The key type in this example it will be:

Authentication key

Now we need to put the contents of our public ssh key into the “key” text field.
To finish the key setup, click on:

Add SSH key

All set, new public ssh key successfully registered on github. The image below illustrates the registered example key:

Configure Git personal computer/workstation

So that we can set up our repository on our personal computer or workstation, it is first necessary to perform an initial configuration in git. If you don’t have git installed on your computer, just access the project’s official website to download and install it:

https://git-scm.com/downloads

With git installed, we basically need to configure some personal data like email address and username.
To configure the user’s email address in git, use the command from the prompt or terminal:

git config --global user.email "myemail@email-example.com"

To configure the username, use the command:

git config --global user.name "Vinicius Paes"

Remember to update the email and username in the examples above to your personal details.

How to clone a repository, add files, commit and push with ssh key authentication

First, to clone a repository with SSH, we need its URL. In your repository page it is possible to extract this information. In our example, we created the repository called “repo-gitlab“, and we are using the username viniciuspaes. So our URL and command to clone looks like:

git clone git@gitlab.com:viniciuspaes/repo-gitlab.git

After cloning the directory, we can verify it with the command:

dir

To navigate into the repository, use the command:

cd repo-gitlab

To test the commit/push functionality for the main branch, let’s create a “new.txt” file:

type nul > new.txt

Now add the file to the commit list:

git add .

Now we need to add a message to our commit, so we use the command:

git commit -m "add file new.txt"

All done, we can use the push command to update the main branch with the new file created:

git push origin main

If everything went well, we can see in the gitlab interface that the new file has been added, as illustrated in the image below:

And everything is ready! SSH key pair created, git configured, gitlab configured, github configured, repository clone example done, add new file and commit/push performed via command line!

Did you like this tutorial, was there any information missing or did you have any questions? Write it down in the comments!

O post How to create an SSH key pair to connect to gitlab or github on mac os, windows or linux apareceu primeiro em Vinicius Paes.

• Saber o que é uma VPN
• Conhecer o software OpenVPN
• Criar um servidor nível gratuito configurado com OpenVPN para permitir conexão VPN grátis (vpn gratuita)

O que significa ou o que é uma VPN?

A sigla VPN vem do inglês e significa “Virtual Private Network“, que pode ser traduzido como “Rede Virtual Privada“.

A utilização de uma conexão VPN permite encriptar e proteger seu tráfego de internet do seu dispositivo de origem até o seu servidor VPN de destino.
Uma VPN é muito útil caso esteja utilizando uma rede pública para acesso a internet, pois a encriptação utilizada dificulta que hackers ou pessoas mal intencionadas rastreiem suas atividades e tentem roubar/interceptar dados pessoais.

Além do processo de proteção de navegação ponto a ponto (dispositivo origem até servidor VPN de destino), a VPN pode ser útil quando é necessário acessar websites que limitam tráfego para faixas de IP do seu próprio país.

Quando a NASA pousou um de seus robôs em marte, havia uma restrição no website para visualização das imagens disponibilizadas. A NASA utilizava possivelmente a faixa de IP para determinar quem tinha permissão de acesso. Um usuário no Brasil teria o acesso negado pra as imagens, por causa de seu IP de origem.

O site da GameStop também tinha, no passado, uma limitação de acesso por faixa de IP (testei atualmente e não verifiquei mais estas restrições). Quando acessado pelo Brasil, uma página de erro era mostrada.

Em uma conexão VPN, seu “IP” de origem passa a ser o IP do seu servidor VPN. Nos 2 exemplos acima, possivelmente não haveria uma restrição de acesso, caso o servidor VPN estivesse sediado nos Estados Unidos.

Em alguns países há restrição de acesso a determinados sites e aplicativos. Geralmente estas restrições são de nível nacional, aplicadas pelo Governo. Basicamente todo o tráfego de internet nacional é impedido de acessar determinados destinos. Porém, caso você tenha uma conexão VPN ativa, você consegue realizar uma “ponte” até o seu servidor e de lá acessar os sites e aplicativos que originalmente seriam bloqueados.

Em nível empresarial, algumas empresas possuem recursos que só podem ser acessados internamente, pela rede local. Agora imagine que novas filiais desta empresa foram criadas e estas também precisam de acesso aos recursos dentro desta rede centralizada. Uma opção é realizar uma conexão entre a matriz e as filiais por VPN. Ou até mesmo garantir acesso por VPN para usuários que precisam deste acesso “local”.

Em resumo, uma conexão VPN (caso corretamente configurada) faz um túnel seguro do seu dispositivo de origem (notebook, celular, desktop, etc) até seu servidor VPN. Todo seu “tráfego” tem uma nova porta de saída.

O que é o OpenVPN?

Em uma conexão VPN usual, temos um dispositivo que quer se conectar (o cliente) e o computador configurado com software VPN que provê o serviço (servidor).
Neste sentido, o software OpenVPN que provê as funcionalidades para que o computador funcione como um servidor VPN.

Interessante destacar que o OpenVPN é um software livre e de código aberto (open source). Além do exemplo acima de conexão virtual privada do tipo ponto a ponto, ele também permite no formato servidor para múltiplos clientes.

Esta conexão é configurada como um túnel criptografado, visando a segurança das informações trafegadas entre os computadores.

O que é uma VPN grátis?

Basicamente é a possibilidade de se conectar de forma segura em um servidor VPN que provê o serviço de forma gratuita. Existem diversas empresas que prestam serviços de conexão VPN e em seus pacotes básicos, ofertam VPN grátis por um período de tempo ou por volume de dados trafegados.

Mas é interessante ter certeza que a empresa escolhida é confiável, senão o seu túnel seguro, pode ter esta brecha de segurança, e a própria empresa pode estar espiando seus dados.

Mas também é possível criar seu próprio servidor VPN de forma gratuita. Existem empresas que ofertam produtos em nuvem e possuem pacotes de nível gratuito. Uma opção é reservar um servidor gratuito (mesmo que por tempo limitado) e criar seu próprio servidor VPN. Que é a proposta deste passo a passo!

Passo a passo para criar servidor e conectar com VPN grátis

Primeiramente, vamos mostrar as etapas necessárias de forma resumida:

1. Criar um servidor de nível gratuito
   • Servidor nível gratuito (Free Tier) na Amazon AWS; ou
   • Servidor nível gratuito no Google Cloud Platform (VM no Compute Engine)
2. Instalar e configurar software OpenVPN
3. Criar arquivo de conexão para cada cliente
4. Conectar dispositivo em sua VPN grátis com o OpenVPN Connect

Passo 1 – Criar servidor de nível gratuito

Para garantir sua VPN grátis, o primeiro passo é o setup de um servidor de nível gratuito. Já abordamos em publicações anteriores o passo a passo para criar e configurar um servidor ofertado pela Amazon AWS e Google Cloud.

Desta forma, é necessário escolher em qual empresa deseja criar o servidor:

• Como criar servidor nível gratuito Amazon AWS; ou
• Como criar servidor nível gratuito no Google Cloud

Neste passo a passo, utilizei o servidor configurado no Google Cloud Platform. Reservei a instância de VM no Compute Engine e escolhi os recursos dentro do nível gratuito, com uma instância do tipo e2-micro na região us-east1.

Passo 2 – Conectar no servidor

Com o servidor criado, é preciso então realizar a conexão SSH para que seja possível iniciar sua configuração. Neste primeiro exemplo, caso tenha o servidor no Google Cloud com IP externo 34.148.148.148 e tenha já configurado sua chave SSH pública durante o setup com usuário/email da chave sendo debian@exemplo.com (por exemplo, ao gerar sua chave SSH no seu computador pessoal, você informou que seu nome de usuário era debian e seu email era @exemplo.com, desta forma ao realizar o comando de ssh abaixo, utilize o seu nome de usuário que definiu na chave: neste exemplo seria debian), temos o comando para login:

ssh debian@34.148.148.148

Caso tenha realizado o setup na Amazon AWS e gerado uma chave de conexão pela interface da AWS, sua conexão será similar a:

ssh -i ChaveVPCaws.pem ubuntu@34.148.148.148

Passo 3 – Instalar e configurar software OpenVPN

Como o propósito deste servidor é a funcionalidade de conexão VPN, precisamos de um software para prover o serviço. Como mencionado anteriormente, o OpenVPN é um software gratuito e de código aberto muito utilizado para prover o serviço de conexão VPN.

Um usuário criou um script automatizado muito útil para instalação e configuração semiautomática do OpenVPN. Para realizar o download do script diretamente do repositório, basta executar o comando:

curl -O https://raw.githubusercontent.com/angristan/openvpn-install/master/openvpn-install.sh

Para garantir permissão de execução do script, é necessário executar o comando:

chmod +x openvpn-install.sh

Para executar o script é necessário utilizar o comando:

sudo ./openvpn-install.sh

Agora é necessário seguir as opções disponibilizadas pelo script.

A maioria das opções mostradas como padrão, são recomendadas para a maioria dos usuários. Lembrando que a porta padrão do OpenVPN é a:

1194

Você poderá alterar a porta para uma de sua escolha, ou até mesmo permitir que o script escolha uma porta aleatoriamente. Porém é importante anotar qual porta escolheu, pois vamos precisar abrir esta porta (regra do firewall) na interface do provedor (AWS ou Google Cloud), para permitir nossa conexão VPN (cliente-servidor).

Na escolha dos servidores DNS, por padrão o script aconselha utilizar os servidores do Adguard, que já possuem um filtro de bloqueio contra propagandas. Como prefiro ter a opção de habilitar e desabilitar o filtro contra propagandas (ads) e o servidor está configurado no backbone do Google Cloud, preferi utilizar por padrão os servidores do DNS do Google.

Neste momento o script já instalou e configurou o OpenVPN. No próximo passo será solicitado um nome para criação do primeiro cliente habilitado para conexão VPN. Neste exemplo, criei um cliente com o nome de “vinicius”.

Tudo pronto! OpenVPN criado e arquivo de configuração/acesso de cliente criado. Neste exemplo criei um cliente com o nome de “vinicius”, então o arquivo de configuração terá o nome:

vinicius.ovpn

Para criar novos arquivos de configuração para outros clientes, basta executar o script novamente. Quando o menu do script abrir, escolha a opção número 1:

Como mencionado, o nome escolhido para o cliente vai gerar um arquivo no formato:

nomecliente.ovpn

Passo 4 – Copiar arquivo de configuração do cliente .ovpn para seu computador pessoal

Com o OpenVPN instalado e configurado, assim como o arquivo de configuração do cliente, agora precisamos enviar este arquivo para nosso computador pessoal.

A opção mais simples é verificar o conteúdo do arquivo, copiar (control+c) e colar o conteúdo (control+v) em um arquivo do bloco de notas e salvar com a extensão .ovpn. Para verificar o conteúdo do arquivo de configuração, execute o comando:

cat nomecliente.ovpn

A segunda opção é abrir outro prompt de comando no seu computador pessoal com sistema operacional Windows, e copiar o arquivo de configuração por SCP (ssh) do seu servidor para a pasta Downloads, utilizando o comando:

scp debian@34.148.148.148:~/nomecliente.ovpn "%userprofile%\Downloads"

Caso utilize linux ou Mac OS, abra o terminal e execute o comando (irá salvar o arquivo na pasta pessoal do seu usuário):

scp debian@34.148.148.148:~/nomecliente.ovpn ~/

Passo 5 – Abrir a porta de conexão VPN no seu servidor

No Google Cloud Platform, acesse a página de dashboard do Compute Engine / Instâncias de VM:

https://console.cloud.google.com/compute/instances

Nesta tela você irá ver uma linha com a instância da sua máquina virtual. No fim da linha haverá 3 pontos alinhados em pé. Ao clicar neles, um menu irá aparecer com algumas opções. Selecione a opção:

Ver detalhes da rede

Nesta nova página que abriu, haverá novas opções no menu lateral esquerdo. Clique na opção:

Firewall

Agora no menu superior, clique na opção:

CRIAR REGRA DE FIREWALL

As opções que precisa definir/selecionar:

• Nome: openvpn
• Descrição: conexão vpn
• Registros: desativado
• Rede: default
• Prioridade: 1000
• Direção do tráfego: Entrada
• Ação se houver correspondência: Allow (Permitir)
• Destinos: Todas as instâncias da rede
• Filtro de origem: Intervalos IPv4
• Intervalos IPV4 de origem: 0.0.0.0/0
• Segundo filtro de origem: Nenhum
• Filtro de destino: Nenhum
• Protocolos e portas: Portas e protocolos especificados:
  • Selecione: UDP
  • Número porta: 1194

Agora basta clicar no botão:

CRIAR

Passo 6 – Instalar e configurar o software OpenVPN Connect em seu dispositivo pessoal

Para recapitular o que foi feito até o momento, já temos o servidor de nível gratuito configurado. Temos o OpenVPN corretamente instalado no servidor, já geramos o arquivo de configuração do cliente e criamos a regra de firewall para permitir a conexão pela porta 1194. O próximo passo então é efetivamente realizar a conexão VPN do cliente até o servidor para verificar o funcionamento. Desta forma, vamos precisar do software “OpenVPN Connect” instalado no dispositivo “cliente”. Vamos importar neste software o arquivo de configuração (nomecliente.ovpn) para que possamos realizar a conexão.

Caso queira conectar um computador com Microsoft Windows na VPN, faça o Download:

• Download OpenVPN Connect para Windows

Caso esteja em um computador configurado com o Mac OS na VPN, faça o Download:

• Download OpenVPN Connect para Mac OS

Para o Sistema Operacional Linux conectado na VPN, faça o Download:

• Download OpenVPN Connect para Linux

Caso queira utilizar a conexão VPN pelo celular ou tablet com Android, faça a instalação:

• Download OpenVPN Connect Google Play – Celular e Tablet com Android

Caso queira utilizar a conexão VPN no iPhone ou ipad, acesse o aplicativo na apple store:

• Download OpenVPN Connect Apple Store – Iphone e Ipad

No exemplo abaixo, vou configurar a conexão do meu computador pessoal com Sistema Operacional Windows. Após instalar e executar o OpenVPN Connect, vamos ter uma tela semelhante a imagem abaixo. Como nossa configuração não é feita por URL e sim pelo arquivo .ovpn, vamos clicar na opção:

FILE

Agora estamos na aba de importação do perfil de configuração por arquivo. Você pode arrastar o arquivo .ovpn gerado e soltar dentro do campo do file upload, ou selecionar o seu arquivo, clicando no botão:

BROWSE

Caso o arquivo de importação de perfil tenha sido carregado corretamente, você será redirecionado para a tela de perfis. Neste exemplo, temos o perfil vinicius configurado:

Passo 7 – Ativar o serviço de VPN Grátis configurado

Nesta etapa já temos todo o setup configurado. Para habilitar uma conexão segura por VPN em seu dispositivo, basta clicar no botão ao lado do seu perfil. No exemplo abaixo, temos a conexão VPN estabelecida para o cliente “vinicius“.

Atenção! Caso receba algum problema de conexão, possivelmente não configurou corretamente a abertura da porta do OpenVPN no Firewall na interface do servidor, como descrito no Passo 5!

Lembrando que a conexão VPN possivelmente será mais lenta que sua internet contratada, um dos fatores é o poder de processamento do servidor de vpn grátis. Neste exemplo, eu tenho um plano de internet de 500/250Mbps, que a provedora costuma entregar algo perto de 750/350Mbps. Minha latência varia entre 20-30ms (já não é lá muito boa). Segue abaixo os testes de velocidade executados com a conexão VPN ativa:

Como é possível verificar nos testes acima, minha velocidade de conexão foi limitada, principalmente pelo poder de processamento do servidor, como era esperado. Minha latência também subiu para algo perto de 160ms, que faz sentido, pois a minha rota agora sai pelo servidor sediado nos Estados Unidos (mais longe geograficamente). Para termos de comparação, se executo um ping do meu computador para o servidor VPN, com a VPN desligada, tenho algo perto de 150ms de latência.

Conclusão

Com este tutorial foi possível criar de forma bem simples um servidor VPN de nível gratuito utilizando o software OpenVPN. É uma opção viável para se obter uma VPN grátis e segura. Existem diversas empresas que ofertam também os serviços de VPN e com muitos mais recursos, onde você pode mudar sua rota de saída para diferentes países e cidades. Os planos pagos geralmente ainda garantem conexões mais rápidas e para múltiplos clientes, sendo uma opção caso queira implantar uma VPN para todo seu tráfego da rede doméstica, configurando esta opção diretamente em seu roteador.

Caso tenha alguma dúvida ou sugestão na implantação de uma VPN grátis, basta informar aí nos comentários!

O post Tutorial criar servidor OpenVPN e conectar com VPN grátis apareceu primeiro em Vinicius Paes.

• Conhecer o Google Cloud Platform
• Entender a diferença do nível gratuito e teste gratuito do Google Cloud
• Passo a passo para criar um servidor no nível gratuito no google cloud – máquina virtual do compute engine

O que é o Google Cloud

O Google Cloud é uma plataforma de serviços de computação em nuvem. Assim como a Amazon possui o AWS (Amazon Web Services) e a Microsoft possui o Azure, o Google possui o Google Cloud Platform.

O Google Cloud Platform foi criado em 2008, e oferta uma diversidade de ferramentas e recursos em nuvem, utilizando a mesma infraestrutura que o próprio Google utiliza em seus produtos e serviços.

O que é o nível gratuito e o teste gratuito do Google Cloud Platform?

Basicamente o nível gratuito fornece acesso gratuito, porém limitado, a alguns produtos e serviços do Google. O usuário precisa estar elegível para o nível gratuito, para não receber cobranças.

Na documentação do Google Cloud ele deixa claro que os usuários elegíveis não podem ter nenhum contrato de preços negociados com google, precisa estar no período de avaliação gratuita e precisa ter dados de faturamento configurados e em situação regular. Eles deixam claro que, se em algum momento o usuário deixar de cumprir as metas estabelecidas do nível gratuito, será cobrado pelos serviços.

O teste gratuito é basicamente um programa do Google Cloud que fornece crédito gratuito para utilização da plataforma. A ideia do teste gratuito é fornecer, dentro de um período de tempo, créditos para que o usuário possa se familiarizar com a plataforma e aprender a utilizá-la.

Porém existem alguns critérios para o período de teste gratuito, o usuário não pode ter sido um cliente pagante anteriormente e ser a primeira vez que se inscreve no teste gratuito. Lembrando que também é necessário ter uma conta de faturamento configurada (com cartão de crédito cadastrado) para iniciar o período de teste gratuito.

Passo a passo para criar uma máquina virtual (servidor) no nível gratuito no google cloud / compute engine

Primeiramente vamos mostrar um resumo dos passos necessários:

1. Acessar a url da plataforma do google Cloud: https://cloud.google.com/compute
2. Será possível então clicar no botão para realizar uma avaliação gratuita
   • Preencha os dados pessoais e de faturamento
   • Responda o pequeno questionário no primeiro acesso
3. No menu, selecione a opção Compute Module, em seguida Instância de VM (Máquina Virtual)
4. Ao selecionar a região da Máquina Virtual, tenha cuidado para selecionar as regiões que o nível gratuito abrange para não ser cobrado
   • A instância de nível gratuito atualmente é a e2-micro
   • As regiões disponíveis no nível gratuito (na data da escrita deste tutorial) são: Oregon: us-west1, Iowa: us-central1, Carolina do Sul: us-east1
5. Opcional: Informe sua chave pública do SSH
6. Será mostrado um valor estimado do custo da máquina virtual, mas como está no nível gratuito, não será cobrado se atender todas as exigências do programa.

Passo 1

Neste primeiro passo, vamos supor que já possui uma conta no gmail, ou seja, já possui uma conta no Google. Em seguida, precisamos acessar a url do Google Cloud Platform:

https://cloud.google.com/compute

Nesta página inicial já deve aparecer a opção para realizar um teste gratuito no Google Cloud. Dependendo na região que estiver acessando e da data, é possível que apareça também um cupom de U$300 para ser utilizado em até 3 meses. Neste tutorial vamos focar no nível gratuito (que é diferente do teste gratuito de 90 dias), então se realizar o setup do passo a passo, não será cobrado nada, e nem será descontado nenhum valor do seu cupom de U$300.

Clique na opção:

Comece gratuitamente

ou

Faça uma avaliação gratuita do Compute Engine

Passo 2

Neste primeiro acesso será necessário preencher algumas informações pessoais. Em seguida também será necessário informar algumas informações sobre faturamento. Sobre o faturamento, é basicamente informar os dados de um cartão de crédito válido.

Pode parecer estranho o google oferecer o serviço de teste grátis ou nível grátis e pedir para preencher dados de faturamento e informações sobre cartão de crédito. Mas a justificativa é para evitar fraudes. O Google garante que não irá fazer nenhuma cobrança, mesmo tendo o cartão registrado, e qualquer cobrança só será realizada caso o usuário faça um upgrade da conta e permita o faturamento.

Uma dica é criar um cartão virtual no Nubank ou outro banco digital somente para validar o faturamento, e após este processo, imediatamente bloquear o cartão. Desta forma evita qualquer dor de cabeça.

Após preencher todos os dados, clique no botão:

INICIAR MEU TESTE GRATUITO

Passo 3

Após o passo anterior, caso seja seu primeiro acesso no Google Cloud e tenha ativado o teste gratuito, um pequeno formulário será apresentado.

Basicamente são perguntas para entender o seu perfil de usuário, suas necessidades e qual motivo principal está utilizando o Google Cloud.

Basta responder com o que mais se aproxima de suas necessidades, mesmo que esteja acessando o portal apenas por curiosidade, para verificar os serviços escolhidos.

Após responder todas as perguntas, clique em:

CONCLUÍDO

Passo 4

Se não tiver ativado a API do Compute Engine ainda (primeiro acesso), clique no botão:

ATIVAR

Passo 5

Após executar todos os passos anteriores, você estará na página principal do Google Cloud, também conhecida como console.

Como o objetivo é criar um servidor de nível gratuito no Google Cloud, precisamos primeiramente acessar o menu no canto superior esquerdo.

No menu, primeiramente acesse a opção:

Compute Engine

Em seguida clique na opção de:

Instâncias de VM

Passo 6

Agora você está na tela principal das Instâncias de Máquina Virtual do Google Cloud. É uma tela resumo onde mostra informações das máquinas virtuais que possui.
Como ainda não temos nenhuma configurada, vamos clicar na opção:

CRIAR INSTÂNCIA

Passo 7

Estamos agora na página para criar uma nova instância de máquina virtual no compute engine do Google Cloud. A parte mais importante desta etapa é verificar os limites de recursos para ficar dentro do nível gratuito, caso seja seu interesse.

Na data da escrita deste tutorial, o Google ofertava 3 regiões diferentes para o nível gratuito, sendo elas:

• Região: us-west1 (zona a, b, c – Cidade de The Dalles, Estado do Oregon – Estados Unidos da América)
• Região: us-central1 (zona a, b, c, f – Cidade de Council Bluffs, Estado de Iowa – Estados Unidos da América)
• Região: us-east1 (zona b, c, d – Cidade de Moncks Corner, Estado da Carolina do Sul – Estados Unidos da América)
  

Interessante verificar a latência de cada região e zona comparado com seu local de origem, para verificar qual local atende melhor suas necessidades. Lembrando que geograficamente a cidade de Moncks Corner na região us-east1, é a mais próxima do Brasil, e possivelmente terá latência menor.

Outro ponto é garantir que sua instância (VM) tem os recursos que estão cobertos pelo nível gratuito, na data de criação deste tutorial, a instância do nível gratuito é a e2-micro. O nível gratuito garante também 30GB de espaço em disco.

Para ter certeza que está elegível para o nível gratuito, lembre-se de conferir na página oficial do google:

• Google Cloud Platform nível gratuito e teste gratuito.

A necessidade de sempre conferir os recursos disponíveis do nível gratuito é que o Google costuma atualizar as diretrizes, então é bom ficar atento.

Nestas primeiras opções disponíveis na criação da instância, temos a opção de definir um nome de identificação para ela. No meu caso, optei por chamar a mesma de “vpn”, pois pretendo configurar o servidor (VM) com openvpn futuramente. Escolhi então a região que apresentou a menor latência:

us-east1

Para a definição de zona, escolhi a primeira opção disponível, que era a zona:

us-east1-b

Configurei a VM para ser de uso geral também, para atender a especificação de nível gratuito.

A próxima opção é definir a série da instância. Basicamente cada grupo desta série possui especificação de recursos distintos. A instância com menos recursos disponíveis é também a ofertada para o nível gratuito. No meu caso então, escolhi a série:

E

E no tipo da máquina, selecionei:

e2-micro (2 vCPU, 1GB de memória)

Vou utilizar o servidor em linha de comando, então não vou ativar dispositivo de exibição.

Não vou utilizar serviço de VM confidencial e nem vou implantar um contêiner. Então não vou alterar essas configurações.

A parte de Disco de inicialização fará um resumo da máquina virtual e imagem de Sistema Operacional instalado.

A parte de contas de serviço vou deixar na configuração padrão.

Em escopos de acesso, deixei a opção:

Permitir acesso padrão

Em firewall, deixei habilitado acesso http e https. Basicamente será criado entradas no firewall para as portas 80 e 443. Mas você poderá criar manualmente depois. Se for utilizar o servidor como um servidor de páginas, fará sentido deixar estas portas abertas. Ou se for utilizar estas portas para outro tipo de tráfego, também vale a pena deixar habilitadas.

Como mencionei, pretendo futuramente testar o openvpn, então em nome de host eu escolhi vpn.server. Faça a escolha de acordo com suas necessidades. Em configuração de desempenho da rede, não fiz modificações. Em interface de rede, deixei as configurações padrão também.

Não realizei alterações na interface de rede e nem nos discos.

Nas opções de segurança, ativei todas as possíveis.

Recomendo já configurar uma chave SSH pública, para ter a liberdade de realizar conexão diretamente no servidor. Caso tenha dúvida em como gerar uma chave SSH, é só seguir os passos deste tutorial:

• Tutorial como criar chave SSH (pública e privada)

Não vou realizar alterações nas próximas opções, então é possível ir até o fim da página e clicar no botão:

Criar

Lembrando que é comum aparecer uma estimativa de custos para a criação do servidor (VM). Mas como estamos selecionando recursos dentro do nível gratuito, você não será cobrado. Mas lembre-se de confirmar se selecionou todas as opções elegíveis para o nível gratuito.

Passo 8

Após clicar no botão para criar a máquina virtual, você será redirecionado de volta para a tela de resumo das máquinas virtuais.

Será possível então perceber que agora a máquina virtual criada está disponível, sendo possível também verificar o status de funcionamento, o IP interno (conexão entre VM’s distintas) e o IP externo (para conexões externas).

Lembre-se que poderá abrir portas adicionais no firewall. Mas a porta 25 (smtp) é bloqueada por padrão, pois é a porta utilizada em servidores de email. Para evitar problemas em que usuários mal intencionados criam servidores de spam, por padrão esta funcionalidade é desativada no Google Cloud Platform.

Tudo pronto, servidor de nível gratuito criado e funcional! Caso tenha configurado uma chave SSH pública, basta conectar no servidor com seu usuário configurado na chave com o ip externo.

Conclusão

Neste passo a passo percebemos que o setup para um servidor (VM) no Google Cloud Platform é bem simples. Na data de criação deste tutorial, o Google ofertava um cupom de U$300 para ser utilizado dentro do período de teste gratuito. Mas como o objetivo do tutorial era o setup de uma VM de nível gratuito, verificamos na documentação quais eram os critérios e qual tipo de máquina virtual estava disponível. Uma dica para ter certeza que escolheu os recursos disponíveis no nível gratuito é verificar a página de faturamento.

Na imagem acima, podemos verificar que não consumimos nenhum crédito do teste gratuito (~U$300), pois selecionamos com êxito os recursos de nível gratuito.

Espero que tenha gostado deste tutorial para realizar o setup de uma VM no Google Compute Engine. Caso tenha alguma dúvida ou sugestão, escreve aí nos comentários!

O post Tutorial criar servidor nível gratuito no Google Cloud / Compute Engine apareceu primeiro em Vinicius Paes.

Configurar o Raspberry Pi para funcionar como uma câmera de time lapse.

Neste exemplo utilizei a câmera module v2, mas também é funcional com a versão v1 e câmeras USB compatíveis. Outras versões do Raspberry Pi também são funcionais, neste teste optei pela versão Zero W por ser mais compacta e o case já permitir o acoplamento do módulo da câmera.

O que é um time lapse?

Neste contexto de utilizar o Raspberry Pi com uma câmera fotográfica, o time lapse é o processo de fotografar o mesmo local em janelas de tempo pré determinadas. Em seguida, é possível juntar estas imagens e formar um vídeo.

O efeito do time lapse é muito interessante, caso acople a câmera para captar uma paisagem, o vídeo gerado mostra evoluções ao longo do tempo. Existem vários vídeos interessantes de time lapse mostrando a evolução de uma paisagem diante as estações do ano. O time lapse também é utilizado para monitorar obras da construção civil e mostrar sua evolução. Na agricultura também pode ser utilizado acompanhando o crescimento da lavoura. O efeito é sempre o mesmo, captar toda a mudança que pode ter levado meses, em apenas alguns minutos.

Requisitos para criar câmera de time lapse com o Raspberry Pi

Para seguir este tutorial, é necessário que tenha um Raspberry Pi e também um módulo de câmera fotográfica compatível. Lembrando que o Raspberry possui 3 módulos de câmeras oficiais o v1, v2 e v3 (além da HQ camera) disponíveis para serem adquiridos.

Também é possível utilizar câmeras, webcams e módulos de outros fabricantes (arducam, por exemplo).

Mas para seguir este passo a passo, estes módulos de câmera precisam ser compatíveis com o Raspberry Pi e com a biblioteca do raspistill.

Tutorial passo a passo para configurar um raspberry pi como uma câmera fotográfica de time lapse

Um resumo para configurar um raspberry como camera de time lapse:

1. Instalar câmera no Raspberry
2. Se conectar no Raspberry Pi: com teclado e monitor ou por SSH
3. Executar o raspi-config e habilitar o módulo de câmera
4. Criar um shell scrip configurado com o raspistill e timestamp para realizar as fotografias e inserir os nomes numéricos corretamente
5. Criar um cron job para executar o shell script do item acima em intervalos de tempo pré-determinados (a cada 1 minutos por exemplo)

Passo 1 – Conexão ao Raspberry Pi

O primeiro passo é se conectar ao seu Raspberry por conexão SSH. Caso não tenha um nome de usuário e senha configurados, conecte pelo usuário padrão. Neste exemplo nosso raspberry está configurado no ip 192.168.1.52. Então o comando para conexão será:

 ssh pi@192.168.1.52

A senha padrão do Raspbian recém instalado é:

raspberry

Um alerta, por padrão o raspberry não vem com o servidor SSH habilitado. Na hora de salvar a imagem do sistema operacional no cartão SD pelo Raspberry Pi Imager é possível solicitar que o servidor SSH fique habilitado já no primeiro boot.

Passo 2 (Opcional) – Configurar servidor de arquivos

Este é um passo opcional, mas garante grande facilidade na utilização do seu raspberry como uma câmera de time lapse. Configurando a pasta onde guarda as fotografias como uma pasta compartilhada pela rede, permite facilmente acessar suas imagens e movê-las para seu computador.

Caso tenha interesse nesta feature, basta seguir este tutorial opcional:

• Tutorial como criar um servidor de arquivos NAS com Raspberry Pi – SMB e AFP

Passo 3 – Habilitar o módulo de câmera

Caso esteja utilizando o Camera Module, é necessário verificar se o mesmo está ativado. Lembrando que estamos partindo do princípio que você já tem o sistema operacional Raspbian instalado no seu Raspberry Pi. Execute o comando para abrir o gerenciador do raspi-config:

sudo raspi-config

Caso o comando acima não seja encontrado, é possível que esteja utilizando uma outra imagem do sistema operacional no Raspberry e não o Raspbian. Caso esteja utilizando o Ubuntu, é possível instalar o raspi-config com o comando:

sudo apt install raspi-config

Quando o menu no raspi-config abrir, caminhe no menu até a opção:

3 Interface Options

Em seguida selecione o item:

I1 Legacy Camera

Passo 4 – Testar a câmera

Após realizar os passos anteriores, é possível então realizar uma fotografia de teste.

Ao executar o comando abaixo, vamos solicitar que o Raspberry tire 1 fotografia e salve a mesma em arquivo. Se estiver conectado diretamente no raspberry (com teclado e monitor), sem ser por conexão SSH, a imagem da câmera irá aparecer na tela por alguns segundos.

raspistill -o fotografia.jpg

Para verificar se o arquivo foi criado, é possível pesquisar no diretório e verificar os arquivos presentes:

ls -l

Caso tenha configurado o servidor de arquivos em rede (NAS) no seu raspberry, como descrito no Passo 2 deste tutorial, basta mover a imagem para sua pasta compartilhada, para que possa verificar a mesma em seu computador:

mv fotografia.jpg /home/fileserver/shared

Caso não tenha o servidor de arquivo e gostaria de verificar a imagem criada em seu pc, é possível enviar a mesma por ssh (scp). Em seu computador pessoal (com Windows, Linux ou Mac) abre o prompt de comando (caso windows) ou o terminal (caso linux ou Mac). Neste exemplo vamos conectar no Raspberry com o usuário padrão “pi” e o mesmo está configurado no IP “192.168.1.52”. Lembre-se de atualizar estas informações para as definidas em seu raspberry.

Caso utilize o windows, abra o prompt e digite o comando:

scp pi@192.168.1.52:/home/pi/fotografia.jpg "%userprofile%\Downloads"

O comando acima vai conectar no Raspberry, acessar o arquivo da imagem e copiar ela para a pasta Downloads no seu computador configurado com Windows.

Caso utilize o Mac Os ou Linux, abra o terminal e digite o comando:

scp pi@192.168.1.52:/home/pi/fotografia.jpg ~/

O comando acima vai fazer uma cópia da fotografia na pasta pessoal do seu usuário.

Passo 4 – Criar shell script para padronizar nome das fotos

Como queremos criar um time lapse, é importante que as imagens estejam com nomes que indicam a sequência em que foram criadas. No bash, o código abaixo retorna a data no padrão: AAAA-MM-DD_HHMM

$(date +"%Y-%m-%d_%H%M")

Ou seja, vamos pegar o dia 17 de junho de 2023 como exemplo, e o horário sendo 18 horas e 4 minutos; o código acima vai gerar uma data no formato: 2023-06-17_1804. Se pensarmos então no nome da imagem, ela vai ter o nome de 2023-06-17_1804.jpg

Vamos então agora criar o arquivo de shell script que basicamente vai informar qual shell vamos utilizar e o caminho dele (bash), definir o formato do nome da imagem que queremos (AAAA-MM-DD_HHMM.jpg) e o comando para efetivamente fotografar com o módulo de câmera e salvar o arquivo em disco em um diretório escolhido.

Primeiro crie o arquivo e abra para edição com o comando:

nano fotografar.sh

Agora copie o código abaixo para dentro do arquivo:

#!/bin/bash
DATA=$(date +"%Y-%m-%d_%H%M")
raspistill -o /home/pi/$DATA.jpg

Caso queira salvar as imagens em outra pasta, basta editar a última linha definindo o caminho “/home/pi/$DATA.jpg”. Neste exemplo estamos salvando as imagens dentro da pasta home do usuário pi (/home/pi).

Caso tenha seguido o Passo 2 deste tutorial, você pode optar por salvar as imagens dentro da pasta compartilhada em rede do seu Raspberry (NAS). Mas primeiro crie uma pasta time lapse:

mkdir /home/fileserver/shared/timelapse

E deixe seu shell script com o caminho atualizado:

#!/bin/bash
DATA=$(date +"%Y-%m-%d_%H%M")
raspistill -o /home/fileserver/shared/timelapse/$DATA.jpg

Agora precisamos conceder permissão de execução para o shell script criado:

sudo chmod +x fotografar.sh

Para testar o shell script criado, é possível executá-lo uma vez com o comando:

./fotografar.sh

A fotografia será salva na pasta escolhida. Caso tenha algum erro, talvez tenha definido o nome da pasta incorretamente, ou a pasta não existe. Ou talvez não tenha permissão de escrita na pasta.

Passo 5 – Criar um cron job para fotografar automaticamente em um intervalo de tempo definido (time lapse)

No passo anterior criamos um shell script que a cada vez que é executado, fotografa apenas 1 vez. Mas queremos que o Raspberry fique fotografando automaticamente em um intervalo de tempo definido.

Uma possível solução é criar um cron job, e definir de quanto em quanto tempo ele deve executar o shell script fotografar.sh.

Neste exemplo, vamos criar um cron job para executar o script criado a cada minuto. Ou seja, nosso time lapse terá um intervalo de 1 minuto entre cada fotografia.

Para criar o cron job, execute o comando:

sudo crontab -e

Caso seja a primeira vez que está utilizando o crontab, o editor mais fácil de utilizar é o nano. Você será perguntado qual deseja escolher na primeira execução.

Agora caminhe até a última linha do arquivo e insira o código:

* * * * * sh /home/pi/fotografar.sh 2>&1

Agora salve e feche o arquivo (ctrl+o, Enter, Ctrl+x)

Repare o termo “2>&1” no fim da linha, esta parte do código indica para direcionar qualquer saída de erro que a execução possa ocasionar (stderr) para a saída padrão (stdout). Os caracteres “*” presente no início da linha são utilizados para definir a periodicidade de execução do código.

Caso queira uma periodicidade diferente de a cada minuto, basta verificar na documentação as variáveis que precisa substituir no local de “* * * * *”, para atender suas necessidades de time lapse.

Caso esteja utilizando o raspberry como um NAS (Passo 2), lembre-se de atualizar o caminho do script no crontab:

* * * * * sh /home/fileserver/shared/fotografar.sh 2>&1

Se estiver utilizando o raspberry como NAS (Passo 2), mova seu arquivo fotografar.sh para dentro da pasta compartilhada:

mv fotografar.sh /home/fileserver/shared/

Ter um NAS configurado no Raspberry Pi é uma facilidade, pois para desligar a execução do time lapse é muito mais simples. Como o arquivo de shell (fotografar.sh) está dentro da pasta “/home/fileserver/shared”, caso queira desligar a criação das fotografias, basta comentar as linhas de código dentro do arquivo (inserir “#” no começo de cada linha). Desta forma não precisa conectar por SSH no Raspberry, acessar a crontab, e comentar a linha que executa o script.

Se chegou até aqui, tudo pronto! As fotos consecutivas foram criadas, mas como montar o time lapse em vídeo?

Como criar time lapse em vídeo com fotos consecutivas utilizando ffmpeg

Passo 1 – Instalando ffmpeg no Raspberry Pi

Vamos utilizar o ffmpeg para criar o vídeo de time lapse no formato mpeg. Mas primeiro precisamos instalar o ffmpeg no Raspberry Pi:

sudo apt install ffmpeg

Agora vamos organizar as imagens, o ffmpeg é meio chato, e usa uma sistemática numerada e ordenada para acessar as imagens. Mas podemos também criar uma lista dos arquivos e passar por parâmetro para que o ffmpeg siga esta ordem.

Partindo do pressuposto que suas fotos do time lapse estão dentro da pasta:

/home/fileserver/shared/timelapse/

Vamos criar um shell script para criar a lista:

nano criar_lista_arquivos_timelapse.sh

Agora insira o texto abaixo dentro do script:

#!/bin/bash
\ls /home/fileserver/shared/timelapse/*.jpg | sed "s/^/file '/;s/$/'/" > lista_timelapse.txt

Grave e feche o arquivo (ctrl +o, enter, ctrl+x).

Garante permissão de execução para o shell:

sudo chmod +x criar_lista_arquivos_timelapse.sh

Agora crie o arquivo de shell script para executar o ffmpeg, carregar a lista de arquivos e gerar o time lapse:

nano criar_timelapse.sh

Insira o código dentro do arquivo:

#!/bin/bash
ffmpeg -f concat -safe 0 -i lista_timelapse.txt video_timelapse.mpeg

Grave e feche o nano (ctrl +o, enter, ctrl+x).

Garante permissão de execução para o shell:

sudo chmod +x criar_timelapse.sh

Com tudo pronto, primeiro crie a lista de arquivos que vão gerar o vídeo de time lapse com o comando:

./criar_lista_arquivos_timelapse.sh

Você pode abrir o arquivo criado para conferir se a lista está correta.

O próximo passo é executar o shell script para criar o vídeo de time lapse:

./criar_timelapse.sh

Dependendo da sua versão do raspberry e do número de imagens, o procedimento acima pode demorar bastante. Sugiro começar com um teste mais rápido, com uma gravação de 60 imagens (1h de time lapse = 1 foto por min = 60 imagens)

Executei o procedimento acima em um Raspberry Pi Zero W, com o câmera module V2 e demorou poucos minutos para o arquivo de vídeo ficar pronto.

Dependendo do programa player de vídeo que for executar, ele pode reclamar do formato do time lapse criado (mpeg). É possível alterar alguns parâmetros na execução do ffmpeg a fim de mitigar estes problemas também e aumentar a compatibilidade.

Conclusões

Neste passo a passo vimos como configurar o Raspberry Pi para que este funcione como uma câmera de time lapse. Foi possível também utilizar o próprio raspberry para gerar o vídeo de time lapse junto com o ffmpeg.

A etapa opcional de criar uma pasta compartilhada para transferência de arquivos (NAS) é muito útil, para gerenciar as imagens e vídeos criados, sendo uma etapa altamente recomendada.

O ffmpeg também permite customizações de formato de saída de vídeo, o que permite otimizar ainda mais o processo. É possível também desabilitar a criação do canal de áudio e aumentar a compatibilidade do arquivo para diversos players de vídeo.

Caso tenha alguma dúvida ou dificuldade em alguma etapa, basta informar nos comentários! Farei o possível para ajudar!

O post Tutorial como criar câmera de time lapse no Raspberry Pi apareceu primeiro em Vinicius Paes.

• Saber o que é um NAS
• Entender o que é um servidor de arquivos
• O que é o protocolo SMB
• O que é o protocolo AFP
• Passo a passo para configurar um Raspberry Pi como um servidor de arquivos / NAS com suporte a smb (samba) e afp (netatalk e avahi-daemon)

O que significa NAS?

O termo NAS vem do inglês “Network Attached Storage“, que pode ser traduzido como uma unidade de armazenamento ligado à rede. De forma geral, funciona como um servidor de arquivos.

Para que serve um servidor de arquivos?

Um servidor de arquivos ligado em rede tem como objetivo facilitar o fluxo de informação. Pensando em uma rede doméstica ou empresarial, um servidor de arquivos permite que usuários tenham acesso rápido a arquivos de interesse comuns. Seja uma área de transferência temporária para troca de arquivos entre usuários; ou de forma estruturada, visando organizar informações importantes para acesso de longo prazo.

O que é o software Samba e o protocolo SMB?

Samba é um software que provê recursos para transferência de arquivos através do protocolo smb. Desta forma, é um software que provê os recursos de servidor de arquivos. Tem origem em 1992 e suporte aos sistemas operacionais DOS, Windows, OS/2, Linux etc.
O samba também oferece recursos de servidor de impressão, para integrar diversos clientes a uma impressora.

O que é o protocolo AFP?

O termo AFP vem do inglês “Apple Filing Protocol” que antigamente era conhecido apenas como protocolo Appletalk. É um protocolo de rede proprietário desenvolvido pela Apple Inc.
O protocolo AFP foi o protocolo padrão utilizado pelo Mac OS até antes do Mac OS Mavericks (Mac OS 10.9). Em seguida o protocolo smb foi definido como protocolo primário/padrão. A capacidade de autenticação por AFP ainda é mantida no sistema operacional da Apple na versão Ventura.

Necessidades para realização desta tutorial

Para que seja possível realizar este projeto, basta ter um Raspberry Pi disponível e computadores para testar a conexão. Todas as versões do Raspberry Pi são compatíveis, desde a primeira versão do Raspberry.

Tutorial passo a passo para configurar um Raspberry Pi como um NAS

Passo 1 – Conexão ao Raspberry Pi

O primeiro passo é se conectar ao seu Raspberry por conexão SSH. Caso não tenha um nome de usuário e senha configurados, conecte pelo usuário padrão. Neste exemplo nosso raspberry está configurado no ip 192.168.1.52. Então o comando para conexão será:

 ssh pi@192.168.1.52

A senha padrão do Raspbian recém instalado é:

raspberry

Um alerta, por padrão o raspberry não vem com o servidor SSH habilitado. Na hora de salvar a imagem do sistema operacional no cartão SD pelo Raspberry Pi Imager é possível solicitar que o servidor SSH fique habilitado já no primeiro boot.

Passo 2 – Configuração da estrutura de arquivos

Vamos criar agora um usuário com o nome fileserver. Um grupo com o nome fileserver será criado automaticamente junto com a criação deste usuário. Vamos também utilizar o comando -m, para que ao criar o usuário e o grupo a pasta /home/fileserver também seja criada:

sudo useradd -m fileserver

Devemos agora definir uma pasta para ser compartilhada em nosso NAS. Esta pasta poderá receber acesso de vários usuários registrados. Então vamos chamar ela de “shared”. Vamos criar a pasta com o comando:

sudo mkdir /home/fileserver/shared

Interessante configurar a pasta /home/fileserver/shared de forma que todos os arquivos criados dentro dela, mantenham o grupo fileserver. Execute então o comando abaixo para esta configuração:

sudo chmod g+s /home/fileserver -R

Pensando já nos próximos passos, é interessante que todos os usuários que pertençam ao grupo fileserver, possam ter permissão de leitura/escrita na pasta shared. Execute então o comando:

sudo chmod 770 /home/fileserver -R

Passo 3 – Adicionando usuários ao grupo fileserver

Caso tenha outros usuários configurados no raspberry pi e também deseja que eles tenham acesso a esta pasta compartilhada, precisamos adicioná-los ao grupo do fileserver.

Neste exemplo, vou adicionar o usuário viniciuspaes ao grupo fileserver. O comando será:

sudo usermod -a -G fileserver viniciuspaes

Caso tenha mais usuários, utilize o exemplo do comando acima e adicione todos que deseja fornecer acesso a pasta.

Passo 4 – Instalando o protocolo SMB e Configurando o Samba

O protocolo smb é amplamente utilizado pelo windows para transferência de arquivos entre cliente e servidor. Instalando o conjunto de aplicativos do Samba temos suporte ao protocolo smb. Para instalar o samba, utilize o comando:

sudo apt install samba samba-common-bin

Agora vamos editar o arquivo de configuração com o comando:

sudo nano /etc/samba/smb.conf

Caminhe até o fim do arquivo e adicione as linhas:

[shared]
path = /home/fileserver/shared
writable = Yes
create mask = 0770
directory mask = 0770
public = no

Com o comando acima, vamos criar o compartilhamento com o nome “shared”. A pasta onde os arquivos deste compartilhamento serão armazenados é a “/home/fileserver/shared”. A máscara de permissão dos diretórios e arquivos vai ser “770” para escrita de grupo. Este compartilhamento não é público, é necessário que o usuário informe login e senha para acesso.

O samba nesta configuração padrão, não utiliza os usuários do linux para autenticação, sendo necessário definir os usuários que podem se autenticar.

Desta forma, vamos adicionar o usuário “viniciuspaes” como um usuário que pode se autenticar no samba e acessar o compartilhamento “shared”:

sudo smbpasswd -a viniciuspaes

Agora vamos reiniciar o daemon do samba com o comando:

sudo systemctl restart smbd

Passo 5 – Testando conexão Samba no Windows

No windows, acesse o windows explorer, e no canto esquerdo localize o item:

Rede (Network)

Clique com botão direito em cima de “Rede” e escolha a opção:

Mapear unidade de rede… (Map network drive…)

Neste exemplo o raspberry pi está configurado no IP 192.168.1.52 e o nome do compartilhamento que criamos se chama “shared” ([shared]). Então no campo de Pasta (Folder) preencha com:

\\192.168.1.52\shared

Caso queira que a pasta de rede se conecte automaticamente a cada vez que iniciar o windows, deixe marcado o campo:

Reconectar ao realizar login (Reconnect at sign-in)

Como minhas credenciais de login do windows são diferentes do servidor (login samba), vou marcar a caixa:

Conectar utilizando credenciais diferentes (Connect using different credentials)

Clique agora no botão:

Terminar (Finish)

Para testar se a conexão está funcional e temos permissão de escrita na pasta do servidor, vamos criar um arquivo chamado “teste.txt”. Caso tudo ocorra como planejado, o arquivo estará criado dentro da pasta do servidor e estará disponível.

No terminal do servidor, podemos verificar quais arquivos estão presentes na pasta “shared”, com o comando:

ls -lah /home/fileserver/shared/

Podemos verificar o arquivo teste.txt que criamos para testar a funcionalidade.

Passo 5 – Instalando o protocolo AFP e Bonjour com pacote Netatalk e Avahi

O sistema operacional Mac OS tem suporte tanto para samba, quanto para AFP nativos.
Porém, desde o OS Mavericks a Apple adotou o protocolo smb como padrão. Mas como os usuários possam estar utilizando o protocolo AFP ou precisem utilizar este protocolo em versões mais antigas no Mac OS, é interessante também conceder este acesso ao nosso servidor de arquivos/NAS.

A configuração do Bonjour é realizada através do pacote avahi-daemon, garante descobrimento automático do servidor na rede, e também há suporte/anúncio para configuração de time machine.

Para ter suporte ao AFP e Bonjour, vamos instalar o pacote:

sudo apt install netatalk

Após a instalação podemos verificar um panorama geral do suporte do AFP, assim como características do local de instalação, versão do protocolo, etc. Execute o comando para verificar diversas informações sobre o suporte ao AFP:

afpd -V

Agora é necessário editar o arquivo de configuração do AFP e definir as formas de login, suporte ao time machine, caminho da pasta compartilhada, etc:

sudo nano /etc/netatalk/afp.conf

Agora caminhe até o final do arquivo e cole a configuração:

[shared]
    path = /home/fileserver/shared
    time machine = yes
    vol size limit = 20000
    valid users = viniciuspaes

Na configuração acima, lembre-se de adicionar os usuários que vão ter permissão de acessar a pasta compartilhada por AFP. No exemplo acima temos o usuário viniciuspaes com permissão de acesso, basta substituir por seu usuário e adicionar mais usuários na mesma linha separados por espaço.

Lembrete

A conexão do AFP será feita pelas credenciais de login e senha dos usuários já configurados no sistema operacional linux (raspberry pi). E lembrando que no Samba (SMB) é necessário adicionar cada usuário que tem permissão de login no serviço (smbpasswd -a ).

Passo 6 – Testando conexão AFP no Mac OS (netatalk + avahi-daemon)

No Mac OS, abra o aplicativo finder. No menu superior, clique na opção:

Ir (Go)

No submenu que vai abrir, escolha a opção:

Conectar no servidor… (Connect to server…)

A janela de conexões ao servidor vai abrir. Nesta janela podemos escolher qual protocolo queremos nos conectar. Lembrando que podemos nos conectar por samba também (smb://), mas neste exemplo vamos optar por conectar com AFP. No campo para digitar o endereço, preencha o protocolo de conexão (afp://) seguido do IP do servidor (192.168.1.52) juntamente com o nome da conexão que definimos no arquivo afp.conf ([shared]):

afp://192.168.1.52/shared

Caso queira salvar este endereço na lista de favoritos para conexão, lembre de clicar no campo “+”. Clique agora no botão:

Conectar (Connect)

Uma janela solicitando as credenciais de conexão vai abrir. Digite o usuário e senha do seu usuário criado no raspberry. Caso queira armazenar as credenciais de login e senha, marque a opção para que elas fiquem salvas em seu keychain. Agora clique novamente no botão:

Conectar (Connect)

Ao se conectar no servidor, será possível que o hostname do servidor (raspberry) irá aparecer no menu lateral na parte de “Locations”. Você estará dentro da aba da conexão da pasta de rede “shared” e poderá ver o arquivo de teste.txt que criamos quando nos conectamos no samba no windows.

Conlusões

Caso tenha seguido o tutorial acima, foi possível verificar o passo a passo para criar um NAS com o Raspberry Pi, tanto com suporte ao protocolo smb, quanto o afp. A configuração é bem simples e lembrando que este recurso também é uma comodidade caso utilize o raspberry em outros projetos que necessitam a troca de arquivos entre seu computador e o dispositivo.

Lembrando que até o modelo do Raspberry Pi 3 a porta ethernet é limitada a 100Mbps (100mbps/8 = ~12,5MB/s transferência). Porém nessas versões mais antigas, é possível utilizar um dongle USB/Ethernet de 1Gbps e aproveitar a banda de 480mbps da porta USB 2.0. Porém a conexão deve ficar algo próximo/máximo de 320mbps (~40MB/s transferência), por limitação da banda do controlador do USB 2.0 e o compartilhamento da velocidade com outros dispositivos.

Caso utilize um SSD como unidade de armazenamento, consegui velocidades próximas a 25Mb/s em escrita e leitura sequencial com testes realizados com o software DD do linux na porta USB 2.0.

Caso utilize muita troca de informações, lembre-se que estas transferências consomem processamento da CPU. O raspberry pi na versão 4 ou superior pode ser uma opção mais eficiente. Com a porta USB 3.0 e um SSD Sata, consegui velocidades próximas a 220MB/s com testes utilizando o DD.

No geral, percebo que o Raspberry ainda possui muitas limitações de IO perante seus concorrentes que já tem suporte a armazenamento em M.2 NVME e eMMC. Mas ainda é um gadget super recomendado, pois há extenso suporte ao dispositivo, desde sua primeira versão.
Tenho por exemplo um ODROID-X2 com recursos próximos a um Raspberry Pi 3 e não há mais suporte oficial do fabricante, nem para o uboot, nem para o kernel e nem imagens atualizadas do linux. Desta forma, continuo recomendando o raspberry pelo suporte a longo prazo.

Espero que tenham gostado deste passo a passo e qualquer dúvida ou sugestão, basta informar nos comentários!

O post Tutorial como criar um servidor de arquivos NAS com Raspberry Pi – SMB e AFP apareceu primeiro em Vinicius Paes.

O objetivo principal é poder substituir o modem de fibra em comodato cedido pela sua provedora de internet por outro modelo. Neste tutorial vamos utilizar de exemplo a substituição de um Humax HP610 pelo modem VSOL V2802RH.

Este tutorial é baseado em histórias de sucesso deste link.

Qual a vantagem em substituir o modem de fibra (ont, onu ou hgu)?

Atualmente a principal vantagem é ter acesso a velocidades melhores em planos de 1Gbps+.

Por exemplo, o HUMAX Hp610 tem capacidade de receber banda de 2,5Gbps de download e 1,25Gbps de upload pela interface de fibra óptica (gpon). Porém, este só possui portas 1 Gbps. Ou seja, caso planos de 1Gbps+ estejam disponíveis, o aparelho irá limitar a velocidade máxima pela limitação da porta ethernet gigabit (a não ser que utilize mais de uma porta e faça balanceamento de carga).

O modem VSOL V2802RH por sua vez, possui uma porta ethernet de 2,5Gbps. Usuários já relataram velocidades melhores em planos 1Gbps utilizando este aparelho. Ou seja, as portas gigabit realmente estão limitando o potencial máximo de planos de 1 Gbps ou superiores. Isto ocorre, pois as operadoras costumam oferecer uma velocidade um pouco acima da contratada.

Quais as desvantagens em tentar substituir o modem da fibra

Caso seu modem de fibra óptica forneça outros serviços, como telefone voip, TV por assinatura, etc; será necessário verificar se o seu novo modem também tem esta disponibilidade. Caso contrário, só terá o funcionamento da internet.

É possível substituir o modem de fibra de qualquer provedor/operadora?

Depende muito do tipo de autenticação utilizada pelo provedor. Há diversos relatos de casos de sucesso, porém há também relatos onde não foi possível a mudança de forma alguma.

Como muitas vezes a substituição do modem não é algo que a provedora dê suporte, não vão ajudar no procedimento. Sendo necessário anotar informações do seu modem antigo e replicar as mesmas para seu novo modem. Em alguns casos, é necessário autenticação com login e senha (LOID) que não estão disponíveis para o usuário. Em outros casos, o novo modem pode não ter suporte para “clonar” dados (OMCI) do modem antigo. Em casos específicos, o novo aparelho precisa ser autorizado diretamente na OLT do provedor para receber sinal de internet.

Passo a passo em como substituir modem fibra FTTH da provedora pelo modem VSOL V2802RH

Aviso importante antes de começar (disclaimer)

Neste exemplo tive muita felicidade (sorte) na substituição do aparelho. Pois minha provedora só utilizava o pon serial e o vendor id para autenticar o modem. Então muita calma se quiser realizar o mesmo procedimento, há grandes chances de você não conseguir o mesmo resultado. Não me responsabilizo caso ocorra qualquer problema. Lembrando que os comandos utilizados por telnet podem acarretar em um softbrick e seu novo modem pode virar um peso de papel. Utilize o tutorial por sua conta e risco.

Passo 1 – Exemplo de configuração de Rede Doméstica

Neste exemplo, vamos supor que temos o modem HUMAX HP610 (pode ser outro modem de provedor) em modo bridge, com o IP:

192.168.0.1

Temos um roteador configurado na rede, que também provê acesso por WIFI e está configurado com o IP:

192.168.1.1

O roteador possui DHCP configurado, então automaticamente irá ofertar IP dentro da faixa:

192.168.1.2 até 192.168.1.254

Neste exemplo temos 4 aparelhos conectados no roteador: 2 computadores, 1 celular e 1 tablet.

A figura abaixo exemplifica o setup deste exemplo:

Passo 2 – Característica do modem de fibra óptica VSOL V2802RH

O modem da VSOL vem de fábrica configurado com o IP estático:

192.168.1.1

Como pode perceber, se ligar o modem diretamente na minha rede do exemplo acima, vamos ter conflito de endereço IP com o roteador.

Vamos primeiro então, conectar o modem VSOL por cabo ethernet diretamente em um computador.

Segue o exemplo na figura abaixo, para exemplificar o processo:

Passo 3 – Garantir que estamos na mesma rede do modem VSOL

Como fizemos uma ligação direta com o modem VSOL e não temos certeza se o mesmo está com o DHCP configurado, uma opção é definir um IP estático momentaneamente no computador pessoal, para realizar as configurações iniciais.

Caso esteja no Windows:

• Clique no ícone do antigo botão “iniciar”.
• Agora clique no botão de engrenagem “configurações”.
• Vá em “Rede e Internet”.
• No menu à esquerda clique em: “Ethernet”.
• No canto direito, clique no link de: “Mudar opções de adaptador”
• Identifique o ícone da sua conexão de rede cabeada (ethernet), clique com o botão direito e selecione: “propriedades”.
• Clique duplo em cima da opção: “Protocolo de Internet Versão 4 (TCP/IPv4)”

Agora poderá selecionar seu IP estático e sua máscara de subrede e gateway. Como o VSOL está utilizando o IP 192.168.1.1, vamos definir o IP do nosso computador para:

192.168.1.2

Para máscara de subrede, vamos utilizar:

255.255.255.255

Para o gateway, podemos colocar o IP do modem VSOL:

192.168.1.1

Agora salve as mudanças e feche as opções de configuração.

Passo 4 – Confirmando acesso ao modem e primeiro acesso

Se as configurações de rede foram realizadas corretamente, agora podemos acessar o VSOL pelo browser. Lembre-se que o modem é um pouco lento para iniciar, se acabou de ligar ele na tomada aguarde pelo menos 1 minuto e tente acessar pelo browser:

192.168.1.1

Será necessário inserir as credenciais de login da interface web:

Login: admin
Senha: stdONUi0i (senha padrão de fábrica)

Neste primeiro acesso, a interface vai pedir que mude a senha. Lembre-se de anotar a nova senha escolhida em local seguro.

Este primeiro acesso é somente para confirmar que o modem está funcional e trocar a senha padrão de fábrica.

Passo 5 – Conexão por telnet e copiar configurações de fábrica

Após confirmar o funcionamento do modem, o próximo passo é copiar todas as informações de fábrica do modem VSOL. Neste processo, precisamos conectar no aparelho por conexão telnet.

Você pode utilizar o programa Putty para realizar a conexão por telnet.
No windows, é possível habilitar o telnet nativamente (Turn windows features on and off), mas é necessário reiniciar o computador após o procedimento. Caso esteja no Mac OS, poderá instalar o telnet pelo gerenciador de pacotes homebrew (brew). No linux basta instalar o pacote telnet pelo gerenciador de pacotes.

Vamos então conectar por telnet no modem VSOL V2802RH. Neste exemplo tenho o telnet instalado nativamente no windows, então no prompt de comando utilizo o comando:

telnet 192.168.1.1

Será necessário inserir as credenciais de login:

Login: admin
Senha: (nova senha que definiu pela interface web)

Agora execute o comando:

cfgmib all

Copie a saída do comando acima e salve em um arquivo. Basicamente este arquivo é um backup das configurações do seu roteador.

Passo 6 – Realizando upgrade de firmware (opcional)

Antes de iniciar as configurações no modem é interessante ressaltar que até o firmware 1.1.3 há um bug onde o modem perde a persistência de dados do OMCI a cada reboot, caso estes sejam configurados pela interface web.

Interessante então verificar qual a versão de firmware do seu modem da VSOL. A partir da versão 1.1.4 o bug relatado acima foi corrigido. Caso não tenha intenção de realizar o upgrade de firmware, e esteja em uma versão afetada pelo bug, há possibilidade de configurar o OMCI por telnet e desta forma manter a persistência.

Segue o link para a versão 1.1.4 da VSOL V2802RH (atualize por sua conta e risco, se possível utilize um nobreak para não arriscar com falta de energia elétrica durante o processo):

• Download firmware 1.1.4 modem VSOL V2802RH (firmware oficial do fabricante)

Firmware V2802RH_V1.1.4_230518_S575.img
Hash MD5 - 92ba3aa35e675a0dfbc87c9de7483bab
Hash SHA1 - 807f39a311ec6d01413ace7e1e3e44446bf9cd97
Hash SHA256 - 6667e54974ec199debe069a0802fe81909fc557130e4c777ec80b0f836f0fbb2

• Download firmware 1.1.4 modem VSOL V2802RH – build 230628 (firmware oficial do fabricante)

Firmware V2802RH_V1.1.4_230628_S632.img
Hash MD5 - a0480945dfeaddb9f2abceca35a2033b
Hash SHA1 - bf176a1bcb911af623e2b98771d56e72f91221c4
Hash SHA256 - 6fcf99198372576b9ece7c76cc031b8d145a3f0653a9bbc6d2825affbbc67224

• Download firmware 1.1.5 modem VSOL V2802RH – build 230706 (firmware oficial do fabricante)

Firmware V2802RH_V1.1.5_230706_S640.img
Hash MD5 - a09754134e84d8d95e3359ae02ba895c
Hash SHA1 - 0497ceed63a38c3e9a42429cec932cd811a73bad
Hash SHA256 - 068af57bfe44cfcdffcdbbed191c6a76c7817cab8a9eb9c52b567888db91bc1a

• Download firmware 1.1.6 modem VSOL V2802RH – build 230801 (firmware oficial do fabricante)

Firmware V2802RH_V1.1.6_230801_S663.img
Hash MD5 - 2b035109cb4558bd6dc04339939c0f49
Hash SHA1 - d4cfa19bbb968c2f05e7767e75dc49c2db60323b
Hash SHA256 - da4107febb6e50e8b249cbdbf8e229dc65f98264634df6d5ece70b645004e0aa

• Download firmware 1.1.6 modem VSOL V2802RH – build 230810 (firmware oficial do fabricante)

Firmware V2802RH_V1.1.6_230810_S670.img
Hash MD5 - 727c7a679d679a2605b04a7899ff24aa
Hash SHA1 - d00c53bd562e06d7b5fb24226098928aff62c533
Hash SHA256 - 8b8883646a8efa7eb72b12f49b08f3dcb9785d220f9768ab10e928aa31b587a3

• Download firmware 1.1.7 modem VSOL V2802RH – build 230911 (firmware oficial do fabricante)

Firmware V2802RH_V1.1.7_230911_S693.img
Hash MD5 - 9ba5ae8c94e792c0a8180a1df48e27ca
Hash SHA1 - 58d4ead49c50d1c6bdb3b7fccb9bc29b9b0b24df
Hash SHA256 - fccaf44cf32b6aef03cfd39b5081a384a3b9886640dd494dc42a248190d13cfb

• Download firmware 1.1.8 modem VSOL V2802RH – build 240507 (nova versão! – firmware oficial do fabricante)

Firmware V2802RH_V1.1.7_240507_S893.img
Hash MD5 - 10321664c4dd7e8c657884e7d0433f34
Hash SHA1 - 3537cf428c33267bdfbda78db381b6b5032c6b43
Hash SHA256 - aeb1c563930848d00d300dd25335e9616ec89578d4aeda03451460d25ceb712b

Firmware Custom para VSOL V2802RH

O site tripleoxygen.net trabalhou em um firmware custom (CFW) para a VSOL V2802RH. Alguns usuários tinham problemas com limitações em número de caracteres dos campos: SW Version, HW Version. Foi removido também o bloqueio do MAC Address por chave de autorização, agora qualquer endereço MAC pode ser utilizado. Estes firmwares são baseados no Firmware Oficial (OFW) da versão 1.1.6.

Utilize este firmware por sua conta e risco. Lembre-se que não é um firmware oficial do fabricante, não me responsabilizo por qualquer problema. Qualquer dúvida, podem entrar em contato direto com o autor do firmware no site: tripleoxygen.net/wiki/ont/vsol/v2802rh

• Download custom firmware 1.9.2 modem VSOL V2802RH –  (CFW baseado no firmware 1.1.6)

Firmware V2802RH_V1.9.2_CFW.img
Hash MD5 - 7c265174548643bcda2fddfa0404cb38
Hash SHA1 - 1a149461e74cc105b90d72aef04cbb744dd03364
Hash SHA256 - 8a1c432223a6237616d10aea9926b028a34c240ed6fffc4cc9e59e8b401a6111

Como verificar o hash do arquivo

Após realizar o download do arquivo de firmware é importante verificar se o hash está idêntico ao hash informado. Ou seja, no processo de download, pode haver algum tipo de interrupção e corromper o arquivo, se tentar atualizar seu equipamento com o arquivo corrompido o mesmo irá parar de funcionar (softbrick). Desta forma, utilize os comandos abaixo para confirmar o hash do arquivo em seu computador pessoal, utilize estes comandos no prompt de comando (windows) ou pelo terminal (mac os ou linux).

Se estiver utilizando o Windows:

Para md5:    certutil -hashfile V2802RH_V1.1.6_230810_S670.img md5
Para SHA1:   certutil -hashfile V2802RH_V1.1.6_230810_S670.img sha1
Para SHA256: certutil -hashfile V2802RH_V1.1.6_230810_S670.img sha256

Para testar o hash no Mac OS ou linux:

Para md5:    openssl md5 V2802RH_V1.1.6_230810_S670.img
Para SHA1:   openssl sha1 V2802RH_V1.1.6_230810_S670.img
Para SHA256: openssl sha256 V2802RH_V1.1.6_230810_S670.img

Passo 7 – Configurando modem Fibra VSOL V2802RH – definindo acesso por ACL – Firewall

Como neste setup vamos utilizar o modem em modo bridge na rede/IP 192.168.0.1. E nossos computadores vão estar na rede 192.168.1.x. É interessante realizar uma alteração no firewall para que permita este acesso oriundo de rede diferente do modem, para facilitar acesso futuro. Então no menu superior, vamos clicar na opção:

Firewall

Agora na página de firewall, novas opções vão aparecer no menu que fica na lateral esquerda. Vamos clicar na opção:

ACL

Podemos criar uma regra específica para definir qual rede tem acesso a interface. Mas para simplificar, podemos apenas selecionar a opção:

LAN ACL Switch: Disable

Em seguida, para que a modificação tenha efeito, clique em:

Apply

Passo 8 – Configurando modem Fibra VSOL V2802RH – configurações GPON

No menu superior, clique na opção:

Setup

Agora, no menu da lateral esquerda, selecione a opção:

GPON Settings

Nesta tela agora temos a opção de definir as seguintes características:

• LOID
• LOID Password
• PLOAM Password
• OMCI OLT Mode

A minha provedora não utiliza os parâmetros de LOID e PLOAM, é possível deixar nos padrões de fábrica estas opções. Algumas provedoras utilizam os valores padrão:

LOID: user
LOID Password: 1234567890
PLOAM Password: 1234567890

Nesta tela, para que seja possível configurações avançadas na página de OMCI Information, é preciso alterar o OMCI OLT MODE, para:

Huawey OLT Mode

É possível reparar que não é possível alterar o valor do Serial Number pela interface web e a maioria das provedoras utiliza autenticação por serial pon. A VSOL permite essa modificação, porém, apenas por telnet.

Para salvar as modificações realizadas, clique em:

Apply Changes

Passo 9 – Alterando Pon Serial Number por telnet

Mantenha a interface web aberta e volte para a janela de conexão por telnet.

Nesta etapa vamos clonar o Serial Number do modem antigo (provedora) para o novo aparelho (modem VSOL). No meu caso, meu serial possui 12 caracteres, sendo que os 4 primeiros identificam o Vendor ID. Esta informação está presente tanto na interface web do meu modem antigo (provedora) quanto na etiqueta que veio colada nele. Na etiqueta essa informação vem com o nome “PON S/N”; e na interface web ela vem descrita como “PON serial”.
Segue então o exemplo do serial PON do meu aparelho:

HUMA12345678

Se o seu modem da provedora for da marca Huawei, seu serial deve começar como HWTC12345678. Pois o Vendor ID da Huawei é HWTC. Ficar atento a esta característica e peculiaridade de cada modem.

Após verificar corretamente o Serial PON do seu modem da provedora, execute o comando no console telnet:

flash set GPON_SN HUMA12345678

Lembrar de substituir HUMA12345678 acima, pelo seu PON Serial.

Agora volte para a interface web. Aperte F5 para dar refresh na tela de Setup -> GPON Settings.

Se tudo correu bem, o campo “Serial Number” foi atualizado para:

HUMA12345678

Passo 10 – Interface Web – OMCI Information

Na interface Web, dentro da página de “Setup”, vamos agora acessar o menu lateral a opção:

OMCI Information

Nesta página podemos observar as informações:

• OMCI Vendor ID
• OMCI software version 1
• OMCI software version 2
• OMCC version
• Traffic Management option
• CWMP Product Class
• HW Version

Nesta etapa é interessante lembrar que o VSOL tem um problema de não reter informações do OMCI após reboot, quando estas são feitas pela interface web e o firmware do modem está na versão 1.1.3 ou anterior. Na versão 1.1.4 este bug já foi consertado, sendo possível realizar todas as atualizações pela interface web.

Passo 11 – Alterar Vendor ID

A minha provedora de internet utiliza apenas o Pon Serial e Vendor ID para autenticação, então são etapas iniciais importantes de já ficarem persistentes no modem da VSOL.

Lembrando que meu modem de fibra é um Humax HP610 e o meu PON Serial é semelhante a HUMA12345678. Ou seja, meu Vendor ID é HUMA (4 primeiros caracteres).

Se estiver na versão do firmware 1.1.4, altere o campo “OMCI Vendor ID” para (no caso deste exemplo):

HUMA

Se estiver na versão do firmware 1.1.3 ou anterior, execute o comando por telnet (substitua HUMA pelo seu vendor id):

flash set PON_VENDOR_ID HUMA

Vá no browser e aperte F5 (refresh) na página de OMCI Information. O campo OMCI Vendor ID irá aparecer atualizado após executar o comando acima.

Algumas informações adicionais sobre OMCC Version

O atributo OMCC version  identifica a versão do protocolo OMCC utilizado pela ONU. Este recurso permite a OLT gerenciar uma rede com diferentes tipos de ONU que suportam diferentes tipos de OMCC.
As versões do OMCC suportadas são identificadas na forma ox8y e 0x9y, onde o y é um digito hexadecimal que varia de 0 até F.
As demais versões do protocolo são definidas dentro da faixa 0xAy e 0xBy.
Algumas características das versões do OMCC:

• 0x80 ITU-T G.984.4 (junho/2004)  (esta versão também pode aparecer em ONUs que suportam versões posteriores do ITU-T G.984.4)
• 0x81 ITU-T G.984.4 Amd.1 (junho/2005)
• 0x82 ITU-T G.984.4 Amd.2 (março/2006)
• 0x83 ITU-T G.984.4 Amd.3 (dezembro/2006)
• 0x84 ITU-T G.984.4 2008 (fevereiro/2008)
• 0x85 ITU-T G.984.4 2009 Amd.1 (junho/2009)
• 0x86 ITU-T G.984.4 2009 Amd.2 (2009). Somente conjunto de mensagens básicas, sem a opção de conjunto de mensagens estendidas
• 0x96 ITU-T G.984.4 2009 Amd.2 (2009). Upgrade da versão anterior com suporte a mensagens estendidas
• 0xA0 ITU-T G.988 (2010). Somente conjunto de mensagens básicas, sem suporte para mensagens estendidas
• 0xA1 ITU-T G.988 Amd.1 (2011). Somente conjunto de mensagens básicas
• 0xB0 ITU-T G.988 (2010). Suporte de mensagem nível básico e estendido
• 0xB1 ITU-T G.988 Amd.1 (2011). Suporte  conjunto de mensagens nível básico e estendido (R) (obrigatório) (1 byte)

Fonte: itu.int

Passo 12 – Configuração de VLAN de Internet

Dependendo do seu modem de fibra óptica FTTH (ont/onu/hgu) ele pode oferecer serviços distintos em diferentes VLAN’s. Por exemplo: VLAN de Internet no ID 11, VLAN de VoIP no ID 12, Wifi para clientes da operadora na VLAN 14, acesso de interface de configuração na VLAN 10. Mas qual VLAN oferece qual serviço varia de cada provedora.

Caso não consiga verificar as configurações de VLAN no seu modem antigo, é possível tentar escutar o equipamento OLT e verificar quais VLAN’s estão sendo ofertadas.

Para poder executar este passo, é importante que seu modem da VSOL esteja conectado na fibra óptica. Execute então o comando abaixo por telnet:

omcicli mib get 84

Caso não obtenha nenhum resultado, confira primeiramente se está com conexão na fibra. Na página inicial do modem é possível também verificar a qualidade do sinal. Caso esteja tudo certo, preencha as demais informações do OMCI. Talvez seja necessário a OLT autenticar seu equipamento, antes de fornecer as VLAN’s disponíveis. Então ela precisa reconhecer o novo modem como se fosse o antigo, tente preencher os dados de OMCI baseado nos dados modem da provedora:

• OMCI software version 1: (pegar versão do seu modem antigo)
• OMCI software version 2: (pegar versão do seu modem antigo, ou repetir a versão acima)
• OMCC version: 0x80
• Traffic Management option: (testar as opções – verificar velocidade e compatibilidade após ter conexão com internet)
• CWMP Product Class: (pegar versão do seu modem antigo)
• HW version: (pegar versão do seu modem antigo, VSOL tem limitação de 4 caracteres no firmware 1.1.4 e anteriores)

Caso ainda tenha problemas de compatibilidade, ver este post.

Com a informação do ID da VLAN de internet disponível, acesse a opção no menu superior:

Setup

Em seguida, no menu esquerdo, escolha a opção:

WAN

Vamos então configurar a VLAN de internet nesta página. Em default Route Selection, escolha:

Specified

Em Channel Mode, para este exemplo, vamos deixar o modem da VSOL em modo Bridge. então escolha a opção:

Bridge

Na opção de “VLAN”, escolha:

Enable

Agora na opção VLAN ID, você deve informar qual a ID da VLAN de internet ofertada por sua operadora. Neste exemplo, a VLAN ID de Internet é a 11. Então na opção VLAN ID (1-4095) vou inserir:

11

Em VLAN Cos(0-7), vamos definir prioridade:

0

Na opção de MVLAN (Multicast VLAN ID(1-4095)) neste exemplo não vou deixar configurado. Então vou preencher com:

0

Em Application Mode, vamos deixar marcado como VLAN de internet:

INTERNET

Não vou configurar as opções de DNS manualmente, vou deixar que o modem pegue automaticamente da provedora.

Na opção de LAN, vou deixar marcado:

LAN1 e LAN2

Para que estas configurações fiquem salvas, clique no botão:

Add

Solução de Problemas VLAN 10 na VSOL V2802RH

Caso recebe uma mensagem de erro ao definir sua VLAN de internet sendo 10, muito provavelmente é um bug do firmware da VSOL. Ela fala “VLAN 10 is reserved…“.

Existem 2 formas de contornar este problema.

1. Ao invés de colocar a VLAN com o valor “10”, coloque o valor 10 seguido de uma vírgula:

   10,

2. Outra solução é realizar um comando por telnet. Eu particularmente não realizei o comando abaixo, foi um visitante aqui do site que recebeu esse fix pelo suporte da VSOL. Então avaliar com cautela, para evitar problemas de softbrick. Não me responsabilizo e não posso confirmar sua eficácia.

   cfgmib set LAN_VLAN_ID2 0xfcb
   restart

Passo 13 – Mudar IP do modem

Como mencionei no começo do post, meu modem da provedora estava configurado na rede 192.168.0.x. Quero substituir o modem da provedora pelo VSOL para poder usufruir da porta 2,5Gbps e garantir o máximo de banda de internet que a interface gpon pode fornecer.

Então, neste passo vou alterar o IP estático do modem da VSOL para 192.168.0.1, para que não tenha conflito com meu roteador previamente configurado na minha rede.

No menu superior selecione a opção:

Setup

No menu lateral esquerdo, selecione a opção:

LAN

Em IP Address, vou alterar o IP de 192.168.1.1, para:

192.168.0.1

Para gravar as modificações, basta clicar no botão:

Apply Changes

Agora é necessário remover o IP estático do seu computador pessoal.

Conecte o modem de fibra de volta em sua rede e conecte seu computador pessoal para pegar IP por DHCP novamente pelo roteador.

Caso sua provedora utilize autenticação somente por Pon Serial e Vendor ID você conseguirá Status 05 e conexão de internet seguindo os passos descritos.

Opcional – Remover Captcha da tela de Login da VSOL

Caso você acesse muitas vezes a interface administrativa web da VSOL, digitar o Captcha toda vez pode ser cansativo. Há a possibilidade de remover o captcha utilizando o seguinte comando por telnet:

flash set VALIDATE_CODE_SWITCH 0

Mas entenda que o captcha tem a função de inserir uma cada de proteção a interface para ataques de “brute force”. Se não estiver utilizando a VSOL em modo bridge e a mesma estiver acessível pela internet, é interessante rever as opções de segurança da sua rede.

Opcional – Remover limitação velocidade na porta 2.5Gbe da VSOL V2802RH

Dependendo da versão de firmware que estiver utilizando, é possível que sua VSOL tenha o flow control limitando a velocidade na porta 2.5GbE.

Os comandos abaixo vão remover a limitação e poderá utilizar sua porta 2.5GbE na velocidade máxima suportada. A única desvantagem que este procedimento não fica persistente, então toda vez que reiniciar a VSOL, terá que utilizar novamente os comandos abaixo. É possível que este problema esteja resolvido em uma próxima revisão de firmware. Segue os passos:

1. Conecte na VSOL utilizando telnet
2. Digite o comando:
   • diag
3. Tecle enter
4. Agora digite o comando:
   • port set auto-nego port 0 ability 2500f asy-flow-control
5. Tecle enter

Faça um teste de velocidade para verificar se a limitação da porta foi resolvida.

Conclusões

Neste tutorial foi possível ver os principais comandos para realizar a substituição do modem de internet fibra FTTH por outro modelo de sua preferência. Neste caso específico, a escolha pelo novo aparelho foi o VSOL V2802RH. A grande vantagem do VSOL é ter possibilidade de customização OMCI para permitir maior compatibilidade e a porta ethernet 2.5Gbps.

O setup final proposto neste exemplo é mostrado na imagem abaixo:

Caso tenha sucesso na troca do seu equipamento de fibra, conte aí nos comentários!

O post Tutorial como substituir modem fibra FTTH do provedor pelo modem VSOL V2802RH apareceu primeiro em Vinicius Paes.

Sempre tive o desejo de substituir meu modem de fibra oferecido pela minha prestadora de serviços de internet. No meu caso, utilizo o Humax HP610 e quando estava em modo roteador + wifi tinha sérios problemas na rede. Vou relatar alguns problemas encontrados logo abaixo.

Com este aparelho tive problemas na configuração do port forward, em certo momento as configurações ficaram travadas e não conseguia editar as configurações existentes, adicionar e nem excluir. Quando tentava utilizar as 4 portas de switch que vinha junto no aparelho, sempre a última porta que eu conectava o cabo de rede parava de funcionar.

Eu perdi as contas de quantas vezes crimpei as pontas dos cabos de rede e desperdicei conectores cat6, até perceber que o problema era no aparelho. Meu troubleshoot começou reiniciando o dispositivo, retirando e conectando os cabos de rede, etc. Mas os problemas eram sempre em cima do último cabo conectado, então uma hora um dos computadores de casa parava de funcionar, outra hora o wifi; aquela intermitência. Só quando comprei um testador de cabos, percebi que os cabos de rede estavam funcionais.

A primeira opção que cogitei foi upgrade de firmware, mas não encontrei no site da operadora uma lista de firmware para download e nem mesmo no site do fabricante.

A segunda opção era realizar um reset do aparelho, reiniciando todas as configurações para o modo de fábrica. Talvez resolvesse o meu problema de port foward, mas fiquei na dúvida sobre a liberação das 4 portas de switch. E outra, já estava ruim, fiquei com medo do reset travar o modem e ainda por cima ficar sem internet.

Conversando com o atendente da operadora, a resposta padrão é sempre enviar o técnico e trocar o equipamento. Como na época o HUMAX era o melhor modem disponibilizado, fiquei com medo de trocarem por um aparelho inferior.

Pesquisei bastante na internet e percebi que estes aparelhos que possuem VLAN configurada para internet, voip, tv, (HGU); muitas vezes não tem recursos dimensionados para prover os serviços da melhor forma possível. São aparelhos “de entrada” e atendem muito bem a maioria da população, mas alguns usuários que demandam de uma estabilidade maior da rede, com QoS/SQM não terão acesso a estes recursos.

Continuando a pesquisa, vi vários relatos que a melhor forma de utilização dos aparelhos fornecidos pela operadora era remover a opção de roteamento e utilizar um aparelho dedicado para esta atribuição, ou seja, usar o modem em modo bridge.
Outra vantagem desta abordagem era ter uma rede modular, com aparelhos distintos provendo serviço específico. A desvantagem era aumentar o número de aparelhos na rede, pois precisaria adicionar um roteador e caso este não tivesse wifi, ainda ia ser necessário adicionar um access point para prover internet sem fio.

Nesta mesma época, pensei em trocar o modem/roteador da operadora, pois sempre fiz isso quando tinha internet DSL/VDSL. Era um processo tranquilo, adicionava um produto superior e com configurações simples (VCI, VPI, PPoE) a rede já ficava funcional.

Sempre gostei da marca Ubiquiti e na minha inocência, comprei um modem GPON UF-LOCO-BR na época (~2021). Conectei o mesmo na fibra, acessei a interface e me dei conta: parece que não vai rolar. Pois é, fiz uma pesquisa e vi que não era tão simples a substituição, mas felizmente conversei com o vendedor e consegui devolver o aparelho (hoje já é possível utilizar o UF-loco: link).

Pelo jeito não era o único insatisfeito com este setup padrão da operadora. Olhando em fórum online, vários usuários também buscavam formas de substituir o modem. Alguns tiveram sucesso, mas utilizavam outra operadora.

Recentemente, pesquisando na internet, verifiquei que vários usuários já tinham conseguido realizar o procedimento e tinha bastante informação disponível. Compilei de forma geral as informações que encontrei e segue uma visão geral do processo, baseado em experiência de vários usuários. Caso o leitor tenha interesse, o link principal que pesquisei foi:

https://forum.adrenaline.com.br/threads/topico-dedicado-eliminar-ou-trocar-onu-ont-hgu-da-operadora-provedor.699243/

Para contextualizar toda experiência segue o artigo criado:

Introdução

Atualmente as provedoras de internet de fibra óptica fornecem um modem/roteador para os clientes. Muitas vezes estes aparelhos não são muito eficientes em suas atribuições de rede, ou possuem recursos escassos, não atendendo as necessidades.

Porém, sua substituição não é trivial, pois o mercado de fibra óptica não segue um padrão de compatibilidade bem definido e cada marca de equipamento tem suas particularidades de configuração.

Com a oferta de planos de 1Gbps ou superiores pelas provedoras de internet, muitas vezes os equipamentos oferecidos em comodato deixam a desejar. Pois o limite prático de transferência em uma porta 1Gbps é de ~944Mbps. Lembrando que a tecnologia GPON suporte até 2,5Gbps de Download e 1,25Gbps de upload.

Alguns usuários que realizaram o upgrade de seus equipamentos (portas 2,5Gbps), e que assinam planos de 1Gbps reportaram que conseguiram velocidades superiores ao contratado.

Vantagens em utilizar um setup próprio em sua infraestrutura de fibra doméstica/empresarial

Em linhas gerais, ter o seu próprio equipamento para receber internet de fibra tem as seguintes vantagens:

• Maior controle da sua rede doméstica/empresarial
• Atingir velocidades melhores de internet para planos de 1Gb+
  • Interessante utilizar equipamentos com suporte 2,5Gb ou superior
• Utilizar equipamentos mais confiáveis, com mais recursos, mais eficientes e com menos emissão de EMF
• Integração com equipamentos da sua rede já existentes
  • Caso já tenha switch/roteador com porta SFP/SFP+ em seu setup
• Diminuir o número de equipamentos em sua rede
  • Existem roteadores com suporte SPF+ e portas 2,5GB com Wifi 6

Quais os desafios para substituir o equipamento fornecido pela operadora?

De forma geral, o principal problema é a compatibilidade e ter os equipamentos corretos.

Caso opte por uma interface gbic SFP GPON é necessário verificar:

• Compatibilidade da Interface SFP GPON (ou XPON): especificação comprimento de onda, monomodo ou multimodo, etc. A interface ser destinada ao usuário final com rede GPON e não uma interface para OLT.
• Possibilidade de configuração da interface: ser “unlocked”, podendo o usuário editar as configurações existentes do transceiver óptico (OMCI).
• Lembrando que nem todas as portas SFP+ tem suporte para módulos GPON/XPON em 2.5Gbps, pesquisar bastante antes de comprar.

Caso opte por outro modem ONU/ONT/HGU:

• Verificar se consegue alterar configurações do mesmo. Principalmente clonar características do seu modem anterior, para que não tenha problemas de compatibildiade, visto que algumas OLT são travadas para uso com ONU/ONT/HGU da mesma marca.

Em relação ao seu modem da operadora, é necessário:

• Ter possibilidade de extrair as informações de configuração, para que possam ser inseridas em sua nova interface, ou seja, copiar os dados para o novo modem GPON ou interface SFP GPON.
• Compatibilidade da sua provedora com mudanças de equipamentos. Cada operadora realiza a autenticação de uma forma. Seja pela serial gpon do modem, pelo mac address, por LOID, etc. Consultando o fórum, a maioria dos usuários tiveram sucesso com utilização do serial e ID da VLAN de rede.

Objetivos

Diante todo o contexto apresentado, os objetivos são:

• Entender quais equipamentos serão necessários para substituir o modem da operadora e a finalidade de cada um
• Ver alguns casos de sucesso de usuários que conseguiram realizar a troca do equipamento

Mas quais equipamentos da operadora de fibra posso substituir?

O objetivo é substituir a interface GPON, ONT, ou HGU; que conhecemos mais pelo nome de Modem de internet de fibra. As marcas e modelos que os usuários já tiveram sucesso em substituir, são:

• Askey RTF3505VW-N1
• Askey RTF8115VW
• Huawei HG8245Q2
• Huawei HG8245W5-6T-V2
• Humax HP610
• Kaon PG2447
• Mitrastar 2741-N1
• Mitrastar 2741-N2
• Mitrastar GPT-2741GNAC-N1
• Mitrastar GPT-2741GNAC-N2
• Nokia G-140W
• Nokia G-1425G-A
• Nokia G-240W-C
• Technicolor TCG2232

As principais informações do equipamento vêm anotadas na etiqueta de identificação: como serial, MAC ADDRESS, modelo, etc.

Quais equipamentos posso utilizar no lugar do modem de fibra?

Vamos destacar aqui os setup’s possíveis, o conjunto de vantagens e desvantagens de cada um. O objetivo desta etapa é que o leitor consiga ver o universo de possibilidades, desde um setup preparado para velocidade de 10Gbps que possa a vir ser uma realidade futura, até mesmo opções de custo e benefício satisfatórias.

De forma geral, as fontes de informações de casos de sucesso podem ser encontradas em:

• Fórum Adrenaline
• Fórum Lowyat (Malásia)

Substituir o modem de fibra da operadora por outro modem/terminal GPON

Alguns usuários tiveram sucesso na substituição do modem da operadora, por outro modelo. Este setup não oferece grandes vantagens de forma geral, pois os terminais utilizados não dão suporte a 2,5Gbps cabeado (exceto VSOL V2802RH). Porém os usuários ficaram satisfeitos, principalmente por serem terminais menores, que ocupam menos espaço e equipamentos de boa qualidade. Um lembrete que ao substituir sua HGU (internet, voip, tv, etc) por um terminal/modem GPON você terá somente acesso a internet. Em alguns setup’s é necessário adicionar um roteador com suporte para configurar VLAN e PPoE. Lembre-se de pesquisar antes de decidir, para ter certeza qual setup é o ideal para você.

• VSOL V2802RH – Mais informações: Tutorial como substituir modem de fibra óptica pela VSOL V2802RH
• Ubiquiti UF LOCO – Mais informações: https://forum.adrenaline.com.br/threads/banda-larga-tim-live-xdsl-vdsl-fibra-optica.447175/post-1076118604 e também em: https://github.com/Unifi-Tools/UFiber.Configurator
• Intelbras R1 – Mais informações: https://forum.adrenaline.com.br/threads/topico-dedicado-eliminar-ou-trocar-onu-ont-hgu-da-operadora-provedor.699243/post-1076514800
• TP-Link XZ000-G3 – Mais informações:
  https://forum.adrenaline.com.br/threads/banda-larga-vivo-xdsl-vdsl-fibra-optica-hfc.594503/post-1076399107

Neste tipo de setup, tendo em vista apenas trocar o modem, o VSOL V2802RH é a opção mais recomendada, por ter uma porta ethernet de 2.5Gbps. Um destaque também para o modelo Ubiquiti UF-WiFi6, que apesar das portas ethernet serem gigabit, poderá alcançar velocidades superiores pelo wifi (wifi6).

Substituir o modem de fibra da operadora por Interface Gbic SFP GPON/XPON

É nesta configuração que podemos alcançar as verdadeiras vantagens de upgrade da rede. Quando utilizamos uma interface SFP GPON, temos uma variedade maior de equipamentos de rede de ponta, que podemos utilizar.

Damos um destaque especial para o módulo SPF:

ODI ONU STICK - DFP-34X-2C2

Esta Gbic GPON/XPON é bastante utilizada, o principal motivo é ser destravada (unlocked), ter uma interface web, e muitos usuários terem sucesso de configuração da sua internet fibra com ela. Permite conexão telnet e ssh para configurações avançadas (OMCI).

Ela também possui velocidade máxima de download de 2.5Gbps e 1.25Gbps de upload. Mas aqui preciso dar um alerta sobre compatibilidade ao forçar a velocidade de 2.5Gbps. Ao conectar ela em um aparelho de rede com entrada SPF, seja roteador ou switch, é necessário verificar se o mesmo tem suporte aos protocolos:

2500base-X / Hi-SGMIII

Se forçar a negociação de velocidade no DFP-34X-2C2 para 2.5Gbps e o aparelho que ela estiver conectada não tiver o protocolo implementado, você não conseguirá acessar a interface para voltar a configuração normal (somente por UART). Mas se deixar no automático, irá conectar normalmente a 1Gbps.

Se for conectar a um roteador/switch, lembre-se de verificar então a compatibilidade para 2.5Gbps. Cuidado com portas SFP+ de 10Gbps pois muitas não possuem a implementação, como o Ubiquiti Dream Machine Pro/SE. Este caso é descrito aqui:

https://forum.lowyat.net/topic/4925452/all

Qual setup indicado para suporte 2.5Gbps e GPON SFP?

Segue alguns exemplos, mas nem todos foram testados. Alguns usuários relatam aumento da latência (no caso o Mikrotik CRS305-1G-4S+IN) e ainda há dúvidas se é devido compatibilidade da operadora, ou problemas no GPON/porta SFP.

• Conversor de mídia óptica de 2.5Gbps (Optical Media Converter) + roteador de 2.5Gbps. Uma opção de roteador sem porta SFP para ser utilizado com este setup é o nanoPi R6S.
• R86S-U4: é uma excelente solução como roteador/firewall. Possui 3 portas 2.5Gbps além de 2 portas SFP+ de 10Gbps. Há algumas ressalvas pela temperatura que o aparelho alcança. Alguns usuários optaram por utilizar refrigeração ativa por fora do case para mitigar qualquer problema. Possui também Wifi, eMMC de 128GB, entrada de cartão de memória micro SD e slot NVME PCI-e x3 (no teste que vi só alcançou 800MB/s). Além de possuir arquitetura x86 permitindo uso de Pfsense, OPNSense, Proxmox, etc. A placa PCI-e que dá suporte aos 2 módulos SFP+ não consegue negociar a 2.5Gbps com o ODI DFP-34X-2C2, necessário outra interface GPON/XPON com compatibilidade.
• Mikrotik RB5009 UG-S-IN ou RB5009 UPR-S-IN: possui porta SFP+ e 1 porta 2.5Gbps (além de outras portas 1Gbps). É um setup em que poderá realizar o uso máximo de sua internet fibra pela porta 2.5Gbps. Ficar atento novamente pela compatibilidade da porta SFP+ em 2.5Gbps.
• Mikrotik CCR2004-1G-12S+2XS: é uma versão bem topo de linha. Lembrando que vai precisar de gbic ethernet junto com a gpon. Pois este roteador possui 1 porta Ethernet 1Gbps e 12 portas SFP+ (10Gbps) e 2 portas SFP28 (25Gbps). Utilizando módulos SFP de 2,5Gbps poderá utilizar a velocidade máxima da internet, sem gargalos da porta gigabit. Ficar atento novamente pela compatibilidade da porta SFP+ em 2.5Gbps.
• Glink Series: do mesmo fabricante do R86S, porém com upgrade de processador (N100). Ainda está em fase de desenvolvimento e deve ser lançado ainda em 2023.
• Banana Pi R3: é um setup com muitos recursos, 2 portas SFP e 5 portas gigabit. Para tirar o maior proveito tanto da GPON, quanto do roteador, é necessário uma interface SFP Ethernet de 2.5Gbps, compatível. Tem um usuário que relatou que a imagem do OpenWRT disponível ainda não está muito estável.
• Mikrotik CRS305-1G-4S+IN: é um switch com 1 porta Gigabit e 4 portas SFP+. Necessário ligar uma interface SFP 2.5Gbps ethernet para utilizar a rede de internet em sua velocidade máxima. Ainda não vi usuários testarem o suporte 2500base-X/Hi-SGMIII, é preciso testar o funcionamento. Lembrando que também vai precisar de um roteador.

Nas opções citadas acima, um destaque para o R86S-U4, por ser uma solução completa para ser utilizada com uma GPON SFP+ compatível; capaz de prover internet na velocidade máxima, ter portas 2.5Gbps, suporte wifi6, processamento suficiente para firewall, etc. Mas lembrando que até o momento não é possível negociar a interface SFP+ em 2.5Gbps. Alguns usuários optaram por substituir a interface SFP+, por uma mais atual. para conseguir utilizar o ODI DFP-34X-2C2. Lembrando que na opção padrão não vai funcionar o ODI.

Interessante também destacar a opção de utilizar o conversor de mídia óptica + SFP GPON, pois em termos de compatibilidade, é uma opção a ser considerada.

Quais outros setups SFP também podem ser utilizados, mesmo sem suporte a 2.5Gbps?

• Ubiquiti UDM Pro/SE – um excelente equipamento. Futuramente pode ter um upgrade de firmware para suportar 2500base-X/Hi-SGMIII, quem sabe. Mas para atingir velocidade gigabit da internet é suficiente. Olhando o fórum do fabricante é mencionado que não há possibilidade de negociação a 2,5GbE por limitação de hardware, quem sabe em uma nova revisão.
• Mikrotik hex S – um excelente roteador gigabit com porta SFP.
• Ubiquiti Edgerouter X SFP – um excelente roteador gigabit com porta SFP da ubiquiti.
• Ubiqui USW-Aggregation: é um switch, então além dele, vai ser necessário ter um roteador configurado. Lembrando que este aparelho só possui portas SFP+, então sendo necessário interface SFP Ethernet. Verificar se o mesmo possui suporte 2500base-X/Hi-SGMIII, para evitar problemas, utilizar a conexão com a GPON em configuração automática e não forçar 2.5Gbps para não correr risco de perder acesso a gbic.
• Tplink AX: roteador wifi6 com suporte entrada SFP. Lembrando que a conexão por wifi6 permite utilizar sua internet GPON no limite máximo contratado. Não encontrei o modelo a venda (apenas no taobao na china), mas é possível verificar no fórum da Malásia o post.

Os cabos/conectores de fibra são todos iguais, como verificar compatibilidade?

Ficar bastante atento ao modelo do seu novo modem de fibra ou módulo GPON SFP. O modelo amplamente utilizado nos modems de fibra no Brasil é o SC/APC. É um conector de fibra na cor verde. Agora o módulo SFP GPON da ODI, o DFP-34X-2C2 utiliza o conecotor SC/UPC que tem a cor azul. O modem VSOL V2802RH também utiliza conector SC/UPC.

O que fazer caso o conector da minha fibra seja o SC/APC (verde) e o novo aparelho utiliza o SC/APC (azul)?

A melhor abordagem é utilizar um adaptador. Ou, caso na instalação da sua internet de fibra tenha uma caixinha de conexão (Roseta), onde se conecta o patch cable da fibra, basta comprar um patch cable/cord com terminais SC-APC de um lado e SC-UPC de outro. De forma mais objetiva, segue as opções:

• Opção 1: Adaptador UPC (macho) e APC (Fêmea)
• Opção 2: Quem tem Roseta instalado, só precisa do: patch cord SC-APC / SC-UPC
• Opção 3: Quem não tem Roseta instalado: Adaptador SC-APC Simplex + patch cord SC-APC / SC-UPC

Qual a diferença entre os conectores APC e UPC?

A principal diferença está no acabamento do fim da fibra, ou seja, onde há instalação dos conectores.
Se repararmos no nome APC – Angled Physical Contact, este já destaca que o corte da fibra na ponta possui um ângulo, mais precisamente um ângulo de 8 graus.
Para o conector UPC – Ultra Physical Contact, o corte no fim da fibra é reto.

Mas o que estas diferenças existentes nos conectores APC e UPC impactam de forma prática?

Basicamente, com o conector UPC toda luz refletida tende a retornar de forma paralela a fonte de luz. Já no conector APC, por causa do ângulo de 8 graus no corte do fim do cabo, a luz quando refletida, não retorna de forma paralela ao sinal de origem.
Estas diferenças impactam a perda de retorno. Para entender o que isto significa, tente imaginar o ruído que esta luz refletida pode causar no sinal. Para fins comparativos, a faixa de tolerância para conector UPC é de -50dB ou superior (quanto mais próxima de zero melhor). Para o conector APC, o padrão é de -60dB ou superior, ou seja, quanto mais próxima de zero melhor, por se tratar de um valor negativo.

Após ter os equipamentos corretos, quais informações preciso do modem da provedora?

Antes de iniciarmos a lista de variáveis necessárias, é importante ressaltar que cada provedora utilizar uma forma diferente para validar o aparelho na OLT e disponibilizar acesso a rede. De forma generalista então, vou listar todos dados que consegui acessar do meu modem Humax HP610.

• Modelo do Aparelho: HP610
• Mac Address: 00:00:00:00:00:00
• Número de série do Modem: 12345678901234567890 (no meu aparelho o número de série tem 20 digitos)
• Versão do Hardware: HW1.1
• Versão Software: VER.1.2.34.AB
• Serial do PON: HUMAB1234A56
• Vendor ID (4 primeiras letras do Pon Serial): HUMA
• Número LOID: não tinha
• Senha LOID: não tinha

Estou com todos os dados necessários do meu modem antigo, como configurar o novo setup?

A configuração é muito específica para cada aparelho, mas basicamente é inserir o máximo de informações possíveis do seu modem antigo para o novo, aumentando a compatibilidade. Se quiser utilizar a VSOL, já criei o tutorial: Tutorial como substituir modem de fibra óptica pela VSOL V2802RH

Mas diversos usuários já conseguiram realizar o upgrade do aparelho da provedora e postaram os resultados no fórum. Uma forma mais rápida para verificar a configuração realizada pelos usuários é acessar:

• Casos de sucesso para upgrade modem de fibra

Conclusões

Nesta publicação foi apresentado a idéia da possibilidade de trocar os equipamentos que a prestadora de serviços de internet fibra deixa em comodato na casa do cliente. Como é possível verificar existem uma infinidade de possibilidades, pois há grande variedade de quipamentos que podem ser utilizados.

A parte mais complicada é definir o que esperar do novo setup da rede: suporte 2.5Gbps, suporte 5Gbps, suporte 10Gbps?

Pensando na evolução/aumento de velocidade da internet contratada e da capacidade de transferência de 2.5Gbps de download máximo da GPON, um setup que garanta um mínimo de 2.5Gbps de throughput da rede parece interessante. Porém alguns usuários possuem demandas específicas, com utilização de NAS em sua rede local, onde um setup de 10Gbps será verdadeiramente útil.

De forma geral, podemos destacar 4 setup’s principais, que visam atender da melhor forma possível cada caso de uso:

• Garantir suporte ethernet 2.5Gbps no modem: VSOL V2802RH
• Já tenho um roteador com porta SFP, quero me livrar do modem da operadora:  ODI ONU STICK – DFP-34X-2C2
• Utilizar o mínimo de equipamentos de rede possível, solução All-in-one: R86S-U4 (encontrar uma interface SFP/GPON compatível com SFP+ e 2,5GbE)
• Não ligo para velocidade cabeada, quero suporte a velocidade acima de 1Gbps no wifi:
  • Ubiquiti UF-WiFi6 (ainda não testado pelos usuários)
  • Tplink AX + ODI ONU STICK – DFP-34X-2C2

Está pensando em trocar seu modem da operadora também? Confira o passo a passo que criei quando configurei o modem VSOL V2802RH na minha residência:

• Tutorial como substituir modem fibra FTTH do provedor pelo modem VSOL V2802RH

O post Tutorial como trocar o modem fibra da internet – onu, ont ou hgu apareceu primeiro em Vinicius Paes.

• Entender o que é o BufferBloat
• Saber o significado de QoS e SQM
• Aprender sobre Packet Steering e IRQbalance
• Passo a passo para resolver problemas de BufferBloat do seu roteador configurado com OpenWRT

O que BufferBloat causa?

Uma maneira objetiva de explicar o bufferbloat é explicar o que este causa. Basicamente, o efeito principal do bufferbloat é o aumento da latência da rede. Pode influenciar no atraso/sincronia dos pacotes que causa jitter e até impactar de forma crônica a velocidade de transferência da rede.

Em qual cenário o bufferbloat é mais evidente?

É comum verificar seus efeitos em redes com muitos clientes e aplicações que exigem do throughput da rede: streaming e voip. Usuários que demandam da rede para jogos online também são afetados negativamente pelo bufferbloat. Os efeitos mais comuns que os usuários relatam é um ping mais alto com o servidor destino e efeitos de lag durante a partida online. Tais efeitos ficam mais evidentes em equipamentos de rede de entrada (equipamentos com poucos recursos).

Na prática, o que é o Bufferbloat?

De forma sucinta, é um efeito negativo de aumento de latência devido ao buffer dos equipamentos de rede, quando estes estão sob estresse. A grande demanda na rede pode ocasionar um aumento excessivo da utilização dos buffers, causando um efeito cascata de atraso de pacotes.

O que significa QoS?

O termo QoS é um acrônimo para “Quality of Service” ou Qualidade do Serviço. Pode ser explicado como um conjunto de prioridades especificamente definidas para o controle do tráfego da rede, garantindo prioridade para serviços/aplicações mais sensíveis/críticas racionalizando o uso da rede.

Lembrando que para um QoS real, seria necessário garantir a qualidade do serviço de ponta a ponta. Quando habilitamos o QoS em nosso roteador pessoal, vamos definir as prioridades do serviço somente em nossa rede local.

O que significa SQM?

O termo SQM é um acrônimo para “Smart Queue Management” ou Gerenciamento Inteligente de Filas. É utilizado para melhorar o fluxo de informação em redes de computadores, muito utilizado com as metodologias de Gerenciamento de Tamanho de Fila Ativa (AQM), QoS, limitação de banda e modelagem de tráfego.

O que é Packet Steering?

Alguns equipamentos de rede possuem implementação em hardware para trabalhar com múltiplos núcleos da CPU, para transmissão e recebimento de pacotes. Porém, nem todos os equipamentos possuem esta implementação, e trabalham apenas com uma fila para processamento dos pacotes, usualmente esta fila é processada por apenas um núcleo da CPU. Pensando na evolução dos processadores ao longo dos anos, é possível verificar o foco no aumento dos núcleos e na otimização de eficiência. Então faz sentido a implementação em software de um procedimento para paralelizar o fluxo da rede, para que o fluxo de informação (pacotes) possa ser processado por vários núcleos, otimizando o funcionamento do equipamento.

O termo “Packet Steering” ou “Receive Packet Sterring” (RPS) é uma técnica onde é criado um hash do número da porta e IP da requisição de rede, que é utilizado para determinar qual core da CPU será responsável pelo pacote, nesta implementação de fluxo paralelizado. Desta forma, ele também garante que um conjunto de pacotes de um mesmo fluxo de informação seja alocado no mesmo núcleo da CPU. Para um balanceamento do fluxo em todos os núcleos do processador o packet steering é utilizado junto com o daemon do irqbalance.

Para que serve o IRQbalance?

É uma implementação de um daemon para o sistema operacional Linux com a finalidade de reorganizar/distribuir pedidos de interrupções em vários núcleos do processador. É utilizado juntamente com o packet steering, para prover o serviço. Sua utilização pode resultar em um melhor desempenho da rede de forma geral.

Lembrando que caso seu roteador tenha recursos limitados/escassos, habilitar o packet steering+irqbalance pode piorar o desempenho da rede. Muitas vezes isto acontece pois a implementação em software destes recursos consome mais poder de processamento da CPU. Caso o processador não seja eficiente o suficiente, sendo um gargalo para o sistema, ou sofrer de throttling por causa do aumento da temperatura; o desempenho da rede pode piorar.

Os requisitos para seguir este tutorial

Este tutorial tem foco em resolver o problema de BufferBloat da sua rede doméstica/corporativa através de recursos de software presentes no repositório do OpenWRT. Desta forma é necessário que seu roteador tenha o OpenWRT instalado.

Lembrando que as variáveis controláveis deste processo estão dentro da nossa rede, vamos habilitar as funcionalidades do roteador para mitigar o bufferbloat da nossa rede particular/doméstica. Não temos como mitigar o bufferbloat externamente a nossa rede.

De forma geral, roteadores de marcas conceituadas no mercado, já possuem estas opções de QoS/SQM + Packet Steerring implementadas em seus respectivos sistemas embarcados. Antes de cogitar instalar OpenWRT em seu roteador ou comprar um roteador habilitado, verifique se já não possui esta funcionalidade no seu roteador atual.

Passo a passo para resolver o problema de Bufferbloat com OpenWRT

De forma geral, a metodologia utilizada, segue as etapas:

1. Realizar teste de velocidade da rede em vários momentos do dia, para ter uma média de velocidade de download e upload
2. Realizar o teste de BufferBloat e verificar o estado da rede
3. Habilitar packet steering, qos/sqm e irqbalance no OpenWRT
4. Configurar as métricas do QoS/SQM
5. Testar novamente a rede para verificar o estado do Bufferbloat
6. Repetir os itens 4 e 5 (realizando um ajuste fino) até conseguir um resultado satisfatório

Segue então os passos de forma detalhada, para resolver os problemas de bufferbloat de sua rede:

Passo 1

O primeiro passo é verificar a velocidade da internet. Mesmo se souber exatamente a velocidade contratada, é interessante realizar o teste, pois muitas operadoras oferecem uma banda de internet um pouco maior. O ideal é realizar testes ao longo do dia e ter uma média de velocidade. Alguns sites recomendados para realizar teste:

• Speedtest
• Fast
• Speed Cloudflare

Eu particularmente gosto do teste da cloudflare para testes reais de velocidade. O Speedtest muitas vezes mostra velocidades de pico da rede. Mas tive mais sucesso utilizando o speedtest para ajustes finos de velocidade junto ao QoS (vou explicar melhor nos próximos passos).

Passo 2

Agora precisamos verificar a qualidade da rede no quesito de teste de bufferbloat. Uma opção é acessar o site da Waveform e realizar o teste.

https://www.waveform.com/tools/bufferbloat

Para realizar este teste adequadamente, é interessante que sua rede doméstica esteja sem utilização. O teste consiste em comparar a latência da sua rede com fluxo baixo de requisições. Em seguida ele compara a latência com um fluxo alto de transferência. Se tiver outros usuários utilizando a rede, o teste pode perder um pouco a precisão.

O resultado do teste é baseado em métricas de qualidade, com notas baseadas em letras: A+, A, B, C, D…

Para conseguir um resultado excelente, é interessante que no teste o aumento de latência com fluxo alto de transferências seja muito baixo, próximo a zero. Desta forma, irá conseguir nota A+.

Lembrando que muitas vezes a rede da operadora pode estar mal dimensionada, dificultando mitigar os problemas de bufferbloat ponto a ponto. Mas pelo menos, dentro da sua rede doméstica, poderá otimizar da melhor forma possível.

Neste teste, repare no aumento da latência em download e upload, e sua nota. Se receber uma nota A ou B, provavelmente já possui um bom roteador, necessário apenas alguns ajustes. Se receber nota C ou pior, talvez sua rede tenha alta utilização, e seus equipamentos estejam subdimensionados.

Lembrando que o indicado é realizar este teste via cabo de rede, evitar as latências extras que o wifi pode adicionar na rede.

Passo 3

Após realizar os testes acima e anotar os resultados, vamos para a etapa de configuração do roteador.

Conecte no seu roteador com OpenWRT instalado. Neste exemplo, o roteador está configurado no IP e será acessado pelo browser:

192.168.1.1

Passo 4

Agora vamos ativar a opção de Packet Sterring.

No menu, vá na aba “Network” e selecione a opção:

Interfaces

Na página de Interfaces, selecione a aba de:

Global network options

Agora marque o checkbox de:

Packet Steering

Clique na opção de:

Save & Apply

Passo 5

Vá novamente até o menu, selecione a aba “System” e clique na opção:

Software

Na página de instalação de softwares, clique no botão:

Update lists…

Agora está tudo pronto para buscar a instalar novos pacotes no roteador.

Passo 6 – Instalar suporte QoS/SQM no OpenWRT

No textfield do campo Filter, busque pelo pacote:

luci-app-sqm

O pacote vai aparecer na lista abaixo, clique no botão:

Install…

Lembrando que ao instalar o luci-app-sqm, ele já vai instalar os demais pacotes de dependência, como o sqm-scripts, etc.

Passo 7 – Instalar, ativar, verificar funcionamento e testar o irqbalance

Instalar o irqbalance

Agora vamos instalar o pacote do irqbalance.
Novamente, vá até o textfield de Filter, mas agora busque pelo pacote:

irqbalance

O pacote irqbalance vai aparecer logo abaixo, clique no botão:

Install…

Verificar funcionamento irqbalance

Lembrando que o pacote irqbalance não vem ativado por padrão. É necessário ir até a aba do menu “System” e clicar na opção:

Startup

É necessário habilitar (enable) o mesmo no início do sistema. Clique no botão

Enable

Em seguida, clique no botão:

Restart

Para ter certeza que o daemon está ativo, vá na aba do menu “Status” e clique na opção:

Processes

Se encontrar o processo do irqbalance, como mostrado na imagem, o daemon está em funcionamento. Mas é comum que o mesmo não inicie pela interface. Caso o seu não esteja habilitado, será necessário habilitar pela linha de comando.

Ativar irqbalance pela linha de comando

Conecte no roteador por SSH, com usuário@IP. Neste exemplo, vamos conectar com o usuário root.

ssh root@192.168.1.1

Edite o arquivo de configuração do irqbalance (se utilizar o editor nano, precisa instalar o mesmo antes):

nano /etc/config/irqbalance

Na linha:

option enable '0'

Altere para:

option enable '1'

Salve as modificações e feche o modo edição do arquivo.

Necessário então ativar o serviço:

service irqbalance start

Para ver o funcionamento, execute o comando:

service irqbalance status

Se receber a mensagem de “running” o daemon está ativo.

Testar irqbalance pela linha de comando

Bom, se seguiu os passos anteriores corretamente, o daemon do irqbalance deve estar ativo. Porém é interessante verificar o funcionamento. Nesta etapa, precisamos verificar se o irqbalance está dividindo as requisições de rede entre todos os núcleos disponíveis da CPU. Vamos executar o comando abaixo e verificar se na interface eth0 (WAN no meu caso) as requisições estão sendo distribuídas:

cat /proc/interrupts

Vamos reparar na saída abaixo:

root@OpenWrt:~# cat /proc/interrupts
	CPU0	CPU1	CPU2	CPU3
   3:	499	130	250	795	GICv2 30 Level arch_timer
 11:	971	0	0	0	GICv2 65 Level fe00b880.mailbox
 14:	2	0	0	0	GICv2 153 Level uart-pl011
 17:	31	0	0	0	GICv2 114 Level DMA IRQ
 24:	1	0	0	0	GICv2 66 Level VCHIQ doorbell
 25:	629	0	0	0	GICv2 158 Level mmc1, mmc0
 31:	740	0	0	0	GICv2 189 Level eth0
 32:	141	0	0	0	GICv2 190 Level eth0
 38:	0	0	0	0	GICv2 175 Level PCIe PME, aerdrv
 39:	781	0	0	0	BRCM STB PCIe MSI 524288 Edge eth1
IPI0:	248	546	1250	390	Rescheduling interrupts
IPI1:	30	45	34	68	Function call interrupts
IPI2:	0	0	0	0	CPU stop interrupts
IPI3:	0	0	0	0	CPU stop (for crash dump) interrupts
IPI4:	0	0	0	0	Timer broadcast interrupts
IPI5:	174	870	138	439	IRQ work interrupts
IPI6:	0	0	0	0	CPU wake-up interrupts
Err:	0

A primeira coluna do exemplo acima é destinada aos IRQ’s. Neste exemplo, estamos utilizando um Roteador com Raspberry Pi CM4, que possui 4 núcleos. Então as 4 colunas seguintes, após a coluna de IRQ diz respeito a cada núcleo. Repare nas linhas do IRQ 31 e 32, que dizem respeito a interface ETH0 (wan). O ideal é que as requisições estivessem distribuídas entre os 4 núcleos e não concentradas apenas no primeiro número (CPU0).

Caso tenha problema no IRQ balance, é possível que sua internet fique mais lenta quando ativar o QoS/SQM, pois apenas um núcleo não irá conseguir processar toda a demanda. Verificando no fórum do OpenWRT, em uma das atualizações da versão 22.03 houve problemas de execução do irqbalance e uma issue foi aberta no github. Caso venha a ter problemas, o recomendado é atualizar todo o sistema para uma versão atualizada mais estável.

Caso não seja possível atualizar o sistema operacional de forma alguma, é possível definir manualmente qual núcleo cada interface deve utilizar. Ver a página do mantenedor no irqbalance para mais detalhes.

Atualizei o OpenWRT para a última versão disponível e o IRQbalance voltou a funcionar:

	 CPU0	 CPU1	 CPU2	 CPU3
 11:	10918	30975	23301	27570	GICv2 30 Level arch_timer
 18:	283	0	0	0	GICv2 65 Level fe00b880.mailbox
 21:	2	0	0	0	GICv2 153 Level	 uart-pl011
 24:	31	0	0	0	GICv2 114 Level	 DMA IRQ
 31:	133	0	0	0	GICv2 66 Level VCHIQ doorbell
 32:	9339	0	0	0	GICv2 158 Level	 mmc1, mmc0
 39:	568	10111	0	0	GICv2 189 Level eth0
 40:	136	0	0	65735	GICv2 190 Level eth0
 46:	0	0	0	0	GICv2 175 Level PCIe PME, aerdrv
 47:	14371	0	0	0	BRCM STB PCIe MSI 524288 Edge eth1
IPI0:	2032	2198	2114	2137	Rescheduling interrupts
IPI1:	20282	17235	41603	32947	Function call interrupts
IPI2:	0	0	0	0	CPU stop interrupts
IPI3:	0	0	0	0	CPU stop (for crash dump) interrupts
IPI4:	0	0	0	0	Timer broadcast interrupts
IPI5:	7550	9874	3154	7590	IRQ work interrupts
IPI6:	0	0	0	0	CPU wake-up interrupts
Err:	0

Passo 8

Com todos os softwares instalados, é possível agora ativar o QoS/SQM.

Acesse a aba do menu “Network” e selecione a opção:

SQM QoS

Agora marque a caixa com o escrito:

Enable this SQM instance.

Em interface name, precisamos selecionar nossa interface WAN. No meu exemplo, minha WAN está em eth0. Então vou selecionar:

eth0

Agora precisamos configurar o “ingress” e “egress” shaping. Basicamente é definir as velocidades da nossa internet. É aqui que precisamos realizar os ajustes finos, por exemplo, se minha internet possui 750Mbps de Download, uma boa janela para definir o “ingress shaping” (download) é algo em torno de 80 a 95% da velocidade média. Vamos começar com algo próximo a 95% da minha velocidade total, então vou configurar o “ingress shaping” para:

700000

Para o “egress” shaping (upload), vou seguir com a mesma metodologia. Tenho em média 370Mbps de velocidade de download. Então vou colocar algo próximo de 95% da mesma. Vou colocar meu “egress shaping” com o valor de:

350000

Agora precisamos verificar as configurações na aba:

Queue Discipline

Por padrão, o Queueing discipline vem selecionado com o algoritmo cake. Não vamos realizar modificações, pois o Raspberry Pi 4 tem processamento suficiente para este algoritmo, com esta banda de internet.

Também vamos deixar o queue setup script com o “piece_of_cake.qos”. Que é o padrão da instalação.

É interessante você verificar o algoritmo que atenda melhor sua demanda, caminhamos por estas opções apenas para evidenciar as escolhas.

Vamos agora selecionar a aba:

Link Layer Adaptation

Na primeira opção, devemos selecionar a tecnologia de link layer que vamos utilizar. Vou utilizar a opção:

Ethernet with overhead…

No campo de textfield de Per Packed Overhead (bytes) para minha internet de fibra, vou selecionar o valor de:

44

Agora vamos clicar no botão:

Salvar e Aplicar

Passo 9

Tudo pronto, agora precisamos verificar os resultados e realizar o setup fino.
Acesse novamente a página de teste de bufferbloat:

https://www.waveform.com/tools/bufferbloat

Realize o teste e verifique qual a latência atingida em “Download Active” e “Upload Active”. O ideal é ficar com algo próximo de 0 de latência, para conseguir nota A+. Caso ainda tenha recebido latência, não tem problema, será necessário realizar ajustes finos.

O ajuste fino nada mais é que ir na página “Network”->”SQM QoS” e realizar mudanças no “ingress” e “egress shaping”. Vá diminuindo os valores e realizando testes até conseguir uma latência em “Download” e “Upload Active” igual a zero. Lembre-se de salvar e aplicar as mudanças, toda vez que alterar os valores.

Se sua internet sofrer muitas variações de velocidade durante o dia, é recomendado colocar o ingress e egress shaping na casa dos 80% da velocidade média.

Tudo certo! Problemas de bufferbloat foram mitigados em nossa rede!

Conlusões

Este tutorial abordou uma forma de resolver problemas de bufferbloat que podem afetar uma rede doméstica. Existem diversas outras parametrizações que podem ser realizadas, a fim de maximizar o potencial da rede, além de outros algoritmos de SQM/QoS que podem ser utilizados. Mas as configurações padrão são também eficientes de forma geral.

Espero que tenham gostado deste passo a passo! Qualquer dúvida ou sugestão, basta escrever nos comentários!

O post Tutorial como resolver problema de Bufferbloat com OpenWRT apareceu primeiro em Vinicius Paes.

O objetivo deste tutorial é habilitar a opção de configuração de DNS Dinâmico pela interface do OpenWRT. Vamos detalhar todos os softwares necessários e demonstrar um exemplo de configuração de um domínio no Google Domains para receber um IP dinâmico da nossa rede.

Visão geral de utilização de DNS dinâmico

Mas afinal, para que serve o DNS dinâmico?

Um exemplo prático, é ter uma forma de acessar sua rede local, mesmo quando estiver fora da sua casa.

Qual a dinâmica que se faz necessário utilizar DDNS

Alguns provedores de internet fornecem IP real para seus clientes, ou seja, um IP que pode ser acessado de rede externa (internet). Mas este IP muitas vezes não é fixo, eventualmente quando o equipamento de rede de sua provedora sofre alguma manutenção, ele pode reiniciar o DHCP delegando IP’s diferentes aos clientes.

Uma alternativa é configurar DDNS, este serviço avisa a mudança do seu IP da sua residência para serviço de terceiros.

Quais as principais empresas que fornecem o serviço de DDNS?

De forma geral, as empresas abaixo oferecem o serviço de DNS dinâmico. Elas vinculam o seu IP a um endereço de subdomínio, desta forma, acessando aquele subdomínio, você sempre é direcionado ao IP da sua casa:

• No-ip
• FreeDNS
• ClouDNS
• Dynu
• Duck DNS
• DynDNS
• Digital Ocean
• Google Domains
• Cloudflare
• CNkuai
• Gandi
• Godaddy
• Amazon AWS Route 53

Mas lembrando que você precisa ter um software em sua residência que avise esta mudança do seu IP de internet, então neste exemplo, o software OpenWRT instalado em nosso roteador fará esta comunicação.

Mas como pode ser útil o acesso através de DDNS?

Imagina que você possui um sistema de câmeras de vigilância em sua residência que possuem uma interface web de acompanhamento. Quando você está conectado na sua rede local, você consegue acessar esta interface tranquilamente e ver as câmeras.

Mas e quando você está fora da sua residência, muitas vezes conectado pela interface 4G/5G do seu celular, como ter acesso a sua rede local para ver as câmeras? Uma opção é conectar ao IP da sua residência e caso o roteador esteja configurado para redirecionar as requisições da porta 80/443 para a interface das suas câmeras, você conseguirá este acesso externo facilmente. Com um serviço de DDNS ativado, você sempre terá um nome de domínio/subdomínio vinculado ao IP da sua residência, facilitando este processo. Só um lembrete, os novos serviços de câmeras de vigilância muitas vezes possuem um pacote de serviços que contemplam este acesso externo, este exemplo é só para exemplificar como poderia ser útil.
Um outro exemplo prático. Imagina que possui um servidor local na sua residência, onde guarda arquivos, fotos da família, etc. O DDNS fornece uma forma prática de acessar sua rede, mesmo quando está fora de casa e não lembra seu IP.

Requisitos Necessários

• Seu roteador de internet possui OpenWRT instalado
• Sua provedora de internet fornece IP com acesso externo (IP real)

Para testar se seu IP tem visibilidade externa, descubra qual seu ip de internet (uma rápida pesquisa no google já encontra uma solução). Depois no seu celular, desligue a conexão wifi e habilite 4G/5G. Digite seu IP no browser e verifique se você se conecta ao seu roteador/modem da provedora.

Caso não tenha conexão, pode ser que seu roteador/modem esteja bloqueando login vindo da internet. Tente realizar conexão com seu modem/roteador pela rede local, habilite opção de conexão pela rede externa (wan) e tente novamente.

Caso seja possível a conexão, então você tem um IP real. Lembrando que o IP real pode não ser fixo, que é a proposta de habilitar o DDNS.

Tutorial configurar DNS Dinâmico (DDNS) no OpenWRT, exemplo prático com o Google Domains

Passo 1

Faça login no seu roteador, acessando o IP do mesmo pela interface web. Neste exemplo, o roteador está configurado com o ip:

192.168.1.1

Passo 2

No menu superior, acesse a aba de:

System

Em seguida, clique no link com a opção:

Software

Passo 3

Dentro da página de Software, clique no botão:

Update lists…

Aguarde até o package manager terminar a execução.
Quando finalizar, um log do processo será apresentado, clique no botão:

Dismiss

Passo 4

Ainda na tela da página de Software, vá até o text box de busca que tem o nome “Filter” e digite o nome do pacote a ser instalado:

ddns-scripts

Logo abaixo será apresentado dados sobre o pacote e um botão para iniciar a instalação. Clique então em:

Install…

Será aberto um modal com mais dados sobre a instalação, as dependências do pacote, etc. Esta é uma tela de confirmação, caso esteja de acordo, clique no botão:

Install

Será apresentado o log de instalação do package manager. Clique no botão:

Dismiss

Você voltará novamente para a página de Software e poderá ser possível que o pacote ddns-script aparece com o botão escrito “Installed”.

Passo 5

Repita os passos de instalação do passo 4 para o pacotes:

• luci-app-ddns
• ca-certificates
• ca-bundle
• curl
• wget-ssl (não instale o wget-no-ssl, quando instalei aqui todos os downloads que realizava pelo sistema pararam de funcionar)
• luci-i18n-ddns-en (caso queira tradução da interface em outro idioma substitua “en” pela sigla do idioma desejado)

Abaixo segue as imagens da instalação de todos os pacotes citados acima:

Passo 6

Ainda na página de “Software” é necessário recarregar a página para que os softwares instalados apareçam no menu. No windows a tecla de refresh é o F5.

Agora vá no menu superior, na aba:

Services

E clique na opção de:

Dynamic DNS

Passo 7

Na página de “Dynamic DNS” temos a opção de configurar IPv4 ou IPv6. Neste exemplo, vou configurar IPv4 para um subdomínio de teste que tenho no Google Domains.

Na linha de serviço myddns_ipv4, clique no botão:

Edit

Em “lookup hostname” vou colocar o nome do subdomínio que vou configurar, no caso, vai ser:

teste.viniciuspaes.com

Em “IP address version”, vou manter:

IPv4-Address

Em “DDNS service provider”, vou escolher:

Google.com

Lembre que no campo DDNS Service Provider você deve escolher a empresa que irá configurar o DNS Dinâmico. No meu caso vou configurar pelo Google Domains.

No fim da página é preciso confirmar a mudança de serviço “Really switch service?”, clique então no botão:

Switch service

Ao clicar no botão, 3 novos campos vão aparecer, estes são os campos de autenticação no DDNS do Google Domains.

Por enquanto deixe esta página aberta e vamos abrir uma nova aba para acessar o Google Domains.

Passo 8

Faça login no Google Domains, selecione o domínio em que vai configurar o DDNS e selecione a opção do menu “DNS”.

No fim da página clique na opção:

Mostrar configurações avançadas

Vai aparecer o campo de “DNS Dinâmico”, clique no link:

Gerenciar DNS dinâmico

Neste exemplo vou criar uma entrada do tipo A. Vou habilitar o DDNS para o subdomínio:

teste.viniciuspaes.com

Em seguida clico em:

Salvar

Agora desça para o fim da página e na configuração do DNS Dinâmico agora vai aparecer um link:

Ver credenciais

Clique no link descrito acima e exiba as informações das credenciais. Anote as credenciais de:

Nome de usuário
Senha

Agora volte para a aba que deixamos aberto o OpenWRT.

Passo 9

De volta na tela de edição da configuração myddns_ipv4, preenchemos os 3 campos:

• Domain: teste.viniciuspaes.com
• Username: (copiar a informação da tela de credenciais do DDNS do google domains)
• Password: (copiar a informação da tela de credenciais do DDNS do google domains)

Logo abaixo vamos selecionar o checkbok:

Use HTTP Secure

Ao selecionar o checkbok irá aparecer um textfield com o nome de “Path to CA Certificate”, insira o texto:

/etc/ssl/certs

Tudo pronto nesta etapa, agora clique no botão:

SAVE

Passo 10

Ainda na página de Dynamic DNS, clique no botão:

Save & Apply

Ainda na mesma página, na linha d myddns_ipv4, clique no botão:

Reload

Agora vá para a página principal do OpenWRT. Clique no logo escrito OpenWRT no canto superior esquerdo, ou pelo menu selecione Status -> Overview.

Passo 11

Na página inicial do OpenWRT use a barra de rolagem e caminhe até o fim.

Agora terá uma sessão nova sobre o DNS dinâmico. Como configuramos o DDNS para o ipv4 com o Google Domains, ele agora aparecerá também nesta tela principal. As informações do ip da WAN atribuída e o intervalo de atualização da entrada DNS também vão aparecer.

Passo 12

Vá agora na aba de DNS Dinâmico do Google Domains. É possível verificar que o IP da WAN do roteador foi atualizado e o tutorial para configurar o DDNS está completo.

Conclusão

Este passo a passo ensinou quais os pacotes/softwares necessários para habilitar o DDNS no OpenWRT. Neste exemplo, utilizamos a configuração para um subdomínio hospedado no Google Domains e a configuração foi super simples.
O processo é semelhante caso queira configurar o DDNS para outra empresa, sem ser o Google Domains.

Gostou deste passo a passo? Tem alguma dúvida ou sugestão? Conta aí nos comentários!

O post Tutorial configurar DNS Dinâmico (DDNS) no OpenWRT exemplo com Google Domains apareceu primeiro em Vinicius Paes.

Configurar uma interface de ponte (bridge) entre a rede do roteador e a do modem. Facilitando o acesso a interface de login do seu modem pelo browser, quando conectado pela rede do roteador.

Mas na prática, para que preciso desta configuração?

Geralmente o roteador fornecido pela empresa provedora de internet não é da melhor qualidade. Seja por baixo poder de processamento, pouca memória ram, ou ele recebe uma carga muito alta de demanda de IO onde o equipamento não consegue dar conta.

Caso não esteja conseguindo utilizar toda sua internet contratada, pode ser que seu roteador da provedora não esteja dando conta do throughput da rede. Uma alternativa é mudar a configuração do seu roteador da provedora para modo bridge (o que diminui a demanda de processamento do mesmo).

Porém, caso tenha mais dispositivos na sua rede, é interessante e necessário que tenha um equipamento para roteamento. Ou seja, você precisa de um roteador, este que agora ficará dedicado a esta atribuição.

Mas nessa configuração, por exemplo, o modem fica acessível pelo IP 192.168.0.1
Já o roteador, está em outra rede, e seu IP é 192.168.1.1

Se estiver conectado na rede do roteador, e digitar o IP do modem no browser, não vai conseguir acessá-lo. Normalmente, os usuários, desconectam o computador da rede do roteador e conectam por cabo diretamente no modem, quando querem acessá-lo, para mudar alguma configuração. Não sendo nada prático.

Uma alternativa é criar uma ponte da rede 192.168.0.x para a rede 192.168.1.x (do exemplo acima). Desta forma, se está conectado na rede do roteador, consegue acessar a interface do modem, e vice-versa. Facilita muito o processo de manutenção e acesso a interface dos dispositivos.

O objetivo deste tutorial é exatamente ensinar os passos para configurar essa interface de bridge entre as 2 redes, utilizando o OpenWRT.

Requisitos Necessários

• Seu roteador/modem de internet fornecido pelo provedor está em modo bridge
• Seu roteador principal possui OpenWRT instalado

Tutorial passo a passo de como configurar acesso ao modem em bridge através da rede do roteador que possui OpenWRT instalado

Passo 1

Faça login no seu roteador principal, digitando o ip do mesmo pelo browser. Neste exemplo, o roteador está configurado com o IP:

192.168.1.1

Passo 2

Após realizar login com usuário e senha, no menu superior, acesse a aba:

Network

Em seguida, acesse a opção do menu:

Interfaces

Passo 4

No canto inferior esquerda desta página, tem a opção:

Add new interface…

Clique na opção acima.

Passo 5

Agora há 3 campos a serem preenchidos, o primeiro é o nome que você vai dar para essa interface. Eu particularmente chamo essa interface de:

MODEM

Para o protocolo, vamos utilizar:

Static address

Para device, devemos escolher a porta WAN do nosso roteador.
No meu roteador a porta WAN é configurada pela “eth0”, então no meu exemplo fica:

Ethernet Adapter: “eth0” (wan)

Passo 6

Nesta nova tela que abriu, você estará na primeira aba (General Settings), agora precisamos definir o IP que teremos nessa interface de ponte. Como o meu modem está com IP 192.168.0.1, vou colocar a interface de ponte com o IPv4 estático:

192.168.0.2

A máscara de rede que vou utilizar (Ipv4 Netmask) será:

255.255.255.0

Passo 7

Como mencionei, estamos na aba “General Settings”, agora vamos clicar para ir na aba:

Firewall Settings

Nesta aba, vamos definir no campo “Create / Assign firewall-zone” a mesma política de firewall atribuída para nossa interface wan. Então vamos selecionar a opção:

wan

Passo 7

Agora salve todas as modificações. E clique na opção:

Save & Apply

Passo 8

Agora digite o endereço IP do seu modem no browser e poderá acessá-lo diretamente.

Conclusão

O passo a passo para configurar o acesso ao modem pela rede do roteador é bem tranquilo. Só ficar atento ao IP que está configurado na sua rede e seguir o mesmo padrão.

Ficou com alguma dúvida sobre os passos acima? Ou tem alguma sugestão? Escreve aí nos comentários, que farei o possível para responder!

O post Tutorial acessar modem em bridge pela rede do roteador com OpenWRT apareceu primeiro em Vinicius Paes.

Build a custom OpenWRT image to be installed on the SD card or eMMC on the Raspberry Pi, so that it works as an network router.

Project Requirements

• Raspberry Pi
• USB to Ethernet dongle (regular Raspberry Pi) or DFRobot Router Board for Raspberry Pi CM4
• USB Power Supply
• 2 RJ45 cables – one to connect the raspberry to the modem and other to connect raspberry router to the computer or network switch
• Micro SD card if using a Raspberry Pi without eMMC

Initial considerations

The objective of this tutorial is to build a custom OpenWRT image ready to run on a Raspberry Pi. This tutorial works for any Raspberry model, but be aware of the need for additional drivers depending on the USB-Ethernet dongle you are using.

This walkthrough also serves to create OpenWRT images for Odroid, Nvidia Jester, ZimaBoard, and other tinker boards. However, in the configuration step, it is necessary to select the appropriate drivers.

For transparency purposes, I’m going to configure a Raspberry Pi CM4 to act as a router. If you are using a Raspberry Pi CM4 Router Board from DFRobot, just follow this step by step.

Host Setup

This step-by-step needs to be performed on a Linux operating system, with good processing power, to speed up the compilation process. If you don’t use Linux operating system, no problem, just install a virtual machine on your computer with Mac OS or Windows.

If you have questions on how to create a virtual machine, access this tutorial: Create Virtual Machine Tutorial with Virtualbox

If you are going to use a virtual machine, I recommend the setup:
Processing: at least 4 cores
Storage: 25GB (minimum)
RAM: at least 2GB

After creating the virtual machine and later creating 4 OpenWRT images (2 complete images and 2 for upgrade), the virtual machine had only 1.1GB of available disk space. So the minimum size of 25GB for disk space is adequate (pictured below).

Step by step tutorial to create OpenWRT image for Raspberry Pi to act as a network router

Step 1

The first step is to package update and upgrade. So, we need to update the system software, using the commands:

sudo apt update
sudo apt upgrade

Step 2

Now you need to install the necessary software for the openwrt image creation environment:

sudo apt install build-essential clang flex bison g++ gawk gcc-multilib g++-multilib gettext git libncurses5-dev libssl-dev python3-distutils rsync unzip zlib1g-dev file wget

Step 3

Now it is necessary to download openwrt source code directly from its github repository. I usually do this download inside my user folder (cd ~). Let’s clone the project with the command:

git clone https://git.openwrt.org/openwrt/openwrt.git

Step 4

After downloading the source code, we need to enter (cd) the created folder:

cd openwrt

Step 5

Let’s now check the available branches. Remembering that the main branch (master) is not a stable version of openwrt.

git branch -a

Step 6

Let’s see the available versions with the command:

git tag

Step 7

The latest stable version available as of the date of this tutorial is v22.03.4. So let’s choose it to create our OpenWRT image.

git checkout v22.03.4

Step 8

Now we can use the command to update the dependencies for this version of openwrt:

./scripts/feeds update -a

Step 9

Next, we now need to install the required software and dependencies for this selected version of openwrt:

./scripts/feeds install -a

Step 10

Now let’s move on to settings performed by menuconfig. Run the command to open the menu:

make menuconfig

Step 11

Within the menu, it is necessary to define the Target System. Use the keyboard arrows and press ENTER over the option:

Target System  (...) --->

Now choose Broadcom’s 27xx processor family option:

BROADCOM BCM27xx

Step 12

After selecting the Target System, you will be returned to the main menu. Now it is necessary to define the exact processor of the BCM27xx family in subtarget. Navigate through the menu and select the option:

Subtarget (...) --->

Within the Subtarget menu, select the option:

BCM2711 boards (64 bit)

Step 13

After selecting the Subtarget, you will be redirected back to the initial screen of the menu. Now we need to define aspects of the openwrt image to be created. The file system type and size of partitions. Select option:

Target Images --->

In the target images menu you have several options. For the purpose of this example, I will create custom images for ext4 and squashfs filesystem and also compress them with gzip.
I don’t recommend changing the default kernel partition size unless you know what you’re doing.
If you know the exact size of your memory card or eMMC, you can change the root partition size so that you don’t have to perform file system expansion after installation. Remember to discount the size of the root partition so that the calculation is precise.

After configuring the Target Images settings, use the keyboard arrow and select the EXIT option to return to the main Menu screen.

Step 14

In these next steps, we need to install 3 main drivers:

• kmod-r8169
• kmod-usb-dwc2
• bcm27xx-userland

However, there are several submenu divisions and it can be difficult to find out which submenu is the option to install the necessary packages. But menuconfig has a search tool that can be activated using the hotkey:

/

This hotkey is similar to the VI or VIM text editor search option.
If you need to install additional packages to enable your USB dongle, ethernet, or USB ports, etc; this search option is recommended (it informs the path within the menu to the driver you search for, if found/available).

You don’t need to perform any search at this time, you can close the search field and follow the steps from the main menu.

Step 15

To install the kmod-r8169 driver, we need to navigate through the submenu:

Kernel Modules

Then go to the submenu:

Network Devices

Find the option:

kmod-r8169 (Realtek RTL-8169 PCI Gigabit Ethernet kernel support)

To be able to select this option, press the SPACE key twice. It will be selected when an asterisk <*> appears inside the brackets.

Use the keyboard arrows and select the EXIT option to return to the Kernel Modules submenu.

Step 16

Still inside the Kernel Modules submenu, go to the option:

USB Support --->

Find the option:

kmod-usb-dwc2 DWC2 USB controller drive

To be able to select this option, press the SPACE key twice. It will be selected when an asterisk <*> appears inside the brackets.

Use the keyboard arrows and select the EXIT option to return to the Kernel Modules submenu. Select EXIT again, to return do the main menu.

Step 17

Now we need to install the bcm27xx-userland driver to support the Broadcom BCM27xx family of processors. Select submenu option:

Utilities --->

Find the option:

bcm27xx-userland BCM27xx userland tool

To be able to select this option, press the SPACE key twice. It will be selected when an asterisk <*> appears inside the brackets.

Then select EXIT to return to the main menu.

Step 18

From the main menu, search for and select the option:

LuCI --->

Within the LuCI menu, find and activate the 2 options below:

luci          LuCI interface with Uhttpd as Webserver (default)
luci-ssl      LuCI with HTTPS support (WolfSSL as SSL backend)

To be able to select this option, press the SPACE key twice. It will be selected when an asterisk <*> appears inside the brackets.

Then select EXIT to return to the main menu.

Step 19

If you are not going to install any more drivers of your choice, select EXIT again to close the menuconfig.

The option to save the selected settings will appear. Select:

< YES >

Step 20

If an error appears when closing the menuconfig, try to identify which package or software has a problem. In my specific case, an error appeared in the apinger package. An unusual error as I didn’t select to install it.

To solve this error, I just deleted the file:

rm openwrt/package/feeds/luci/luci-app-apinger

Probably when you run this tutorial, the above error will be corrected already in the repository, as other users opened an ISSUE in github.

Step 21 – Optional Settings

Now let’s introduce some optional settings:

Change login banner

If you want to make cosmetic changes, just edit the file:

nano package/base-files/files/etc/banner

Enable UART

The UART is disabled by default, to enable it, just edit the file:

nano target/linux/bcm27xx/image/config.txt

Just below the field “Place your custom settings here.”, insert the text:

enable_uart=1

Load configuration files about login, network, firewall, dhcp, etc

This step is NOT RECOMMENDED for general use. The best option is to let openwrt generate the files and later perform the modifications manually. One justification is that openwrt can undergo updates that change the layout of these files, which can cause installation problems. But for the purposes of automating the generation of images, it is certainly an interesting option.

If you want to perform this step, you need to create the directory structure:

mkdir files
mkdir files/etc
mkdir files/etc/config

Now edit the configuration files and fill in with the settings you have. A tip for this step is to already have openwrt configured on another router and copy and paste your settings. In any case, the main files to edit are:

nano files/etc/config/dhcp
nano files/etc/config/firewall
nano files/etc/config/network
nano files/etc/config/wireless
nano files/etc/passwd
nano files/etc/shadow

Step 22 – Compile

With all the desired changes already made, let’s now run the make command to start compiling the source code. Remembering that the -j option defines the number of cores to be used. As I have 4 cores, I use -j4, to speed up the process. Use the command to start compilation:

make -j4

The compilation process may take lot of time, please wait with patience.

Step 23 – Image files created

After the build process is finished, you can check the created files in the folder:

ls bin/targets/bcm27xx/bcm2711

In this example, 4 files were created, based on OpenWRT v22.03.4, they are also available to download from my google drive:

• openwrt-bcm27xx-bcm2711-rpi-4-ext4-factory.img.gz (full version with ext4)
• openwrt-bcm27xx-bcm2711-rpi-4-ext4-sysupgrade.img.gz (upgrade version for ext4)
• openwrt-bcm27xx-bcm2711-rpi-4-squashfs-factory.img.gz (full version with squashfs)
• openwrt-bcm27xx-bcm2711-rpi-4-squashfs-sysupgrade.img.gz (upgrade version for squashfs)

Remembering that you must choose which file system you want to use on your raspberry. I use ext4 for the general case, when I install other packages on the raspberry (LAMP server). If the raspberry is dedicated to work as a router, the squashfs partition is the recommended option, as it preserves the file system to the factory default after boot.

If you have any questions or suggestions about the process of creating a custom OpenWRT image, please write them in the comments! I will do my best to answer!

O post How to build a custom OpenWRT image for Raspberry Pi Router apareceu primeiro em Vinicius Paes.

Criar uma imagem de sistema operacional OpenWRT para ser instalado no cartão SD ou memória eMMC no Raspberry Pi, para que funcione como um roteador de rede de internet.

Requisitos Necessários

• Raspberry Pi
• Adaptador USB para Ethernet no caso de Raspberry Pi comum ou Placa Router Board da DFRobot para Roteador com Raspberry Pi CM4
• Fonte de Alimentação USB
• 2 cabos RJ45 – um para ligar o raspberry no modem e outro para ligar o raspberry no computador ou switch de rede
• Cartão micro SD caso utilize um Raspberry Pi sem eMMC

Considerações Iniciais

O objetivo deste tutorial é criar uma imagem de sistema operacional com OpenWRT preparada para funcionar em um Raspberry Pi. Este tutorial serve para qualquer modelo do Raspberry, lembrando de ficar atento à necessidade de drivers adicionas dependendo do dongle USB-Ethernet que estiver utilizando.

Este passo a passo serve também para criar imagens do OpenWRT para Odroid, Nvidia Jester, ZimaBoard, e demais tinker boards. Porém, na etapa de configuração, é necessário selecionar os drivers apropriados.

Para fins de transparência, vou configurar um Raspberry Pi CM4 para funcionar como roteador. Se estiver utilizando um Raspberry Pi CM4 junto com uma placa Router Board da DFRobot, basta seguir a risca este passo a passo.

Necessidades para o setup

Este passo a passo precisa ser realizado em um Sistema Operacional Linux, com um bom poder de processamento, para agilizar o processo de compilação.

Caso não utilize sistema operacional linux, não tem problema, basta instalar uma máquina virtual em seu computador com Mac OS ou Windows. Caso utilize o Windows, também é possível utilizar o WSL, mas necessário remover o compartilhamento de PATH.

Informações gerais caso utilize Máquina Virtual

Se tiver dúvidas em como criar uma máquina virtual, acesse o tutorial: Tutorial Criar Máquina Virtual com Virtualbox

Caso vá utilizar uma máquina virtual, recomendo o setup:
Processamento: pelo menos 4 cores
Armazenamento: 25GB
Memória RAM: pelo menos 2GB

Para fins de curiosidade, após a criação da máquina virtual e posteriormente criação de 4 imagens do OpenWRT (2 completas e 2 para upgrade), a máquina virtual ficou com apenas 1,1GB de espaço em disco disponível. Então o tamanho mínimo de 25GB para espaço em disco é adequado (foto abaixo).

Considerações necessárias caso utilize Windows WSL

Durante o processo de compilação, o compartilhamento da variável PATH entre o windows e o WSL pode causar problemas. Desta forma precisamos editar o arquivo /etc/wsl.conf. Dentro do prompt do WSL, execute o comando:

sudo nano /etc/wsl.conf

Agora é necessário inserir o texto no fim do arquivo:

[interop]
appendWindowsPath = false

Agora abra o Windows Power Shell e execute o comando para reiniciar a instância do WSL:

wsl --shutdown

Abra novamente o WSL e digite o comando:

echo $PATH

Terá como saída algo similar ao conteúdo abaixo, o que varia para cada distribuição do linux:

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/usr/lib/wsl/lib

Tutorial passo a passo para criar imagem do OpenWRT para Raspberry Pi funcionar como roteador

Passo 1

O primeiro passo é estar com seu computador ou máquina virtual com Sistema Operacional Linux em funcionamento. Assim, precisamos atualizar os softwares do sistema, utilizando os comandos:

sudo apt update
sudo apt upgrade

Passo 2

Agora necessário instalar os softwares necessários para o ambiente de criação da imagem do openwrt:

sudo apt install build-essential clang flex bison g++ gawk gcc-multilib g++-multilib gettext git libncurses5-dev libssl-dev python3-distutils rsync unzip zlib1g-dev file wget

Passo 3

Precisamos agora fazer o download do openwrt direto do seu repositório do github. Costumo fazer este download dentro da minha pasta de usuário (cd ~). Vamos realizar o clone do projeto com o comando:

git clone https://git.openwrt.org/openwrt/openwrt.git

Passo 4

Após o download do projeto, precisamos entrar na pasta criada:

cd openwrt

Passo 5

Vamos agora verificar as branch’s disponíveis. Lembrando que a branch principal (master) não é uma versão estável do openwrt.

git branch -a

Passo 6

Vamos ver as versões disponíveis com o comando:

git tag

Passo 7

A última versão estável disponível na data deste tutorial é a v22.03.4. Então vamos escolher ela para criar nossa imagem do OpenWRT.

git checkout v22.03.4

Passo 8

Agora podemos utilizar o comando para realizar o update das dependências e necessidades desta versão do openwrt:

./scripts/feeds update -a

Passo 9

Em seguida, precisamos agora instalar os softwares e dependências necessários para esta versão selecionada do openwrt:

./scripts/feeds install -a

Passo 10

Agora vamos seguir para configurações realizadas pelo menuconfig. Execute o comando para abrir o menu:

make menuconfig

Passo 11

Dentro do menu, é necessário definir o Target System. Utilize as setas do teclado e aperte ENTER em cima da opção:

Target System  (...) --->

Agora escolha a opção da família de processador 27xx da Broadcom:

BROADCOM BCM27xx

Passo 12

Após selecionar o Target System, você irá voltar para o menu principal. Agora precisamos definir o processador exato da família BCM27xx pelo subtarget. Navegue pelo menu e selecione primeiro a opção:

Subtarget (...) --->
Dentro do menu do Subtarget, selecione a opção:

BCM2711 boards (64 bit)

Passo 13

Após selecionar o Subtarget, você será redirecionado novamente para tela inicial do menu. Agora precisamos definir aspectos da imagem do openwrt a ser criada. O tipo do sistema de arquivos e o tamanho das partições. Selecione a opção:

Target Images --->

No menu de target images você tem diversas opções. Para fins deste exemplo, vou criar imagem do tipo ext4 e squashfs e a opção de compactar com gzip as imagens.
Não recomendo alterar o tamanho padrão da partição de kernel, a não ser que saiba o que está fazendo.
Se souber o tamanho exato do seu cartão de memória ou memória eMMC, você pode alterar o tamanho da partição de root para que não precise executar a expansão do sistema de arquivos após a instalação. Lembre-se de descontar o tamanho da partição de root, para que o cálculo fique correto.

Após definir as configurações do Target Images, utilize a seta do teclado e selecione a opção EXIT para voltar para tela principal do Menu.

Passo 14

Nestes próximos passos, precisamos instalar 3 drivers principais para o funcionamento:
kmod-r8169
kmod-usb-dwc2
bcm27xx-userland

Porém, há diversas divisões de submenu e pode ficar complicado descobrir em qual submenu está a opção de instalação dos pacotes necessários. O menu tem uma ferramenta de pesquisa que pode ser acionada utilizando a tecla:

/

Esta tecla é semelhante à opção de pesquisa do editor de texto VI ou VIM.
Caso precise instalar pacotes adicionais para habilitar seu dongle USB, ethernet, ou portas USB, etc; esta opção de busca é recomendada (ela informa o caminho dentro do menu até o driver que buscar, caso encontrado).

Não precisa realizar nenhuma busca neste momento, pode fechar o campo de busca e siga com os passos pelo menu principal.

Passo 15

Para instalar o driver kmod-r8169, precisamos navegar pelo submenu:

Kernel Modules

Em seguida para o submenu:

Network Devices

Encontre a opção:

kmod-r8169 (Realtek RTL-8169 PCI Gigabit Ethernet kernel support)

Para conseguir selecionar esta opção, aperte a tecla de ESPAÇO por 2 vezes. Ela estará selecionada, quando aparecer um asterisco <*> dentro da opção.

Utilize as setas do teclado e selecione a opção EXIT para voltar para o submenu de Kernel Modules.

Passo 16

Ainda dentro do submenu de Kernel Modules, vá na opção:

USB Support --->

Encontre a opção:

kmod-usb-dwc2 DWC2 USB controller drive

Para conseguir selecionar esta opção, aperte a tecla de ESPAÇO por 2 vezes. Ela estará selecionada, quando aparecer um asterisco <*> dentro da opção.

Utilize as setas do teclado e selecione a opção EXIT para voltar para o submenu de Kernel Modules. Depois selecione novamente EXIT para voltar para o menu principal.

Passo 17

Agora precisamos instalar o driver bcm27xx-userland, para ter suporte a família de processadores da Broadcom BCM27xx. Selecione a opção de submenu:

Utilities --->

Encontre a opção:

bcm27xx-userland BCM27xx userland tool

Para conseguir selecionar esta opção, aperte a tecla de ESPAÇO por 2 vezes. Ela estará selecionada, quando aparecer um asterisco <*> dentro da opção.

Depois selecione novamente para voltar para o menu principal.

Passo 18

No menu principal, procure e selecione a opção:

LuCI --->

Dentro do menu de LuCI, encontre e ative as 2 opções abaixo:

luci          LuCI interface with Uhttpd as Webserver (default)
luci-ssl      LuCI with HTTPS support (WolfSSL as SSL backend)

Para conseguir selecionar estas opções, aperte a tecla de ESPAÇO por 2 vezes em cada uma. Ela estará selecionada, quando aparecer um asterisco <*> dentro de cada opção.

Com as setas do teclado caminhe até a opção EXIT para voltar para o menu principal.

Passo 19

Caso não vá instalar mais nenhum driver de sua preferência, selecione novamente EXIT para fechar o menuconfig.

Irá aparecer a opção de salvar as configurações selecionadas. Selecione a opção:

< YES >

Passo 20

Caso apareça algum erro ao fechar o menuconfig, tente identificar qual pacote ou software está com problema. No meu caso específico, apareceu erro no pacote apinger. Um erro incomum, pois não selecionei para instalar o mesmo.

Para resolver este erro, apenas apaguei o arquivo do mesmo:

rm openwrt/package/feeds/luci/luci-app-apinger

Provavelmente quando executar este tutorial o erro acima já estará corrigido no repositório, pois verifiquei a ISSUE aberta no github para solucionar o problema.

Passo 21 – Configurações Opcionais

Agora vamos apresentar algumas configurações opcionais:

Alterar banner de login

Caso queira realizar modificações cosméticas, basta alterar o arquivo:

nano package/base-files/files/etc/banner

Habilitar UART

O UART vem desabilitado por padrão, para habilitar, basta editar o arquivo:

nano target/linux/bcm27xx/image/config.txt

E inserir o texto, logo abaixo do campo “Place your custom settings here.”

enable_uart=1

Carregar arquivos de configuração sobre login, rede, firewall, dhcp, etc

Esta etapa NÃO É RECOMENDADA para uso geral. O ideal é deixar o openwrt gerar os arquivos e posteriormente realizar as modificações manualmente. Uma justificativa, é que o openwrt pode sofrer atualizações que alterem o layout destes arquivos, o que pode causar problemas na instalação. Mas para fins de automação da geração das imagens, com certeza é uma opção interessante.

Caso queira realizar esta etapa, é necessário criar a estrutura de diretórios:

mkdir files
mkdir files/etc
mkdir files/etc/config

Agora edite os arquivos de configuração e preencha com as configurações que possui. Uma dica para esta etapa é já ter o openwrt configurado em outro roteador e copiar e colar suas configurações. Em todo caso, os principais arquivos para editar são:

nano files/etc/config/dhcp
nano files/etc/config/firewall
nano files/etc/config/network
nano files/etc/config/wireless
nano files/etc/passwd
nano files/etc/shadow

Passo 22 – Compilar

Com todas as modificações desejadas já realizadas, vamos agora executar o comando make para iniciar a compilação do código fonte.

O comando make defconfig é útil pare verificar dependências faltantes. O comando make download irá realizar o download de todas as dependências antes de inicializar a compilação.

Lembrando que a opção -j (do comando make -j4) define o número de cores a serem utilizadas no processo. Como estou com 4 cores, utilizo -j4, para agilizar o processo. Utilize os comandos para iniciar o processo de compilação:

make defconfig
make download
make -j4

O processo é bem demorado, aguarde de forma paciente.

Caso tenha erros durante a compilação, é possível utilizar as opção V=s ou V=sc junto com o make -j4.

Passo 23 – Arquivos de imagem criados

Após o término do processo de compilação, é possível verificar os arquivos criados na pasta:

ls bin/targets/bcm27xx/bcm2711

Neste exemplo foram criados 4 arquivos, baseados no OpenWRT v22.03.4.

Downloads – Arquivos de firmware para download Openwrt Raspberry Pi 4

Download firmware baseado na versão OpenWRT v22.03.4

Versão configurada exatamente igual os passos do tutorial.

• openwrt-bcm27xx-bcm2711-rpi-4-ext4-factory.img.gz (full version with ext4)
• openwrt-bcm27xx-bcm2711-rpi-4-ext4-sysupgrade.img.gz (upgrade version for ext4)
• openwrt-bcm27xx-bcm2711-rpi-4-squashfs-factory.img.gz (full version with squashfs)
• openwrt-bcm27xx-bcm2711-rpi-4-squashfs-sysupgrade.img.gz (upgrade version for squashfs)

Download firmware baseado na versão OpenWRT v23.05.4

Nesta versão o diretório /var  é definido como persistente.

• openwrt-bcm27xx-bcm2711-rpi-4-ext4-factory.img.gz (full version with ext4)
• openwrt-bcm27xx-bcm2711-rpi-4-ext4-sysupgrade.img.gz (upgrade version for ext4)
• openwrt-bcm27xx-bcm2711-rpi-4-squashfs-factory.img.gz (full version with squashfs)
• openwrt-bcm27xx-bcm2711-rpi-4-squashfs-sysupgrade.img.gz (upgrade version for squashfs)

Lembrando que você deve escolher qual sistema de arquivos quer utilizar em seu raspberry. Utilizo o ext4 para caso geral, quando instalo outros pacotes no raspberry (servidor LAMP). Se o raspberry for dedicado para funcionar como um roteador, a partição squashfs é a opção recomendada, por preservar sistema de arquivos para o padrão de fábrica após reset/boot.

O post Tutorial criar imagem OpenWRT para roteador com Raspberry Pi apareceu primeiro em Vinicius Paes.

• Entender o que é o Programa Universidade para Todos (Prouni)
• Saber onde acessar e extrair os dados abertos do Prouni
• Aprender a realizar manipulação e limpeza de dados
• Passo a passo para extrair, manipular, limpar e unificar o dataset do Prouni disponibilizado pelo Ministério da Educação (MEC)

O que é o Prouni?

É um programa social criado pelo governo federal, através do Ministério da Educação (MEC). Criado efetivamente em 2004 e já com bolsas disponíveis para o ano seguinte.
O Prouni visa conceder bolsas de estudos complementares (25%), parciais (50%) e integrais (100%) em instituições de ensino superior particulares.

As bolsas complementares (25%) foram uma iniciativa presente em 2008, onde estudantes poderiam solicitar o FIES e complementar 25% do valor com o Prouni.

Existem diversos critérios para que o aluno possa solicitar o Prouni, estes que podem ser verificados diretamente no site oficial do programa.

Dataset (dados) disponíveis do Prouni

Os dados disponíveis do Prouni são os presentes no site de dados abertos do governo federal:

https://dadosabertos.mec.gov.br/prouni

No momento da escrita deste tutorial, somente os dados referentes aos anos de 2005 até 2020 estavam disponíveis.
Para fins de replicabilidade, segue os arquivos que encontramos no site dos dados abertos e o hash. Desta forma, é possível comparar se estamos utilizando versões diferentes do dataset, caso o leitor deste artigo tenha resultados diferentes do esperado.

arquivo	md5	sha1
pda-prouni-2005.csv	8ca2170765eca8944366c3b58c81eeaf	cb579982eba8ce9c303af4db4349c165df4e7284
pda-prouni-2006.csv	e2c7255913e4d06a3f2e3eea7689af6b	b39ae6d21ec796fe3db0f80581e0f77f8f4e0fe8
pda-prouni-2007.csv	8a9e9491228a9c3663d154e975b471df	343d94483bd49fc586506b8a5e4affabe54ebde8
pda-prouni-2008.csv	57d72a8be0fd81a947d73dcdac0c3778	9ef571d484aa6455e1588bbb5643cc964779fa2f
pda-prouni-2009.csv	b48443ae129fb1128f39db925822b02a	70a3dcd403bd1bbb0a52202b23baee7cce169967
pda-prouni-2010.csv	439c1e8437282599878b861b7d11ac43	0380949a5e408ac7e5ba8d073b49cbe9e746df81
pda-prouni-2011.csv	8ecaf8c2a602471122d2d60fb426cfbd	de26faf06149245412e1455c7492e6df7416d238
pda-prouni-2012.csv	093c02c6b44fb4f5d8750e9bccde54ae	cda0697d521777f63bc5d6b5260652609311f571
pda-prouni-2013.csv	2560c46e70ff393123a7bed6ab1a27c8	9b605bbf583f04ffe68fc7fde7e3ed09dc48c301
pda-prouni-2014.csv	bf7faaae1e11b7966dd8d18f5534c199	843bb60219a1b0a60d0e95b24b527d5019009f9f
pda-prouni-2015.csv	8fb5b3ab276c0a0f8533308a839dbb02	002c0bff3c831d29c7ccc69ffe4b65574a546244
pda-prouni-2016.csv	6ba774bb2e703e8417f2a13dfa4ce39d	b40b80e347753c1b649c4feaa5ce27e58adacc7a
pda-prouni-2017.csv	c9a1062ac6b1f6571f4d24750c1a5772	849beb6715a696fb7288b5e13f60d911a81600c7
pda-prouni-2018.csv	c4f385b284056af95f16073cc216d74b	c2d7c795a212142c7648e7781648c23a2f06cc88
pda-prouni-2019.csv	a4bee519238a59fc0eb513016d11ffef	bcefd063f2d76667ebf32986310bfe16b78f7286
pda-prouni-2020.csv	f81f0ec21dcc6d09dd37abdb13732e9a	50f1df4292820e760c1cb17f13211420bcd6b40a

Na lista acima, alteramos o nome dos arquivos para que ficassem no mesmo formato, facilitando a leitura dos arquivos no R. Também tive o cuidado de salvar estes datasets no google drive e disponibilizar para download neste link: Dataset Original dados abertos Prouni anos 2005 até 2020 separados por ano em formato csv

Pré-processamento dos dados

O código completo que vamos utilizar está organizado no fim desta publicação. Mas vamos caminhando e explicando cada etapa. Se só tiver interesse no código pronto, basta ir para o fim do artigo.

Vamos utilizar 2 bibliotecas para leitura e manipulação dos dados:

library(data.table) #para utilizar o fwrite e estrutura data.table
library(cli) #para utilizar hash

Neste passo a passo, vamos levar em conta que já realizou o download dos arquivos do site dos dados abertos. Ao criar um projeto ou script no R, é interessante que defina o seu “working directory” para o projeto, desta forma evita necessidade de referenciar o caminho completo para acessar os dados.

setwd("c:/prouni/")

Vamos criar agora um vetor com todos os anos do Prouni que queremos manipular (isso facilita caso queira acessar só alguns anos):

anos  = c(2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020)

Agora vamos criar uma variável para armazenar o nome dos arquivos que temos disponíveis e verificar o hash MD5 e SHA1:

md5 = sha1 = arquivo = NULL
for (x in anos[1]:anos[length(anos)]) {
  arquivo = append(arquivo, paste("pda-prouni-",x,".csv",sep=""))
  md5     = append(md5,     hash_md5(paste("pda-prouni-",x,".csv",sep="")))
  sha1    = append(sha1,    hash_sha1(paste("pda-prouni-",x,".csv",sep="")))
}
hash = data.frame(arquivo, md5, sha1)

Se digitarmos o nome da variável no console, vamos ter:

               arquivo                              md5                                     sha1
1  pda-prouni-2005.csv 8ca2170765eca8944366c3b58c81eeaf cb579982eba8ce9c303af4db4349c165df4e7284
2  pda-prouni-2006.csv e2c7255913e4d06a3f2e3eea7689af6b b39ae6d21ec796fe3db0f80581e0f77f8f4e0fe8
3  pda-prouni-2007.csv 8a9e9491228a9c3663d154e975b471df 343d94483bd49fc586506b8a5e4affabe54ebde8
4  pda-prouni-2008.csv 57d72a8be0fd81a947d73dcdac0c3778 9ef571d484aa6455e1588bbb5643cc964779fa2f
5  pda-prouni-2009.csv b48443ae129fb1128f39db925822b02a 70a3dcd403bd1bbb0a52202b23baee7cce169967
6  pda-prouni-2010.csv 439c1e8437282599878b861b7d11ac43 0380949a5e408ac7e5ba8d073b49cbe9e746df81
7  pda-prouni-2011.csv 8ecaf8c2a602471122d2d60fb426cfbd de26faf06149245412e1455c7492e6df7416d238
8  pda-prouni-2012.csv 093c02c6b44fb4f5d8750e9bccde54ae cda0697d521777f63bc5d6b5260652609311f571
9  pda-prouni-2013.csv 2560c46e70ff393123a7bed6ab1a27c8 9b605bbf583f04ffe68fc7fde7e3ed09dc48c301
10 pda-prouni-2014.csv bf7faaae1e11b7966dd8d18f5534c199 843bb60219a1b0a60d0e95b24b527d5019009f9f
11 pda-prouni-2015.csv 8fb5b3ab276c0a0f8533308a839dbb02 002c0bff3c831d29c7ccc69ffe4b65574a546244
12 pda-prouni-2016.csv 6ba774bb2e703e8417f2a13dfa4ce39d b40b80e347753c1b649c4feaa5ce27e58adacc7a
13 pda-prouni-2017.csv c9a1062ac6b1f6571f4d24750c1a5772 849beb6715a696fb7288b5e13f60d911a81600c7
14 pda-prouni-2018.csv c4f385b284056af95f16073cc216d74b c2d7c795a212142c7648e7781648c23a2f06cc88
15 pda-prouni-2019.csv a4bee519238a59fc0eb513016d11ffef bcefd063f2d76667ebf32986310bfe16b78f7286
16 pda-prouni-2020.csv f81f0ec21dcc6d09dd37abdb13732e9a 50f1df4292820e760c1cb17f13211420bcd6b40a

Desta forma você poderá confirmar se está utilizando um dataset na mesma versão deste tutorial ou uma versão atualizada pelo governo federal.

Precisamos também definir a normalização dos nomes de cada coluna do Dataset. Já adianto que os anos de 2005 até 2019 possuem 15 variáveis e no ano de 2020 foram adicionadas mais 2.
Vamos primeiramente definir como base os 15 nomes das colunas, criando o seguinte vetor:

nome_colunas = c("ANO_CONCESSAO_BOLSA","CODIGO_EMEC_IES_BOLSA","NOME_IES_BOLSA","TIPO_BOLSA","MODALIDADE_ENSINO_BOLSA","NOME_CURSO_BOLSA","NOME_TURNO_CURSO_BOLSA","CPF_BENEFICIARIO_BOLSA","SEXO_BENEFICIARIO_BOLSA","RACA_BENEFICIARIO_BOLSA","DATA_NASCIMENTO","BENEFICIARIO_DEFICIENTE_FISICO","REGIAO_BENEFICIARIO_BOLSA","SIGLA_UF_BENEFICIARIO_BOLSA","MUNICIPIO_BENEFICIARIO_BOLSA")

Leitura e processamento de arquivos do dataset do Prouni

Para a leitura do dataset, vamos utilizar a função read_delim. Existem diversas outras funções para esta tarefa, a mais rápida testada foi a fread() do pacote data.tables. Porém tive dificuldade para carregar o correto encoding dos arquivos, desta forma tinha problemas com acentuação.

Pelos testes que realizei os datasets do Prouni de 2005-2016 e o 2020 possuem codificação ISO-8859-1. Os datasets de 2017-2019 são UTF-8. A primeira vez que tive contato com estes datasets o ano de 2020 não era compatível com nenhuma codificação que tinha testado. Entrei em contato com o Fala.br e solicitei informação sobre qual codificação utilizar, posteriormente, com o arquivo atualizado, consegui acessar os arquivos com a codificação ISO-8859-1.

Fui informado pelo MEC que os datasets podem ser gerados por equipes distintas, à medida que há mudanças no governo. Isso explicaria a falta de padrão nos arquivos.

Para acessar os arquivos, utilizei então as 2 formas:

#(x < 2017 || x >= 2020)
temp = read_delim(paste("pda-prouni-",x,".csv",sep=""), delim = ";", na = c("", "NA"), escape_double = FALSE, trim_ws = TRUE, col_types = cols(), locale = locale(encoding = "ISO-8859-1"))

#(x > 2017 ||  x < 2020)
temp = read_delim(paste("pda-prouni-",x,".csv",sep=""), delim = ";", na = c("", "NA"), escape_double = FALSE, trim_ws = TRUE, col_types = cols(), locale = locale(encoding = "UTF-8"))

Tendo disponível a data de nascimento do aluno, seria interessante utilizar esse dado para criar posteriormente a faixa-etária dos alunos bolsistas. Pensando nessa possibilidade, já criei uma coluna “ANOS_VIDA”. Porém, tive que ajustar os datasets anteriores a 2017, pois o padrão da data vinha no formato dd-mm-AAAA e o restante do dataset no padrão dd/mm/AAAA.

  if ( x < 2017){
    temp$DATA_NASCIMENTO = as.Date(temp$DATA_NASCIMENTO,"%d-%m-%Y")
    temp$DATA_NASCIMENTO = format(temp$DATA_NASCIMENTO ,"%d/%m/%Y")
  }

Como mencionei o dataset de 2020 veio em outro padrão. Possui 2 colunas a mais “MUNICIPIO” e “CAMPUS”. Como já queria criar uma coluna de ANOS_VIDA, já aproveitei para realizar tudo de uma vez:

  if (x == 2020){
    temp[,"ANOS_VIDA"] = NA #adicionando coluna ANOS_VIDA
    temp = select(temp, 1:3,6:18,4,5) #ordenando colunas
    nome_colunas_2020 = append(nome_colunas, c("ANOS_VIDA","MUNICIPIO","CAMPUS"))
    colnames(temp) = nome_colunas_2020
    #Vamos criar a coluna MUNICIPIO e CAMPUS na variável dados, para poder executar o rbind na mesma proporção de número de colunas
    dados[,"MUNICIPIO"] = NA
    dados[,"CAMPUS"] = NA
  }
  else{
    #Normalizando o nome das colunas dos outros anos
    colnames(temp) = nome_colunas
  }

Com a coluna ANOS_VIDA criada e a variável de nascimento no mesmo padrão, podemos popular a coluna de ANOS_VIDA. Criamos também uma variável data_relativa_idade, pois precisamos calcular a idade do aluno no ano do Prouni. Assim vamos saber a idade do aluno contando com o aniversário que ele fará naquele ano, e não a idade no dia de inscrição do Prouni. Mas caso deseje alterar a data relativa, basta alterar esta variável. Repare que também altero idades inválidas para NA.

data_relativa_idade = as.Date(paste(x,"12","31", sep="/"))
temp$ANOS_VIDA = as.integer(as.numeric(difftime(data_relativa_idade, as.Date(temp$DATA_NASCIMENTO,"%d/%m/%Y"), units = "days"))/365)
temp$ANOS_VIDA[temp$ANOS_VIDA<0] <- NA

Com as mudanças acima, podemos concatenar com uma estrutura de repetição do tipo FOR, todos os datasets de todos os anos em um único data.table (ou data.frame) utilizando o rbind.
Então o código destacado acima ficaria dentro de uma estrutura:

for (x in anos[1]:anos[length(anos)]) {
…

dados = rbind(dados,temp)
}

Limpeza e organização do dataset do Prouni

O dataset não possui muitos dados faltantes, as maiores incoerências encontradas são na data de nascimento dos alunos. Desconfio que talvez na hora que o MEC exportou a data possa ter acontecido algum problema. Ou o aluno tenha inserido sua data de nascimento incorreta, sendo um problema no processo de coleta de dados.

Para eliminar as linhas faltantes, podemos utilizar o comando:

dados = dados[rowSums(is.na(dados)) != ncol(dados), ]

O comando acima só irá remover as linhas em que todos os campos forem ausentes. Verifiquei que algumas linhas em branco foram adicionadas durante o processo de junção dos datasets em um único arquivo. Mas o comando acima corrige este problema.

Outro processo importante é a organização dos dados, a fim de normalizar nomes distintos que correspondem à mesma informação. É interessante que as colunas abaixo sejam definidas com o tipo factor (fator) e níveis definidos:

• TIPO_BOLSA
• MODALIDADE_ENSINO_BOLSA
• NOME_TURNO_CURSO_BOLSA
• SEXO_BENEFICIARIO_BOLSA
• BENEFICIARIO_DEFICIENTE_FISICO
• REGIAO_BENEFICIARIO_BOLSA

Caso não tenha realizado essa mudança no momento que carregou o dataset, não tem problema, vamos realizar o processo abaixo. Repare que também já vamos modificar nomes distintos que definem a mesma informação:

#Normalizar variável TIPO_BOLSA
dados$TIPO_BOLSA = as.factor(dados$TIPO_BOLSA)
levels(dados$TIPO_BOLSA)[levels(dados$TIPO_BOLSA)=="BOLSA INTEGRAL"] <- "INTEGRAL"
levels(dados$TIPO_BOLSA)[levels(dados$TIPO_BOLSA)=="BOLSA PARCIAL 50%"] <- "PARCIAL"
levels(dados$TIPO_BOLSA)[levels(dados$TIPO_BOLSA)=="BOLSA COMPLEMENTAR 25%"] <- "COMPLEMENTAR" #ano de 2008

#Normalizar variável MODALIDADE_ENSINO_BOLSA
dados$MODALIDADE_ENSINO_BOLSA = as.factor(dados$MODALIDADE_ENSINO_BOLSA)
levels(dados$MODALIDADE_ENSINO_BOLSA)[levels(dados$MODALIDADE_ENSINO_BOLSA)=="EDUCAÇÃO A DIST NCIA"] <- "EAD"
levels(dados$MODALIDADE_ENSINO_BOLSA)[levels(dados$MODALIDADE_ENSINO_BOLSA)=="Presencial"] <- "PRESENCIAL"

#Normalizar variável NOME_TURNO_CURSO_BOLSA
dados$NOME_TURNO_CURSO_BOLSA = as.factor(dados$NOME_TURNO_CURSO_BOLSA)
levels(dados$NOME_TURNO_CURSO_BOLSA)[levels(dados$NOME_TURNO_CURSO_BOLSA)=="CURSO A DIST NCIA"] <- "EAD"
levels(dados$NOME_TURNO_CURSO_BOLSA)[levels(dados$NOME_TURNO_CURSO_BOLSA)=="Curso a distância"] <- "EAD"
levels(dados$NOME_TURNO_CURSO_BOLSA)[levels(dados$NOME_TURNO_CURSO_BOLSA)=="Integral"] <- "INTEGRAL"
levels(dados$NOME_TURNO_CURSO_BOLSA)[levels(dados$NOME_TURNO_CURSO_BOLSA)=="Matutino"] <- "MATUTINO"
levels(dados$NOME_TURNO_CURSO_BOLSA)[levels(dados$NOME_TURNO_CURSO_BOLSA)=="Noturno"] <- "NOTURNO"
levels(dados$NOME_TURNO_CURSO_BOLSA)[levels(dados$NOME_TURNO_CURSO_BOLSA)=="Vespertino"] <- "VESPERTINO"

#Normalizar variável SEXO_BENEFICIARIO_BOLSA
dados$SEXO_BENEFICIARIO_BOLSA = as.factor(dados$SEXO_BENEFICIARIO_BOLSA)
levels(dados$SEXO_BENEFICIARIO_BOLSA)[levels(dados$SEXO_BENEFICIARIO_BOLSA)=="Feminino"] <- "F"
levels(dados$SEXO_BENEFICIARIO_BOLSA)[levels(dados$SEXO_BENEFICIARIO_BOLSA)=="Masculino"] <- "M"

#Normalizar variável BENEFICIARIO_DEFICIENTE_FISICO
dados$BENEFICIARIO_DEFICIENTE_FISICO = as.factor(dados$BENEFICIARIO_DEFICIENTE_FISICO)
levels(dados$BENEFICIARIO_DEFICIENTE_FISICO)[levels(dados$BENEFICIARIO_DEFICIENTE_FISICO)=="SIM"] <- "S"
levels(dados$BENEFICIARIO_DEFICIENTE_FISICO)[levels(dados$BENEFICIARIO_DEFICIENTE_FISICO)=="NÃO"] <- "N"

#Normalizar variável REGIAO_BENEFICIARIO_BOLSA
dados$REGIAO_BENEFICIARIO_BOLSA = as.factor(dados$REGIAO_BENEFICIARIO_BOLSA)
levels(dados$REGIAO_BENEFICIARIO_BOLSA)[levels(dados$REGIAO_BENEFICIARIO_BOLSA)=="Centro-Oeste"] <- "CENTRO-OESTE"
levels(dados$REGIAO_BENEFICIARIO_BOLSA)[levels(dados$REGIAO_BENEFICIARIO_BOLSA)=="Nordeste"] <- "NORDESTE"
levels(dados$REGIAO_BENEFICIARIO_BOLSA)[levels(dados$REGIAO_BENEFICIARIO_BOLSA)=="Norte"] <- "NORTE"
levels(dados$REGIAO_BENEFICIARIO_BOLSA)[levels(dados$REGIAO_BENEFICIARIO_BOLSA)=="Sudeste"] <- "SUDESTE"
levels(dados$REGIAO_BENEFICIARIO_BOLSA)[levels(dados$REGIAO_BENEFICIARIO_BOLSA)=="Sul"] <- "SUL"

Com os comandos acima a base de dados já estará unificada e organizada. É interessante então gerar um novo arquivo unificado, vamos chamar de pda-prouni-2005-2020.csv. Vamos criar um hash deste novo arquivo e juntar com o hash dos arquivos de dataset de origem e também salvar em disco com o nome hash-datasets.txt. Este passo é importante para fins de reprodutibilidade posteriormente.

#Salvar o arquivo gerado em disco
dataset_saida = "pda-prouni-2005-2020.csv"
fwrite(dados, dataset_saida)

#Criar o hash para o arquivo de dataset unificado que acabamos de criar
hash = rbind(hash, data.frame(arquivo=dataset_saida, md5=hash_md5(dataset_saida), sha1=hash_sha1(dataset_saida)))
fwrite(hash, "hash-datasets.txt", sep = " \t ")

Com o passo acima temos uma base uniforme do Prouni referente aos anos de 2005-2020, facilitando o processo de análise e ciência de dados. O código também está disponível abaixo, de forma organizada:

Ao executar o código acima, gerei um dataset unificado. Deixo ele disponível para download neste link: Dataset completo Prouni 2005 até 2020 – Portal dados Abertos

Gostou do conteúdo? Tem alguma sugestão para melhorar o código acima? Quer mais funcionalidades presentes? Deixa sua mensagem aí nos comentários, que farei o possível para responder!

O post Data Science – Tutorial Extração, Limpeza e Unificação dos Dados Abertos do Prouni com R apareceu primeiro em Vinicius Paes.

• Entender o que é o PHP-FPM
• Quais casos é interessante configurar uma pool distinta para cada site ou conjunto de sites
• As necessidades para seguir este tutorial
• Passo a passo para criar uma pool independente para cada site com o PHP-FPM

O que é o PHP-FPM

A sigla FPM do PHP-FPM vem do inglês “FastCGI Process Manager” sendo uma alternativa ao Apache 2.0 handler mod_php e SUPHP baseados no método CGI tradicional.

Uma característica do PHP-FPM é que sua implementação possui um desempenho superior e a possibilidade de parametrização com propósito de otimizar o uso de recursos disponíveis no servidor.

O PHP-FPM já vem como padrão no Servidor Http Nginx, mas se estiver utilizando o Servidor HTTP Apache, é necessário instalar e configurar o mesmo.

Quais casos é interessante configurar uma pool distinta para cada site ou conjunto de sites

• CASE 1:
  Servidor de páginas precisa ser dividido para 2 empresas. É necessário que o usuário e grupo de execução do PHP seja diferente para cada conjunto de websites. Ou seja, cada empresa precisa ter sua própria pool do php-fpm configurada desta forma.
• CASE 2:
  Servidor dividido para 2 empresas novamente, mas agora cada empresa deseja utilizar uma versão diferente do PHP para seus websites. Novamente, basta instalar a versão do php-fpm que cada empresa deseja utilizar e configurar uma pool definindo qual versão do php cada empresa vai utilizar.
• CASE 3:
  Servidor dividido para 2 ou mais empresas, mas cada empresa tem preferência distinta para uso dos recursos do servidor na execução de arquivo php. Necessário então configurar pools diferentes para cada conjunto de websites, para que cada empresa tenha os recursos acordados.
• CASE 4:
  Servidor dividido para um grupo de 10 amigos, mas cada um gerencia seu próprio website no servidor. Desta forma, para garantir uma melhor gestão de permissão de arquivos, é necessário criar uma pool para cada pessoa/website e configurar o usuário de cada um para ser o responsável de executar o php no seu website.

Os requisitos para seguir este tutorial

Este tutorial leva em conta que já possui o PHP-FPM instalado no seu servidor. Caso ainda não tenha, basta verificar este tutorial e verificar os passos da instalação: Tutorial instalar e configurar servidor web (HTTP) com PHP-FPM
Caso esteja utilizando o servidor Nginx, você já possui o PHP-FPM instalado.

Passo a passo para criar uma pool independente para cada site com o PHP-FPM

Passo 1

Primeiro passo é verificar qual versão do PHP-FPM possui instalado, ou quais versões, pois pode ter mais de uma instalada.

grep "php-fpm: master process"

Aqui no meu exemplo tenho a saída:

root       74015  0.0  1.4 242116 14332 ?        Ss   Mar21   0:12 php-fpm: master process (/etc/php/8.1/fpm/php-fpm.conf)

Verificando a saída acima, vemos que o php-fpm que temos em funcionamento é o da versão 8.1.

Então, as Pool’s da versão instalada do PHP-FPM são configuradas na pasta:

etc/php/8.1/fpm/pool.d/

Passo 2

Agora vamos pensar no seguinte setup de utilização do servidor:

Temos 2 usuários que são webmasters e precisam mexer em websites distintos. Vamos supor então que eles possuem o nome de usuário de login:

• webmaster1
• webmaster2

Eles podem ser responsáveis por um conjunto de websites distintos. Mas neste exemplo, vamos supor de forma resumida, que cada um possui acesso a 1 website distinto apenas, então estes websites são:

• website1
• website2

Passo 3

Precisamos então criar uma pool para cada usuário, e esta pool eles vão utilizar no conjunto de websites que tiverem acesso. Neste exemplo porém, cada 1 terá apenas acesso a 1 website.

Então vamos utilizar a pool padrão como modelo e fazer uma cópia alterando o nome:

sudo cp /etc/php/8.1/fpm/pool.d/www.conf /etc/php/8.1/fpm/pool.d/webmaster1.conf
sudo cp /etc/php/8.1/fpm/pool.d/www.conf /etc/php/8.1/fpm/pool.d/webmaster2.conf

Passo 4

Agora vamos alterar a pool do webmaster1.

sudo nano /etc/php/8.1/fpm/pool.d/webmaster1.conf

Encontre a linha que define o nome da pool “[www]” e altere para:

[webmaster1]

Encontre a linha “user = www-data” e altere para:

user = webmaster1

Encontre a linha:

listen = /run/php/php8.1-fpm.sock

Altere para:

listen = /run/php/php8.1-fpm-webmaster1.sock

Passo 5

Agora vamos alterar a pool do webmaster2.

sudo nano /etc/php/8.1/fpm/pool.d/webmaster2.conf

Encontre a linha que define o nome da pool “[www]” e altere para:

[webmaster2]

Encontre a linha “user = www-data” e altere para:

user = webmaster2

Encontre a linha:

listen = /run/php/php8.1-fpm.sock

Altere para:

listen = /run/php/php8.1-fpm-webmaster2.sock

Passo 6

Agora em cada arquivo de configuração de um domínio, precisamos informar qual pool deverá ser utilizado para execução do php-fpm.

Costumo ter 3 arquivos de configuração por domínio, um para acesso http, um para acesso ssl, e outro para acesso ssl com subdomínio www. Se no seu setup utiliza de outra forma, não tem problema.

Configuração do Website1

Mas para fim de exemplo, para o website1, vou editar estes 3 arquivos (exemplo utilizando servidor apache):

sudo nano /etc/apache2/sites-available/website1.com.br.http.conf
sudo nano /etc/apache2/sites-available/website1.com.br.ssl.conf
sudo nano /etc/apache2/sites-available/website1.com.br.ssl.www.conf

Dentro da diretiva de virtualhost, é necessário inserir o seguinte texto:

 <FilesMatch \.php$>
  SetHandler "proxy:unix:/run/php/php8.1-fpm-website1.sock|fcgi://localhost"
 </FilesMatch>

Segue o exemplo abaixo de como ficaria dentro do arquivo de configuração:

Configuração do Website2

Da mesma forma, para o website2, temos os arquivos:

sudo nano /etc/apache2/sites-available/website2.com.br.http.conf
sudo nano /etc/apache2/sites-available/website2.com.br.ssl.conf
sudo nano /etc/apache2/sites-available/website2.com.br.ssl.www.conf

E precisamos inserir dentro da diretiva de virtualhost o texto:

 <FilesMatch \.php$>
  SetHandler "proxy:unix:/run/php/php8.1-fpm-website2.sock|fcgi://localhost"
 </FilesMatch>

As mesmas modificações precisam ser realizadas, como já destacamos os exemplos do website1, não vamos repetir aqui, mas é o mesmo processo.

Passo 7

Um passo opcional é desligar a pool padrão “[www]”. Eu particularmente deixo a mesma ligada, para utilização quando acesso algum site do servidor pelo IP. Mas, caso não seja seu caso, é possível desligar a pool padrão mudando seu nome:

sudo mv /etc/php/8.1/fpm/pool.d/www.conf /etc/php/8.1/fpm/pool.d/www.conf-desligada

Passo 8

Agora, para que as modificações que realizamos tenham efeito, é preciso reiniciar tanto o servidor apache, quanto o PHP-FPM.

Ao reiniciar o PHP-FPM, ele vai verificar os novos arquivos de configuração das pool’s dentro do diretório e irá criar as mesmas, assim como os arquivos .sock. Tenho preferência em reiniciar o PHP-FPM primeiro e em seguida o servidor apache (executar os comandos abaixo um de cada vez).

sudo service php8.1-fpm restart
sudo service apache2 restart

Considerações Finais

O processo de setup das pools é bem simples. Lembrando que para ter um desempenho otimizado, é possível ainda realizar algumas modificações nos arquivos de configuração, visando as necessidades da sua aplicação php. É possível configurar mais workers, etc.

Tem alguma dúvida ou sugestão? Escreve aí nos comentários!

O post Tutorial configurar pool PHP-FPM distinta para cada website apareceu primeiro em Vinicius Paes.

• Entender o que é um servidor
• Saber as atribuições de um servidor de email
• As necessidades para criar um servidor de email
• Passo a passo para criar um servidor de email completo no Ubuntu

O que é um servidor

Dentro do contexto de computação, rede, internet e serviços, um servidor possui duas características principais:
Do ponto de vista de hardware (equipamento necessário), um servidor é um computador, e possui a maioria das características que um computador possui: placa mãe, processador, memória ram, dispositivo de armazenamento, etc.
Na visão de software, um servidor pode ser definido como um conjunto de programas de computador que visam prestar um serviço.

Quais as atribuições de um servidor de email?

Como vimos a definição generalista para o conceito de servidor, agora podemos especificar de uma forma mais sucinta o que é um servidor de emails.
Uma explicação bastante simplificada define um servidor de emails como um computador configurado com softwares que visam realizar tarefas relacionadas ao envio e recebimento de emails.
Este servidor pode ser configurado em uma rede local, sem acesso a internet, provendo envio e recebimento de emails de forma restrita dentro de uma empresa, por exemplo. Ou pode ser configurado com acesso a internet, provendo serviço de envio e recebimento de email de forma ampla, para domínios externos.

Quais as necessidades para criar um servidor de emails

O primeiro passo é ter um computador disponível.

Caso pense em um projeto didático, pode criar um servidor localmente em sua casa. Se sua empresa de fornecimento de internet disponibilizar um IP real, é possível abrir as portas necessárias no seu roteador, para dar acesso a envio e recebimento de emails na internet para o seu servidor, a única ressalva é que geralmente não poderá configurar facilmente uma entrada DNS do tipo PTR, mas não é um problema tão grande inicialmente.

Lembrando que é necessário ter um sistema operacional instalado. Você pode realizar esta etapa manualmente ou utilizar uma imagem pronta do sistema operacional para seu setup. Por exemplo, se optar por um Raspberry Pi, pode utilizar uma imagem pronta do Ubuntu Server, poupando a etapa de instalação do sistema operacional.

Caso opte por utilizar uma máquina virtual, também existem imagens do Sistema Operacional já prontas.

Agora, se tiver um computador antigo em casa e precise instalar o sistema operacional, basta seguir os passos do Tutorial setup Servidor Linux Ubuntu Local, lembre de começar a partir do passo 9 (e você precisa de um pen drive com a imagem de um SO para dar boot no instalador).

Uma opção mais funcional é alugar um servidor do tipo VPS (Virtual Private Server), ele funciona como um computador já ligado na internet, com IP real configurado e geralmente é possível configurar a entrada DNS do tipo PTR sem problemas. Este servidor já vem com sistema operacional instalado, poupando esta etapa de configuração.

Uma visão ampla do processo envolve várias etapas, mas podemos citar:

• • Escolha de um domínio/subdomínio para o servidor
  • Setup de Hardware
    • Escolha do equipamento: computador pessoal ou raspberry pi, ou um VPS, etc.
  • Setup de Software
    • Instalação do Sistema Operacional
    • Configuração DNS
    • Configuração do domínio/subdomínio no servidor
    • Instalação servidor http (Apache ou Nginx) – para dar suporte administrativo (PostfixAdmin) e cliente web para acesso aos emails (Roundcube)
    • Instalação de banco de dados (MySQL/MariaDB ou Postgresql) – para gerenciar armazenamento de emails
    • Instalação de certificados SSL (TLS) para o domínio e subdomínio
    • Instalação do Postfix para gerenciar processo de envio e recebimento de emails
    • Instalação e configuração PostfixAdmin (acesso web para criar novas caixas de email)
    • Verificar portas abertas no servidor (firewall) e abrir portas, caso necessário
    • Instalação do OpenDKIM
    • Configurar suporte SPF, DKIM e DMARC no DNS do domínio do servidor de email
    • Integrar DKIM e DMARC no Postfix
    • Instalação e configuração Dovecot para suporte de conexão IMAP para clientes de email
    • Mudar o escopo de armazenamento de emails do tipo sistema de arquivos para banco de dados
    • Mudar o escopo de caixas de email vinculadas aos usuários do linux, para caixas de email virtuais (gerenciadas pelos usuários cadastrados no banco de dados pelo postfixadmin – virtual mail box)
    • Instalação e configuração Roundcube (acesso web para ler e enviar emails)
    • Suporte para configuração de vários domínios no servidor de email: neste setup, configuramos que o servidor só pode enviar email e criar caixas para o dominio1.com.br, por exemplo; Com esta etapa, permite configurar domínios adicionais: dominio2.com.br, dominio3.com.br, onomededominioqueeuquiser.com.br, etc.

Passo a para criar servidor de email completo no Ubuntu

Vamos começar partindo do princípio que você já tem um computador com sistema operacional instalado, ou um VPS.
Neste exemplo, vou criar o servidor baseado no domínio viniciuspaes.com. Lembre-se de alterar este domínio, para seu domínio escolhido. Lembre-se que você precisa ser o dono do domínio escolhido, ou seja, tenha realizado o processo de registro do domínio que deseja utilizar. Caso tenha dúvida em como fazer, acesse o Tutorial de como registrar domínio na internet. Lembrando que domínio com final .br só pode ser registrado pelo site do Registro.br.

Passo 1

Conecte no seu servidor por SSH, exemplo:

ssh usuario@ip

Ou caso utilize uma chave:

ssh -i chave.pem usuario@IP

Passo 2

Verificar o hostname do servidor, digite:

hostname

O ideal é termos o hostname configurado corretamente. Por exemplo, caso meu domínio escolhido seja o viniciuspaes.com, quero configurar o meu servidor de email em um subdomínio chamado mail.viniciuspaes.com. O ideal é ter então o hostname configurado para mail.viniciuspaes.com.
Podemos editar o arquivo:

sudo nano /etc/hostname

E alterar seu conteúdo para:

mail.viniciuspaes.com

Outra opção é utilizando o comando:

sudo hostnamectl set-hostname mail.viniciuspaes.com

É comum o hostname não ficar persistente após reiniciar o servidor, para garantir que não ocorra, esta etapa opcional pode resolver o problema:
Edite o arquivo:

sudo nano /etc/cloud/cloud.cfg

Procure a linha que começa com:

preserve_hostname

Precisamos que ela fique ativada, se ela tiver com a opção “false”, então altere a linha toda para:

preserve_hostname: true

Agora faça um teste, reinicie o servidor:

sudo reboot now

Agora conecte novamente por SSH no servidor após ele terminar o boot (pode demorar alguns minutos).
Verifique novamente o hostname, para verificar se ficou persistente:

hostname

Passo 3

Agora é necessário realizar algumas alterações nas entradas DNS do seu domínio. O que eu faço para facilitar o processo, é redirecionar meus domínios do Registro.BR para a DigitalOcean gerenciar o DNS. Pois a considero o serviço de gerenciar o DNS do Registro.BR um pouco lento. Então, se utilizar um domínio com final .BR é uma opção a ser considerada. É possível utilizar também outra empresa para gerenciar o DNS, como o Route66 da Amazon AWS.
Neste exemplo utilizo um domínio .com, registrado no Google Domains; local também onde gerencio o DNS. A interface do Google Domains é satisfatória, então não vou redirecionar meu DNS do Google Domains para outra empresa gerenciar.

Neste passo, precisamos inserir entradas DNS. Primeiramente precisamos informar qual servidor irá gerenciar os emails para o domínio. Isto é feito pela entrada do tipo MX.
Então vou criar uma entrada MX com as informações:

Nome do host: viniciuspaes.com
Tipo: MX
TTL: 3600
Prioridade: 0
Dados: mail.viniciuspaes.com

No exemplo acima, algumas empresas optam por separar o campo de prioridade do servidor de email, no caso do Google Domains, ele aparece no campo Dados, separando a prioridade com um espaço do nome do subdomínio.

Com a criação desta entrada DNS quando alguém enviar um email para qualquercaixa@viniciuspaes.com, ele vai entender que o servidor de email está configurado no subdomínio mail.viniciuspaes.com, pois foi o que configuramos no exemplo acima.

Mas agora precisamos informar em qual IP o servidor de email está configurado. Então, para esta etapa, precisamos criar uma entrada do tipo A, que direciona um nome de domínio (ou subdomínio) para um IP, ou seja, o mail.viniciuspaes.com vai para qual IP?
Então, vamos criar uma entrada DNS do tipo A:

Nome do host: mail.viniciuspaes.com
Tipo: A
TTL: 1800
Dados: (digite o endereço IP do seu servidor)

Passo 4

Vamos instalar agora o principal software do servidor de emails. Este que gerencia o processo de envio e recebimento de emails. Digite o comando abaixo para instalar o Postfix:

sudo apt install postfix

No processo de instalação quando perguntarem “General type of mail configuration”, selecione:

Internet Site

Quando perguntarem “System mail name”, selecione o seu domínio principal, não insira o subdomínio:

viniciuspaes.com

Agora é interessante verificar se a porta 25 (smtp) responsável por enviar emails está aberta e funcional, acesse o site do link abaixo e insira seu IP e a porta 25 e clique para realizar o teste:

https://www.yougetsignal.com/tools/open-ports/

Caso a porta esteja fechada, teste se o seu IP do servidor realmente está correto. Se utilizar o endereço do subdomínio (mail.viniciuspaes.com) tenha certeza que o endereço está com o DNS correto direcionando para o IP do servidor. Caso esteja tudo certo, tente abrir a porta 25 no firewall do Ubuntu (caso o firewall realmente esteja instalado):

sudo ufw allow 25/tcp

Caso ainda tenha algum erro, é possível verificar quais portas o Postfix está escutando, digite o comando:

sudo ss -lnpt | grep master

No comando acima, é possível verificar algo parecido como:

LISTEN 0      100          0.0.0.0:25        0.0.0.0:*    users:(("master",pid=1610,fd=13))

O resultado acima mostra que o processo mestre do Postfix está utilizando a porta 25 (0.0.0.0:25)

Uma outra forma de testar, é se conectar ao servidor de email do google por telnet. Vamos instalar telnet com o comando:

sudo apt install telnet

Agora vamos tentar realizar uma conexão, utilizando o comando:

telnet gmail-smtp-in.l.google.com 25

Caso consiga realizar a conexão nas etapas acima, tudo certo!
Caso negativo, será necessário entrar em contato com a empresa onde contratou o VPS e pedir para abrirem as portas de envio e recebimento de emails para você. Caso seu servidor seja local, em sua residência, será necessário abrir as portas de envio e recebimento de email, e realizar um port foward para o IP local do seu servidor.

Passo 5

Tecnicamente já temos o servidor de email pronto para enviar email. Porém não possui autenticação TLS e nem entradas DNS para proteção contra spoof, spam e outros. Mas já podemos realizar um teste, enviando email pela linha de comando. Já adianto que o email será recusado, pois ainda não temos SPF, DKIM e DMARC configurados, mas vamos lá:

echo "teste envio de email por linha de comando" | sendmail seuemail@gmail.com

No comando acima, lembre-se de trocar seuemail@gmail.com por uma caixa de email que você tenha acesso.

Agora é interessante olhar o log de email, para ver se o email foi enviado, ou se aconteceu algum problema:

cat /var/log/mail.log

Fiz um teste de envio para uma conta que tenho no gmail.com e outra no icloud.com, em ambos os casos o email foi recusado. Segue um exemplo de erro que pode aparecer:

GMAIL:
<seuemail@gmail.com>: host gmail-smtp-in.l.google.com[142.250.0.26] said: 550-5.7.1 [100.100.100.100] 
The IP you're using to send mail is not authorized to 550-5.7.1 send email directly to our servers. 
Please use the SMTP relay at your 550-5.7.1 service provider instead. Learn more at 550 5.7.1  
https://support.google.com/mail/?p=NotAuthorizedError .157 - gsmtp (in reply to end of DATA command)


ICLOUD:
<seuemail@icloud.com>: host mx02.mail.icloud.com[17.57.156.30] said: 550 5.7.1 Mail from IP 100.100.100.100 
was rejected due to listing in Spamhaus PBL. For details please see http://www.spamhaus.org/query/bl?ip=100.100.100.100 (in reply to RCPT TO command)

Na sua conta de email externa (gmail, icloud, outlook, etc) tente enviar um email para você. Por exemplo, se o seu login no Ubuntu é ubuntu e o seu domínio é viniciuspaes.com, automaticamente sua conta de usuário do Linux também é uma caixa de email. Ou seja, tente enviar um email para ubuntu@viniciuspaes.com.

As caixas de email baseadas em usuário do linux ficam armazenadas no diretório /var/mail.
Para olhar as caixas já criadas, utilize o comando:

ls /var/mail

Neste exemplo temos o usuário ubuntu criado. Podemos editar o arquivo para ver o email:

sudo nano /var/mail/viniciuspaes

Ou apenas mostrar seu conteudo:

sudo cat /var/mail/viniciuspaes

Caso o email tenha chego corretamente, o arquivo irá contar com bastante texto, boa parte sendo o header (cabeçalho) do email. Estas informações de cabeçalho normalmente são ocultas quando olhamos o email em um cliente com interface gráfica.

Um upgrade para visualizar o email em linha de comando é instalar o pacote mailutils:

sudo apt install mailutils

Faça outro teste e envie um novo email para seu usuário do servidor, utilizando uma caixa de email externa (por exemplo, vá no seu gmail e mande um email para ubuntu@viniciuspaes.com, não esqueça de trocar viniciuspaes.com pelo nome do seu domínio e ubuntu pelo seu nome de usuário de login).

Com o mailutils instalado, você pode checar a caixa de email com o comando:

mail

Se tudo correr bem, você vai entrar no aplicativo em linha de comando chamado mail. Se tiver emails em sua caixa de entrada, cada email vai ter um ID numérico: 1, 2, 3 …, n.
Para ler o email, basta digitar o ID do mesmo para abrí-lo.

O email será apresentado por pedaços, pois geralmente seu cabeçalho é muito grande. Tecle ENTER ou seta para baixo para ir mostrando o email aos poucos. Ao terminar de ler, aperte a tecla “x” para fechar.

Não precisa se preocupar muito em aprender a utilizar o programa mail (linha de comando) futuramente vamos instalar interface gráfica com roundcube. Estes passos são somente para testes iniciais no servidor. Mas em todo caso, segue um resumo das principais funções (teclas de execução/atalho) do software:

• h – acessar o header de um email
• z – ir para o fim do email
• n – ir para o próximo email
• r – responder um email que está lendo
• r 1 – (dentro do menu inicial) responder o email com ID = 1
• d 1 – (dentro do menu inicial) excluir o email com ID = 1
• d 1 3 4 6 – (dentro do menu inicial) excluir os emails com ID’s = 1 3 4 6
• d 1-15 – (dentro do menu inicial) excluir os emails com ID’s = 1-15
• q – sair e arquivar o email lido na pasta /home/usuario/mbox
• x – sair sem arquivar emails lidos

Se quiser saber mais sobre o mailutils, pode acessar a man page ou a url:

https://mailutils.org/manual/mailutils.html

Caso tenha lido emails e saído do programa utilizando a tecla “q”, os emails lidos serão arquivados na pasta pessoal do usuário. Então, o usuário com nome ubuntu, terá seus emails arquivados na pasta “/home/ubuntu/mbox”.

Caso queira acessar estes emails arquivados, basta acessar o arquivo:

sudo nano /home/ubuntu/mbox

Resumindo, os emails que chegam ficam disponíveis na pasta “/var/mail/usuario/”, e os emails que foram lidos e arquivados são movidos para a pasta “/home/usuario/mbox”. Levando em conta que a pasta padrão dos usuários fique dentro de /home.

Passo 6 – Configurações iniciais no Postfix

Agora é importante realizar algumas configurações iniciais no Postfix.

Vamos verificar qual o tamanho definido para cada caixa de email do usuário, de forma geral:

postconf | grep mailbox_size_limit

No comando acima, utilizamos o postconf para verificar no arquivo de configuração do postfix (/etc/postfix/main.cf) o valor da variável mailbox_size_limit. Lembrando que a saída será em bytes. Caso retorne o valor “0” (zero) quer dizer que a caixa de email não possui nenhum limite de tamanho, o que é perigoso, pois se receber um bombardeio de spam nesta fase inicial de configuração, pode encher todo o dispositivo de armazenamento (HD/SSD/SD, etc) e ter problema no boot do sistema operacional.

Vamos definir então um tamanho máximo de 250MB para cada caixa de email criada:

sudo postconf -e mailbox_size_limit=256000000

Lembrando que 1024 bytes = 1KB, logo, 256000000/1024 = 250MB

Agora vamos verificar qual o tamanho máximo que uma mensagem pode ter, contando com anexo. Costumo utilizar o limite adotado pelo gmail, que é de 25MB, sendo também 10% do tamanho total da caixa. Mas fique livre para escolher os valores que funcionam melhor para o seu setup. Utilizando o comando abaixo vamos verificar como está configurado:

postconf | grep message_size_limit

Geralmente o Postfix vem com o tamanho padrão de 10240000. Que é equivalente a 10.240.000 Bytes = 10240 Kbytes = 1024 * 10 Kbytes = 1 * 10 MB = 10MB.
Caso queira aumentar o limite para 25MB, utilize o comando:

sudo postconf -e message_size_limit=25600000

Outro ponto importante é verificar se o hostname do servidor está corretamente configurado no Postfix. Como comentamos em um passo anterior, ter o hostname corretamente configurado no servidor é uma etapa importante. Uma alternativa, é definir o hostname manualmente no postfix também. Vamos então editar manualmente o arquivo de configuração para verificar como o mesmo está configurado:

sudo nano /etc/postfix/main.cf

Na linha que começa com a variável “myhostname”, certifique-se de alterar para que apareça somente o subdomínio escolhido pro servidor de email, no meu caso ficaria como:

myhostname = mail.viniciuspaes.com

É importante também verificar se o seu servidor tem suporte tanto para IPv4, quanto para IPv6. O Postfix possui suporte para ambos os casos, mas caso só tenha suporte para IPv4, ou tenha o desejo de utilizar somente o IPv4 com o Postfix, é possível alterar com o comando:

sudo postconf -e "inet_protocols = ipv4"

Para que todas as mudanças realizadas no arquivo de configuração do postfix tenham efeito, basta reiniciar o serviço:

sudo service postfix restart

Passo 7 – Lembrete ao realizar upgrade no sistema com apt

Esta etapa é apenas para lembrar que caso faça o upgrade do Postfix pelo apt (sudo apt upgrade) e no momento do upgrade apareça a opção de reconfigurar o Postfix, recuse (no configuration). Caso realize novamente a configuração, será necessário realizar o passo anterior novamente, pois a modificações que acabamos de realizar podem ser reescritas pelo arquivo padrão de configuração do postfix.

Passo 8 – Como configurar Alias por linha de comando

Posteriormente neste tutorial vamos instalar o PostfixAdmin, configurar maildir, dovecot e virtual mail boxes (vmail). O processo de configurar o Alias que será mostrado neste passo não ficará funcional e sim o Alias criado pelo PostfixAdmin. Então se pretende seguir este tutorial até o fim, não se preocupe tanto com esta etapa. Esta etapa é mais didática, para mostrar como seria a configuração.

Como dito acima, nesta etapa inicial de configuração do servidor em modo de linha de comando, é possível também criar redirecionamento de caixas de email. Ou seja, se receber um email em webmaster@viniciuspaes.com, você pode redirecionar para a caixa de um outro usuário, como exemplo, para ubuntu@viniciuspaes.com. Este redirecionamento é conhecido como Alias, ou seja, um pseudônimo.
Uma característica de um Alias, é que a caixa “webmaster@viniciuspaes.com” não existe, os emails que forem enviados para ela serão direcionados para “ubuntu@viniciuspaes.com”. Em contrapartida, em um redirecionamento de caixas, as 2 caixas iriam existir, e o email enviado para a primeira seria replicado para a outra, mas estaria presente nas 2 caixas.
Então vamos lá, para criar um alias, edite o arquivo:

sudo nano /etc/aliases

A lógica dentro do arquivo de alias é a seguinte: “origem: destino”
Então como só temos 1 domínio configurado no servidor, podemos realizar o exemplo citado acima como:

webmaster: ubuntu

Que seria o mesmo que:

webmaster@viniciuspaes.com: ubuntu@viniciuspaes.com

Agora é uma boa hora para criar os Alias que desejar, algumas sugestões:

postmaster: ubuntu@viniciuspaes.com
hostmaster: ubuntu@viniciuspaes.com
webmaster: ubuntu@viniciuspaes.com
dmarc: ubuntu@viniciuspaes.com

Importante! Toda vez que editar o arquivo de alias (/etc/aliases) é necessário recriar o banco de dados de redirecionamentos do sistema. Utilize o comando:

sudo newaliases

Passo 9 – Configurando SPF

Como mostramos em um dos passos anteriores, os emails que estamos enviando pelo servidor estão sendo recusados. A maioria das grandes empresas de servidor de email costumam recusar as mensagens que não contenham o mínimo de segurança e autenticidade do remetente. Para suprir esta necessidade, neste passo vamos ensinar como configurar o SPF (Sender Policy Framework).
O SPF é configurado primeiramente pelo DNS, sendo um registro do tipo TXT. Uma tradução para seu acrônimo seria “Estrutura da Política do Remetente”.
O SPF pode ser utilizado para definir quais servidores são autorizados para enviar emails do domínio. Uma finalidade conhecida do SPF é a proteção dos seus emails contra técnicas em que um servidor malicioso tenta se passar pelo seu servidor (técnica conhecida como spoofing) enviando emails de SPAM e muitas vezes realizando Phishing.

Então faça login na empresa que utiliza para gerenciar as entradas DNS do seu servidor. Precisamos então criar uma nova entrada DNS.

A configuração da entrada DNS  deve ser:

Nome do host: @ (dependendo da sua empresa de registro, deixe em branco ou insira seu nome de domínio)
Tipo: TXT
TTL: 3600
Dados: v=spf1 mx ~all

Da configuração acima, estamos definindo o SPF como:

• v=spf1: indica a versão, no caso, versão spf1
• mx: indica que apenas os servidores destacados na entrada mx estão autorizados a enviar email deste domínio
• ~all: emails oriundos deste domínio só devem ter como origem os servidores definidos pelo SPF

A propagação do DNS pode demorar alguns minutos ou até muitas horas. Mas no meu caso, quando faço alterações no Google Domains, as mudanças são quase que instantâneas. Em todo caso, utilize o comando abaixo para verificar se a entrada TXT criada já está funcional (já foi propagada):

dig viniciuspaes.com txt

Terá uma resposta parecida com os dados abaixo:

;; ANSWER SECTION:
viniciuspaes.com.       3563    IN      TXT     "v=spf1 mx ~all"

Agora precisamos instalar e configurar o agente de políticas SPF que irá trabalhar juntamente com o Postfix. Instale com o comando:

sudo apt install postfix-policyd-spf-python

Agora precisamos configurar o agente de políticas SPF. Primeiramente, vamos configurar para que o mesmo seja iniciado junto com o postfix. Então, vamos editar o arquivo:

sudo nano /etc/postfix/master.cf

Agora vá até o fim do arquivo e insira o texto abaixo:

policyd-spf  unix  -       n       n       -       0       spawn 
  user=policyd-spf argv=/usr/bin/policyd-spf

No texto acima, fique atento que a segunda linha tem 2 caracteres de espaço. Ela fica assim para frente da primeira linha. Isso indica que a linha abaixo é uma continuação do comando.

Agora vamos editar outro arquivo de configuração:

sudo nano /etc/postfix/main.cf

Nesta etapa, vamos definir o timeout para o agente SPF, caso aconteça algum problema de execução. Vamos também definir uma regra para rejeitar emails que não atendam as regras do SPF:

policyd-spf_time_limit = 3600
smtpd_recipient_restrictions =
   permit_mynetworks,
   permit_sasl_authenticated,
   reject_unauth_destination,
   check_policy_service unix:private/policyd-spf

Na inserção acima, atenção novamente no espaçamento e indentação, como explicado anteriormente.

Agora precisamos reiniciar o Postfix, para que as configurações do SPF tenham efeito:

sudo service postfix restart

Passo 10 – Configurando DKIM com OPENDKIM

Continuando com o processo para garantir confiabilidade ao nosso novo servidor de email e das mensagens enviadas por ele, precisamos também configurar o DKIM. O DKIM vem do termo em inglês “DomainKeys Identified Mail”. Basicamente é um protocolo que permite assinar os emails digitalmente em um processo que o destinatário consiga confirmar a veracidade sobre o remetente da mensagem por autenticação criptografada.

Para dar suporte ao DKIM no servidor, vamos instalar o pacote opendkim e o opendkim-tools:

sudo apt install opendkim opendkim-tools

Ao instalar o opendkim, automaticamente um usuário e grupo com o nome opendkim será criado. Como o opendkim e o postfix irão precisar acessar alguns arquivos em comum, é interessante já adicionar o usuário postfix ao grupo do opendkim para facilitar o gerenciamento de acesso de arquivos e suas permissões:

sudo gpasswd -a postfix opendkim

Precisamos realizar agora algumas configurações no opendkim, para isso vamos editar o arquivo de configuração:

sudo nano /etc/opendkim.conf

Encontre a linha “#LogWhy no”, precisamos habilitar a mesma. O caracter “#” no começo da linha transforma a linha em um comentário. Precisamos descomentar a linha e habilitar o LogWhy, altere então a linha para:

LogWhy	yes

Precisamos agora garantir que a linha que começa com “Mode” e a linha que começa com “SubDomains” estejam descomentadas. Então estas linhas devem ficar como:

Mode			sv
SubDomains		no

Agora encontre a linha “OversignHeader From”, precisamos inserir as informações abaixo desta linha:

AutoRestart			yes
AutoRestartRate		        10/1M
Background			yes
DNSTimeout			5
SignatureAlgorithm		rsa-sha256

Caminhe agora para o fim do arquivo e insira estas linhas:

KeyTable		refile:/etc/opendkim/key.table
SigningTable		refile:/etc/opendkim/signing.table
ExternalIgnoreList	/etc/opendkim/trusted.hosts
InternalHosts		/etc/opendkim/trusted.hosts

Precisamos definir uma estrutura de arquivos e diretórios para armazenar as chaves para o opendkim e definir as permissões de acesso. Execute as linhas abaixo 1 de cada vez no terminal, não copie tudo e cole no terminal, senão somente a primeira linha será executada:

sudo mkdir /etc/opendkim
sudo mkdir /etc/opendkim/keys
sudo chown -R opendkim:opendkim /etc/opendkim
sudo chmod go-rw /etc/opendkim/keys

Vamos criar e editar agora o arquivo de tabela de assinaturas:

sudo nano /etc/opendkim/signing.table

Insira o conteúdo abaixo dentro do arquivo, lembre-se de trocar o domínio viniciuspaes.com pelo seu domínio configurado:
*@viniciuspaes.com default._domainkey.viniciuspaes.com
*@*.viniciuspaes.com default._domainkey.viniciuspaes.com

Seguimos agora criando e editando o arquivo de chaves de assinaturas:

sudo nano /etc/opendkim/key.table

Insira o texto no arquivo:

default._domainkey.viniciuspaes.com     viniciuspaes.com:default:/etc/opendkim/keys/viniciuspaes.com/default.private