Hur man utvecklar applikationer för MongoDB och Redpanda med Docker Compose

MongoDB behöver ingen introduktion. Sedan debuten 2007 har dokumentdatabasen stadigt ökat i popularitet och är nu den 5:e rankade databasen i världen enligt DB Engines. Det spårar nu endast Oracle, MySQL, SQL Server och PostgreSQL. Detta är desto mer imponerande när man betänker att de fyra främsta är traditionella relationsdatabaser som kom ut under förra seklet. MongoDB är nummer ett bland den nya generationen skalbara, distribuerade "NoSQL"-databaser.

MongoDB:s kvicksilvertillväxt kan tillskrivas ett starkt fokus på utvecklarupplevelse. Produkten i sig är enkel, lätt att använda och ger en lycklig väg från prototyp till produktion. När man försöker MongoDB tenderar utvecklare att lyckas med att flytta fungerande prototyper till fullskaliga produktionsinstallationer. Det är historien att komma ihåg.

Medan MongoDB förenklade databasutveckling för miljontals utvecklare över hela världen, är Redpanda på ett liknande uppdrag för att förenkla realtidsströmningsapplikationer. Redpanda byggdes från början med samma hängivenhet för enkelhet, användarvänlighet och viktigast av allt, utvecklarproduktivitet.

Olika men samma

Medan MongoDB och Redpanda tar upp olika delar av teknikstacken, är det intressant att notera likheterna i hur de levererar en trevlig utvecklarupplevelse individuellt och hur de kompletterar varandra när de kombineras. Alltså:

• MongoDB skickas som en enda binär. Det gör Redpanda också. Till skillnad från andra jämförbara streamingplattformar har Redpanda inga beroenden av externa tjänster som Apache Zookeeper. Detta gör Redpanda lika lätt att installera via pakethanterare som det är lokalt på en utvecklares bärbara dator. Den levereras också som en Docker-avbildning så att du kan snurra upp den via Docker Compose, integrera med CI/CD-pipelines eller distribuera i Kubernetes med en enkel kontroller.
• Både Redpanda och MongoDB är distribuerade system. För att uppnå skala och motståndskraft installerar du helt enkelt exakt samma binära filer på flera servrar och riktar dem mot varandra. Detta gör att utvecklare och arkitekter kan skjuta upp beslut om skalbarhet och prestanda tidigt i utvecklingsprocessen. Den mentala modellen och koden för applikationen är densamma oavsett om den körs på en bärbar dator, en virtuell maskin med en kärna eller på flera kraftfulla produktionsservrar.
• Både Redpanda och MongoDB levereras med vettiga standardinställningar. Detta minimerar antalet rattar som utvecklare eller administratörer behöver justera, oavsett om de tar upp en prototypmiljö (som med Docker Compose) eller tillhandahåller ett produktionskluster. Redpanda går ännu längre med möjligheten att autotuna mot underliggande hårdvara, vilket gör att den kan maximera tillgängliga CPU-, minnes- och diskresurser med minimal ansträngning.
• Den kognitiva belastningen för utvecklare beror inte bara på skalbarheten byte per sekund utan också på att de måste bestämma vilken form de ska ge din data och vilka typer de ska välja. MongoDB ger utvecklare flexibiliteten att utveckla schemat över tid med en vänlig JSON-liknande datamodell. På samma sätt kräver händelser och meddelanden som skickas till Redpanda inget schema i förväg. Det finns dock möjlighet att använda ett schema när det behövs och att utveckla schemat för att matcha förändrade affärsbehov.

Ansluter MongoDB till Redpanda

MongoDB integreras med Redpanda på två sätt:som en diskbänk, där Redpanda-händelser konsumeras och skickas till MongoDB för insättningar eller uppdateringar, eller som en CDC-källa, där MongoDB externiserar sin ändringslogg till ett Redpanda-ämne för andra (inklusive andra MongoDB-instanser) för att konsumera. Integrationen görs via Kafka Connect. Eftersom Redpanda är trådkompatibel med Apache Kafka fungerar de befintliga Kafka-kontakterna sömlöst. Denna förmåga att dra nytta av det enorma Kafkas ekosystem är ännu ett sätt Redpanda gör utvecklarnas liv enklare!

Våra vänner på MongoDB har satt ihop en aktieticker-demo som integrerar MongoDB och Redpanda via Kafka Connect. Demon kräver Docker Compose och docker-compose.yml filen ser ut ungefär så här:

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"

För en fullständig handledning och genomgång, besök det kompletterande blogginlägget på MongoDB. Vi välkomnar alla från MongoDB-communityt att prova Redpanda och gå med i Redpanda-communityt Slack, där du kan engagera dig med ingenjörerna som bygger Redpanda och formar framtiden för realtidsströmning!

Ytterligare läsning

• Redpanda-dokumentation
• Benchmark för Redpanda kontra Kafka
• Komma igång med Redpanda