DEV Community: Ili Aliaj

How to Run MongoDB in Docker

Ili Aliaj — Sat, 16 Nov 2024 21:30:48 +0000

Running MongoDB in Docker is an excellent way to set up a database without installing it directly on your local machine. This guide will show you how to use Docker to quickly spin up a MongoDB instance using the latest mongo:8 image.

Prerequisites

Before you begin, make sure you have the following:

Docker installed on your system (Docker Desktop for Windows/Mac, or Docker CLI for Linux).
Basic understanding of how Docker works.

*Step 1: Pull the MongoDB Image
*

Docker Hub provides an official MongoDB image. To ensure you’re using the latest MongoDB 8 version, pull the mongo:8 image with this command:

docker pull mongo:8

This command fetches the latest MongoDB 8 image from Docker Hub and makes it available locally.

Step 2: Run MongoDB in a Container

Run a container with the mongo:8 image using the following command:

docker run -d \ --name mongodb-container \ -p 27017:27017 \ -e MONGO_INITDB_ROOT_USERNAME=admin \ -e MONGO_INITDB_ROOT_PASSWORD=adminpassword \ mongo:8

Breaking Down the Command:

• docker run -d: Starts the container in detached mode.

• --name mongodb-container: Assigns a name to the container (you can choose any name).

• -p 27017:27017: Maps MongoDB’s default port 27017 to your local machine, making it accessible.

•-e: Sets environment variables to configure the database:

• MONGO_INITDB_ROOT_USERNAME: Sets the root username (e.g., admin).

• MONGO_INITDB_ROOT_PASSWORD: Sets the root password (e.g., adminpassword).

• mongo:8:
Specifies the image to use.

Step 3: Verify the Container is Running

Check if the container is running with the following command:

docker ps

You should see something like this:

CONTAINER ID IMAGE COMMAND STATUS PORTS NAMES abcdef123456 mongo:8 "docker-entry..." Up 5 minutes 0.0.0.0:27017->27017/tcp mongodb-container
This confirms MongoDB is running and accessible on

localhost:27017

Step 4: Connect to MongoDB

Using the Mongo Shell:

If you have the MongoDB client installed locally, connect to the running container with:

mongo --host localhost --port 27017 -u admin -p adminpassword

Using a GUI:

Tools like MongoDB Compass or Robo 3T make it easy to interact with your database visually. Just connect to localhost:27017 and use the credentials:

• Username: admin
• Password: adminpassword

Step 5: Persist Data with Volumes (Optional)

By default, Docker containers are ephemeral, meaning all data will be lost when the container is removed. To persist MongoDB data, map a local directory to the container’s data directory.

Run the container with a volume:

docker run -d \ --name mongodb-container \ -p 27017:27017 \ -e MONGO_INITDB_ROOT_USERNAME=admin \ -e MONGO_INITDB_ROOT_PASSWORD=adminpassword \ -v /path/to/your/local/data:/data/db \ mongo:8

What Changed?

• -v /path/to/your/local/data:/data/db : Maps a local directory (/path/to/your/local/data) to MongoDB’s data directory (/data/db), ensuring data persists even after the container is removed.

Step 6: Stop and Remove the Container

When you’re done, you can stop the MongoDB container:

docker stop mongodb-container

Conclusion

Using Docker to run MongoDB is a simple and efficient way to manage your database. It saves time, ensures consistency, and keeps your local machine clean from unnecessary installations. By following these steps, you can set up a MongoDB instance with Docker in just a few minutes

Why should you use Docker

Ili Aliaj — Sat, 16 Nov 2024 21:11:31 +0000

In the world of web development, one thing is certain: consistency is key. Whether you’re working on a local project, deploying to production, or collaborating with a team, ensuring that everything works the same way everywhere is crucial. This is where Docker comes in.

What is Docker?

Docker is an open-source platform that automates the deployment, scaling, and management of applications inside containers.

A container is like a lightweight, portable virtual machine that encapsulates your application and its dependencies, ensuring that it works uniformly across any environment. Think of it as a box that holds everything your app needs to run, from the code to the operating system libraries.

Docker is not a virtual machine (VM), though. It uses the host machine’s OS and isolates the application processes, making containers faster and more resource-efficient compared to VMs.

Why Should You Learn Docker?

As developers, we all know how frustrating it can be to run into issues like:

• “It works on my machine!”
when a colleague can’t run the app.

• Configuration headaches: trying to get the right versions of libraries, databases, and dependencies.

• Inconsistent environments: different systems running different configurations, leading to bugs that are hard to reproduce.

Docker solves these problems by ensuring that your application, along with its environment, is packaged together and runs the same way on every machine—whether it’s your local machine, a testing server, or a production environment.

Why is Docker Helpful for Developers?

Here are some key reasons why Docker is a must-learn tool for developers:

1. Consistency Across Environments

With Docker, you can define your development environment in a Dockerfile, which specifies all the dependencies and configurations. This ensures that everyone on the team has the same environment, eliminating the “works on my machine” problem.

Example Dockerfile:

`# Use an official Node.js runtime as a parent image
FROM node:14

Set the working directory

WORKDIR /app

Install dependencies

COPY package*.json ./
RUN npm install

Copy the rest of the application

COPY . .

Expose the port the app runs on

EXPOSE 3000

Command to run the app

CMD ["npm", "start"]`

