Comment développer des applications pour MongoDB et Redpanda à l'aide de Docker Compose

MongoDB n'a pas besoin d'être présenté. Depuis ses débuts en 2007, la base de données de documents n'a cessé d'augmenter en popularité et est maintenant la 5e base de données au monde selon DB Engines. Il suit désormais uniquement Oracle, MySQL, SQL Server et PostgreSQL. C'est d'autant plus impressionnant si l'on considère que les quatre premières sont des bases de données relationnelles traditionnelles apparues au siècle précédent. MongoDB est numéro un parmi la nouvelle génération de bases de données "NoSQL" distribuées et évolutives.

La croissance mercurielle de MongoDB peut être attribuée à l'accent mis sur l'expérience des développeurs. Le produit lui-même est simple, facile à utiliser et offre un chemin heureux du prototype à la production. Lorsqu'ils essaient MongoDB, les développeurs ont tendance à réussir à déplacer des prototypes fonctionnels vers des déploiements de production complets. C'est l'histoire à retenir.

Alors que MongoDB a simplifié le développement de bases de données pour des millions de développeurs dans le monde, Redpanda a pour mission similaire de simplifier les applications de streaming en temps réel. Dès le départ, Redpanda a été conçu avec le même souci de simplicité, de facilité d'utilisation et, surtout, de productivité des développeurs.

Différent mais pareil

Alors que MongoDB et Redpanda traitent différentes parties de la pile technologique, il est intéressant de noter les similitudes dans la façon dont ils offrent une expérience de développement agréable individuellement et comment ils se complètent lorsqu'ils sont combinés. A savoir :

• MongoDB est livré sous la forme d'un binaire unique. Redpanda aussi. Contrairement à d'autres plateformes de streaming comparables, Redpanda n'a aucune dépendance vis-à-vis de services externes comme Apache Zookeeper. Cela rend Redpanda aussi facile à installer via les gestionnaires de packages que localement sur l'ordinateur portable d'un développeur. Il est également livré sous forme d'image Docker afin que vous puissiez le lancer via Docker Compose, l'intégrer aux pipelines CI/CD ou le déployer dans Kubernetes avec un simple contrôleur.
• Redpanda et MongoDB sont des systèmes distribués. Pour atteindre l'évolutivité et la résilience, il vous suffit d'installer exactement le même binaire sur plusieurs serveurs et de les diriger l'un vers l'autre. Cela permet aux développeurs et aux architectes de reporter les décisions sur l'évolutivité et les performances au début du processus de développement. Le modèle mental et le code de l'application sont les mêmes, qu'ils s'exécutent sur un ordinateur portable, une machine virtuelle monocœur ou sur plusieurs serveurs de production puissants.
• Redpanda et MongoDB sont livrés avec des valeurs par défaut raisonnables. Cela minimise le nombre de boutons que les développeurs ou les administrateurs doivent modifier, qu'ils créent un environnement de prototypage (comme avec Docker Compose) ou provisionnent un cluster de production. Redpanda va encore plus loin avec la possibilité de s'adapter automatiquement au matériel sous-jacent, ce qui lui permet de maximiser les ressources CPU, mémoire et disque disponibles avec un minimum d'effort.
• La charge cognitive des développeurs n'est pas seulement liée à l'évolutivité en octets par seconde, mais également au fait de devoir décider de la forme à donner à vos données et des types à choisir. MongoDB donne aux développeurs la possibilité de faire évoluer le schéma au fil du temps avec un modèle de données convivial de type JSON. De même, les événements et les messages envoyés à Redpanda ne nécessitent pas de schéma à l'avance. Cependant, il est possible d'utiliser un schéma en cas de besoin et de faire évoluer le schéma en fonction de l'évolution des besoins de l'entreprise.

Connecter MongoDB à Redpanda

MongoDB s'intègre à Redpanda de deux manières :en tant que récepteur, dans lequel les événements Redpanda sont consommés et envoyés à MongoDB pour des insertions ou des mises à jour, ou en tant que source CDC, où MongoDB externalise son journal des modifications vers un sujet Redpanda pour que d'autres (y compris d'autres instances de MongoDB) puissent consommer. L'intégration se fait via Kafka Connect. Étant donné que Redpanda est compatible avec Apache Kafka, les connecteurs Kafka existants fonctionnent de manière transparente. Cette capacité à tirer parti du vaste écosystème Kafka est une autre façon pour Redpanda de faciliter la vie des développeurs !

Nos amis de MongoDB ont mis en place une démonstration de stock ticker qui intègre MongoDB et Redpanda via Kafka Connect. La démo nécessite Docker Compose et le docker-compose.yml le fichier ressemble à ceci :

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"

Pour un didacticiel complet et une procédure pas à pas, visitez le billet de blog complémentaire sur MongoDB. Nous invitons tous les membres de la communauté MongoDB à essayer Redpanda et à rejoindre la communauté Redpanda Slack, où vous pourrez dialoguer avec les ingénieurs qui construisent Redpanda et façonnent l'avenir du streaming en temps réel !

Lectures complémentaires

• Documentation Redpanda
• Référence de Redpanda contre Kafka
• Démarrer avec Redpanda