Neste artigo, vamos explorar o treinamento de um modelo de aprendizado de máquina não supervisionado usando o algoritmo K-means e, em seguida, expor esse modelo através de uma API Flask. O foco deste artigo é o público que já trabalha com tecnologia, mas não é especialista em aprendizado de máquina.

Aprendizado Não Supervisionado

O aprendizado não supervisionado é um conjunto de técnicas de aprendizado de máquina que analisam e agrupam dados sem um “gabarito” pré-definido. Os algoritmos não supervisionados buscam padrões e estruturas nos dados sem usar rótulos de saída prévios. O objetivo é encontrar agrupamentos naturais, relações ou padrões nos dados.

Algoritmo K-means

O algoritmo K-means é uma técnica popular de aprendizado não supervisionado que se baseia em agrupar os dados em K grupos distintos, onde K é um número pré-definido de clusters. O algoritmo tenta minimizar a soma das distâncias entre os pontos de dados e os centroides dos clusters, ajustando iterativamente a posição dos centroides até que os clusters se estabilizem.

Conjunto de Dados Iris

O conjunto de dados Iris é um conjunto de dados popular que consiste em 150 amostras de flores de íris de três espécies diferentes: Iris setosa, Iris versicolor e Iris virginica. Cada amostra contém quatro características (comprimento e largura das sépalas e pétalas). Nosso objetivo é usar o algoritmo K-means para agrupar as amostras em três clusters, correspondendo às três espécies de íris.

Treinamento do Modelo K-means

Vamos começar treinando nosso modelo K-means no conjunto de dados Iris. Usaremos a biblioteca scikit-learn em Python para treinar o modelo. Primeiro, carregamos o conjunto de dados Iris, criamos um DataFrame e treinamos o modelo K-means com K=3.

# Importar bibliotecas necessárias
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.datasets import load_iris

# Carregar o conjunto de dados Iris
iris = load_iris()
data = iris.data
target = iris.target

# Criar um DataFrame com os dados e as colunas
iris_df = pd.DataFrame(data, columns=iris.feature_names)

# Treinar o modelo K-means com K=3
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(iris_df)

Exportando o Modelo Treinado

Para salvar e carregar o modelo treinado, usaremos a biblioteca joblib. Primeiro, salvamos o modelo treinado em um arquivo.

import joblib

# Salvar o modelo treinado em um arquivo
joblib.dump(kmeans, 'kmeans_model.joblib')

Criando uma API Flask

Agora que treinamos e salvamos nosso modelo, podemos criar uma API Flask para expor o modelo e fazer previsões.

from flask import Flask, request, jsonify
import numpy as np
import joblib

app = Flask(__name__)

# Carregar o modelo treinado
kmeans = joblib.load('kmeans_model.joblib')

@app.route('/predict', methods=['POST'])
def predict():
  input_data = request.json
  features = [input_data['sepal_length'], input_data['sepal_width'], input_data['petal_length'], input_data['petal_width']]
  features = np.array(features).reshape(1, -1)
  cluster = kmeans.predict(features)
  return jsonify({'cluster': int(cluster[0])})
  
if name == 'main':
  app.run(debug=True)

Em seguida, iniciamos o servidor Flask executando o arquivo app.py.

python app.py

Agora, a API está disponível em `http://localhost:5000/predict`. Podemos fazer solicitações POST para essa URL com um JSON contendo os valores das características do Iris (comprimento e largura das sépalas e pétalas) e obter o cluster previsto como resposta.

Exemplo de requisição POST usando o curl no Linux

Aqui está um exemplo de como fazer uma solicitação POST para a API usando o comando curl.

curl -X POST -H "Content-Type: application/json" -d '{"sepal_length": 5.1, "sepal_width": 3.5, "petal_length": 1.4, "petal_width": 0.2}' http://localhost:5000/predict

Este comando envia uma solicitação POST para a API com o cabeçalho Content-Type: application/json e os dados no formato JSON.

Conclusão

Neste artigo, exploramos o treinamento e a implantação de um modelo de aprendizado não supervisionado usando o algoritmo K-means e o conjunto de dados Iris. Demonstramos como treinar o modelo, exportá-lo e criar uma API Flask para expor o modelo e fazer previsões.

Treinamento e Implantação de um Modelo de Aprendizado Não Supervisionado com K-means e Flask was originally published in Juntos Somos Mais on Medium, where people are continuing the conversation by highlighting and responding to this story.

O KEDA (Kubernetes Event-driven Autoscaling) é um projeto de código aberto que oferece escalabilidade baseada em eventos para aplicativos Kubernetes. Neste post, mostraremos como configurar o KEDA para autoescalar um consumidor com base no número de mensagens em uma fila do RabbitMQ. O objetivo é ter um consumidor em espera (sem instâncias) até que uma mensagem seja enfileirada.

Pré-requisitos:

1. Kubernetes cluster configurado.
2. kubectl instalado e configurado.
3. Helm instalado e configurado.
4. Acesso ao RabbitMQ (local ou remoto).

Passo 1: Instalar o KEDA usando Helm

Para instalar o KEDA usando o Helm, execute o seguinte comando:

helm repo add kedacore https://kedacore.github.io/charts
helm repo update
helm install keda kedacore/keda --namespace keda --create-namespace

Passo 2: Criar um consumidor

Crie um arquivo chamado consumer.yaml com o seguinte conteúdo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: rabbitmq-consumer
spec:
  replicas: 0
  selector:
    matchLabels:
      app: rabbitmq-consumer
  template:
    metadata:
      labels:
        app: rabbitmq-consumer
    spec:
      containers:
      - name: consumer
        image: <SUA_IMAGEM_DO_CONSUMIDOR>
        env:
        - name: RABBITMQ_CONNECTIONSTRING
          valueFrom:
            secretKeyRef:
              name: rabbitmq-secret
              key: connectionString
---
apiVersion: v1
kind: Secret
metadata:
  name: rabbitmq-secret
type: Opaque
stringData:
  connectionString: <SUA_STRING_DE_CONEXÃO_DO_RABBITMQ>

Substitua <SUA_IMAGEM_DO_CONSUMIDOR> pela imagem do seu consumidor e <SUA_STRING_DE_CONEXÃO_DO_RABBITMQ> pela string de conexão do RabbitMQ.

Passo 3: Configurar o ScaledObject

Crie um arquivo chamado scaledobject.yaml com o seguinte conteúdo:

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: rabbitmq-scaledobject
spec:
  scaleTargetRef:
    name: rabbitmq-consumer
  minReplicaCount: 0
  maxReplicaCount: 10
  triggers:
  - type: rabbitmq
    metadata:
      queueName: <NOME_DA_FILA>
      queueLength: '1'
      hostFromEnv: RABBITMQ_CONNECTIONSTRING

Substitua <NOME_DA_FILA> pelo nome da fila do RabbitMQ que você deseja monitorar.

Passo 4: Aplicar as configurações

Execute os seguintes comandos para aplicar as configurações:

kubectl apply -f consumer.yaml
kubectl apply -f scaledobject.yaml

Agora, o KEDA monitorará a fila do RabbitMQ e ajustará o número de réplicas do consumidor com base no número de mensagens na fila. Quando a fila estiver vazia, não haverá instâncias do consumidor em execução. Quando uma mensagem chegar à fila, o KEDA escalará o consumidor

