Como Instalar e Configurar o Framework Sails.js no Ubuntu 22.04

O Sails é uma estrutura Model-View-Controller (MVC) em tempo real, projetada para a construção de aplicativos corporativos Node.js prontos para produção. Esta ferramenta é altamente eficaz para acelerar o desenvolvimento e prototipagem de sites. Construído sobre o Node.js e o Express.js, o Sails oferece compatibilidade total com as funcionalidades dessas plataformas, garantindo uma transição suave para quem já está familiarizado com elas. Além disso, o Sails oferece suporte a WebSockets escalonáveis, uma arquitetura orientada a serviços e permite a integração de múltiplos armazenamentos de dados em um único projeto. Além disso, proporciona recursos de segurança básica e controle de acesso baseado em funções.

Neste guia, mostraremos como instalar o Sails.js com o Apache como proxy reverso no Ubuntu 22.04.

Pré-requisitos:

  • Um servidor executando Ubuntu 22.04.
  • Acesso com senha root configurado no servidor.

Começando:

Antes de iniciar o processo de instalação do Sails.js, é recomendável atualizar todos os pacotes do sistema para a versão mais recente. Isso pode ser feito executando o seguinte comando no terminal:

sudo apt update && sudo apt upgrade ou

apt update -y
apt upgrade -y

Depois que todos os pacotes forem atualizados, instale outras dependências necessárias usando o seguinte comando:

apt-get install curl wget gnupg2 -y

Esse comando instalará as ferramentas essenciais que serão utilizadas durante o processo de instalação e configuração do Sails.js. Quando a instalação estiver concluída, você estará pronto para prosseguir para a próxima etapa do processo.

Instale o Node.js.

Após atualizar as dependências necessárias, o próximo passo é instalar o Node.js e o NPM para criar um aplicativo Sails.js. Siga estas etapas:

curl -sL https://deb.nodesource.com/setup_16.x | bash -

Depois que o repositório for adicionado, instale o pacote Node.js com o seguinte comando:

apt-get install nodejs -y

Após a instalação, você pode verificar a versão do Node.js usando o seguinte comando:

node --version

Este comando mostrará a versão do Node.js instalada. Por exemplo, a saída pode ser algo como:

v16.17.1

Com estas etapas concluídas, você terá o Node.js e o NPM instalados em seu sistema, prontos para criar e executar aplicativos Sails.js.

Instale Sails.js

Em seguida, você precisará instalar o Sails.js em seu servidor. Você pode instalar o Sails usando o Node Package Manager.

npm -g install sails

Depois que o Sails estiver instalado, você pode verificá-lo com o seguinte comando:

sails --version

Você obterá a versão do Sails na seguinte saída:

1.5.3

Crie um aplicativo Sails.js

Depois de instalar o Sails, vamos criar um aplicativo Sails simples usando o seguinte comando:

sails new sails-app

Você deve obter a seguinte saída:

 Choose a template for your new Sails app:
 1. Web App  ·  Extensible project with auth, login, & password recovery
 2. Empty    ·  An empty Sails app, yours to configure
 (type "?" for help, or <CTRL+C> to cancel)
? 2
 info: Installing dependencies...
Press CTRL+C to cancel.
(to skip this step in the future, use --fast)
 info: Created a new Sails app `sails-app`!

Você pode verificar todos os arquivos criados pelo Sails usando o seguinte comando:

ls sails-app

Você deve obter a seguinte saída:

api  app.js  assets  config  Gruntfile.js  node_modules  package.json  package-lock.json  README.md  tasks  views

Você pode verificar todos os arquivos criados pelo Sails usando o seguinte comando:

cd sails-app
sails lift

