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
- Build the services:
docker-compose build
- Start the containers:
docker-compose up
- Verify the containers:
docker ps
Step 7: Test the Application
- Access the Node.js application at
http://localhost:3000/. -
Use an API tool like Postman or
curlto 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
- Stop the containers:
docker-compose down
- Restart the containers:
docker-compose up
- Access the
/usersendpoint 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!!!
Top comments (0)