Para monitorar os logs do KEDA e verificar se o autoescalonamento está funcionando corretamente, você pode verificar os logs do pod do operador KEDA. Siga os passos abaixo:

Passo 1: Liste os pods no namespace do KEDA

Execute o seguinte comando para listar todos os pods no namespace do KEDA:

kubectl get pods -n keda

Você verá uma saída semelhante a esta:

NAME                                      READY   STATUS    RESTARTS   AGE
keda-6d869d66bd-5ht5j                      1/1     Running   0          1d
keda-operator-7c87884b75-4vwmn             1/1     Running   0          1d

Passo 2: Verifique os logs do operador KEDA

Para verificar os logs do operador KEDA, execute o seguinte comando substituindo <KEDA_OPERATOR_POD> pelo nome do pod do operador KEDA obtido no passo anterior:

kubectl logs -f <KEDA_OPERATOR_POD> -n keda

Por exemplo:

kubectl logs -f keda-operator-7c87884b75-4vwmn -n keda

Você verá logs semelhantes a estes ao monitorar o autoescalonamento:

{"level":"info","ts":...,"logger":"scalehandler","msg":"Scaling","ScaledObject.Namespace":"default","ScaledObject.Name":"rabbitmq-scaledobject","ScaledObject.ScaleType":"deployment","ScaledObject.Scaler":{},"ScaledObject.MinReplicas":0,"ScaledObject.MaxReplicas":10,"ScaledObject.Replicas":0}
{"level":"info","ts":...,"logger":"controllers.ScaledObject","msg":"Successfully updated status","ScaledObject.Namespace":"default","ScaledObject.Name":"rabbitmq-scaledobject"}
{"level":"info","ts":...,"logger":"scalehandler","msg":"Scaling","ScaledObject.Namespace":"default","ScaledObject.Name":"rabbitmq-scaledobject","ScaledObject.ScaleType":"deployment","ScaledObject.Scaler":{},"ScaledObject.MinReplicas":0,"ScaledObject.MaxReplicas":10,"ScaledObject.Replicas":1}

Agora você pode monitorar os logs do KEDA e ver o autoescalonamento em ação. Verifique se o número de réplicas aumenta e diminui com base no número de mensagens na fila do RabbitMQ.

Configurando o KEDA para autoescalar com base nas mensagens em uma fila do RabbitMQ was originally published in Juntos Somos Mais on Medium, where people are continuing the conversation by highlighting and responding to this story.

Eu tive um problema com a montagem de um volume no meu ubunto e quando isso aconteceu o meu serviço docker subiu com erro porque os dados do Docker estavam nesse volume.

Para isso eu mudei a configuração do Docker para ele esperar a montagem do volume antes de iniciar o serviço. Fui atrás para entender qual a maneira correta de se fazer isso.

A primeira coisa para entender é que o arquivo que é responsável por inicializar o Docker no Ubuntu é o arquivo /lib/systemd/system/docker.service e ele é gerenciado pelo Docker, por isso não devemos altera-lo.

Para conseguir mudar o comportamento desse arquivo vamos criar o diretório /etc/systemd/system/docker.service.d/ e dentro dele o arquivo mount.conf e o conteúdo dele será esse:

[Unit]
RequiresMountsFor=/mnt/disk1

Essa configuração vai adicionar ou alterar a configuração RequiresMountsFor do arquivo /lib/systemd/system/docker.service usando o valor /mnt/disk1 que é o nome do volume que eu preciso que ele espere estar montado.

Após criar um arquivo personalizado em /etc/systemd/system/docker.service.d/, você deve recarregar o daemon do systemd para que as alterações tenham efeito usando o comando:

sudo systemctl daemon-reload

Em seguida, você pode reiniciar o serviço do Docker para que as alterações sejam aplicadas usando o comando:

sudo systemctl restart docker

Agora toda vez que o serviço docker for iniciado ele vai verificar se o volume está montando antes.

Como modificar a inicialização do serviço do Docker no Ubuntu was originally published in Juntos Somos Mais on Medium, where people are continuing the conversation by highlighting and responding to this story.

Primeiro precisamos entender o que é o systemd .

O Systemd é um sistema de inicialização usado por muitas distribuições Linux. Ele é responsável por iniciar e gerenciar os serviços do sistema. Para configurar um serviço no Systemd, é necessário criar um arquivo de unidade no diretório /etc/systemd/system/. Neste artigo, vamos explicar cada um dos parâmetros que podem ser usados no arquivo de unidade.

Crie um arquivo no diretório /etc/systemd/system

[Unit]
Description=Onion Share
Wants=network-online.target
After=network-online.target
Wants=docker.service
After=docker.service

StartLimitInterval=0

[Service]
Type=forking
TimeoutStartSec=infinity
TimeoutStopSec=16min
ExecStart=/mnt/disk1/onion-farm/scripts/start
ExecStop=/mnt/disk1/umbrel/scripts/stop
User=root
Group=root
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=onion-service-startup
RemainAfterExit=yes
Restart=always
RestartSec=10  

[Install]
WantedBy=multi-user.target

Segue um resumo sobre os campos que podem ser usados nesse arquivo.

Seção [Unit]

A seção [Unit] é usada para definir informações gerais sobre o serviço.

• Description: Uma descrição curta do serviço.
• Documentation: Uma URL ou caminho para a documentação do serviço.
• Requires: Uma lista de unidades que devem ser iniciadas antes deste serviço.
• After: Uma lista de unidades que devem ser iniciadas antes deste serviço.

Seção [Service]

A seção [Service] é usada para definir informações específicas do serviço.

• ExecStart: O comando ou script que deve ser executado para iniciar o serviço.
• Type: O tipo do serviço, pode ser simple, forking, oneshot, dbus, notify, idle.
• User: O usuário que deve ser usado para executar o serviço.
• Group: O grupo que deve ser usado para executar o serviço.
• WorkingDirectory: O diretório de trabalho para o serviço.
• Environment: Uma lista de variáveis de ambiente a serem definidas para o serviço.
• StandardOutput: Onde enviar a saída padrão do serviço, pode ser inherit, null, tty, journal, syslog, kmsg, journal+console, syslog+console, kmsg+console.
• StandardError: Onde enviar a saída de erro do serviço, pode ser inherit, null, tty, journal, syslog, kmsg, journal+console, syslog+console, kmsg+console.
• Restart: Quando o serviço deve ser reiniciado, pode ser no, on-success, on-failure, on-abnormal, on-abort, on-watchdog, always.
• RestartSec: O tempo a esperar antes de reiniciar o serviço.
• TimeoutStartSec: Quanto tempo esperar pelo início do serviço antes de considerá-lo falhado.
• TimeoutStopSec: Quanto tempo esperar pelo término do serviço antes de considerá-lo falhado.
• SyslogIdentifier: A identificação a ser usada ao registrar o serviço no syslog.

Seção [Install]

A seção [Install] é usada para definir como o serviço deve ser instalado.

• WantedBy: A unidade ou alvo que deve ser iniciado quando este serviço é iniciado.

Agora precisamos criar os arquivos que vão iniciar e para o serviço docker.