Você deverá ver a seguinte saída:

 info: Starting app...

 info: 
 info:                .-..-.
 info: 
 info:    Sails              <|    .-..-.
 info:    v1.5.3              |\
 info:                       /|.\
 info:                      / || \
 info:                    ,'  |'  \
 info:                 .-'.-==|/_--'
 info:                 `--'-------' 
 info:    __---___--___---___--___---___--___
 info:  ____---___--___---___--___---___--___-__
 info: 
 info: Server lifted in `/root/sails-app`
 info: To shut down Sails, press  + C at any time.
 info: Read more at https://sailsjs.com/support.

debug: -------------------------------------------------------
debug: :: Sun Sep 25 2022 05:43:59 GMT+0000 (Coordinated Universal Time)

debug: Environment : development
debug: Port        : 1337
debug: -------------------------------------------------------

Pressione CTRL+C para interromper o aplicativo. Criaremos um arquivo de serviço systemd para iniciar e gerenciar o aplicativo Sails.

Crie um arquivo de serviço Systemd para Sails.js

Em seguida, você precisará criar um arquivo de serviço systemd para gerenciar o aplicativo Sails.js. Você pode criá-lo com o seguinte comando:

nano /etc/systemd/system/sails-app.service

Adicione as seguintes linhas:

[Unit]
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/root/sails-app
ExecStart=/usr/bin/sails lift
Restart=on-failure

[Install]
WantedBy=multi-user.target

Salve e feche o arquivo e recarregue o daemon systemd para aplicar as alterações:

systemctl daemon-reload

Em seguida, inicie o serviço Sails.js e habilite-o para iniciar na reinicialização do sistema:

systemctl start sails-app
systemctl enable sails-app

Agora você pode verificar o status do aplicativo Sails com o seguinte comando:

systemctl status sails-app

Você deve obter a seguinte saída:

? sails-app.service
     Loaded: loaded (/etc/systemd/system/sails-app.service; disabled; vendor preset: enabled)
     Active: active (running) since Sun 2022-09-25 05:44:42 UTC; 6s ago
   Main PID: 2896 (node)
      Tasks: 22 (limit: 4579)
     Memory: 159.2M
        CPU: 3.676s
     CGroup: /system.slice/sails-app.service
             ??2896 node /usr/bin/sails lift
             ??2903 grunt "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ">

Sep 25 05:44:44 ubuntu2204 sails[2896]:  info:  ____---___--___---___--___---___--___-__
Sep 25 05:44:44 ubuntu2204 sails[2896]:  info:
Sep 25 05:44:44 ubuntu2204 sails[2896]:  info: Server lifted in `/root/sails-app`
Sep 25 05:44:44 ubuntu2204 sails[2896]:  info: To shut down Sails, press  + C at any time.
Sep 25 05:44:44 ubuntu2204 sails[2896]:  info: Read more at https://sailsjs.com/support.
Sep 25 05:44:44 ubuntu2204 sails[2896]: debug: -------------------------------------------------------
Sep 25 05:44:44 ubuntu2204 sails[2896]: debug: :: Sun Sep 25 2022 05:44:44 GMT+0000 (Coordinated Universal Time)
Sep 25 05:44:44 ubuntu2204 sails[2896]: debug: Environment : development
Sep 25 05:44:44 ubuntu2204 sails[2896]: debug: Port        : 1337
Sep 25 05:44:44 ubuntu2204 sails[2896]: debug: -------------------------------------------------------

Neste ponto, o aplicativo Sails é iniciado e escuta na porta 1337. Agora você pode prosseguir para a próxima etapa..

Configure o Apache como um proxy reverso para Sails.js

Configurar o Apache como proxy reverso para acessar o aplicativo Sails é uma boa ideia. Primeiro, instale o servidor Apache com o seguinte comando:

apt install apache2 -y

Depois que o pacote Apache estiver instalado, crie um arquivo de configuração do host virtual Apache com o seguinte comando:

nano /etc/apache2/sites-available/sails.conf

Adicione as seguintes linhas:

<VirtualHost *:80>
    ServerName sailsapp.example.com

    ServerAdmin webmaster@example.com
    DocumentRoot /root/sails-app

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

    <LocationMatch  "^/(?!js|css|media)" >
            ProxyPass   http://127.0.0.1:1337
            ProxyPassReverse   http://127.0.0.1:1337
    </LocationMatch>

    <Location "/dist/">
            ProxyPass !
    </Location>

    RewriteEngine On
    RewriteCond %{REQUEST_URI}  ^/socket.io            [NC]
    RewriteCond %{QUERY_STRING} transport=websocket    [NC]
    RewriteRule /(.*)           ws://localhost:1337/$1 [P,L]
</VirtualHost>

Salve e feche o arquivo e ative o host virtual Sails com o seguinte comando:

a2ensite sails.conf

Em seguida, habilite outros módulos do Apache com o seguinte comando:

a2enmod headers proxy_http xml2enc proxy ssl proxy_wstunnel rewrite proxy_ajp deflate proxy_balancer proxy_connect proxy_html

Em seguida, reinicie o serviço Apache para aplicar as alterações:

systemctl restart apache2

Agora você pode verificar o status do serviço Apache com o seguinte comando:

systemctl status apache2

Você deve obter a seguinte saída:

? apache2.service - The Apache HTTP Server
     Loaded: loaded (/lib/systemd/system/apache2.service; enabled; vendor preset: enabled)
     Active: active (running) since Sun 2022-09-25 05:46:54 UTC; 2s ago
       Docs: https://httpd.apache.org/docs/2.4/
    Process: 3986 ExecStart=/usr/sbin/apachectl start (code=exited, status=0/SUCCESS)
   Main PID: 3990 (apache2)
      Tasks: 55 (limit: 4579)
     Memory: 6.8M
        CPU: 90ms
     CGroup: /system.slice/apache2.service
             ??3990 /usr/sbin/apache2 -k start
             ??3991 /usr/sbin/apache2 -k start
             ??3992 /usr/sbin/apache2 -k start

Sep 25 05:46:54 ubuntu2204 systemd[1]: Starting The Apache HTTP Server...

Atualmente, o servidor web Apache está instalado e configurado como proxy reverso para o aplicativo Sails.js. Agora você pode prosseguir para a próxima etapa.

Acesse a IU da Web Sails.js

Agora você pode abrir seu navegador e acessar a interface da web Sails.js usando o URL http://sailsapp.example.com. Você deverá ver a IU da web Sails.js na tela a seguir:

Conclusão

Parabéns! Você instalou Sails.js com sucesso com Apache como proxy reverso no Ubuntu 22.04. Agora você pode hospedar um aplicativo da web escalonável e pronto para produção usando a estrutura Sails.js. Sinta-se à vontade para me perguntar se tiver alguma dúvida.

Como instalar Wiki.js com proxy reverso Apache2 no Ubuntu 22.04

Wiki.js é um software wiki gratuito e de código aberto baseado em Node.js, Git e Markdown. É lançado sob a licença AGPL-v3 e projetado para desempenho e conservação de recursos do sistema. Wiki.js é um poderoso software Wiki que pode ser instalado em qualquer lugar do seu sistema; você pode instalá-lo em seu sistema operacional ou usando serviços de nuvem como Heroku e também implantar Wiki.js em seus ambientes de contêiner como Docker e Kubernetes.

Wiki.js é compatível com o banco de dados PostgreSQL e fornece mais de 50 integrações para autenticação adicional, sistemas de registro, mecanismos de pesquisa, renderização e armazenamento. É um poderoso software Wiki construído em interfaces bonitas e intuitivas para o painel e páginas de administração. é um software wiki totalmente personalizável para documentar sua pilha de tecnologia.

Neste guia, você instalará e configurará o Wiki.js em um servidor Ubuntu 22.04, usando PostgreSQL como banco de dados padrão e Apache2 como proxy reverso. Além disso, você terá uma conexão HTTPS/SSL segura na instalação do Wiki.js. Quando terminar, você terá um Wiki.js totalmente funcional e seguro em seu sistema Ubuntu.

Pré-requisitos

Para concluir este guia, primeiro você precisará dos seguintes requisitos:

  • Um servidor Ubuntu 22.04.
  • Um usuário não root com privilégios root/administrador.
  • Um nome de domínio apontado para o endereço IP do seu servidor Ubuntu.

Instalando Node.js

Antes de instalar o Wiki.js, você deve instalar as dependências exigidas pelo Wiki.js.

Wiki.js é um software wiki escrito principalmente em JavaScript para que você instale o tempo de execução JavaScript Node.js nesta primeira etapa. O repositório Ubuntu padrão fornece o pacote Node.js, mas para este guia, você usará o repositório Nodesource para instalar o Node.js.

Execute o comando curl abaixo para adicionar o repositório Nodesource ao seu sistema Ubuntu. No momento em que este artigo foi escrito, o Wiki.js exigia pelo menos Node.js v8 e superior . E para este guia, você instalará a versão LTS do Node.js v16.

curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -

Agora você pode instalar o pacote Node.js usando o comando apt abaixo.

sudo apt install nodejs

Após a conclusão da instalação, verifique e verifique a versão do Node.js usando o seguinte comando. Você deverá ver a versão Node.js v16 LTS na tela do seu terminal.

node --version
npm --version

Instalando o banco de dados PostgreSQL

O WIki.js padrão suporta vários RDBMS, como PostgreSQL, MySQL/MariaDB e SQLite (padrão), mas o banco de dados recomendado para produção é PostgreSQL. Você instalará o pacote PostgreSQL no sistema Ubuntu e, em seguida, criará o banco de dados e o usuário para o Wiki.js.

Para começar, execute o seguinte comando apt para instalar o banco de dados PostgreSQL em seu servidor. Insira Y para confirmar a instalação e pressione ENTER para continuar e a instalação começará.

sudo apt install postgresql postgresql-common

Quando a instalação for concluída, execute o seguinte comando systemctl para verificar e verificar o serviço PostgreSQL. E você deverá ver que o serviço PostgreSQL está habilitado, o que significa que ele será iniciado automaticamente na inicialização do sistema. E o status atual do serviço PostgreSQL é “ Active”.

sudo systemctl is-enabled postgresql
sudo systemctl status postgresql

Faça login no console PostgreSQL usando o comando abaixo para criar o banco de dados e o usuário PostgreSQL.

sudo -u postgres psql

Execute o seguinte comando em seu console PostgreSQL para criar um novo banco de dados e usuário para Wiki.js. Neste exemplo, estamos criando um banco de dados ” wikijs ” e o usuário ” wiki ” com a senha ” wikijspassword “.

CREATE DATABASE wikijs;
CREATE USER wiki WITH ENCRYPTED PASSWORD 'wikijspassword';
GRANT ALL PRIVILEGES ON DATABASE wikijs TO wiki;

Agora você pode usar ” Ctrl+d ” para sair do console do PostgreSQL ou simplesmente usar o comando ” \q ” para sair.

Instalando Wiki.js

Agora você instalará o Wiki.js manualmente em seu sistema Ubuntu. Através deste guia, você criará um usuário de sistema para Wiki.js, baixará o código-fonte do Wiki.js, configurará o Wiki.js com o banco de dados PostgreSQL e, por último, executará o Wiki.js como um serviço systemd.

Primeiro, execute o seguinte comando para criar um novo usuário para Wiki.js. Neste exemplo, estamos criando um novo usuário do sistema chamado ” wiki ” com o diretório inicial padrão ” /opt/wikijs ” e como este é um usuário do sistema, estamos desabilitando o acesso ao shell.

sudo useradd -r -d /opt/wikijs -s /usr/sbin/nologin wiki

Agora baixe o código-fonte do Wiki.js usando o comando wget abaixo.

wget https://github.com/Requarks/wiki/releases/latest/download/wiki-js.tar.gz

Quando o download terminar, crie um novo diretório ” /opt/wikijs ” e extraia o código-fonte do Wiki.js nele. Você deverá ver que o código-fonte do Wiki.js está disponível no diretório de instalação “/opt/wikijs “.

mkdir -p /opt/wikijs
tar xzf wiki-js.tar.gz -C /opt/wikijs

Para configurar o Wiki.js com o banco de dados PostgreSQL, você copiará a configuração de amostra padrão ” config.sample.yml ” e a modificará/editará usando seu editor de texto.

Execute o seguinte comando para copiar o arquivo de configuração Wiki.js de exemplo para ” /opt/wikijs/config.yml” . Em seguida, edite o novo arquivo ” /opt/wikijs/config.yml ” usando o editor nano.

cp /opt/wikijs/config.sample.yml /opt/wikijs/config.yml
nano /opt/wikijs/config.yml

Altere a configuração padrão conforme abaixo.

Neste exemplo, executaremos o Wiki.js na porta TCP padrão ” 3000 “. Certifique-se de alterar o nome, usuário e senha do banco de dados PostgreSQL. Na opção ” bindIP “, mude para localhost ou ” 127.0.0.1 “. Para a configuração do log do Wiki.js, usaremos o nível padrão ” info ” com o formato ” json “.

# default port wikijs will run
port: 3000

# PostgreSQL database details
db:
type: postgres
host: localhost
port: 5432
user: wiki
pass: wikijspassword
db: wikijs
ssl: false

# bind wikijs to localhost only
bindIP: 127.0.0.1

# setup log and the format
loglevel: info
logFormat: json

Salve e feche o arquivo quando terminar.

Agora execute o comando chown abaixo para alterar a propriedade do diretório de instalação do Wiki.js “/opt/wikijs” para o usuário “wiki” .

sudo chown -R wiki:wiki /opt/wikijs

Neste exemplo, executaremos Wiki.js como um serviço systemd. Portanto, você precisa criar um novo arquivo de serviço systemd para Wiki.js.

Execute o seguinte comando para criar um novo arquivo de serviço systemd “/etc/systemd/system/wikijs.service” .

sudo nano /etc/systemd/system/wikijs.service

Adicione a seguinte configuração ao arquivo.

[Unit]
Description=Wiki.js
After=network.target postgresql.service

[Service]
Type=simple
ExecStart=/usr/bin/node server
Restart=always

User=wiki
Environment=NODE_ENV=production
WorkingDirectory=/opt/wikijs

[Install]
WantedBy=multi-user.target

Salve e feche o arquivo quando terminar.

Em seguida, execute o seguinte comando para recarregar o gerenciador do sistema e aplicar o novo arquivo de serviço “ wikijs.service ”

sudo systemctl daemon-reload

Agora você pode iniciar e ativar o serviço ” wikijs ” usando o seguinte comando.

sudo systemctl start wikijs
sudo systemctl enable wikijs

Por último, verifique e verifique o serviço ” wikijs ” usando o seguinte comando. Agora você deve ver que o serviço ” wikijs ” está sendo executado na porta TCP padrão ” 3000 ” com PostgreSQL como banco de dados padrão.

sudo systemctl status wikijs

Configurando o Apache2 como proxy reverso

Neste exemplo, o Wiki.js agora está sendo executado na porta TCP “3000”. Para expor a redes externas ou à Internet, é melhor configurar o proxy reverso na frente do Wiki.js e aplicar HTTPS/SSL sobre ele para proteger quaisquer credenciais e login. Você também usará o Apache2 como proxy reverso para Wiki.js.

Execute o comando apt abaixo para instalar o pacote Apache2. Insira Y para confirmar a instalação e pressione ENTER para continuar e a instalação começará.

sudo apt install apache2

Após a conclusão da instalação, execute o comando “ufw” abaixo para abrir as portas HTTP e HTTPS em seu sistema Ubuntu. Em seguida, verifique a lista de regras do UFW.

sudo ufw allow "Apache Full"
sudo ufw status

A seguir, habilite alguns módulos do Apache2 usando o seguinte comando. Você usará esses módulos para configurar o proxy reverso Apache2.

sudo a2enmod proxy proxy_http ssl remoteip http2

Agora crie uma nova configuração de host virtual do Apache2 ” /etc/apache2/sites-available/wikijs.conf ” usando o seguinte comando.

sudo nano /etc/apache2/sites-available/wikijs.conf

Adicione a seguinte configuração ao arquivo. Neste exemplo, usaremos o domínio ” wiki.hwdomain.io ” para a instalação do Wiki.js e os certificados SSL do letsencrypt. Certifique-se de alterar o nome de domínio e o caminho dos certificados SSL.

<VirtualHost *:80>
ServerName wiki.hwdomain.io

# Comment to prevent HTTP to HTTPS redirect
Redirect permanent / https://wiki.hwdomain.io

ErrorLog /var/log/apache2/wiki.hwdomain.io-error.log
CustomLog /var/log/apache2/wiki.hwdomain.io-access.log combined
</VirtualHost>

<IfModule mod_ssl.c>
<VirtualHost *:443>
ServerName wiki.hwdomain.io

ProxyPreserveHost On

ProxyPass "/" "http://127.0.0.1:3000/"
ProxyPassReverse "/" "http://127.0.0.1:3000/"

SSLEngine on
SSLCertificateFile /etc/letsencrypt/live/wiki.hwdomain.io/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/wiki.hwdomain.io/privkey.pem
Protocols h2 http/1.1

# Enable only strong encryption ciphers and prefer versions with forwarding Secrecy
SSLCipherSuite HIGH:RC4-SHA:AES128-SHA:!aNULL:!MD5
SSLHonorCipherOrder on

# Disable insecure SSL and TLS versions
SSLProtocol all -SSLv2 -SSLv3 -TLSv1 -TLSv1.1

ErrorLog /var/log/apache2/wiki.hwdomain.io-error.log
CustomLog /var/log/apache2/wiki.hwdomain.io-access.log combined
</VirtualHost>
</IfModule>

Salve e feche o arquivo quando terminar.

Em seguida, ative o arquivo host virtual ‘ wikijs.conf ” usando o seguinte comando.

sudo a2ensite wikijs.conf

Verifique e verifique a configuração do Aache2 usando o seguinte comando. se você receber uma mensagem de saída como ” Syntax OK “, significa que a configuração do Apache2 está pronta. Em seguida, reinicie o serviço Apache2 para aplicar novas alterações.

sudo apachectl configtest
sudo systemctl restart apache2

Configurando a instalação do Wiki.js

Abra seu navegador e visite o nome de domínio da instalação do Wiki.js (ou seja: https://wiki.hwdomain.io/ ).

Insira o novo e-mail do administrador, senha e URL do site para a instalação do Wiki.js. Em seguida, clique no botão “ INSTALAR ” para iniciar a instalação.

Após a conclusão da instalação, você verá a página de login do Wiki.js. insira o e-mail e senha do administrador e clique em ” Entrar “.

Agora você verá a mensagem de boas-vindas do Wiki.js. Clique no botão ” CRIAR PÁGINA INICIAL ” para configurar a página de índice padrão do seu Wiki.js.

Escolha o editor que deseja usar. Neste exemplo, usaremos o editor Markdown .

Insira o título, a descrição e outros. Em seguida, clique em ” OK “.

Digite a página de índice de detalhes do seu Wiki.js e clique em ” CRIAR ” para confirmar.

E você deverá ver a página inicial padrão do Wiki.js que acabou de criar.

Para acessar o painel de administração do Wiki.js, clique no ícone de configurações de engrenagem no canto superior esquerdo. Você deverá ver o painel de administração do Wiki.js abaixo.

Conclusão

Neste tutorial, você configurou o Wiki.js no banco de dados PostgreSQL e no proxy reverso Apache2, rodando no servidor Ubuntu 22.04 mais recente. Você também protegeu seu Wiki.js com um firewall UFW e SSL/HTTPS habilitado no proxy reverso Apache. No final, você também configurou a página inicial ou índice padrão para a instalação do Wiki.js.

Você pode criar conteúdo adicional e configurar categorias para o seu projeto Wiki. Você também pode adicionar alguns módulos ao seu Wiki.js para estender sua funcionalidade ou configurar novos temas para o Wiki.js.

Teste de penetração 101: um guia para iniciantes em hacking ético


jkj

Todos os dias, usamos e geramos enormes quantidades de dados. E esses dados são utilizados por diversos setores como saúde, finanças, marketing, entre outros. No entanto, as violações de dados são cada vez mais violentas atualmente. É por isso que essas informações confidenciais devem ser protegidas.

É aqui que o hacking de penetração se torna útil. Testes de penetração, ou hacking ético, são usados ​​para obter acesso a recursos. Os hackers realizam ataques para descobrir vulnerabilidades de segurança e avaliar seus pontos fortes.

Neste artigo, você aprenderá o que é teste de penetração e por que ele é usado. Também destaca os diferentes tipos e abordagens de testes de penetração. Por último, o artigo listou algumas das ferramentas mais populares usadas pelos pen testers.

O que é teste de penetração?

O teste de penetração (pen testing) inclui a avaliação de vulnerabilidades em um aplicativo ou infraestrutura. O teste de penetração identifica inúmeras vulnerabilidades dentro do sistema. Além disso, também determina o que causa essas vulnerabilidades.

Depois de identificar as falhas do sistema, o processo orienta você sobre como encontrá-las e corrigi-las. Em essência, cada vulnerabilidade detectada recebe uma nota específica. E isso se baseia em qual dessas empresas deve priorizar a correção primeiro.

Os testes de penetração geralmente são exigidos pelas empresas para verificar se há vulnerabilidades em seus sistemas. Na maioria dos casos, não há necessidade de ofuscação.

No entanto, há momentos em que o teste de caneta de caixa preta é necessário. Este é um tipo de teste em que especialistas em segurança lidam com coisas como firewalls. Isso interfere nos testadores enquanto eles executam as verificações. Eles podem bloqueá-los, mas isso consome tempo.

Para contornar essas restrições, o endereço IP deve ser alterado. Nesse caso, um proxy de SEO incrível pode ser útil para fazer o trabalho.

Um servidor proxy estabelece uma conexão TCP em nome do servidor. Em seguida, ele troca pacotes de rede com esse servidor. Você poderá usar seu servidor DNS local ao mesmo tempo e receber um nome para cada solicitação. O site, então, lembrará o endereço de onde vieram as solicitações de DNS.

Por que o teste de penetração é usado?

O teste de penetração é usado para verificar vulnerabilidades. Além disso, os testadores usam isso para avaliar o quão seguro é o sistema.

A tecnologia de hoje está avançando. No entanto, o erro humano ainda é responsável por 88% das violações de dados . Os hackers modernos têm como alvo configurações incorretas de segurança que ocorrem em qualquer nível de uma pilha de aplicativos. Para saber se o seu sistema de segurança pode lidar com esses ataques, você precisa testá-los.

Aqui está uma lista de como as empresas se beneficiam dos testes de penetração:

  1. O teste identifica pontos fracos no hardware, software ou ativos humanos de uma organização para estabelecer controles.
  2. O teste garante que os três aspectos mais importantes da segurança cibernética sejam mantidos. Esses três aspectos incluem confidencialidade, integridade e disponibilidade.
  3. O teste garante que os controles implementados são adequados.
  4. O teste fornece informações sobre as medidas de segurança estabelecidas em uma empresa. Isso é feito determinando como ele será atacado, bem como as etapas necessárias para protegê-lo.
  5. O teste melhora a postura geral de segurança de uma empresa.

Tipos de Penetration Testing

1.  Teste de penetração de rede

A estrutura física do sistema é examinada para descobrir perigos na rede da organização. O testador de penetração realiza testes na rede. Isso ocorre para que possam identificar falhas em sua arquitetura, operação ou implementação. O testador verifica vários componentes do negócio, como computadores e dispositivos, em busca de possíveis falhas.

2. Teste de penetração física

Este tipo de teste de penetração imita os riscos do mundo real. O pen tester assume o papel de um ciberataque, tentando violar a barreira física de segurança. Este teste é usado para procurar falhas em controles físicos, como câmeras de segurança, armários, obstáculos e sensores.

3. Teste de penetração de aplicativos da Web

Nesse tipo, os testadores procuram falhas em sistemas baseados na web. O teste de penetração de aplicativos da Web identifica possíveis vulnerabilidades em sites e aplicativos. Ele também procura problemas de segurança que podem ocorrer como resultado de um desenvolvimento não seguro.

Sites e aplicativos que possuem páginas de transação precisam desse tipo de teste de penetração. Exemplos são sites de compras online, aplicativos bancários e outros sites de comércio eletrônico.

4. Teste de penetração de rede sem fio

Esse tipo de pentest examina a conectividade de todos os dispositivos conectados à internet da empresa. O objetivo é evitar o vazamento de dados que pode ocorrer quando os dados são compartilhados entre dispositivos em uma rede sem fio.

3 abordagens para testes de penetração

Existem três maneiras pelas quais os testadores realizam testes de penetração. Tudo isso depende do tipo de informação disponível.

1. Teste de penetração  Black Box 

Na black box ou nos testes de penetração externos, o testador não tem conhecimento da arquitetura de TI da empresa. Este procedimento é como uma simulação de um ataque cibernético no mundo real e geralmente leva mais tempo para ser concluído.

2. Teste de penetração de Grey Box

Nessa abordagem, os testadores possuem algumas informações sobre a estrutura da empresa. Isso inclui endereços IP, sistemas operacionais, endereços de e-mail, locais e mapas de rede.

É um método mais direcionado, pois o pen tester tem acesso limitado apenas à rede interna. Isto, então, permite-lhes concentrar os seus esforços na exploração de potenciais vulnerabilidades. Como resultado, isso economiza mais tempo e dinheiro.

3. Teste de penetração de White Box

O teste de penetração de White box também é denominado teste de penetração de caixa interna ou transparente. O pen tester possui informações completas como infraestrutura de TI, código-fonte e ambiente.

É um pen test mais extenso e aprofundado, onde todos os aspectos do aplicativo são testados. Isso geralmente inclui a qualidade do código e o design básico. Além disso, testes de penetração desta natureza normalmente levam de duas a três semanas para serem concluídos.

Ferramentas usadas em testes de penetração

O teste de penetração depende muito de ferramentas. Essas ferramentas auxiliam na detecção de falhas de segurança na rede, servidor, hardware e software. Ferramentas de penetração são aplicativos de software criados para verificar lacunas exploradas por hackers reais.

Para executar diversos procedimentos de testes de penetração, existem centenas de ferramentas acessíveis no mercado. Aqui estão algumas das ferramentas de teste de penetração mais populares, úteis para aspectos comuns de teste.

1. SQL Map

SQL Map é um programa que automatiza a descoberta e exploração de problemas de injeção de SQL. Inclui um mecanismo de detecção robusto que funciona com qualquer sistema de gerenciamento de banco de dados. Suporta todas as técnicas de injeção de SQL . Com autenticação, endereço IP, porta e nome do banco de dados adequados, você pode se conectar ao banco de dados sem usar injeção SQL.

2. W3af

Para descobrir quaisquer vulnerabilidades, a estrutura de ataque e auditoria de aplicativos da web (W3af) é empregada. Ele elimina coisas como DNS, envenenamento de cache, gerenciamento de cookies e suporte a proxy.

3. Wireshark

Wireshark é o analisador de protocolo de rede mais utilizado no mundo. Esta ferramenta permite que os testadores examinem a atividade da rede em um nível minúsculo. Também permite um exame completo de centenas de protocolos, bem como capturas ao vivo e análises offline. Wireshark é compatível com todos os principais sistemas operacionais, como Windows, Linux, MacOS e Solaris.

4. Metasploit

Metasploit é uma ferramenta popular para testes de penetração. As equipes de teste o utilizam para verificar e gerenciar avaliações de segurança, mantendo os hackers de chapéu branco afastados.

Metasploit inclui uma linha de comando, bem como uma interface GUI amigável. Ele roda em todos os sistemas operacionais, incluindo Mac OS, Linux e Windows. Embora seja esse o caso, o Linux é o mais popular.

A ferramenta permite que testadores de penetração invadam um sistema e encontrem pontos fracos graves. Com esta ferramenta, os testadores podem explorar pontos fracos e realizar ataques genuínos.

5. NMAP

O Nmap é gratuito, versátil, poderoso, portátil e simples de usar. É usado de diferentes maneiras, como:

  • Examinando e gerenciando cronogramas de atualização de serviço
  • Monitorando o host e os serviços em execução quanto ao tempo de atividade e
  • Gerenciando inventário de rede

Ele determina se os hosts estão disponíveis ou não, analisando pacotes IP brutos. O Nmap também é usado para ver quais serviços estão sendo executados em um host. Além disso, ele também pode verificar o nome do aplicativo, a versão e as informações do sistema operacional.

Os testadores são capazes de ver que tipo de filtros de pacotes são usados. O Nmap pode escanear qualquer coisa, desde um único computador até redes massivas. É compatível com quase todos os sistemas operacionais.

6.   Nessus

Muitas empresas em todo o mundo usam o Nessus como uma de suas ferramentas de pen-testing mais confiáveis. Ele é usado para verificar endereços IP, sites e pesquisas de dados confidenciais. O Nessus pode ajudar na identificação de patches ausentes, malware e verificação móvel. Além disso, possui um painel completo, recursos de digitalização de ampla gama e um recurso de relatório multiformato.

Para resumir

O teste de penetração é importante para identificar as principais falhas de segurança em um sistema. Também é essencial determinar vulnerabilidades em uma infraestrutura de TI ou aplicativo web.

À medida que os ataques cibernéticos se tornam mais prevalentes, torna-se cada vez mais importante detectar ameaças e vulnerabilidades. É por isso que o teste de penetração é obrigatório.

Existem muitas ferramentas e abordagens para testes de penetração que diferem de uma empresa para outra. No entanto, o objectivo continua o mesmo: proteger os activos de uma empresa contra intrusos externos. Testadores de penetração com habilidades avançadas podem descobrir um número cada vez maior de falhas. Isso pode então ser corrigido para tornar os sistemas mais seguros.

Os testes de penetração estão agora sendo expandidos para incluir dispositivos móveis e segurança na nuvem. Como testador de penetração, você precisa estar preparado e ter conhecimento sobre vulnerabilidades. Também é importante saber como realizar testes nessas áreas.

Lembre-se de que um testador de penetração deve estar sempre um passo à frente de um hacker black-hat. Só pode haver um vencedor neste jogo, e deve ser a empresa para a qual você trabalha.

Criação de interface de rede VLAN no Ubuntu 24.04

Este documento detalha a criação de interfaces de rede VLAN em um sistema Ubuntu 24.04. A VLAN (Virtual Local Area Network) possibilita a segmentação de tráfego em sua rede, dividindo uma rede física em grupos lógicos. Isso melhora a segurança e a eficiência da rede, pois impede a comunicação entre VLANs a menos que seja explicitamente permitida. As VLANs funcionam utilizando o padrão de rede IEEE 802.1Q, também conhecido como Dot1q.

Aplicações comuns de VLANs

  • Separação de departamentos em escritórios
  • Isolamento do tráfego Wi-Fi de convidados
  • Priorização de tráfego VoIP
  • Proteção de dispositivos IoT

Antes de prosseguir, certifique-se de que o switch de rede utilizado suporta marcação de VLAN (802.1Q). O processo de verificação de suporte varia de acordo com o fabricante. Consulte a documentação oficial do switch para obter mais informações.

Pré-requisitos

  • Acesso ao seu sistema Ubuntu como root ou usuário com privilégios sudo.
  • Identifique o nome da interface de rede física (Ethernet ou Wi-Fi).
  • Tenha uma ID de VLAN conhecida para configurar em sua rede.

Instalação do pacote vlan

  1. Faça login no seu servidor e instale o pacote vlan:
sudo apt update && sudo apt install vlan

  1. Para hosts utilizados em virtualização, habilite as seguintes configurações em sysctl.conf:
echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf
echo "net.ipv4.conf.all.arp_filter=0" | sudo tee -a /etc/sysctl.conf
echo "net.ipv4.conf.all.rp_filter=2" | sudo tee -a /etc/sysctl.conf

  1. Carregue as configurações após adicioná-las ao arquivo:
sudo sysctl -p

Criação da interface VLAN no Ubuntu

  1. Comece carregando o módulo do kernel que fornece suporte a VLAN. Utilize o seguinte comando no terminal:
sudo modprobe 8021q

  1. Você pode exibir informações adicionais sobre o módulo usando o comando modinfo:
$ sudo modinfo 8021q
filename:       /lib/modules/6.1.0-18-amd64/kernel/net/8021q/8021q.ko
version:        1.8
license:        GPL
alias:          rtnl-link-vlan
srcversion:     686DDAC35CEE6EFE0A30ADC
depends:        mrp,garp
retpoline:      Y
intree:         Y
name:           8021q
vermagic:       6.1.0-18-amd64 SMP preempt mod_unload modversions
sig_id:         PKCS#7
signer:         Debian Secure Boot CA
sig_key:        32:A0:28:7F:84:1A:03:6F:A3:93:C1:E0:65:C4:3A:E6:B2:42:26:43
sig_hashalgo:   sha256
signature:      A9:87:F2:68:22:66:F6:4D:A7:FF:C7:97:A3:C4:DA:73:1F:54:8D:EF:
		92:19:E2:5F:35:96:5A:95:29:25:8B:CD:08:FE:35:AC:4F:66:AE:5D:
		42:91:35:0F:AD:34:A6:6C:F3:13:2E:BF:4B:22:46:DB:A3:A8:39:27:
		6E:C6:81:03:24:93:DC:B0:78:E6:76:68:E7:B8:DF:0A:BB:F6:7F:29:
		97:80:E1:16:2D:C1:24:35:6B:6D:77:08:AE:2A:42:A7:D6:FC:9A:79:
		3A:46:29:4E:F1:53:B8:F2:26:AB:B2:7D:A7:4D:3D:4C:2F:35:AA:24:
		63:A6:F3:0A:C1:67:BE:6A:6A:20:1C:75:61:B1:3E:9D:81:5E:76:B8:
		1F:C6:90:66:20:4F:12:94:80:2B:B3:80:CE:64:C7:39:98:7B:9A:F3:
		BC:B0:AB:2B:E0:2F:5F:8C:B8:8E:2B:F3:D5:AE:ED:D8:A7:B8:37:AA:
		CB:C2:D6:7F:9D:68:91:4E:D2:81:8E:48:75:09:71:4E:B9:8A:A7:91:
		42:F0:6C:33:98:CA:01:CC:FD:71:D8:95:DC:A4:74:0D:9C:7F:23:72:
		BF:14:31:42:91:EA:57:F2:7D:4F:FE:25:BD:7A:7D:62:91:AC:89:02:
		3C:10:E9:03:95:35:F5:ED:BF:56:9A:56:0C:7F:88:74

Opções de configuração de VLAN

Este guia apresenta três opções para configurar VLANs:

1) Configuração temporária de marcação VLAN

Esse método serve para testar o funcionamento da VLAN em um dispositivo. As configurações não persistirão após a reinicialização do sistema.

  • Utilize o comando ip para criar uma interface VLAN em tempo de execução em sua máquina Ubuntu Linux.
  • Liste as interfaces de rede em sua rede:
$ sudo ip link  show
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
2: ens18: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP mode DEFAULT group default qlen 1000
    link/ether bc:24:11:44:e9:6f brd ff:ff:ff:ff:ff:ff
    altname enp0s18
3: ens19: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
    link/ether bc:24:11:bc:3f:d4 brd ff:ff:ff:ff:ff:ff
    altname enp0s19

  • Use o comando ip link add para criar uma nova interface marcada a partir de uma interface física. Substitua <interface_name> pelo nome real da sua interface e <vlan_id> pela ID da sua VLAN.
sudo ip link add link <interface_name> name <vlan_interface_name> type vlan id <vlan_id>

  • Exemplo: Criando uma interface marcada chamada vlan30 com ID de VLAN 30 na interface física ens19:
sudo ip link add link ens19 name vlan30 type vlan id 30

  • Atribua um endereço IP à interface VLAN:
sudo ip addr add 172.20.30.44/24 dev vlan30

  • Onde:
    • 172.20.30.44 é o endereço IP
    • /24 é a máscara de sub-rede (255.255.255.0)
    • vlan30 é o nome da interface VLAN
  • Ative a interface:
sudo ip link set dev vlan30 up

  • Se o roteamento for necessário para usar a interface, adicione o gateway à rede conforme necessário:
sudo ip route add 192.168.89.0 via 172.20.30.1

  • Para um gateway padrão, você pode usar:
sudo ip route add default via 172.20.30.1

  • Verifique as configurações de rede configuradas:
ip addr show dev vlan

2) Usando o arquivo /etc/network/interfaces

Para tornar persistentes as alterações feitas na opção 1, podemos editar o arquivo /etc/network/interfaces e incluir as configurações de VLAN.

  1. Edite o arquivo /etc/network/interfaces:
sudo vim /etc/network/interfaces

  1. Adicione as configurações de VLAN. Substitua os detalhes de exemplo pelas configurações de rede reais:
# Interface primária
auto ens19
iface ens19 inet manual

# Exemplo para ID de VLAN 30 na interface ens19
auto ens19.30
iface ens19.30 inet static
    address 172.20.30.2
    netmask 255.255.255.0
    gateway 172.20.30.1
    dns-nameservers 172.20.30.254

  1. Reinicie a rede para aplicar as alterações:
sudo systemctl restart networking

Observação: Se você estiver usando uma bridge do Linux, a configuração do arquivo será ligeiramente diferente. O exemplo a seguir demonstra a configuração para uma bridge.

# Interface primária
auto ens19
iface ens19 inet manual

# Exemplo para ID de VLAN 30 na interface ens19
auto ens19.30
iface ens19.30 inet manual

# Criação da bridge
auto br0
iface br0 inet static
  bridge_ports ens19.30
  bridge_stp off         # Desabilita o Spanning Tree Protocol
  bridge_waitport 0    # Sem atraso antes que uma porta se torne disponível
  bridge_fd 0             # Sem atraso de encaminhamento
  address 172.20.30.2
  netmask 255.255.255.0
  gateway 172.20.30.1
  dns-nameservers 172.20.30.1

3) Usando Netplan

O Netplan é uma solução de rede que simplifica o gerenciamento de interfaces de rede no Ubuntu. Veja como configurar uma interface VLAN usando o Netplan:

  1. Crie um novo arquivo Netplan:
sudo vim /etc/netplan/01-vlan-interface.yaml

  1. Adicione as configurações de VLAN no arquivo YAML. Ajuste as configurações para atender ao seu caso de uso:

YAML

network:
  version: 2
  ethernets:
    ens19:
      dhcp4: no
  vlans:
    vlan.30:
      id: 30
      link: ens19
      addresses: [ 172.20.30.2/24 ]
      routes:
       - to: default
         via: 172.20.30.1
      nameservers:
        addresses: [172.20.30.1, 8.8.4.4] 

Use o código com cuidado.content_copy

  1. Aplique as configurações e ative a interface:
sudo netplan apply

  1. Verifique a interface usando:
ip addr show

Conclusão

Este guia explicou três métodos diferentes para configurar e ativar uma interface VLAN em seu sistema Ubuntu 24.04. Você pode testar a funcionalidade usando ping ou ferramentas similares para verificar o acesso ao serviço de dispositivos externos. Lembre-se de ajustar os detalhes de rede usados neste guia de acordo com a configuração da sua rede. Caso encontre algum problema ao seguir este guia, não hesite em entrar em contato para auxílio.

Bloqueio de Sites em Roteadores Juniper

Este artigo vai te ensinar a bloquear sites específicos na sua rede usando roteadores Juniper. Vamos usar o roteador MX204 como exemplo, demonstrando como bloquear sites por endereços IP ou redes inteiras.

Criando uma Lista de Bloqueio

Primeiro, precisamos criar uma lista com os endereços IP ou redes que você deseja bloquear. Use o comando set policy-options prefix-list para isso. Cada linha abaixo cria uma entrada na lista de bloqueio chamada blacklist-ip:

set policy-options prefix-list blacklist-ip 192.168.5.5/32
set policy-options prefix-list blacklist-ip 192.168.15.0/24

  • /32 indica um único endereço IP (192.168.5.5 neste caso).
  • /24 indica uma rede inteira (192.168.15.0/24).

Você pode adicionar quantos endereços ou redes precisar na lista blacklist-ip.

Criando um Filtro de Firewall

Agora vamos criar um filtro no firewall que irá utilizar a lista de bloqueio criada. Use o comando set firewall family inet filter para definir o filtro. Veja a explicação passo a passo de cada linha:

  1. set firewall family inet filter blacklist-ip-drop interface-specific: Define um novo filtro chamado blacklist-ip-drop na família IPv4. A opção interface-specific permite aplicar o filtro em interfaces específicas posteriormente.
  2. set firewall family inet filter blacklist-ip-drop term drop from destination-prefix-list blacklist-ip: Cria uma regra dentro do filtro blacklist-ip-drop chamada drop. Essa regra irá bloquear o tráfego direcionado aos endereços IP ou redes definidos na lista blacklist-ip.
  3. set firewall family inet filter blacklist-ip-drop term drop then discard: Define a ação da regra drop. O discard descarta o pacote, impedindo que o acesso ao site seja realizado.
  4. set firewall family inet filter blacklist-ip-drop term other then accept: Cria outra regra chamada other. Essa regra irá permitir todo o tráfego restante que não seja bloqueado pela regra anterior.

Aplicando o Filtro na Interface

Com o filtro criado, precisamos aplicá-lo na(s) interface(s) desejada(s). Use o comando set interfaces para isso. No exemplo abaixo, o filtro blacklist-ip-drop é aplicado na interface ae0 (unidades 777 e 876):

set interfaces ae0 unit 777 family inet filter output blacklist-ip-drop
set interfaces ae0 unit 876 family inet filter output blacklist-ip-drop

  • output indica que o filtro será aplicado ao tráfego de saída da interface.

Caso já exista um filtro configurado na interface, você precisará editá-lo para incluir as regras de bloqueio no início. É importante manter a regra accept no final para permitir todo o tráfego restante. Além disso, a opção interface-specific no filtro garante que ele possa ser aplicado em várias interfaces sem conflitos.

Para switches Juniper da série EX: o filtro deve ser aplicado na interface local onde os dispositivos estão conectados.

Salvando as Alterações

Após configurar o filtro e aplicação, use o comando commit para salvar as alterações na configuração do roteador. Você pode adicionar um comentário para descrever o que o filtro faz:

commit comment "Filtro blacklist-ip-drop para bloquear ixnfo.com"

Considerações Finais

  • Este exemplo bloqueia sites por endereço IP ou rede. Para bloquear sites por nome de domínio, é necessário utilizar técnicas de filtragem DNS, que não foram abordadas neste artigo.
  • Sempre consulte a documentação oficial da Juniper para obter detalhes e opções mais avançadas dos comandos utilizados.

Configurando SOCKS no MikroTik

Neste guia detalhado, vamos mergulhar na configuração de um servidor proxy SOCKS no MikroTik, passo a passo, fornecendo instruções precisas e enriquecidas com informações técnicas. O objetivo é que você possa implementar essa solução com sucesso em seu ambiente e compartilhar seu conhecimento com seu público de maneira completa e informativa.

Cenário:

Imagine um cenário onde as operadoras de sua empresa precisam acessar os roteadores dos clientes remotamente, mas os roteadores dos clientes só possuem acesso à WAN para um endereço IP específico: o escritório com o MikroTik.

Solução:

O servidor proxy SOCKS no MikroTik surge como a solução ideal para esse problema. Ele permite que as operadoras se conectem aos roteadores dos clientes de forma transparente, mascarando seus endereços IP reais e direcionando o tráfego pela rede do MikroTik.

Configuração passo a passo:

1. Habilitando o Servidor SOCKS:

a. Menu MikroTik:

  • Acesse o menu IP > Socks no MikroTik.
  • Defina a versão como 4.
  • Opcionalmente, configure a porta desejada para o servidor SOCKS. A porta padrão é 1080.
  • Salve as alterações.

b. Comando Terminal:

ip socks set enabled=yes

2. Verificando o Status do Servidor SOCKS:

a. Comando Terminal:

ip socks> print

3. Monitorando Conexões Ativas:

a. Comando Terminal:

ip socks connections print

4. Controlando o Acesso ao Servidor SOCKS:

a. Criando Regras de Acesso:

i. Utilize o comando ip socks access para adicionar regras. ii. Defina o src-address para o endereço IP do cliente. iii. Especifique o dst-port ou dst-address para definir o destino da conexão. iv. Utilize action=allow para permitir o acesso ou action=deny para bloquear.

Exemplo:

# Permitir acesso para o endereço IP 192.168.5.5 a qualquer destino:
ip socks access add src-address=192.168.5.5 dst-port=0-65535 action=allow

# Permitir acesso para o endereço IP 192.168.5.6 apenas na rede 10.0.0.0/8:
ip socks access add src-address=192.168.5.6 dst-port=0-65535 dst-address=10.0.0.0/8 action=allow

# Negar acesso para todos os outros endereços IP:
ip socks access add action=deny

5. Configurando o Firewall para Permitir Conexões:

a. Permitir conexões TCP na porta 1080 para o endereço IP 192.168.5.5:

ip firewall filter add action=accept chain=input dst-port=1080 protocol=tcp src-address=192.168.5.5

b. Permitir conexões TCP na porta 1080 para o endereço IP 192.168.5.6 (comentário opcional):

ip firewall filter add action=accept chain=input dst-port=1080 protocol=tcp src-address=192.168.5.6 comment="ixnfo.com"

Observações:

  • Substitua os endereços IP e portas nas regras de acesso e firewall pelas configurações desejadas em seu ambiente.
  • Para configurar a autenticação, utilize o comando ip socks set auth-method e defina as credenciais de login.
  • Consulte a documentação oficial do MikroTik para mais detalhes sobre opções avançadas de configuração do servidor SOCKS.
  • Lembre-se de salvar as alterações após cada comando.

Configuração do Cliente:

a. Navegador Mozilla Firefox:

  • Acesse as configurações de proxy no Firefox.
  • Defina o endereço do servidor SOCKS como o endereço IP do MikroTik.
  • Especifique a porta do servidor SOCKS (a porta padrão é 1080 ou a porta configurada no MikroTik).

Como configurar cluster NFS de alta disponibilidade no RHEL 9/8

Nesta postagem do blog, mostraremos como configurar cluster NFS de alta disponibilidade no RHEL 9/8 usando pacemaker.

NFS (Network File System) é o servidor mais amplamente utilizado para fornecer arquivos pela rede. Com o servidor NFS podemos compartilhar pastas pela rede e clientes ou sistemas permitidos podem acessar essas pastas compartilhadas e usá-las em seus aplicativos. Quando se trata do ambiente de produção, devemos configurar o servidor NFS em alta disponibilidade para descartar o ponto único de falha.

Pré-requisitos

  • Pré-instale o RHEL 9/8 em node1 e node2
  • Assinatura Red Hat ou repositório yum local
  • Usuário Root ou Usuário Sudo com acesso de Administrador
  • Acesso SSH remoto

Detalhes do laboratório

  • Servidor NFS 1 (node1.example.net) – 192.168.1.140 – RHEL mínimo 9/8
  • Servidor NFS 2 (node2.example.net) – 192.168.1.150 – RHEL mínimo 9/8
  • Servidor NFS VIP – 192.168.1.151
  • Disco compartilhado de tamanho 20 GB

1) Defina o nome do host e atualize o arquivo hosts

Faça login em ambos os nós e defina o nome do host usando o comando hostnamectl conforme mostrado abaixo:

//Nó1

$ sudo hostnamectl set-hostname "node1.example.net"

$ exec bash

//Nó2

$ sudo hostnamectl set-hostname "node2.example.net"
$ exec bash

Atualize o arquivo /etc/hosts em ambos os nós, adicione o seguinte conteúdo

192.168.1.140  node1.example.net
192.168.1.150  node2.example.net

2) Instale o pacote de software de alta disponibilidade

Em ambos os nós, primeiro habilite os repositórios yum de alta disponibilidade usando o comando subscription-manager.

Para sistemas RHEL 9

$ sudo subscription-manager repos –enable=rhel-9-for-x86_64-highavailability-rpms

Para sistemas RHEL 8

$ sudo subscription-manager repos –enable=rhel-8-for-x86_64-highavailability-rpms

Após habilitar o repositório, execute o comando abaixo em ambos os nós para instalar software de alta disponibilidade como pcs e pacemaker.

$ sudo dnf install pcs pacemaker fence-agents-all -y

Após instalar os pacotes, permita portas de alta disponibilidade no firewall, execute o comando abaixo em ambos os nós.

$ sudo firewall-cmd --permanent --add-service=high-availability
$ sudo firewall-cmd --reload

3) Atribuir senha ao hacluster e iniciar o serviço pcsd

Sempre que instalamos pcs ele cria um usuário com o nome “hacluster”, esse usuário é usado pelo pacemaker para autenticar os nós do cluster. Execute o seguinte comando echo em ambos os nós.

$ echo "<Password-String>" | sudo passwd --stdin hacluster

Inicie o serviço PCSD usando o comando systemctl em ambos os nós.

$ sudo systemctl start pcsd && sudo systemctl enable pcsd

4) Autenticar nós e formar um cluster

Execute o comando pcs abaixo em qualquer um dos nós para autenticar o nó. No meu caso, estou executando o comando do node1,

$ sudo pcs host auth node1.example.net node2.example.net

Agora, forme um cluster usando esses dois nós. Execute o comando “pcs cluster setup” do node1. Este comando precisa do nome do cluster e dos nós.

$ sudo pcs cluster setup nfs_cluster --start node1.example.net node2.example.net
$ sudo pcs cluster enable --all

Em seguida, verifique o status do cluster usando o comando pcs cluster status de qualquer nó.

$ sudo pcs cluster status

Em meu laboratório, não temos nenhum agente de esgrima, por isso estamos desabilitando o dispositivo de esgrima usando o seguinte comando.

$ sudo pcs property set stonith-enabled=false
$ sudo pcs property set no-quorum-policy=ignore

Nota : Em ambientes de produção, é altamente recomendável configurar o dispositivo de isolamento para o seu cluster.

Se os nós do cluster forem máquinas virtuais VMware, você poderá usar o agente de isolamento “ fence_vmware_soap ”. Para configurar “fence_vmware_soap” como agente de esgrima, consulte as etapas lógicas abaixo:

a) Verifique se os nós do seu cluster podem acessar o hipervisor VMware ou Vcenter

# fence_vmware_soap -a <vCenter_IP_address> -l <user_name> -p <password> \
 --ssl -z -v -o list |egrep "(node1.example.net|node2.example.net)"

ou

# fence_vmware_soap -a <vCenter_IP_address> -l <user_name> -p <password> \
--ssl -z -o list |egrep "(node1.example.net|node2.example.net)"

se você conseguir ver os nomes das VMs na saída, tudo bem; caso contrário, você precisará verificar por que os nós do cluster não conseguem fazer a conexão esxi ou vcenter.

b) Defina o dispositivo de cerca usando o comando abaixo,

# pcs stonith create vmware_fence fence_vmware_soap \
pcmk_host_map="node1:node1.example.net;node2:node2.example.net" \
ipaddr=<vCenter_IP_address> ssl=1 login=<user_name> passwd=<password>

c) verifique o status do stonith usando o comando abaixo,

# pcs stonith show

5) Instale o NFS em ambos os nós

Execute o seguinte comando dnf em ambos os sistemas para instalar o nfs,

$ sudo dnf install nfs-utils -y

Permita portas do servidor NFS no firewall, seguindo firewall-cmd em ambos os nós.

$ sudo firewall-cmd --permanent --add-service={nfs,rpc-bind,mountd}
$ sudo firewall-cmd --reload

6) Configurar disco compartilhado para o cluster

Em meu laboratório, anexamos um disco compartilhado de 20 GB em ambos os nós. Configuraremos o LVM neste disco e formatá-lo-emos com o sistema de arquivos XFS.

Antes de usar este disco, altere o parâmetro “# system_id_source = “none”” para system_id_source = “uname” no arquivo /etc/lvm/lvm.conf em ambos os nós.

Execute o seguinte comando sed em ambos os sistemas.

$ sudo sed -i 's/# system_id_source = "none"/ system_id_source = "uname"/g' /etc/lvm/lvm.conf

Em seguida, execute o seguinte conjunto de comandos apenas no node1 para criar a partição lvm.

$ sudo pvcreate /dev/sdb
$ sudo vgcreate --setautoactivation n vol01 /dev/sdb
$ sudo lvcreate -L19.99G -n lv01 vol01
$ sudo lvs /dev/vol01/lv01
$ sudo mkfs.xfs /dev/vol01/lv01

Para ter esta partição lvm visível no node2, execute o comando abaixo apenas no node2.

$ sudo lvmdevices --adddev /dev/sdb

Em seguida, configure o compartilhamento NFS para o serviço nfs, crie as seguintes pastas em ambos os sistemas

$ sudo mkdir /nfsshare

Agora tente montar acima, crie a partição lvm neste ponto de montagem a partir de qualquer nó.

$ sudo lvchange -ay vol01/lv01
$ sudo mount /dev/vol01/lv01 /nfsshare/
$ df -Th /nfsshare/

Ótimo, a próxima quantidade está usando os comandos abaixo.

$ sudo umount /dev/vol01/lv01
$ sudo  vgchange -an vol01

7) Configurar cluster NFS de alta disponibilidade no RHEL 9/8

Defina o grupo de recursos e os recursos de cluster para seu cluster nfs . Usamos os seguintes recursos de grupo de recursos e recursos de cluster.

  • nfsgroup é o nome do grupo sob o qual todos os recursos serão criados.
  • nfs_lvm é o nome do recurso para volume lvm compartilhado (/dev/vol01/lv01)
  • nfsshare é o nome do recurso do sistema de arquivos que será montado em /nsfshare
  • nfsd é nfs-daemon para nfsserver
  • nfs-root é o recurso que define a especificação do cliente permitido.
  • nfs_vip é o recurso VIP (IPadd2) para nic enp0s3.
  • nfs-notify é o recurso para notificação de reinicialização do NFS.

Execute os seguintes comandos pcs em qualquer um dos nós.

$ sudo pcs resource create nfs_lvm ocf:heartbeat:LVM-activate vgname=vol01 vg_access_mode=system_id --group nfsgroup
$ sudo pcs resource create nfsshare Filesystem device=/dev/vol01/lv01 directory=/nfsshare fstype=xfs --group nfsgroup
$ sudo pcs resource create nfsd nfsserver nfs_shared_infodir=/nfsshare/nfsinfo nfs_no_notify=true --group nfsgroup
$ sudo pcs resource create nfs-root exportfs clientspec=192.168.1.0/24 options=rw,sync,no_root_squash directory=/nfsshare fsid=0 --group nfsgroup
$ sudo pcs resource create nfs_vip IPaddr2 ip=192.168.1.151 cidr_netmask=24 nic=enp0s3  --group nfsgroup
$ sudo pcs resource create nfs-notify nfsnotify source_host=192.168.1.151 --group nfsgroup

Em seguida, verifique o status dos recursos do cluster,

$ sudo pcs status

Perfeito, a saída acima confirma que todos os recursos foram iniciados com sucesso no node1.

8) Teste a instalação do cluster NFS

Para testar a instalação do cluster NFS, coloque o node1 no modo de espera e verifique se os recursos estão sendo movidos para o node2 automaticamente.

$ sudo pcs node standby node1.example.net
$ sudo pcs status

Para desativar o nó, execute

$ sudo pcs node unstandby node1.example.net
$ sudo pcs status

Para montar o compartilhamento NFS na máquina cliente usando o seguinte comando de montagem.

$ sudo mount -t nfs 192.168.1.151:/nfsshare /mnt
$ df -h /mnt
$ cd /mnt
$ sudo touch test-file

A saída acima confirma que podemos acessar o compartilhamento nfs da máquina cliente.

Isso é tudo deste guia. Acreditamos que você o achou informativo e útil. Sinta-se à vontade para postar suas dúvidas e comentários na seção de comentários abaixo.

Como configurar o servidor Web Apache em um contêiner Docker

Se você é um administrador de sistema Linux que fornece suporte para desenvolvedores, é provável que já tenha ouvido falar do Docker . Caso contrário, esta solução de software facilitará sua vida a partir de hoje, ajudando você a reduzir custos operacionais e acelerar implantações – entre outros benefícios.

Mas não é mágica. O Docker como plataforma aproveita contêineres – pacotes de um aplicativo junto com todas as ferramentas necessárias para executar para eliminar diferenças entre ambientes.

Em outras palavras, o software em contêineres funcionará e poderá ser gerenciado de forma consistente, independentemente de onde estiver instalado. Além disso, os contêineres são muito mais fáceis de configurar, iniciar, parar e manter do que as boas e antigas máquinas virtuais.

Se você estiver interessado em saber mais sobre as diferenças entre essas duas tecnologias, o site oficial do Docker oferece uma ótima explicação.

Em seguida, iremos usá-lo para servir uma página web simples a partir de nosso diretório inicial – tudo sem a necessidade de instalar um servidor web em nosso host.

Instalando Docker no Linux

Para começar, vamos instalar o Docker usando o seguinte comando curl , que fará o download e executará um script shell que adicionará o repositório Docker ao nosso sistema e instalará o pacote.

curl -fsSL https://get.docker.com | sh
Instale o Docker no Linux
Instale o Docker no Linux

Em seguida, use o comando systemctl para iniciar o serviço Docker principal , habilitá-lo para iniciar durante as reinicializações e verificar seu status.

systemctl start docker
systemctl enable docker
systemctl status docker
Verifique o status do Docker no Linux
Verifique o status do Docker no Linux

Neste ponto, podemos simplesmente executar.

docker

para ver a lista de comandos disponíveis ou para obter ajuda.

docker COMMAND --help
docker ps --help

nos dirá como listar os contêineres presentes em nosso sistema, enquanto

docker run --help

imprimirá todas as opções que podemos usar para manipular um contêiner.

Ajuda sobre uso de comandos do Docker
Ajuda sobre uso de comandos do Docker

Configurando um contêiner Apache

Uma das coisas incríveis sobre o ecossistema Docker é que existem dezenas de contêineres padrão que você pode baixar e usar facilmente.

No exemplo a seguir, instanciaremos um contêiner Apache 2.4 chamado tecmint-web , desanexado do terminal atual. Usaremos uma imagem chamada httpd:2.4 do Docker Hub .

AD

Nosso plano é fazer com que as solicitações feitas ao nosso endereço IP público na porta 8080 sejam redirecionadas para a porta 80 do contêiner. Além disso, em vez de servir conteúdo do próprio contêiner, serviremos uma página da web simples de /home/user/website .

Fazemos isso mapeando /home/user/website/ em /usr/local/apache2/htdocs/ no contêiner. Observe que você precisará usar sudo ou fazer login como root para continuar e não omita as barras no final de cada diretório.

sudo docker run -dit --name tecmint-web -p 8080:80 -v /home/user/website/:/usr/local/apache2/htdocs/ httpd:2.4
Extrair contêiner Docker Apache
Extrair contêiner Docker Apache

Neste ponto, nosso contêiner Apache deve estar instalado e funcionando.

sudo docker ps
Verifique o contêiner Apache Docker
Verifique o contêiner Apache Docker

Agora vamos criar uma página da web simples chamada docker.html dentro do diretório /home/user/website usando o vim editor .

vi /home/user/website/docker.html

Adicione o seguinte conteúdo HTML de amostra ao arquivo.

<!DOCTYPEhtml>
<html lang="pt">
<cabeça>
    <meta charset="UTF-8">
    <title>Aprenda Docker em Tecmint.com</title>
</head>
<corpo>
    <h1>Aprenda Docker conosco</h1>   
</body>
</html>

Em seguida, aponte seu navegador para Server-IP:8080/docker.html (onde Server-IP é o endereço IP público do seu host). Você deverá ver a página que criamos anteriormente.

Verifique a página do Apache
Verifique a página do Apache

Se desejar, agora você pode parar o contêiner.

sudo docker stop tecmint-web

e remova-o:

sudo docker rm tecmint-web

Para terminar a limpeza, você pode excluir a imagem que foi usada no contêiner (omita esta etapa se estiver planejando criar outros contêineres Apache 2.4 em breve).

sudo docker image remove httpd:2.4

Observe que em todas as etapas acima nunca tivemos que instalar o servidor web em nosso host.

Resumo

Neste artigo, explicamos como instalar o Docker e manipular um contêiner. Infelizmente, estes são apenas o básico – existem cursos inteiros, livros e exames de certificação que cobrem Dockers (e contêineres em geral) de forma mais aprofundada.

Zabbix ERROR 1273 (HY000) na linha 483: Unknown collation: ‘utf8mb4_0900_ai_ci’

Um dia eu estava migrando um banco de dados do servidor Zabbix para outro servidor e ocorreu um erro:

1
2
mysql -D zabbix < zabbix_no_history_2024-01-25.sql
ERROR 1273 (HY000) at line 483: Unknown collation: 'utf8mb4_0900_ai_ci'

O MySQL foi instalado no servidor antigo, e no novo servidor a versão mais nova do MariaDB, que não suportava essa codificação, então alterei corrigindo automaticamente no arquivo sql para utf8mb4_unicode_ci via notepad++ já que o dump não tinha histórico e fez não ocupa muita memória.

Também pode ser alterado usando sed:

1sed -i 's/utf8mb4_0900_ai_ci/utf8mb4_unicode_ci/g' DB.sql

Depois disso, o dump sql foi importado com sucesso para um banco de dados vazio

“Otimizando a Performance da CPU no MikroTik CRS106-1C-5S: Soluções para Alta Carga de CPU”

A MikroTik CRS106-1C-5S é um switch compacto com 5 slots SFP e uma porta combo (SFP/RJ45). Ele é alimentado por uma CPU de 400MHz e 128MB de RAM, e roda o RouterOS com uma licença L5.

Um dia me pediram para dar uma olhada no MikroTik CRS106-1C-5S, cujos usuários não conseguiam usar a Internet normalmente, não havia velocidade e as solicitações de ping caíram. Quando olhei a utilização da CPU, estava quase 100% (no menu Sistema – Recursos).

Como descrevi anteriormente a configuração do MikroTik CRS106-1C-5S, por algum motivo este dispositivo não fez algumas configurações importantes através do QuickSet.

Em IP – Servidor DHCP – Locações vi que 40 usuários receberam um endereço IP.

Na guia IP – Servidor DHCP – Redes, especifiquei servidores DNS de terceiros para que os usuários não usem ou carreguem o servidor DNS de cache no MikroTik (para aplicar as alterações, você deve reiniciar o dispositivo).

O mais importante é que configurei o FastTrack Connection para que o tráfego do usuário fosse menos processado pelo firewall, isso reduziu a carga da CPU pela metade, os usuários tiveram ping estável e o speedtest mostrou 80 Mbit/s via WiFi em vez de 1 Mbit/s. Ao configurar inicialmente o dispositivo, o QuickSet não criou regras FastTrack e este foi o principal problema.

/ip firewall filter
add action=fasttrack-connection chain=forward connection-state=established,related
 
/ip firewall filter
add action=accept chain=forward connection-state=established,related

Estas duas regras devem estar no início, antes de todas as outras regras “chain=forward”.

Lembre-se, é importante manter seu dispositivo seguro configurando uma senha.

Crie um site como este com o WordPress.com
Comece agora