---
title: "Kafka Simulator v1.9 - il livello piattaforma e un formato di URL pubblico"
date: 2026-10-09T00:00:00.000Z
author: "michal"
excerpt: "Gli observer di Multi-Region Cluster, Cluster Linking e il tiered storage completano il racconto su DR e storage in dodici scenari - e il formato di URL del playground diventa pubblico, con monedula-sim-link per trasformare in un link un cluster in esecuzione, o la descrizione di un agente IA."
---
La v1.9 aggiunge **12 nuovi scenari** - altri dieci nel modulo dr e due in un nuovo modulo tiered-storage - e porta il programma del [Kafka Simulator](/kafka-simulator/) a **112 su 134**. Pubblica anche qualcosa su cui il simulatore si basa fin dall'inizio: il formato dei suoi link.

## Cosa c'è nella v1.9

**Altro disaster recovery (`dr`, 10 scenari).** Due risposte a livello di piattaforma ai problemi che la v1.8 aveva posto con MirrorMaker 2:

- **[Observer di Multi-Region Cluster](/kafka-simulator/scenarios/mrc-observers/)** - repliche che seguono il log senza entrare nell'ISR, così una copia remota non costa nulla sul percorso di scrittura. [Quanto restano indietro](/kafka-simulator/scenarios/observer-lag/), [dove posizionarle](/kafka-simulator/scenarios/durability-vs-latency/) e [come vengono promosse](/kafka-simulator/scenarios/observer-promotion/) - compreso [il caso in cui la promozione ha bisogno di un leader ormai irraggiungibile](/kafka-simulator/scenarios/observer-promotion-reachable-leader/).
- **[Cluster Linking](/kafka-simulator/scenarios/cluster-linking-offset-preserving/)** - un mirror byte per byte che preserva gli offset, così un consumer che fa failover non ha bisogno di alcuna traduzione. [I mirror topic restano in sola lettura finché non vengono promossi](/kafka-simulator/scenarios/mirror-read-only-promote-writable/), [gli offset committati dei consumer si sincronizzano attraverso il link così come sono](/kafka-simulator/scenarios/consumer-offset-sync-link/), [il link si inverte sul posto per un failback pulito](/kafka-simulator/scenarios/bidirectional-links-failback/), e [uno scenario lo fa girare fianco a fianco con MirrorMaker 2](/kafka-simulator/scenarios/cluster-linking-vs-mm2/) sulla stessa topologia. Il free play guadagna il controllo corrispondente: un editor di regioni e mirror link sulle topologie a due regioni, dove ogni link è MirrorMaker 2 o Cluster Linking e può essere invertito.

**Tiered storage (`tiered-storage`, 2 scenari).** Vecchi segmenti scaricati sull'object storage: [l'intero ciclo di vita di offload, rilettura e scadenza](/kafka-simulator/scenarios/confluent-tiered-lifecycle/), con `localStartOffset` e `logStartOffset` che si allontanano - e la [retention infinita](/kafka-simulator/scenarios/infinite-retention-tiered/), dove i segmenti invecchiati lasciano il disco locale ma un consumer in ritardo li rilegge comunque tutti, nessuno escluso.

## Ogni sessione è un link

Il playground mantiene tutto il suo stato nell'URL. Un link può aprire uno scenario scritto in anticipo a un passo preciso, riprodurre una sequenza di operazioni sul cluster o tirare su un cluster free-play personalizzato - ed è così che funziona ogni pulsante «condividi» del simulatore.

Dalla v1.9 quel formato è [pubblico e documentato](/flock/docs/kafka-simulator/reference/url-format/) (in inglese): i parametri di query, la grammatica del registro delle azioni, la codifica della forma del cluster e cosa fa il playground con una voce che non riesce a interpretare. Ogni esempio della specifica viene decodificato dalla suite di test del simulatore stesso, quindi il documento non può discostarsi dal codice.

Un formato documentato significa che i link possono arrivare da qualcosa di diverso dal playground - uno script, un job di CI o un agente IA. Il primo generatore esce con questa release.

## monedula-sim-link: un cluster reale come link

Descrivere a mano il cluster a cui tieni davvero - broker per broker, topic per topic - è noioso e soggetto a errori. [monedula-sim-link](/it/flock/sim-link/) è una piccola CLI in Go che si connette **in sola lettura** a un cluster Kafka reale e stampa il link al playground che lo visualizza:

```bash
$ go install github.com/monedula-dev/monedula-sim-link/cmd/monedula-sim-link@latest
$ monedula-sim-link connect --brokers localhost:9092 --topics orders,payments
https://monedula.dev/kafka-simulator/playground?scenario=free&actions=…&size=…
```

Il link apre il cluster in esecuzione come simulatore: broker, topic, posizionamento delle partizioni, fattore di replica, broker offline, gap di ISR, consumer group con i loro membri, configurazioni dei topic e un campione del volume di dati - un'immagine che puoi mettere in pausa, percorrere passo dopo passo, rompere senza toccare la produzione e mandare a un collega nel mezzo di un incidente al posto di un paragrafo che la descriva.

**In sola lettura, e verificabile in un solo file.** Puntare uno strumento su un cluster di produzione è una questione di fiducia, quindi la garanzia è circoscritta ed esplicita. `connect` invia solo richieste di lettura - ApiVersions, Metadata, ListOffsets e, per gruppi e configurazioni, ListGroups, DescribeGroups, OffsetFetch e DescribeConfigs. Metadata imposta `AllowAutoTopicCreation=false`, quindi nemmeno cercare un topic può mai crearlo. Nessun record prodotto, nessuna configurazione modificata, nessun ingresso in un gruppo, nessun offset committato. L'intera superficie client vive in un solo file, [`snapshot/kafka.go`](https://github.com/monedula-dev/monedula-sim-link/blob/main/snapshot/kafka.go), con test che dimostrano che un lookup fallito non crea automaticamente il topic e che leggere gli offset di un gruppo non li modifica mai.