Crie a pasta onde os arquivos serão adicionados. No meu caso eu criei no diretório mnt/disk1/onion-farm/scripts/start

#!/bin/bash

docker run \
    -p 3000:5000 \
    -v $(pwd)/html/:/var/www/html/ \
    -v $(pwd)/http.d/:/etc/nginx/http.d/ \
    -v $(pwd)/torrc.d/:/etc/torrc.d/ \
    -v $(pwd)/tor/:/var/lib/tor/ \
    -d \
    --name onion-farm \
    ricardobchaves6/onion-farm:v1.0.0

Vamos criar o arquivo que vai parar o container.

#!/bin/bash

docker stop -t 30 onion-farm
docker rm onion-farm

Vamos adicionar as permissões para os arquivos: sudo chmod 775 start stop .

Execute o comando abaixo para que o seu serviço seja iniciado ao reiniciar o sistema operacional:

sudo systemctl enable onion-farm-startup.service

Teste seu serviço com:

  systemctl start onion-farm-startup.service
  systemctl stop onion-farm-startup.service

Sobre o start e stop, não vou explicar porque é simples de mais :)

Criando um serviço no Ubuntu para rodar uma imagem Docker was originally published in Juntos Somos Mais on Medium, where people are continuing the conversation by highlighting and responding to this story.

Eu uso o sistema operacional do Ubunto Desktop. Eu explico o porque nesse posto onde detalho minha primeira experiencia com ele.

Depois de uma primeira configuração e tento já o Umbrel rodando eu parei para dar uma olhada no SO para ver o que temos.

Veja bem, eu não sou nenhum profissional de segurança e meu conhecimento na área é muito pequeno, por isso tome esse texto apenas como um guia inicial para projetos pessoais, se quiser segurança profissional procure um profissional. Eu vou Back End, sou bom em abrir brechas de segurança, não de fecha-las. :D

No final, eu não fiz praticamente nada, esto postando aqui para manter um ristro inclusive do que eu não fiz. Caso você veja alguma coisa errada, por favor, me avise.

Primeiro eu peguei meu IP publico e tentei rodar um ssh nele, conectado no ssh dele:

>curl ifconfig.me
111.111.111.11

Depois em qualquer computador:

>ssh 111.111.111.11                                                                                                                                   ricardochaves@Ricardos-MacBook-Pro
ssh: connect to host 111.111.111.11 port 22: Connection refused

Aqui eu já fiquei mais tranquilo porque não tinha mudado a senha do ssh ainda.

Agora eu queria alguma ferramenta que me ajudasse a verificar possíveis vulnerabilidades existentes na minha configuração de Linux. Procurando no Google eu achei algumas e comecei pela Lynis.

Para inslar e rodar é apenas isso:

git clone https://github.com/CISOfy/lynis
cd lynis
./lynis audit system

Ao final do estenso relatório ele me deu 47 Suggestions :

  * This release is more than 4 months old. Check the website or GitHub to see if there is an update available. [LYNIS]
      https://cisofy.com/lynis/controls/LYNIS/

Essa eu não tenho o que fazer. Estou com a versão mais nova.

  * Consider hardening system services [BOOT-5264]
    - Details  : Run '/usr/bin/systemd-analyze security SERVICE' for each service
      https://cisofy.com/lynis/controls/BOOT-5264/

Quando eu fiz com o Docker ele ficou todo vermelho… São muitos serviços e eu vou precisar de tempo para fazer um a um… Se é que eu vou fazer.

  * Determine why /vmlinuz or /boot/vmlinuz is missing on this Debian/Ubuntu system. [KRNL-5788]
    - Details  : /vmlinuz or /boot/vmlinuz
      https://cisofy.com/lynis/controls/KRNL-5788/

Esse eu não entendi… eu tenho o arquivo /boot/vmlinuz-**** , não sei porque ele quesitonou isso, proximo:

  * If not required, consider explicit disabling of core dump in /etc/security/limits.conf file [KRNL-5820]
      https://cisofy.com/lynis/controls/KRNL-5820/

Aqui eu editei o arquivo /etc/sysctl.conf e adicionei fs.suid_dumpable = 0 no final do arquivo. Depois fiz um reload do sysctl com o comando sudo sysctl -p .

  * Check process listing for processes waiting for IO requests [PROC-3614]
      https://cisofy.com/lynis/controls/PROC-3614/

Realmente eu estou usando muito o disco e vou deixar isso para ver depois que reduzir o uso.

  * Install a PAM module for password strength testing like pam_cracklib or pam_passwdqc [AUTH-9262]
      https://cisofy.com/lynis/controls/AUTH-9262/

Aqui é instalar o cracklib e editar o arquivo /etc/pam.d/common-password

sudo apt-get install -y libpam-cracklib
sudo nano /etc/pam.d/common-password

Ache a primeira linha e altere pela segunda:

password        requisite                       pam_cracklib.so retry=3 minlen=8 difok=3
password        requisite                       pam_cracklib.so retry=3 minlen=16 difok=3 ucredit=-1 lcredit=-2 dcredit=-2 ocredit=-2

Proximo:

  * When possible set expire dates for all password protected accounts [AUTH-9282]
      https://cisofy.com/lynis/controls/AUTH-9282/

Eu no nomento não vou configurar nada para expirar, se começar com isso logo vou estar fazendo rotação de chave e tudo mais, avançado de mais para mim.

  * Configure minimum password age in /etc/login.defs [AUTH-9286]
      https://cisofy.com/lynis/controls/AUTH-9286/

Novamente tem a ver com tempo do password, não quero mudar nada disso.

  * Configure maximum password age in /etc/login.defs [AUTH-9286]
      https://cisofy.com/lynis/controls/AUTH-9286/

Mesmo do de cima…

  * Default umask in /etc/login.defs could be more strict like 027 [AUTH-9328]
      https://cisofy.com/lynis/controls/AUTH-9328/

Esse cara é mais problema quando você tem vários usuários, no meu caso, sou apenas eu e tudo bem que a permissão de acesso ao que eu criar fique no padrão mesmo.

  * To decrease the impact of a full /home file system, place /home on a separate partition [FILE-6310]
      https://cisofy.com/lynis/controls/FILE-6310/

Pelo que entendi esse cara também seria problema se tivesse mais gente usando meu linux. O que não é o meu caso também.

  * To decrease the impact of a full /var file system, place /var on a separate partition [FILE-6310]
      https://cisofy.com/lynis/controls/FILE-6310/

Mesmo caso do de cima, só que com outro diretório.

  * Disable drivers like USB storage when not used, to prevent unauthorized storage or data theft [USB-1000]
      https://cisofy.com/lynis/controls/USB-1000/

Esse é um falso positivo, eu preciso do USB ligado direto. Expliquei no post anterior linkado no inicio do artigo.

  * Check DNS configuration for the dns domain name [NAME-4028]
      https://cisofy.com/lynis/controls/NAME-4028/

Esse eu não entendi… A documentação deles é bem ruim na vdd…

  * Split resolving between localhost and the hostname of the system [NAME-4406]
      https://cisofy.com/lynis/controls/NAME-4406/

Esse eu quero que realmente tenha esse comportamento, não vou alterar.

  * Install debsums utility for the verification of packages with known good database. [PKGS-7370]
      https://cisofy.com/lynis/controls/PKGS-7370/

