Devops Open source project Task

To persist data for a MongoDB container by attaching a Docker volume and demonstrate the use of Docker volumes with a Node.js and MongoDB project, here’s a step-by-step approach.

---

Step 1: Install Docker

Ensure Docker is installed and running on your system. If not, install it following the official Docker installation guide.

---

Step 2: Create the Project Structure

Set up a directory structure for the project:

persist-docker-volumes/
├── backend/
│   ├── app.js
│   ├── package.json
│   ├── package-lock.json
├── docker-compose.yml
├── Dockerfile

---

Step 3: Write the Node.js Application

Create a basic Node.js application to interact with MongoDB.

backend/package.json:

{
  "name": "docker-volume-demo",
  "version": "1.0.0",
  "main": "app.js",
  "dependencies": {
    "express": "^4.17.3",
    "mongoose": "^6.0.0"
  },
  "scripts": {
    "start": "node app.js"
  }
}

Run:

npm install

backend/app.js:

const express = require("express");
const mongoose = require("mongoose");

const app = express();
app.use(express.json());

// MongoDB connection
mongoose.connect("mongodb://mongo:27017/dockerVolumeDemo", {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

const db = mongoose.connection;
db.on("error", console.error.bind(console, "MongoDB connection error:"));
db.once("open", () => {
  console.log("Connected to MongoDB!");
});

// Define a simple schema and model
const UserSchema = new mongoose.Schema({
  name: String,
});
const User = mongoose.model("User", UserSchema);

// Routes
app.get("/", (req, res) => {
  res.send("Welcome to the Docker Volumes Demo!");
});

app.post("/users", async (req, res) => {
  const user = new User(req.body);
  await user.save();
  res.json(user);
});

app.get("/users", async (req, res) => {
  const users = await User.find();
  res.json(users);
});

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

---

Step 4: Create the Docker Compose File

docker-compose.yml:

version: "3.9"

services:
  backend:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - mongo
    volumes:
      - ./backend:/app
    environment:
      - NODE_ENV=development

  mongo:
    image: mongo:latest
    ports:
      - "27017:27017"
    volumes:
      - mongodb_data:/data/db

volumes:
  mongodb_data:

---

Step 5: Write the Dockerfile

Dockerfile:

# Use Node.js image
FROM node:14

# Set working directory
WORKDIR /app

# Copy package.json and package-lock.json
COPY backend/package*.json ./

# Install dependencies
RUN npm install

# Copy application files
COPY backend/ .

# Expose port
EXPOSE 3000

# Start the app
CMD ["npm", "start"]

---

Step 6: Build and Run the Containers

1. Build the services:

   docker-compose build

1. Start the containers:

   docker-compose up

1. Verify the containers:

   docker ps

---

Step 7: Test the Application

1. Access the Node.js application at http://localhost:3000/.

2. Use an API tool like Postman or curl to test endpoints:

   • Create a user:

    curl -X POST -H "Content-Type: application/json" -d '{"name": "John"}' http://localhost:3000/users
   

• Retrieve users:
  

   curl http://localhost:3000/users
  

---

Step 8: Verify Data Persistence

1. Stop the containers:

   docker-compose down

1. Restart the containers:

   docker-compose up

1. Access the /users endpoint again. The previously created data should still be present, as it’s stored in the Docker volume.

---

Step 9: Clean Up

To remove the containers and associated volume:

docker-compose down --volumes

---

Technologies Used

• Docker: For containerizing the application and MongoDB.
• Node.js: For the backend server interacting with MongoDB.
• MongoDB: As the database.
• Docker Volumes: To persist MongoDB data across container restarts.

This project demonstrates how to use Docker volumes to ensure data persistence in a containerized environment while integrating Node.js and MongoDB.

Happy Learning!!!