Come sviluppare applicazioni per MongoDB e Redpanda utilizzando Docker Compose

MongoDB non ha bisogno di presentazioni. Dal suo debutto nel 2007, il database dei documenti è cresciuto costantemente in popolarità ed è ora il database al 5° posto al mondo secondo DB Engines. Ora segue solo Oracle, MySQL, SQL Server e PostgreSQL. Ciò è tanto più impressionante se si considera che i primi quattro sono database relazionali tradizionali usciti nel secolo precedente. MongoDB è il numero uno tra la nuova generazione di database "NoSQL" scalabili e distribuiti.

La crescita volubile di MongoDB può essere attribuita a una forte attenzione all'esperienza degli sviluppatori. Il prodotto stesso è semplice, facile da usare e offre un percorso felice dal prototipo alla produzione. Quando provano MongoDB, gli sviluppatori tendono ad avere successo nel trasferire prototipi funzionanti in implementazioni di produzione in piena regola. Questa è la storia da ricordare.

Mentre MongoDB ha semplificato lo sviluppo di database per milioni di sviluppatori in tutto il mondo, Redpanda ha una missione simile per semplificare le applicazioni di streaming in tempo reale. Fin dall'inizio, Redpanda è stato creato con la stessa dedizione alla semplicità, alla facilità d'uso e, soprattutto, alla produttività degli sviluppatori.

Diverso ma uguale

Mentre MongoDB e Redpanda affrontano diverse parti dello stack tecnologico, è interessante notare le somiglianze nel modo in cui offrono un'esperienza di sviluppo piacevole individualmente e come si completano a vicenda quando combinate. Ad esempio:

MongoDB viene fornito come un singolo binario. Così fa Redpanda. A differenza di altre piattaforme di streaming comparabili, Redpanda non ha dipendenze da servizi esterni come Apache Zookeeper. Ciò rende Redpanda facile da installare tramite i gestori di pacchetti come lo è localmente sul laptop di uno sviluppatore. Viene inoltre fornito come immagine Docker, quindi puoi avviarlo tramite Docker Compose, integrarlo con pipeline CI/CD o implementarlo in Kubernetes con un semplice controller.
Sia Redpanda che MongoDB sono sistemi distribuiti. Per ottenere scalabilità e resilienza, è sufficiente installare lo stesso identico binario su più server e puntarli l'uno verso l'altro. Ciò consente a sviluppatori e architetti di rinviare le decisioni su scalabilità e prestazioni nelle prime fasi del processo di sviluppo. Il modello mentale e il codice dell'applicazione sono gli stessi indipendentemente dal fatto che venga eseguita su un laptop, una macchina virtuale single-core o su diversi server di produzione ad alta potenza.
Sia Redpanda che MongoDB vengono forniti con impostazioni predefinite ragionevoli. Ciò riduce al minimo il numero di manopole che gli sviluppatori o gli amministratori devono modificare, indipendentemente dal fatto che stiano creando un ambiente di prototipazione (come con Docker Compose) o effettuando il provisioning di un cluster di produzione. Redpanda va ancora oltre con la possibilità di sintonizzarsi automaticamente sull'hardware sottostante, consentendogli di massimizzare le risorse disponibili di CPU, memoria e disco con il minimo sforzo.
Il carico cognitivo per gli sviluppatori non dipende solo dalla scalabilità dei byte al secondo, ma anche dal dover decidere quale forma dare ai dati e quali tipi scegliere. MongoDB offre agli sviluppatori la flessibilità di evolvere lo schema nel tempo con un modello di dati simile a JSON. Allo stesso modo, gli eventi e i messaggi inviati a Redpanda non richiedono uno schema in anticipo. Tuttavia, c'è la possibilità di utilizzare uno schema quando necessario e di evolvere lo schema per soddisfare le mutevoli esigenze aziendali.

Collegamento di MongoDB a Redpanda

MongoDB si integra con Redpanda in due modi:come sink, per cui gli eventi Redpanda vengono consumati e inviati a MongoDB per inserimenti o aggiornamenti, o come sorgente CDC, in cui MongoDB esternalizza il proprio log delle modifiche a un argomento Redpanda per altri (incluse altre istanze MongoDB) per consumare. L'integrazione avviene tramite Kafka Connect. Poiché Redpanda è compatibile con Apache Kafka, i connettori Kafka esistenti funzionano perfettamente. Questa capacità di sfruttare il vasto ecosistema di Kafka è un altro modo in cui Redpanda semplifica la vita degli sviluppatori!

I nostri amici di MongoDB hanno messo insieme una demo di stock ticker che integra MongoDB e Redpanda tramite Kafka Connect. La demo richiede Docker Compose e docker-compose.yml il file è simile a questo:

version: '3.7'
services:

  redpanda:
    command:
    - redpanda
    - start
    - --smp
    - '1'
    - --reserve-memory
    - 0M
    - --overprovisioned
    - --node-id
    - '0'
    - --kafka-addr
    - PLAINTEXT://0.0.0.0:9092,OUTSIDE://0.0.0.0:9093
    - --advertise-kafka-addr
    - PLAINTEXT://redpanda:9092,OUTSIDE://localhost:9093
    image: docker.vectorized.io/vectorized/redpanda:v21.9.3
    ports:
    - 9093:9093

  connect:
    image: confluentinc/cp-kafka-connect-base:latest
    build:
      context: .
      dockerfile: Dockerfile-MongoConnect
    depends_on:
      - redpanda
    ports:
      - "8083:8083"
    environment:
      CONNECT_BOOTSTRAP_SERVERS: 'redpanda:9092'
      CONNECT_REST_ADVERTISED_HOST_NAME: connect
      CONNECT_REST_PORT: 8083
      CONNECT_GROUP_ID: connect-cluster-group
      CONNECT_CONFIG_STORAGE_TOPIC: docker-connect-configs
      CONNECT_CONFIG_STORAGE_REPLICATION_FACTOR: 1
      CONNECT_OFFSET_FLUSH_INTERVAL_MS: 10000
      CONNECT_OFFSET_STORAGE_TOPIC: docker-connect-offsets
      CONNECT_OFFSET_STORAGE_REPLICATION_FACTOR: 1
      CONNECT_STATUS_STORAGE_TOPIC: docker-connect-status
      CONNECT_STATUS_STORAGE_REPLICATION_FACTOR: 1
      CONNECT_PLUGIN_PATH: "/usr/share/java,/usr/share/confluent-hub-components"
      CONNECT_AUTO_CREATE_TOPICS_ENABLE: "true"
      CONNECT_KEY_CONVERTER: "org.apache.kafka.connect.json.JsonConverter"
      CONNECT_VALUE_CONVERTER: "org.apache.kafka.connect.json.JsonConverter"

  mongo1:
    image: "mongo:5.0.3"
    volumes:
      - /data/db
    ports:
      - "27017:27017"
    restart: always

  nodesvr:
    image: node:16
    build:
      context: .
      dockerfile: Dockerfile-Nodesvr
    depends_on:
      - redpanda
      - mongo1
    ports:
      - "4000:4000"

Per un tutorial completo e una procedura dettagliata, visita il post del blog complementare su MongoDB. Diamo il benvenuto a tutti dalla community di MongoDB per provare Redpanda e unirsi alla community di Redpanda Slack, dove puoi interagire con gli ingegneri che stanno costruendo Redpanda e plasmando il futuro dello streaming in tempo reale!

Ulteriori letture

Documentazione Redpanda
Punto di riferimento di Redpanda contro Kafka
Iniziare con Redpanda