Instalei o debsums executei debsums | grep FAILED e tive esse resultado, depois vou analisar caso a caso. Mas fica para um post futuro.

/usr/bin/rkaiq_3A_server                                                  FAILED
debsums: missing file /usr/lib/NetworkManager/conf.d/10-globally-managed-devices.conf (from network-manager package)
debsums: missing file /etc/default/orangepi-motd.dpkg-dist (from orangepi-bsp-cli-orangepi5 package)
debsums: missing file /etc/default/orangepi-ramlog.dpkg-dist (from orangepi-bsp-cli-orangepi5 package)
debsums: missing file /etc/default/orangepi-zram-config.dpkg-dist (from orangepi-bsp-cli-orangepi5 package)
debsums: missing file /etc/profile.d/orangepi-ssh-title.sh (from orangepi-bsp-cli-orangepi5 package)
/etc/orangepi-release                                                     FAILED
/etc/skel/.config/htop/htoprc                                             FAILED
/etc/skel/.config/xfce4/xfconf/xfce-perchannel-xml/xfwm4.xml              FAILED

  * Install package apt-show-versions for patch management purposes [PKGS-7394]
      https://cisofy.com/lynis/controls/PKGS-7394/

Esse eu até instalei o pacote para brincar, mas nem sei se vou lembrar de usa constantemete: sudo apt-get install apt-show-versions . Da uma olhada na doc deles para entender o que ele faz e usa aí que é legal.

  * Determine if protocol 'dccp' is really needed on this system [NETW-3200]
      https://cisofy.com/lynis/controls/NETW-3200/

Agora começou a ficar complicado de verdade… Eu comecei a conversar com o ChatGPT para entender o que é o protocolo e como verificar se ele está sendo usado ou não. Cheguei a seguinte conclusão, digite os dois comandos abaixo e verifique se ele está em uso:

netstat -an | grep dccp
ss -p | grep dccp

Como não teve nada de resposta estou assumindo que ele não está em uso e vou executar o comando para adiciona-lo ao blacklist e depois reiniciar o Orange Pi:

sudo echo "blacklist dccp" >> /etc/modprobe.d/blacklist.conf

  * Determine if protocol 'sctp' is really needed on this system [NETW-3200]
      https://cisofy.com/lynis/controls/NETW-3200/

Igual ao de cima, muda apenas o nome do protocolo, resolvei desabilitar também

  * Determine if protocol 'rds' is really needed on this system [NETW-3200]
      https://cisofy.com/lynis/controls/NETW-3200/

Também desabilitado como os outros.

  * Determine if protocol 'tipc' is really needed on this system [NETW-3200]
      https://cisofy.com/lynis/controls/NETW-3200/

Desabilitado.

  * Access to CUPS configuration could be more strict. [PRNT-2307]
      https://cisofy.com/lynis/controls/PRNT-2307/

Eu não tenho impressora, por isso nem pensei muito e já restringi o acesso:

sudo chown root:lpadmin /etc/cups/cupsd.conf
sudo chmod 640 /etc/cups/cupsd.conf

  * Check iptables rules to see which rules are currently not used [FIRE-4513]
      https://cisofy.com/lynis/controls/FIRE-4513/

Esse eu não tenho capacidade de ver… Vou precisar estudar mais para verificar o que realmente está em uso ou não.

  * Consider hardening SSH configuration [SSH-7408]
    - Details  : AllowTcpForwarding (set YES to NO)
      https://cisofy.com/lynis/controls/SSH-7408/

  * Consider hardening SSH configuration [SSH-7408]
    - Details  : ClientAliveCountMax (set 3 to 2)
      https://cisofy.com/lynis/controls/SSH-7408/

  * Consider hardening SSH configuration [SSH-7408]
    - Details  : LogLevel (set INFO to VERBOSE)
      https://cisofy.com/lynis/controls/SSH-7408/

  * Consider hardening SSH configuration [SSH-7408]
    - Details  : MaxAuthTries (set 6 to 3)
      https://cisofy.com/lynis/controls/SSH-7408/

  * Consider hardening SSH configuration [SSH-7408]
    - Details  : MaxSessions (set 10 to 2)
      https://cisofy.com/lynis/controls/SSH-7408/

  * Consider hardening SSH configuration [SSH-7408]
    - Details  : PermitRootLogin (set YES to (FORCED-COMMANDS-ONLY|NO|PROHIBIT-PASSWORD|WITHOUT-PASSWORD))
      https://cisofy.com/lynis/controls/SSH-7408/

  * Consider hardening SSH configuration [SSH-7408]
    - Details  : Port (set 22 to )
      https://cisofy.com/lynis/controls/SSH-7408/

  * Consider hardening SSH configuration [SSH-7408]
    - Details  : TCPKeepAlive (set YES to NO)
      https://cisofy.com/lynis/controls/SSH-7408/

  * Consider hardening SSH configuration [SSH-7408]
    - Details  : X11Forwarding (set YES to NO)
      https://cisofy.com/lynis/controls/SSH-7408/

  * Consider hardening SSH configuration [SSH-7408]
    - Details  : AllowAgentForwarding (set YES to NO)
      https://cisofy.com/lynis/controls/SSH-7408/

Aqui ele fala para forçar a barra na configuração do SSH, eu não vou fazer isso agora, uso muito e coisas como manter a conexão aberta são uteis para mim.

  * Enable logging to an external logging host for archiving purposes and additional protection [LOGG-2154]
      https://cisofy.com/lynis/controls/LOGG-2154/

Não vou mandar meus logs para outro lugar, para meu cenário é um overkill.

  * Check what deleted files are still in use and why. [LOGG-2190]
      https://cisofy.com/lynis/controls/LOGG-2190/

O arquivo mais antigo na minha pasta /tmp tinha 3 dias, sei lá se fiz alguma coisa errada, mas acredito que estou bem nesse ponto.

  * Add legal banner to /etc/issue.net, to warn unauthorized users [BANN-7130]
      https://cisofy.com/lynis/controls/BANN-7130/

Esse eu achei bem legal. Editei o arquivo /etc/issue.net e coloquei esse texto:

Go away
This is your last warning
If you try again you will get cancer.

  * Enable process accounting [ACCT-9622]
      https://cisofy.com/lynis/controls/ACCT-9622/

Não entendi o que fazer com esse…

  * Enable sysstat to collect accounting (disabled) [ACCT-9626]
      https://cisofy.com/lynis/controls/ACCT-9626/

Vou deixar para instalar as ferramentas sugeridas e estudar uma a uma futuramente.

  * Enable auditd to collect audit information [ACCT-9628]
      https://cisofy.com/lynis/controls/ACCT-9628/

Instalei oauditd e usei o comando aureport aparece um report legal. Fica a nota para estudar melhor o report

  * Check output of aa-status [MACF-6208]
    - Details  : /sys/kernel/security/apparmor/profiles
    - Solution : Run aa-status
      https://cisofy.com/lynis/controls/MACF-6208/

Primeiro eu verifiquei o statudo do serviço dessa forma com esse resultado:

