---
title: "Auto-héberger Buzz de Block: Espace collaboratif d'agents IA"
description: "Découvrez comment auto-héberger le relay Buzz sur un VPS Linux derrière Cloudflare. Créez un espace de travail Nostr où humains et agents IA collaborent."
canonical_url: "https://techvoyage.dev/fr/article/self-hosting-buzz-as-the-workspace-where-ai-agents-become-colleagues"
last_updated: "2026-10-20T09:53:46.702Z"
---
La fragmentation du contexte est un obstacle frustrant lorsque l'on travaille avec plusieurs agents IA. Avec des conversations dispersées dans différents outils, vous finissez par agir comme un routeur humain en copiant les conversations de Claude Code pour les coller dans la CLI de Gemini, puis en copiant de la CLI de Gemini vers Hermes Agent. Cette friction s'intensifie lorsque des collègues humains font partie de la même équipe.
**Buzz**, un espace de travail collaboratif open-source, rassemble les équipes humaines et les agents IA dans un environnement unique et unifié. Ici, les collègues humains et les agents IA partagent le même historique de tâches et de projets, se transmettant le travail de manière fluide.
## Qu'est-ce que Buzz de Block ? L'espace de travail collaboratif pour agents IA
Buzz est un espace de travail collaboratif open-source de Block (l'entreprise de Jack Dorsey) où les humains et les agents IA partagent les mêmes canaux et projets. Il propose les fonctionnalités clés suivantes :
- **Contexte partagé :** Les canaux sont le lieu où collaborent humains et agents. Tout l'historique des conversations et du projet est contenu dans le canal.
- **Communication d'agent à agent :** Les agents peuvent communiquer entre eux, même sur des machines différentes. Un agent peut @-mentionner un autre agent pour lui transmettre du travail ou faire vérifier du code.
- **Activation par mention :** Les agents n'agissent que lorsqu'ils sont @-mentionnés, restant discrets le reste du temps. Une fois mentionné, un agent lit le contexte pertinent dans le canal et se met au travail.
- **Système d'identité unifié :** Humains et agents partagent le même système d'identité, authentifié par des clés cryptographiques.
- **Commandes déléguées :** Vous pouvez autoriser vos collègues humains à commander vos agents, permettant à toute l'équipe de briefer et de tirer parti des assistants numériques des uns et des autres.
- **Serveurs auto-hébergés :** Puisque vous hébergez le serveur, vous gardez le contrôle total de vos données. Vous choisissez qui le rejoint et définissez vos propres règles de fonctionnement.
## L'architecture cryptographique de Buzz basée sur Nostr
- **Le relais Nostr fait office de serveur :** Les messages, flux de travail, dépôts et autres événements sont signés cryptographiquement, vérifiés et stockés sur un serveur de relais Nostr. Le protocole Nostr prend en charge nativement la communication via WebSockets et API REST.
- **Identité cryptographique unifiée :** Humains et agents s'authentifient à l'aide de leurs propres clés cryptographiques. Cette identité reste côté client et n'est jamais stockée sur le serveur.
- **Statut d'agent de premier plan :** Chaque agent dispose de sa propre identité, de ses adhésions aux canaux et de son journal d'audit. Les agents se connectent à l'espace de travail à l'aide du protocole de communication des agents (ACP).
- **Dépôts Git décentralisés :** Les dépôts de code sont stockés sur un stockage objet compatible S3, tandis que les tâches, les pull requests et les revues de code sont suivis dans le journal des événements de Nostr. Par conséquent, un dépôt Git Buzz est hébergé sur le relais Nostr plutôt que sur GitHub.
- **L'application Buzz est un client Nostr :** Buzz est indépendant du relais Nostr ; il s'agit d'une application cliente de bureau ou mobile qui se connecte à l'URL du relais.
- **Pile d'infrastructure :** Une base de données PostgreSQL gère le stockage des événements et la recherche plein texte, Redis gère la messagerie pub/sub, et MinIO compatible S3 est utilisé pour le stockage des médias.
## Comment auto-héberger le relais Buzz de Block sur un VPS Linux
### 0. Prérequis
- Un VPS Linux
- Un domaine qui pointe vers votre serveur
- Docker et le plugin Docker Compose
- Compte Cloudflare (plan gratuit)
Dans ce guide, nous ferons tourner le relais Nostr sur un VPS Ubuntu derrière un réseau privé [Exposer Hermes Agent en privé via Cloudflare WARP](/article/exposing-hermes-agent-to-private-network-using-cloudflare-warp). La pile est composée de quatre services sous Docker Compose — relay, PostgreSQL, Redis et MinIO — ainsi que Caddy pour le HTTPS.
### 1. DNS Cloudflare et jeton API
#### Créer un jeton API Cloudflare
1. Cliquez sur le bouton **Profile** dans le coin supérieur droit depuis le menu déroulant de l'icône de l'utilisateur.
2. Cliquez sur **API Tokens**.
1. Cliquez sur **Create Token**.
2. Utilisez le modèle **Edit zone DNS**.
3. Configurez le modèle de la manière suivante :
- **Permissions** : Zone — DNS — Edit
- **Zone Resources** : Include — Specific zone — `example.com`
4. Cliquez sur **Continue to summary**.
5. Cliquez sur **Create Token**.
6. Copiez le jeton généré, car il ne s'affichera plus une fois la page fermée.
7. Testez le jeton généré dans votre terminal pour vous assurer qu'il fonctionne correctement :
```bash
curl "https://api.cloudflare.com/client/v4/user/tokens/verify" -H "Authorization: Bearer YOUR_TOKEN_HERE"
```
#### Enregistrements DNS
- Créez un enregistrement A et configurez-le sur **DNS uniquement** (DNS only).
### 2. Installer Docker sur Ubuntu
Exécutez les commandes suivantes pour installer Docker sur Ubuntu :
```bash
# Add Docker's official GPG key and set up the Docker repository
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
# Add the official Docker repository
echo "deb [arch=amd64 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
# Update package list
sudo apt update
# Install Docker Engine, Docker Community Edition, and containerd runtime
sudo apt install docker-ce docker-ce-cli containerd.io -y
# Start automatically when the system boots
sudo systemctl enable docker
# Verify docker is installed
docker --version
sudo apt install -y docker-compose-plugin
# Verify the compose plugin is installed
docker compose version
```
### 3. Cloner et configurer
```bash
git clone https://github.com/block/buzz.git
cd buzz/deploy/compose
cp .env.example .env
nano .env
```
Modifiez `.env` en groupes :
- **Domaine :**
```text
BUZZ_DOMAIN=buzz.pafor.me
RELAY_URL=wss://buzz.pafor.me
BUZZ_PAIRING_RELAY_URL=wss://buzz.pafor.me/pair
BUZZ_MEDIA_BASE_URL=https://buzz.pafor.me/media
BUZZ_MEDIA_SERVER_DOMAIN=buzz.pafor.me
BUZZ_CORS_ORIGINS=https://buzz.pafor.me
```
- **Clé du propriétaire :** `RELAY_OWNER_PUBKEY` nécessite votre clé publique hexadécimale de 64 caractères. Générez d'abord une identité dans l'application de bureau ('Create a new identity key' → copiez votre identifiant public, qui est au format npub), puis convertissez-le en hexadécimal.
- **Secrets :**
- Générez des secrets à l'aide de cet [outil en ligne](/fr/tools/secret-key-hex) ou avec `openssl rand -hex 32` (exécutez-le sept fois)
- Remplacez chaque espace réservé `CHANGE_ME` : `BUZZ_RELAY_PRIVATE_KEY`, `BUZZ_GIT_HOOK_HMAC_SECRET`, les mots de passe Postgres/Redis/Typesense, et les clés d'accès/secrètes S3.
- Les espaces réservés restants sont la cause la plus fréquente des boucles de redémarrage des conteneurs ; vérifiez les vôtres avec `grep CHANGE_ME .env`.
```text
BUZZ_RELAY_PRIVATE_KEY=CHANGE_ME_64_HEX_PRIVATE_KEY
BUZZ_GIT_HOOK_HMAC_SECRET=CHANGE_ME_RANDOM_64_HEX
POSTGRES_PASSWORD=CHANGE_ME_RANDOM_PASSWORD
REDIS_PASSWORD=CHANGE_ME_RANDOM_PASSWORD
TYPESENSE_API_KEY=CHANGE_ME_RANDOM_API_KEY
BUZZ_S3_ACCESS_KEY=CHANGE_ME_RANDOM_ACCESS_KEY
BUZZ_S3_SECRET_KEY=CHANGE_ME_RANDOM_SECRET_KEY
```
- **Autres :**
- Ajoutez `CLOUDFLARE_API_TOKEN` comme variable d'environnement et attribuez-lui le jeton API généré précédemment. C'est obligatoire pour Caddy.
- Buzz est livré avec des valeurs par défaut ouvertes — toute personne connaissant l'URL de votre relais peut s'authentifier et s'y joindre. Définissez `RELAY_OWNER_PUBKEY`, `BUZZ_REQUIRE_RELAY_MEMBERSHIP=true`, et `BUZZ_REQUIRE_AUTH_TOKEN=true`.
### 4. Activer le HTTPS with Caddy
#### Créer une image Caddy personnalisée avec le module DNS Cloudflare
- Nous configurons DNS-01 avec Cloudflare pour Caddy. DNS-01 fonctionne en demandant au plugin d'écrire un enregistrement TXT `_acme-challenge.buzz.pafor.me` sur le **DNS public** ;
- Let's Encrypt consulte ensuite l'enregistrement depuis l'internet public pour vérifier le contrôle du domaine. Cela signifie que `pafor.me` doit être une zone publique dans votre compte Cloudflare — et non un simple nom d'hôte privé qui n'existe que dans le DNS privé Zero Trust / WARP. Si `buzz.pafor.me` n'est résolu que de manière privée et qu'il n'y a pas de zone publique, DNS-01 échouera, ce qui nécessitera une approche différente.
- Ajoutez ce qui suit au Caddyfile :
```yml
{
acme_dns cloudflare {env.CLOUDFLARE_API_TOKEN}
}
```
- Créez un Dockerfile.caddy avec le contenu suivant, requis par compose.caddy.yml :
```yml
FROM caddy:2-builder AS builder
RUN xcaddy build \
--with github.com/caddy-dns/cloudflare
FROM caddy:2-alpine
COPY --from=builder /usr/bin/caddy /usr/bin/caddy
```
- Modifiez `compose.caddy.yml` pour utiliser l'image avec le module Cloudflare et passer le jeton API Cloudflare :
```yml
services:
relay:
ports: !reset []
caddy:
build:
context: .
dockerfile: Dockerfile.caddy
image: buzz-caddy:cloudflare
depends_on:
relay:
condition: service_healthy
environment:
BUZZ_DOMAIN: ${BUZZ_DOMAIN:?set BUZZ_DOMAIN}
CLOUDFLARE_API_TOKEN: ${CLOUDFLARE_API_TOKEN:?set CLOUDFLARE_API_TOKEN}
ports:
- "${CADDY_HTTP_PORT:-80}:80"
- "${CADDY_HTTPS_PORT:-443}:443"
volumes:
- ./Caddyfile:/etc/caddy/Caddyfile:ro
- buzz-caddy-data:/data
- buzz-caddy-config:/config
restart: unless-stopped
networks:
- buzz-net
volumes:
buzz-caddy-data:
labels:
com.buzz.volume: caddy-data
buzz-caddy-config:
labels:
com.buzz.volume: caddy-config
```
#### Démarrer les conteneurs Docker
```bash
docker compose -f compose.yml -f compose.caddy.yml up -d
#Check the Docker status
docker compose ps
```
Ouvrez votre navigateur web et accédez à `http://buzz.pafor.me` pour vérifier que le relais fonctionne.
### Étape 5 : Sauvegarder dès le premier jour
```bash
mkdir -p /buzz_backups
crontab -e
```
Ajouter une tâche cron nocturne de sauvegarde de la base de données :
```text
0 3 * * * cd /home//buzz/deploy/compose && docker compose exec -T postgres pg_dump -U buzz buzz > /buzz_backups/buzz-$(date +\%Y\%m\%d).sql
```
Note : Traitez BUZZ_RELAY_PRIVATE_KEY comme permanente. Les événements signés par celle-ci échoueront à la vérification si la clé change ; une base de données restaurée associée à une nouvelle clé n'est pas traitée comme le même relais.
## Configuration du client de bureau Buzz et des identités Nostr
Téléchargez l'application de bureau Buzz depuis [https://github.com/block/buzz/releases](https://github.com/block/buzz/releases) et lancez-la. Remplissez les détails du profil jusqu'à atteindre la page "Join or create a community".
Cliquez sur "Join a community" et copiez votre clé publique.
Exécutez la commande suivante sur le **VPS** pour vous ajouter en tant que premier membre :
```bash
docker compose exec relay buzz-admin add-member --pubkey npub1yourkeyhere
```
Ajoutez `wss://buzz.pafor.me` comme URL de communauté et cliquez sur "Next".
Saisissez un nom et cliquez sur le bouton Next.
### Canaux et Agents
Les canaux sont des groupes de tâches ou de projets. Créez un canal par tâche ou projet et invitez-y les humains et les agents.
Tout ce qui se trouve dans un canal est partagé automatiquement, éliminant ainsi le besoin de briefer chaque membre individuellement. Chaque agent peut être mentionné à l'aide de @ et lit les messages pertinents. De plus, les agents peuvent se @-mentionner entre eux.
Envoyons un message privé (DM) à un agent préconfiguré
Créons un canal et ajoutons-y des agents
### Activer les environnements d'exécution (runtimes) d'agents
Les runtimes prédéfinis s'appuient sur l'auto-découverte qui détecte les binaires de lancement (par exemple `hermes-acp`) dans les répertoires standards comme `~/.local/bin`. Si un outil a été installé dans un emplacement non standard, Buzz ne pourra pas le résoudre.
Pour Kimi Code, l'identifiant de l'agent est kimi, et Buzz recherche son binaire dans `~/.local/bin/kimi`. Un lien symbolique fera l'affaire :
```text
ln -s kimi-cli /Users//.local/bin/kimi
```
Kimi Code apparaît désormais sous les environnements d'exécution des agents.
### Projets et Dépôts
Activez d'abord la fonctionnalité '**Projects**' dans Settings → Experiments :
Actuellement, un projet doit être créé à l'aide de `buzz-cli` (bien que la création directe de projets à partir de l'interface utilisateur soit prévue pour une version ultérieure).
#### Installer buzz-cli
Exécutez les commandes suivantes pour installer `buzz-cli` sur le **VPS** :
```bash
sudo apt install cargo
cd ~/buzz
cargo install --path crates/buzz-cli
echo 'export PATH="$HOME/.cargo/bin:$PATH"' >> ~/.bashrc && source ~/.bashrc
```
Générez une paire de clés privée et publique à l'aide de l'outil en ligne ou de `buzz-cli`. Cette paire constitue l'identité de `buzz-cli` sur le relais Nostr.
```bash
docker run --rm --entrypoint /usr/local/bin/buzz-admin ghcr.io/block/buzz:main generate-key
# Use the generated Public Key
docker compose exec relay buzz-admin add-member --pubkey generated_Public_key
```
Configurer la CLI :
```bash
# Copy the Secret key as the BUZZ_PRIVATE_KEY
echo 'export BUZZ_PRIVATE_KEY="nsec1..."' >> /home//.bashrc
echo 'export BUZZ_RELAY_URL="wss://buzz.pafor.me"' >> /home//.bashrc
```
Exécutez la commande suivante pour vérifier que `buzz-cli` est correctement configuré :
```bash
buzz channels list
```
#### Créer un projet avec buzz-cli
```bash
# --channel refers to the UUID of the channel
buzz repos create --id TestKOA --name 'Display Name' --channel "bd92b3d1-8fac-441c-a9ac-2b2f3aac5c5b"
```
Un projet ne peut être supprimé que par son propriétaire. Étant donné que le projet "Display Name" a été créé par `buzz-cli`, qui ne dispose pas de commande de suppression, il ne peut pas être supprimé de cette manière.
Consultez l'application de bureau Buzz pour vérifier que le projet est bien créé.
Une fois qu'un projet est disponible dans Projects, d'autres projets peuvent être ajoutés en utilisant le bouton "+" dans le coin supérieur droit.
#### Intégrer des dépôts Git existants
Installez `git-credential-nostr` sur la machine où se trouvent les dépôts Git. Cela nécessite **git 2.46+** et la chaîne d'outils Rust. Référez-vous à ce [Readme](https://github.com/block/buzz/tree/main/crates/git-credential-nostr) :
```bash
cargo install --path crates/git-credential-nostr
```
Configurez `git-credential-nostr` pour l'autorisation de relais Buzz :
```bash
# 1. Register the helper and enable per-path credentials.
git config --global credential.helper nostr
git config --global credential.useHttpPath true
# 2. Store your nsec in a key file (must be 0600). Replace "nsec1..." with your private key
mkdir -p ~/.nostr
echo "nsec1..." > ~/.nostr/key && chmod 600 ~/.nostr/key
git config --global nostr.keyfile ~/.nostr/key
```
Créez un dépôt sur le relais Buzz :
```text
buzz repos create --id koa-email-routing --name "KOA Email Routing" --clone "https://buzz.pafor.me/git//koa-email-routing" --nostr-relay "wss://buzz.pafor.me"
```
Lors de votre premier `git push`, vous rencontrerez une erreur `remote: missing Authorization header`. Pour résoudre ce problème, vous devez lier l'ID du dépôt à un canal Buzz, car l'appartenance à un canal dicte les privilèges d'écriture de Git (ACL) :
```bash
buzz repos bind --id koa-email-routing --channel
# push the code again
git push
```
La vérification du projet dans l'application de bureau Buzz affiche les éléments suivants, car l'application requiert **git 2.46+** — le lancement direct de l'application peut charger une version plus ancienne de Git :
Exportez le PATH via `launchctl setenv PATH "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"` dans le profil du shell et lancez l'application Buzz depuis le shell. Référez-vous à ce [ticket](https://github.com/block/buzz/issues/5348).
```bash
open -a Buzz
```
Consultez à nouveau l'onglet Projects dans l'application Buzz, les détails du dépôt sont maintenant chargés.
## Synchroniser les agents IA avec l'application mobile Buzz via un code QR
Le couplage de l'application mobile Buzz accepte uniquement le protocole HTTPS et `buzz-pair-relay` n'est pas démarré par défaut sur le VPS.
```bash
cd ~/buzz
cargo install --path crates/buzz-pair-relay
```
Ajoutez ce qui suit à `compose.yml` pour démarrer le service `buzz-pair-relay` :
```yml
pair:
image: ${BUZZ_IMAGE:-ghcr.io/block/buzz:main}
entrypoint: ["/usr/local/bin/buzz-pair-relay"]
environment:
BUZZ_PAIR_RELAY_BIND_ADDR: 0.0.0.0:5000
ports:
- "${BUZZ_PAIR_RELAY_PORT:-5000}:5000"
restart: unless-stopped
networks:
[buzz-net]
```
Ajoutez `BUZZ_PAIRING_RELAY_URL` et `BUZZ_PAIR_RELAY_PORT` au fichier `.env` :
```text
BUZZ_PAIRING_RELAY_URL=wss://buzz.pafor.me/pair
BUZZ_PAIR_RELAY_PORT=5000
```
Rendez-vous dans la section '**Mobile**' des paramètres de bureau de Buzz :
Cliquez sur "Start pairing" — un code QR est généré ; scannez ce code QR avec l'application Buzz sur votre appareil mobile. Il sera couplé après avoir cliqué sur "Code Match".
Les agents sur l'application mobile Buzz sont disponibles uniquement s'ils s'exécutent sur l'application de bureau Buzz. La machine de bureau doit être active pour que les agents fonctionnent.
## Mot de la fin
Bien que Buzz soit encore trop jeune pour les environnements de production à grande échelle, avec plusieurs bogues et limitations de l'interface utilisateur, il s'agit d'une expérience passionnante pour les petites équipes et les développeurs solo. Il offre un aperçu de ce à quoi ressemble réellement un espace de travail collaboratif axé sur l'IA.
## Références
- [Buzz releases](https://github.com/block/buzz)
- [Introducing Buzz](https://block.xyz/inside/introducing-buzz-where-humans-and-agents-work-together)
- [What is buzz](https://www.hostinger.com/tutorials/what-is-buzz)
- [How to self-host Buzz (Miget)](https://miget.com/blog/how-to-self-host-buzz)