**Si adatta a come sono protetti i cluster.** TLS, mutual TLS e SASL/SCRAM sono supportati, con la password letta da `MONEDULA_SIM_LINK_PASSWORD` così resta fuori dalla cronologia della shell:

```bash
export MONEDULA_SIM_LINK_PASSWORD='…'
monedula-sim-link connect --brokers broker1:9093,broker2:9093 \
  --tls --ca-cert ./cluster-ca.pem \
  --sasl-mechanism scram-sha-512 --username viewer
```

I topic si selezionano per nome esatto, per regex o in entrambi i modi, e `--dry-run` stampa le corrispondenze tra i nomi reali e quelli del simulatore e la dimensione del cluster derivata prima di consegnarti l'URL. Tutto ciò che il link codifica è una descrizione compatta della forma e un campione del volume; il simulatore non ha un backend, quindi i tuoi dati non lasciano mai la tua macchina.

## Un server MCP per gli agenti IA

`monedula-sim-link mcp` parla il **Model Context Protocol** su stdio, così Claude Code, Claude Desktop o qualsiasi altro client MCP possono costruire link su richiesta. Chiedi «mostrami un cluster di 6 broker in cui muore il leader di `orders`» o «visualizza il nostro cluster di staging», e l'agente restituisce un link che apre esattamente quello. Il server espone quattro strumenti:

- **`build_playground_url`** - una sessione free-play a partire da una descrizione dichiarativa: una topologia, una forma di cluster (broker; topic con partizioni, RF, `min.insync.replicas`, cleanup policy; rack awareness) e una lista ordinata di azioni temporizzate - produrre record, uccidere e riavviare broker, aggiungere producer e consumer group, modifiche di configurazione, riassegnazione, offload sul tiered storage, throttling.
- **`open_scenario`** - il link a uno degli scenari selezionati e scritti in anticipo, tramite il suo identificativo a punti (per esempio `00.1.3`).
- **`validate_actions`** - ciò che il playground caricherebbe *davvero* da una stringa `actions` grezza o da un URL completo: le azioni che sopravvivono, ogni voce scartata con il suo motivo, e la lunghezza e il conteggio confrontati con i limiti del codec.
- **`cluster_to_url`** - lo snapshot di `connect` come strumento, con la stessa garanzia di sola lettura.

Affidare la costruzione degli URL a un LLM è proprio il punto in cui le cose vanno storte senza far rumore - un separatore storpiato, un percorso di configurazione che il simulatore non accetta, un valore `actions` oltre il limite di lunghezza - e il playground scarta in silenzio ciò che non riesce a interpretare. Per questo ogni strumento passa per lo stesso codec fail-fast della CLI, e nessun URL viene restituito a meno che il suo valore `actions` non si decodifichi di nuovo esattamente nello stesso log. Quando la validazione fallisce, l'errore indica il campo, il separatore o il percorso di configurazione colpevole, così l'agente può correggere il proprio input invece di consegnare un link troncato.

Registrarlo in Claude Code richiede una riga:

```bash
claude mcp add monedula-sim-link -- monedula-sim-link mcp
```

Per Claude Desktop, aggiungilo a `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "monedula-sim-link": {
      "command": "monedula-sim-link",
      "args": ["mcp", "--base-url", "https://monedula.dev/kafka-simulator/playground"]
    }
  }
}
```

`--base-url` è facoltativo; puntalo su `http://localhost:4321/kafka-simulator/playground` per generare link verso un server di sviluppo locale. Il server è costruito sull'SDK ufficiale [`modelcontextprotocol/go-sdk`](https://github.com/modelcontextprotocol/go-sdk).

monedula-sim-link vive in un proprio repository open source, [monedula-dev/monedula-sim-link](https://github.com/monedula-dev/monedula-sim-link) su GitHub - un modulo Go autonomo con licenza Apache-2.0, che si installa con `go install` o come binario precompilato per Linux, macOS e Windows dalla [pagina delle release](https://github.com/monedula-dev/monedula-sim-link/releases). Lo strumento non invia telemetria, ed è il generatore di riferimento per il formato degli URL: ogni link che produce si decodifica nel playground esattamente nel log che lo strumento stesso vi ha scritto.

## Scalare un cluster come fa Kafka

Il free play ora cambia il numero di broker come fa un cluster reale. Fino alla v1.9, aggiungere un broker ribilanciava in silenzio le partizioni su di esso - cosa che, come ha [fatto notare](https://github.com/monedula-dev/monedula-kafka-simulator-issues/issues/1) un lettore, Kafka non fa. Un broker che aggiungi ora entra vuoto: nessuna partizione si sposta su di esso da sola, e l'inspector del cluster lo segnala, con un pulsante **Rebalance partitions** accanto. Nel terminale, `kafka-reassign-partitions --generate` propone un piano a partire da una lista di topic e una lista di broker, `--execute` lo avvia e `--verify` lo conferma. Nell'altra direzione vale la stessa regola: un broker che contiene ancora partizioni va drenato prima di poter essere rimosso, nello stesso ordine in cui dismetteresti un broker reale.

Apri il [simulatore](/kafka-simulator/), fai il failover di una regione con Cluster Linking e condividi il link.