>sudo systemctl status apparmor
○ apparmor.service - Load AppArmor profiles
     Loaded: loaded (/lib/systemd/system/apparmor.service; enabled; vendor preset: enabled)
     Active: inactive (dead)
  Condition: start condition failed at Mon 2023-01-16 21:11:08 -03; 3 days ago
       Docs: man:apparmor(7)
             https://gitlab.com/apparmor/apparmor/wikis/home/

Tentei um start e continuou igual, depois reinstalei e nada… Fiz de tudo, nada funcionou… Vou deixar para ver isso depois.

  * Install a file integrity tool to monitor changes to critical and sensitive files [FINT-4350]
      https://cisofy.com/lynis/controls/FINT-4350/

Esse aqui pede para instalar outro sistema de segurança, eu vou ver isso depois também.

  * Determine if automation tools are present for system management [TOOL-5002]
      https://cisofy.com/lynis/controls/TOOL-5002/

Ele ta pedindo para instalar ferramentas de automação, não tenho interesse nisso

  * Consider restricting file permissions [FILE-7524]
    - Details  : See screen output or log file
    - Solution : Use chmod to change file permissions
      https://cisofy.com/lynis/controls/FILE-7524/

Totalmente vago isso aqui… não entendi o que preciso fazer exatamente.

  * One or more sysctl values differ from the scan profile and could be tweaked [KRNL-6000]
    - Solution : Change sysctl value or disable test (skip-test=KRNL-6000:<sysctl-key>)
      https://cisofy.com/lynis/controls/KRNL-6000/

Também não entendi esse. No meu caso eu vou deixar tudo como está.

  * Harden compilers like restricting access to root user only [HRDN-7222]
      https://cisofy.com/lynis/controls/HRDN-7222/

Esse é legal, ele fala para remover os compiladores ou registringir o acesso. Eu não vou remover, mas vou estudar para restrigir o acesso, só não vou fazer no meu Orange Pi agora para evitar que eu estrague alguma coisa, isso é novo pra mim.

  * Harden the system by installing at least one malware scanner, to perform periodic file system scans [HRDN-7230]
    - Solution : Install a tool like rkhunter, chkrootkit, OSSEC
      https://cisofy.com/lynis/controls/HRDN-7230/

Por ultimo ele pede para instalar uma ferramenta de malware scanner, o que faz sentido pra mim. Vou fazer.

Resultado

Aprendi muito lendo sobre cada item e vou deixar esse post como nota para executar o que ficou faltando.

Sugiro você fazer o mesmo para entender melhor como o sistema funciona.

Vou tentar executar isso constantemente.

Verificando e corrigindo problemas de segurança no Orange Pi 5 was originally published in Juntos Somos Mais on Medium, where people are continuing the conversation by highlighting and responding to this story.

Essa é minha primeira experiencia com Orange Pi 5 e eu tive que fazer algumas coisas um pouco diferentes para conseguir colocar tudo para funcionar.

Os equipamentos:

• MicroSd card A2 64g
• Orange Pi 5

A ideia é começar a conversar a partir do momento que você já tem o seu sistema operacional rodando no Oragen Pi 5. Existem alguns guias para isso na internet e por isso não acho que vale a pena perder tempo com isso. Eu usei esse vídeo para aprender e ele é fenomenal.

Eu escolhi a imagem Orangepi5_1.1.0_ubuntu_jammy_desktop_xfce_linux5.10.110.7z, então se você escolheu outra imagem, pode ser que algumas coisas aqui não se aplique a você.

Para ver as opções de imagem entre no site deles, nesse link.

Eu peguei a versão descktop porque o Umbrel precisa de uma interface grafica. Outro requisito é que precisa ser 64 bits.

O CPU do Orange Pi 5 tem suporte para 64 bits, mas eu não sei proque eles não adicionaram isso na imagem que eu falei acima, por isso precisamos executar o seguinte comando:

sudo dpkg --add-architecture amd64 ## adding 64-bits architecture package

Agora já podemos instalar o Umbrel.

Aqui eu tive outro problema, eu tenho apenas um MicroSD Card de 64gb. Eu achei que poderia ficar sem HD rapidamente (quero adicionar mais cosas no PC) e por isso optei por botar um HD externo de 2T que eu tenho na porta USB 3 do Orange Pi.

Para fazer isso direito, pelo menos é o que eu consegui fazer com meu pobre conhecimento de Linux, se existe solução melhor, por favor, deixe no comentário um direcionamento para eu poder estudar.

Eu aprendi muita coisa com esse vídeo:

Eu precisei montar o HD externo na pasta mnt porque quero ele como parte do meu sistema todo o tempo.

Para isso, insira o HD externo na USB, depois use o comando lsblk :

> lsblk
NAME        MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS
sda           8:0    0  1.8T  0 disk
└─sda1        8:1    0  1.8T  0 part
mtdblock0    31:0    0   16M  0 disk
mmcblk1     179:0    0 59.5G  0 disk
├─mmcblk1p1 179:1    0  256M  0 part /boot
└─mmcblk1p2 179:2    0 58.6G  0 part /var/log.hdd
                                     /
zram0       254:0    0  7.7G  0 disk [SWAP]
zram1       254:1    0  200M  0 disk /var/log

Você deve ver alguma coisa com o nome sda ou parecido… Esse é o nome que o Linux da quando você tem alguma coisa no USB.

Com esse nome em mãos, vamos fazer o seguinte:

cd /mnt
mkdir disk1
sudo mount /dev/sda1 /mnt/disk1/

O /dev/ é padrão e você devi adicionar na frente do sda1 ou o nome similar que você tem aí. O próximo parametro é o /mnt/disk1/ que é onde ele vai montar.

Quando você roda o mount ele funciona apenas para a sessão atual, para fazer ele montar isso quando existir um boot você precisa alterar o arquivo /etc/fstab e adicionar essa linha no final dele /dev/sda1 mnt/disk1 ext4 default 0 0 , o meu ficou assim:

> cat /etc/fstab
UUID=bc3a0620-7f52-4f69-9d48-be19c533ab12 / ext4 defaults,noatime,commit=600,errors=remount-ro 0 1
UUID=E429-E94B /boot vfat defaults 0 2
tmpfs /tmp tmpfs defaults,nosuid 0 0
/dev/sda1 /mnt/disk1 ext4 defaults 0 0

Isso feito, o próximo passo é instalar e configurar o docker. Eu não tive problemas com a instalação, então você também não deve ter, basta seguir com qualquer uma dessas opções.

Uma vez instalado, eu queria mudar onde o docker vai salvar os dados. O docker sempre grava tudo em um único diretório, o valor default é /var/lib/docker . No meu caso eu quero que ele grave no meu HD externo. Para isso vamos criar uma uma pasta nele e configurar o docker:

Estou considerando duas coisas no script, uma é que o arquivo daemon.json não existe, ele não é criado na instalação do docker. O segundo ponto é que eu uso nano para editar o arquivo, faça como você acha melhor.

cd /mnt/disk1
mkdir docker-data
cd /etc/docker
touch daemon.json
nano daemon.json

O arquivo deve ficar da seguinte forma:

{
  "data-root" : "/mnt/disk1/docker-data"
}

Agora basta reiniciar o docker:

service docker restart

Se você fizer um ls /mnt/disk1/docker-data verá vários itens criados.