This Dockerfile sets up a Node.js environment. Once built, anyone with Docker can run the same environment by simply executing docker run.

2. Simplifies Dependency Management

Running databases, services, or multiple versions of a stack can be complicated. With Docker, you can containerize these services so that they don’t interfere with each other. For example, you can run both MySQL and MongoDB side by side without worrying about configuration conflicts.

Example docker-compose.yml to run a database container:

version: '3' services: db: image: mysql:5.7 environment: MYSQL_ROOT_PASSWORD: example ports: - "3306:3306"

This file automatically sets up MySQL for you, making it easy to connect your app to a database without hassle.

3. Portability and Reproducibility

Docker containers can be easily shared, versioned, and stored on Docker Hub or a private registry. You can push and pull containers, making it incredibly easy to collaborate with other developers or deploy to a production server. Whether you’re switching machines or working on different teams, Docker guarantees that your app will run exactly the same way everywhere.

4. Faster Deployment and Testing

Docker allows you to quickly spin up containers for testing purposes. You can test your app in isolated environments without the need to worry about changing your local setup. This makes continuous integration (CI) and continuous deployment (CD) pipelines smoother, since Docker containers can easily be integrated into automated workflows.

What Can You Do With Docker?

Docker has many use cases that can improve your development workflow:

• Database Containers:
Easily spin up and tear down databases for development and testing purposes without needing to install them on your local machine.

• Development Environments: Docker can serve as a consistent and isolated environment for every developer working on the project, from front-end developers to back-end engineers.

•Automated Deployments:
Docker is widely used in deployment pipelines for automated testing, building, and pushing to production environments like AWS, Azure, or Google Cloud.

Conclusion

Learning Docker is an investment that pays off for almost every developer. It streamlines the development process, improves collaboration, and helps you manage dependencies and environments with ease. Whether you’re working on a small personal project or a large-scale enterprise application, Docker provides the flexibility and consistency needed to ensure your app runs smoothly in any environment.

If you’re ready to start using Docker, there are plenty of tutorials and documentation available to guide you. The best part? You don’t need to set up complicated virtual machines to test your applications—you can just spin up containers in a matter of minutes

Stop Getting Stuck Before You Even Start Coding: Plan Before You Execute

Ili Aliaj — Sun, 06 Oct 2024 13:06:35 +0000

How many times have you thought of a new project idea, feeling all excited and hyped up to code it? But then, as soon as you open your code editor, you just get stuck. No lines of code come to mind. You don’t know where to start or what to even write.

This happens to many of us, and it’s usually because of bad planning—or no planning at all. Let’s face it, as coders, we’ve all been there.

Plan Before You Code
Before diving into your code editor, you need to have a structured plan in mind. A clear roadmap can save you a lot of frustration and confusion. Here's how you can approach it:

1. Create a User Flow
Write everything down, from the moment the user opens your web app to the point they leave. Map out all interactions. This helps you visualize the flow of your application and understand how users will navigate through it.

For example, if you’re building a simple weather app, you need to detail how users will search for the weather, view results, and maybe even switch locations.

2. Break the Project into Small, Manageable Tasks
Once you’ve got the user flow in mind, break your project down into smaller coding tasks—think of it as solving a puzzle piece by piece. Each task should represent a small step towards building the whole project.

Using a weather app example, here’s how you can break it down:

Fetch weather data from an API.
Display the weather data on the user interface.
Accept user input for different location searches. Each of these steps is manageable on its own, and tackling them one by one makes the project less overwhelming.

3. Start Coding, One Task at a Time
Now that you’ve split the project into smaller tasks, it’s time to start coding. Focus on one task at a time and gradually piece everything together. This step-by-step approach not only keeps you from getting stuck, but it also gives you a sense of accomplishment as you complete each part.

Final Thoughts
The tips above may seem simple, but they can help you tackle coding projects—whether small or massive—with confidence. Proper planning ensures that you always know your next step and avoid getting overwhelmed.

So, next time you think of a new project, don’t just dive into your editor. Plan before you execute, and you’ll be surprised at how much smoother the coding process becomes!

Top 2 React Hooks

Ili Aliaj — Wed, 25 Sep 2024 18:17:10 +0000

What are React hooks?
Hooks provide functional components the ability to manage state & side-effects. They were first introduced in React v16.8 and different hooks have been added since then. Today we will be talking about MY top 3 hooks which i use the most.

The useState hook ** It let's you add a state variable inside a component.

const [age, setAge] = useState(18)

The above is a simple example to how this hook is defined.
The useState hooks takes a paramter (18) as an initial state for the defined variable (age) and provides us with an array of two values:

(age) which returns the current state
(setAge) which is a setter function that lets you update the state.

Here is how a setter function works:
function incrementAge(){ setAge(a => a + 1) }
Each time this function is called, the setter function will update the state based on the last state.

2. The useEffect hook
It lets you synchronize your component with an external system like the DOM, networks... .

useEffect(() => { const connection = createConnection(serverUrl, roomId); connection.connect(); return () => { connection.disconnect(); }; }, [serverUrl, roomId]);

The useEffect hook takes 2 parameters, a function and a dependency array. The function will only execute when the variables in the dependency array, which comes after the function, change it's value or state. If the dependency array is empty, the function will run each time the component gets rendered.

These are just two of many other hooks in React, they are the most common and the most useful in different situations.