Vamos instalar o Umbrel agora. Eu também quero instalar ele no meu HD externo. Por padrão ele vai guardar os dados das aplicações na pasta app-data que é criada onde ele foi instalado.

Para instalar eu usei o comando abaixo com três parametros, um para mudar o diretório e dois para ele não instalar o docker porque a gente já instalou.

cd /mnt/disk1
mkdir umbrel
curl -L https://umbrel.sh | bash -s -- --install-path /mnt/disk1/umbrel/ --no-install-docker --no-install-compose

O log final do comando será alguma coisa assim:

Creating manager   ... done
Creating auth      ... done
Creating tor_proxy ... done
Creating dashboard ... done
Creating nginx     ... done

Removing status server iptables entry...
Exiting iptables setup when not on Umbrel OS

Starting installed apps...


Umbrel is now accessible at
  http://orangepi5.local
  http://10.0.0.147
Skipping status update when not on Umbrel OS

Umbrel has been sucessfully installed!

Quando você abrir essa URL no browser já terá o Umbrel pronto. Basta instalar as apps que você quiser e aproveitar.

Bitcoin Node no Orange Pi 5 com Umbrel was originally published in Juntos Somos Mais on Medium, where people are continuing the conversation by highlighting and responding to this story.

Crie um index.html em uma diretório qualquer:

<h1>Hi</h1>

Vamos usar o OnionShare para hospedar um site na rede Tor. Eu estou usando um MAC M1 para esse projeto e para instalar o OnionShare basta executar brew install --cask onionshare

Abre o programa e vá em Host a Website.

Adicione o diretório que você criou com o index.html dentro, marque a opção This is a public OnionShare service (disabeles private key) e click em Start sharing você recebera um endereço como esse: http://6nvrcuddztfiokksb7phvnv6k4xfu64xpcm55joj5znije22rdsob7id.onion

Abra o endereço em um browser com acesso a rede Onion e veja o seu HTML.

Agora no seu projeto Gatsby, se você como eu, não mudou nada no projeto basta executar npm run build . Ele vai criar a pasta public .

Adicione a pasta public no OnionShare e agora marque a opção Don't send default Content Security Policy header (allows your website to use third-party resources) e Start novamente.

Abra o link e pronto, está tudo funcionando… Bem quase tudo, você não tem HTTPS e coisas como o ServiceWorker não vão funcionar. Mas para quem está querendo usar a rede Onion, já será um ótimo resultado.

Eu esotu esperando o meu Oragen Pi 5 chegar, eu pretendo colocar meu node Bitcoin nele e também hospedar meu blog na rede Onion. Quando eu fizer isso atualizo esse post com o link do meu blog.

Como hospedar seu site gatsby na rede Onion para ser acessível via Tor. was originally published in Juntos Somos Mais on Medium, where people are continuing the conversation by highlighting and responding to this story.

Olá, mundo! Tudo bem com ocês ? Hoje quero falar um pouco sobre SCSS e algumas novidades.

Caso queira ver o funcionamento de todas as novas features e/ou modificar algumas coisas, basta acessar meu repo scss-like-you-never-seen e seguir o passo-a-passo para visualizar. Deixa uma starzinha também ❤️

Importante saber antes de tudo!

Algumas das funcionalidades que vou mostrar ainda não possuem suporte em todos os navegadores, mas é possível testá-las habilitando as respectivas flags em seu navegador.

EX: chrome://flags

Basta, agora, procurar a flag desejada, habilitar e reiniciar o navegador.

Para ter uma leitura mais agradável e ver cada uma das features, aconselho a clonar o meu repo scss-like-you-never-seen e rodar ele localmente. Dentro de cada pasta do repo existe um README.md explicando a feature.

Eu posso utilizar essas features?

A documentação do SASS recomenda utilizar o sass ou dart-sass como compilador do projeto, conseguindo, assim, usar todas essas features sem problema. Caso você esteja utilizando ruby-sass ou lib-sass, por exemplo, acredito que não será capaz, visto que está deprecated.

Sass module mode

Há um tempo foi lançado um feature no scss que é chamado de scss modules. Basicamente, ela permite que o seu estilo funcione como um modulo da aplicação, assim liberando alguns recursos interessantes.

Existem duas formas de se utilizar o sass module:

nome.module.scss ou _nome.scss

Nas duas formas você poderá usufruir de todos os recursos do sass module.

As novidades que vieram foram justamente os:

@use, que permite importar um arquivo de estilo dentro de outro para ser utilizado naquele contexto.

@foward que permite importar um arquivo de estilo dentro de outro e que ele seja passado para frente na importação.

Porque o @import é um problema ?

Usando o @import no scss encontramos um problema, um arquivo que possui, por exemplo, margin: 5rem; no final pode ficar com margin: 10rem; caso tenha alguma variável com o mesmo nome da qual alimenta aquela propriedade, visto que o @import na hora da compilação leva em consideração a ordem.

EXEMPLO:

@import "spacings"; // margin: 10rem;
@import "variables";// margin: 5rem;
@import "mixins";
@import "colors";


.container {
  margin: var(--margin); // essa margin vem do variables
}s

Caso a gente altere a ordem de importação, na hora que ocorrer a compilação será alterado o valor.

@import "variables";// margin: 5rem;
@import "spacings"; // margin: 10rem;
@import "mixins";
@import "colors";


.container {
  margin: var(--margin); // essa margin vem do spacings
}

O sass compila de forma procedural, ou seja, o valor da propriedade vai ser alterado de acordo com a última variável encontrada.

O problema que o @use e @foward resolve

@foward

Ele é similar ao @import, você passará para frente o que estiver em um contexto, não haverá sobre escrita.

@use

É utilizado no contexto e recebe um namespace, então se o meu arquivo se chama util tudo que eu utilizar ali será necessário passar o util como prefixo.

EX:

@use "_util";

.container {
  margin: util.$margin;
}

Caso não queria usar o namespace, esteja em processo de migração ou deseja utilizar outro nome porque o atual é grande, basta utilizar as e colocar um alias.

@use "_util" as u; // o prefixo agora é `u`
@use "_animations" as *; // não será necessário passar o namespace

7–1 pattern scss

“One file to RULE them all.

One file to FIND them.

One file to BRING them all.

And in the sass way MERGE them”.

Esse é o pattern mais utilizado para desfrutar do scss modules, ou seja, o scss modules é um modo de modularizar, cada arquivo é um componente e, cada componente, é um modulo. A sua estrutura é a seguinte:
abstracts, vendors, base, layout, components, pages e themes

Existem vários patterns 4–1, 5–1 etc. Tudo vai depender da sua necessidade.

Particularmente utilizo bastante esse para meus projetos:

styles/
|
|– base/
|   |– _reset.scss       # Reset/normalize
|   |– _color.scss       # Paleta de cores da aplicação
|   |– _typography.scss  # Typography rules
|   |– _index.scss       # File used to import all base
|
|– layout/
|   |– _navigation.scss   # Navigation
|   |– _grid.scss         # Grid system
|   |– _header.scss       # Header
|   |– _footer.scss       # Footer
|   |– _sidebar.scss      # Sidebar
|   |– _forms.scss        # Forms
|
|– pages/                # Base views -> HOME, ABOUT, CONTACT etc.
|   |– _home.scss        # Home specific styles
|   |– _contact.scss     # Contact specific styles
|
|– themes/
|   |– _theme.scss       # Default theme
|
|– abstract/
|   |– _variables.scss   # Sass Variables
|   |– _functions.scss   # Sass Functions
|   |– _mixins.scss      # Sass Mixins
|   |– _index.scss       # File used to import all abstracts
|
`– _index.scss           # Main Sass file

Container Queries

Para utilizar o @container é necessário definir um query para o componente, fazemos isso da seguinte forma:

.nosso-wrapper {
  container-name: wrapper;
  container-type: inline-size;
}

O que fizemos acima foi definir o tipo do container e o nome dele.

Note que o @container tem o mesmo funcionamento do @media, entretanto, o que diferencia os dois é que o container vai ter o adicional de poder utilizar operadores lógicos para definir o tamanho do container.

O que também diferencia o @container do @media é que ele ajusta o tamanho dos elementos baseado na classe pai e não pelo tamanho do viewport.

EX:

@container wrapper (inline > 50px) {
  .nossa-classe {
    display: grid;
    align-items: center;
    justify-content: center;
  }
}

Compatibilidade: Chrome(🚧Beta), Firefox(🚧Beta), Chromium(🚧Beta) & Safari(✅Suportado)

Extend Rule

O extend é um recurso em que você replica o mesmo estilo de uma classe em outra.

Mas qual a diferença entre o @mixin e o @extend?

O mixin vai gerar uma cópia daquele estilo em outro componente na hora da compilação.
Já o extends, gera uma referência para a classe original.

EXEMPLO:

@mixin placeHolder {
    display: -webkit-box;
    display: -ms-flexbox;
    display: -webkit-flex;
    display: flex;
}
.classe1 {
    @include placeholder;
}
.classe2 {
    @include placeholder;
}

/// Mixin output
.classe1 {
    display: -webkit-box;
    display: -ms-flexbox;
    display: -webkit-flex;
    display: flex;
}
.classe2 {
    display: -webkit-box;
    display: -ms-flexbox;
    display: -webkit-flex;
    display: flex;
}

/// Extend input
.placeHolder {
    display: -webkit-box;
    display: -ms-flexbox;
    display: -webkit-flex;
    display: flex;
}
.classe1 {
    @extend %placeHolder;
}
.classe2 {
    @extend %placeHolder;
}

/// Extend output
.classe1,
.classe2 {
    display: -webkit-box;
    display: -ms-flexbox;
    display: -webkit-flex;
    display: flex;
}

Apesar do @extend ser mais simples, ele é tão poderoso quanto @mixin. Mas isso pode causar alguns problemas.

• Como a classe .placeHolder é copiada para duas classes, elas são independentes e não se comportam como se fossem uma única classe.
• Dependendo do comportamento da classe, a classe pai pode não ser a classe original.

Quando usar ou não o @extend?

• Mixin: utilize para gerar seu código de modo dinâmico através de variáveis.
• Extend: utilize para elementos comuns mas que haverá pouca repetição.

Quando for necessário criar algum tipo de automatização, utilize o @mixin, caso contrário utilize o @extend, ou até mesmo os dois juntos.

Compatibilidade: Chrome(✅Suportado), Firefox(✅Suportado), Chromium(✅Suportado) & Safari(✅Suportado)

Has Selector

É uma pseudo classe que permite ao usuário selecionar um elemento do DOM e manipular caso o mesmo exista. Ele não pode ser utilizado dentro de classes css, somente selecionando seletores para seletores.

section:has(div) {
  color: red;
}

<section>
    <h1>Has Selector</h1>
    <div>
      <p>Message</p>
    </div>
  </section>

Compatibilidade: Chrome(🚧Beta), Firefox(🚧Beta), Chromium(🚧Beta) & Safari(✅Suportado)

Layer Rule

Define uma camada de cascata para ser trabalhada, as regas farão parte daquele contexto, não do escopo global da view.

EXEMPLO:

@layer base, component;

@layer base {
  .button {
    background: #eee;
    border: 1px solid #ccc;
    border-radius: 3px;
    color: #333;
    padding: 10px;
    margin: 10px;
  }
}

@layer component {
  .button {
    &__title {
      font-size: 1.5rem;
      font-weight: bold;
    }
    &__icon {
      margin-right: 0.5rem;
    }
  }
}

A ordem de declaração de camadas é importante, pois a camada mais acima será a camada mais próxima do contexto. Caso você altere a ordem, a prioridade do estilo também mudará.

A propriedade layer pode ser útil para resolver problemas de prioridade, não sendo mais necessário usar o atributo important.

Compatibilidade: Chrome(✅Suportado), Firefox(✅Suportado), Chromium(✅Suportado) & Safari(✅Suportado)

Conclusão

Ufa! Foram muitas coisas que conseguimos ver hoje, mas algumas ainda estão em estado de desenvolvimento e será necessário ativar flags do seu navegador para testar.

Caso queria ver o código funcional de cada funcionalidade apresentada aqui, basta acessar o meu repo scss-like-you-never-seen deixa uma star!

Até a próxima!

SCSS como você nunca viu! was originally published in Juntos Somos Mais on Medium, where people are continuing the conversation by highlighting and responding to this story.

A ideia aqui é mostrar a solução que eu consegui. Não consigo afirmar que é a melhor solução, mas funciona.

O código desse post pode ser visto nesse repositório.

Estou começando um projeto do zero para criar um exemplo funcional, como sempre, usando interpretador remoto. Falei sobre isso no meu blog em outro post: Remote interpreter. A new word for develops.

Uma vez o projeto inicial pronto, vamos instalar os plugins:

docker compose run --rm app npm --prefix ./image-mdxbody install --save gatsby-plugin-image gatsby-plugin-sharp gatsby-source-filesystem gatsby-transformer-sharp
docker compose run --rm app npm --prefix ./image-mdxbody install --save gatsby-plugin-mdx gatsby-source-filesystem @mdx-js/react
docker compose run --rm app npm --prefix ./image-mdxbody install --save gatsby-remark-images

Nosso package.json fica da seguinte forma:

  "dependencies": {
    "@mdx-js/react": "^2.2.1",
    "gatsby": "^5.3.3",
    "gatsby-plugin-image": "^3.3.2",
    "gatsby-plugin-mdx": "^5.3.1",
    "gatsby-plugin-sharp": "^5.3.2",
    "gatsby-remark-images": "^7.3.1",
    "gatsby-source-filesystem": "^5.3.1",
    "gatsby-transformer-sharp": "^5.3.1",
    "react": "^18.2.0",
    "react-dom": "^18.2.0"
  }

Precisamos configurar os plugins, vai ficar assim:

  plugins: [
    "gatsby-transformer-sharp",
    "gatsby-plugin-image",
    "gatsby-plugin-sharp",
    {
      resolve: `gatsby-plugin-mdx`,
      options: {
        gatsbyRemarkPlugins: [
          {
            resolve: `gatsby-remark-images`,
            options: {
              maxWidth: 1200,
            },
          },
        ],
      },
    },
  ],

O post não tem como objetivo configuar o MDX, então vou pular a parte de renderizar o MDX na tela.

Uma vez renderizando o MDX você pode usar direto o <img> no body, mas com isso você não tem o benefício do processamento de imagens.

Para conseguir utilizar o maximo possível que o Gatsby pode dar vamos precisar criar o seguinte componente:

import React from 'react';
import { GatsbyImage } from "gatsby-plugin-image";

const MDXImageBody = (props) => {
    console.log(props);
    const image = props.img.mdx.frontmatter.embeddedImagesLocal[props.index].childImageSharp.gatsbyImageData;
    return <GatsbyImage image={image} alt={props.alt}/>

}
export default MDXImageBody;

No body do MDX vamos usar assim:

---
title: Render image in Body
slug: render-image-in-body
embeddedImagesLocal:
  - typeface.jpg
---

import MDXImageBody from "../src/components/MDXImageBody";

# {props.pageContext.frontmatter.title}
My processed image: {props.pageContext.frontmatter.embeddedImagesLocal}

<MDXImageBody img={props.data} index={0} alt={"A new project windows of WebStorm"}/>

A imagem typeface.jpg está no mesmo diretório que o mdx.

Quando você abrir o seu post, a imagem mostrada é uma webp :

Espero conseguir ajudar mais alguém que tenha a mesma dificuldade… Essa é a vida do BackEnd se aventurando em um FrontEnd

Como usar gatsbyImageData no corpo do MDX was originally published in Juntos Somos Mais on Medium, where people are continuing the conversation by highlighting and responding to this story.

Um desenvolvedor, antes de tudo é um profissional. Eu gosto de definir o profissional como alguém que consegue vender uma habilidade para outra pessoa.

Quando você começa a trabalhar, um dos primeiros pensamentos que vem na sua cabeça é: "Como posso ganhar mais?". A resposta é simples, melhores as suas habilidades.

Somos uma categoria privilegiada em muitos sentidos, e ferramentas é o que não falta para um desenvolvedor hoje em dia.

Nesse artigo vamos aprender como se configura um interpretador remoto no WebStorm. Uma IDEs da JetBrains.

Interpretador Remoto

Uma IDE não existe sozinha no seu sistema, o Visual Studio ou Rider precisa do C# na maquina, o Pycharm do Python, WebStorm do npm e assim vai, muitos já instalam junto o que precisam juntos, olha essa imagem onde o WebStorm já diz que vai fazer o download o npm quando eu peço para criar um novo projeto:

O ponto aqui é, quando você vai trabalhar para uma empresa e precisa alterar muitos projetos ao mesmo tempo você começa a ter várias versões de python, npm, c# e coisas como pyenv e nvm começam a aparecer para ajudar. Também começamso a criar ambiente virtuais para instalar versões dos pacotes que preisamos somente para aquele projeto.

E bem, tudo isso funciona… O problema é que em determinado momento você vai precisar de tantas versões que muitas vezes podem nem ser suportadas mais pelo seu SO ou até mesmo encher de tanta coisa a sua máquina que torna ela inutilizável. Quem nunca instalou um pacote sem ---dev ou deu um pip install no lugar errado colocando coisas em lugares onde não deveriam, duvido que você vai lá e remove isso.

O interpretador remoto nada mais é que você ter o ambiente para aquele projeto específico rodar em outro computador, deixando sua máquina local sem absolutamente nenhuma instalação além do necessário para rodar sua IDE.

A maioria das IDEs já dão suporte para isso, o VSCode também tem esse opção. O que vai mudar é a maneira de fazer.

Como computador remoto vamos utilizar o docker, a ideia aqui é ter alguma coisa como esse. docker-compose.ymlna raiz do seu projeto:

version: "3.7"
services:
  db:
    image: postgres:10.1-alpine
  web:
    build: .
    depends_on:
      - db
    command: ["./start.sh"]

Uma uma vez que você fizer o clone do seu projeto e apontar o interpretador remoto para o container web ele será capaz de rodar testes de integração apontando para um banco de dados real que é o container db , consegue ver a mágica? Você consegue ter um ambiente com banco de dados rodando tudo localmente sem instalar nada na sua máquina.

Agora vamos a prática. Lembrando que estou escrevendo isso em 12/2022, e futuramente os prints podem ficar desatualizados, por isso é importante você entender o conceito e não apenas sair fazendo o que está escrito aqui.

Configurando o WebStorm

Se você quiser um exemplo funcional, basta olhar o repositório do meu blog, ele é feito com Gatsby e para construi-lo eu nem mesmo instalei o npm no meu MAC.

Vamos usar como exemplo a criação de um projeto usando Gatsby.

A primeira coisa que você precisa são dois arquivos no diretório que você vai criar o seu projeto:

Dockerfile:

FROM node:19-alpine3.16

RUN npm install -g gatsby-cli@5.2.0

RUN apk update
RUN apk add --update --repository https://dl-3.alpinelinux.org/alpine/edge/testing vips-tools vips-dev fftw-dev gcc g++ make libc6-compat
RUN apk add git
RUN apk add --update --no-cache python3
RUN rm -rf /var/cache/apk/*

WORKDIR /app

COPY . .

docker-compose.yml:

version: "3.8"
services:
  app:
    build: .
    volumes:
      - .:/app
    ports:
      - "8000:8000"
    command:
      [
        "npm", "run", "develop"
      ]

Agora, basta executar . Ele vai fazer o build da imagem e pedir as informações para criar o seu projeto. O resultado final é alguma coisa assim:

Somente com Docker você conseguiu criar um projeto sem instalar absolutamente nada na sua máquina.

Agora você abre o projeto com o WebStorm, vá em settings e procure pela configuração Node.js, a opção Node interpreter estará com um alerta:

Isso, logicamente é porque você não tem o node no seu computador. Vamos criar um interpretar remoto agora.

Abra a combo do interpretador, mande adicionar um novo e escolha remoto. Na janela que for aberta, escolha Docker Compose e na combo Service escolha app que é o nome do serviço que usamos no docker.compose.yml :

Seleciona Ok e Ok de novo.

Agora vamos rodar o projeto, click em Current File:

Edit Configuration, add new e escolha npm:

Configure o necessário para rodar um projeto Gatsby como se fosse localmente:

Selecione OK e aperte Play:

E agora você tem o projeto rodando:

Tente abrir http://localhost:8000/ e você vai tomar um erro: localhost didn't send any data . E agora sim, essa é a pegadinha do interpretador remoto no caso do npm, você precisa explicitar que ele está respondendo no host 0.0.0.0 , basta configurar dessa forma o package.json :

  "scripts": {
    "develop": "gatsby develop -H 0.0.0.0",
    "start": "gatsby develop",
    "build": "gatsby build",
    "serve": "gatsby serve",
    "clean": "gatsby clean"
  },

Agora aperte play novamente e acesse o mesmo endereço:

Pronto, você tem seu projeto rodando localmente. Você pode fazer debug, rodar testes, tudo dentro do container.

Uma vez isso no git, basta outro desenvolvedor fazer o git clone , configurar o interpretador remoto e trabalhar, sem precisar instalar absolutamente nada localmente.

Link para o repositório desse post.

Interpretador Remoto — Um novo mundo para o desenvolvedor was originally published in Juntos Somos Mais on Medium, where people are continuing the conversation by highlighting and responding to this story.