DEV Community: Mahmud Ibrahim

Dockerfile Cheat Sheet – বাংলা গাইড

Mahmud Ibrahim — Tue, 20 May 2025 13:34:57 +0000

আপনি যদি ডকার নিয়ে কাজ করেন, তাহলে Dockerfile ফাইল লিখতে পারাটা একটি অনিবার্য কাজ আপনার জন্য। এই চিটশীটে Dockerfile এর primary instruction set গুলো সংক্ষেপে তুলে ধরা হলো—বাংলা ভাষায়, যেন সহজে শেখা যায়।

🐳 FROM
Usage:

FROM {image}
FROM {image}:{tag}
FROM {image}@{digest}

Example:

FROM node:18-alpine

🔹 ইমেজ তৈরি করার জন্য কোন বেজ ইমেজ ব্যবহার হবে তা নির্ধারণ করে।
🔹 এটি অবশ্যই প্রথম ইনস্ট্রাকশন হতে হবে (কমেন্ট বাদে)।
🔹 :tag বা @digest নির্দিষ্ট করা যেতে পারে। না দিলে latest ধরা হয়।

👤 MAINTAINER (Deprecated)
Usage: Maintainer {name}

MAINTAINER আপনার নাম <ইমেইল>

🔸 ইমেজের লেখক (Author) হিসেবে তথ্য সংরক্ষণ করে।
❌ এটি পুরানো হয়ে গেছে, এখন LABEL ব্যবহার করা হয়।

⚙️ RUN
Usage: Run {command}, RUN ["executable", "param1", "param2"]
Example:

RUN apt-get update && apt-get install -y curl

🔹 ইমেজ তৈরির সময় কমান্ড রান করে।
🔹 Shell ফর্ম ও Exec ফর্মে ব্যবহার করা যায়।

🧠 CMD: Shell vs Exec
Usage: CMD ["executable", "param1", "param2"] --> exec form
CMD command param1 param2 --> shell form

Example:

CMD ["node", "app.js"]
CMD ["/bin/ping","localhost"]

🔸 কনটেইনার চালুর সময় ডিফল্ট কমান্ড বা আর্গুমেন্ট নির্ধারণ করে।
🔸 শুধুমাত্র একটি CMD কার্যকর হয়।

🏷️ LABEL

LABEL maintainer="আপনার নাম" version="1.0"

🔹 মেটাডাটা যোগ করতে ব্যবহৃত হয়।

🌐 EXPOSE
Usage: Expose {port} [ ...]
Example:

EXPOSE 3000

🔹 কোন পোর্টগুলো অ্যাপ্লিকেশন শুনছে তা জানায়।
🔹 কিন্তু এটি পোর্ট এক্সপোজ করে না, -p দিয়ে করতে হয়।

🌱 ENV
Usage: Env{key} {value}
Env = [=...]

ENV NODE_ENV=production

🔹 এনভায়রনমেন্ট ভ্যারিয়েবল সেট করে।
🔹 পরবর্তীতে ব্যবহারযোগ্য থাকে।

📂 ADD vs COPY
Usage: ADD [ ...]
COPY [...]

Example:

ADD ./source /app
COPY ./source /app

🔹 COPY: সাধারণ কপি করা।
🔹 ADD: কপি ছাড়াও .tar.gz আনজিপ করে বা রিমোট ইউআরএল থেকেও ফাইল নামায়।

📁 VOLUME
Usage: Volume["path", ....]
Volume path [path....]

Example:

VOLUME ["/data"]

🔹 হোস্ট বা অন্য কনটেইনার থেকে ডেটা মাউন্ট করার জন্য নির্দিষ্ট লোকেশন তৈরি করে।
🔹 উদাহরণ: লগ, ডেটাবেস ডেটা সংরক্ষণের জন্য।

📌 WORKDIR
Usage: Workdir {/path/to/workdir}
Example:

WORKDIR /app

🔹 পরবর্তী RUN, CMD, COPY, ADD ইনস্ট্রাকশনগুলো এই ডিরেক্টরিতে চালানো হবে।
🔹 একাধিকবার ব্যবহার করা যায়। আপেক্ষিক পাথও দেওয়া যায়।

🛠️ ARG

ARG NODE_VERSION=18

🔹 বিল্ড টাইম ভ্যারিয়েবল যা --build-arg দিয়ে পাস করা যায়।
🔹 ENV ভ্যারিয়েবল ARG-কে override করে।
🔹 নিরাপত্তার জন্য সিক্রেট তথ্য ARG দিয়ে না দেওয়াই উত্তম।

🔁 ONBUILD

ONBUILD COPY . /app

🔹 ভবিষ্যতে এই ইমেজ অন্য কেউ FROM করলে তখন এই ইনস্ট্রাকশনগুলো চালানো হবে।
🔹 শুধুমাত্র child ইমেজে চলে, grandchild এ না।

🛑 STOPSIGNAL

STOPSIGNAL SIGKILL

🔹 কনটেইনার থামানোর সময় কোন সিগন্যাল পাঠানো হবে তা নির্ধারণ করে (যেমন SIGINT, SIGTERM)।

🏥 HEALTHCHECK

HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
  CMD curl -f http://localhost:3000 || exit 1

🔹 কনটেইনার সুস্থ আছে কিনা তা পরীক্ষা করে।
🔹 0 মানে healthy, 1 মানে unhealthy।
🔹 HEALTHCHECK NONE দিয়ে এটি নিষ্ক্রিয় করা যায়।

📘 উপসংহার
এই ছিল Dockerfile এর মৌলিক ইন্সট্রাকশনগুলোর বাংলা সংক্ষিপ্ত বিবরণ।

🔜 পরবর্তী পর্বে:
👉 Dockerfile লেখার সেরা কিছু Best Practices!
👉 কিভাবে ডকার ইমেজ ছোট, দ্রুত এবং নিরাপদ রাখা যায়।

ফলো করুন এবং কমেন্টে জানান, কোন অংশটা আপনার সবচেয়ে দরকারি লেগেছে!

How to Set Up a Monitoring Stack with Prometheus, Grafana, and Node Exporter Using Docker Compose

Mahmud Ibrahim — Sat, 17 May 2025 08:37:00 +0000

Monitoring your infrastructure is crucial for reliability and performance. In this article, we'll walk through a simple and effective monitoring stack using Docker Compose, featuring Prometheus for metrics collection, Grafana for visualization, and Node Exporter for exposing host metrics.

Project Structure

.
├── docker-compose.yml
├── prometheus.yml
└── provisioning/
    └── datasources/
        └── prometheus.yml

Understanding the `docker-compose.yml` File

Let's break down the main components of the docker-compose.yml file:

services:
  prometheus:
    image: prom/prometheus:v3.3.1
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    networks:
      - monitoring

  grafana:
    image: grafana/grafana:12.0.0
    container_name: grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    depends_on:
      - prometheus
    networks:
      - monitoring
    volumes:
      - ./provisioning/datasources:/etc/grafana/provisioning/datasources
      - grafana_data:/var/lib/grafana

  node_exporter:
    image: prom/node-exporter:v1.9.1
    container_name: node_exporter
    ports:
      - "9100:9100"
    networks:
      - monitoring

networks:
  monitoring:
    driver: bridge

volumes:
  prometheus_data:
    driver: local
  grafana_data:
    driver: local

Service Breakdown

Prometheus
- Uses the official Prometheus image.
- Exposes port 9090.
- Mounts a local prometheus.yml config and a Docker volume for persistent data.
- Connected to a custom monitoring network.
Grafana
- Uses the official Grafana image.
- Exposes port 3000.
- Sets the admin password via environment variable.
- Depends on Prometheus (starts after Prometheus is up).
- Mounts provisioning files and a persistent data volume.
- Connected to the monitoring network.
Node Exporter
- Uses the official Node Exporter image.
- Exposes port 9100.
- Connected to the monitoring network.
Networks and Volumes
- All services share the monitoring bridge network.
- Prometheus and Grafana use named volumes for data persistence.

Step-by-Step Guide

1. Clone the Repository

Github Link: https://github.com/rafi021/monitoring-stack-prometheus-grafana-node-exporter

git clone <your-repo-url>
cd <your-repo-directory>

2. Review and Edit Configuration

prometheus.yml: Make sure Prometheus is configured to scrape Node Exporter.
provisioning/datasources/prometheus.yml: Ensures Grafana automatically adds Prometheus as a data source.

The prometheus.yml file is the main configuration file for Prometheus. Here’s what each section does:

global:
  scrape_interval: 5s

global: Sets global configuration options.
scrape_interval: 5s: Prometheus will scrape (collect) metrics from all configured targets every 5 seconds.

scrape_configs:
  - job_name: 'node'
    static_configs:
      - targets: ['node_exporter:9100']  # This points to the Node Exporter container

scrape_configs: Defines the list of jobs (sets of targets) Prometheus should scrape.
job_name: 'node': Names this scrape job "node" (for Node Exporter).
static_configs: Specifies static targets for this job.
targets: ['node_exporter:9100']: Prometheus will scrape metrics from the Node Exporter container at port 9100.

Summary:

This config tells Prometheus to collect metrics from the Node Exporter container every 5 seconds.

This file provisioning/datasources/prometheus.yml is a Grafana data source provisioning configuration. It tells Grafana to automatically add Prometheus as a data source when Grafana starts.

apiVersion: 1

Specifies the version of the provisioning config format.
datasources:

A list of data sources to add.
- name: Prometheus The name that will appear in Grafana.
- type: prometheus Specifies the data source type (Prometheus).
- access: proxy Grafana will proxy requests to Prometheus (recommended for most setups).
- url: http://prometheus:9090 The URL where Prometheus is accessible from within the Docker network (using the service name).
- isDefault: true Sets this data source as the default in Grafana.

Summary:

This file ensures that Prometheus is pre-configured as the default data source in Grafana, so you don’t have to add it manually.

3. Start the Stack

docker-compose up -d

This command will pull the required images and start all services in the background.

4. Access the Services

Prometheus UI: http://localhost:9090
Grafana UI: http://localhost:3000
- Default login: admin / admin
Node Exporter Metrics: http://localhost:9100/metrics

Prometheus UI showing that the, node exporter endpoint is connected successfully.

5. Add Dashboards in Grafana

Prometheus is already set as a data source.
Import community dashboards or create your own to visualize Node Exporter metrics.

Click + Create Dashboard

Import Node Exporter Dashboards: There are pre-configured dashboards available for Node Exporter. You can go to Grafana Dashboards and search for Node Exporter Full Dashboard (ID: 1860), which will give you a comprehensive view of your system metrics.

In the Grafana Dashboards section, search for Node Exporter Full dashboard. The Dashboard ID for Node Exporter Full is 1860.
Enter 1860 in the Import via ID field and click Load.
In the Prometheus drop-down, choose the Prometheus data source you just configured.

Click Import.
Verify the Dashboard:
Once the dashboard is imported, you should see a comprehensive view of your Ubuntu server’s metrics, including CPU usage, memory usage, disk I/O, network statistics, etc.

6. Stopping the Stack

docker-compose down

This will stop and remove all containers, but your data will persist in the named volumes.

Tips & Troubleshooting

Customizing Prometheus Targets: Edit prometheus.yml to add more scrape targets.
Persisting Data: Data is stored in Docker volumes (prometheus_data, grafana_data).
Logs: Check logs with:

  docker-compose logs prometheus
  docker-compose logs grafana
  docker-compose logs node_exporter

Change Default Password: For security, change the Grafana admin password in production.

Conclusion

With just a few files and Docker Compose, you can have a powerful monitoring stack up and running in minutes. This setup is perfect for local development, testing, or even small production environments.

Happy Monitoring!

References:

Step-by-Step Guide: Laravel CI/CD with GitHub Actions

Mahmud Ibrahim — Thu, 15 May 2025 19:49:23 +0000

Continuous Integration (CI) is a must-have for modern web development. It helps you catch bugs early, ensures code quality, and saves you from manual testing headaches. In this article, I’ll walk you through a real-world GitHub Actions workflow for a Laravel project. Whether you’re new to CI/CD or just want to see how it works for Laravel, this guide is for you!

What is GitHub Actions?

GitHub Actions is a free automation tool built into GitHub. It lets you run scripts and commands automatically when certain events happen in your repository—like pushing code or opening a pull request.

Workflow Overview

Our workflow will:

Run on every push or pull request to the main or dev branches.
Set up a MySQL database for testing.
Install PHP and all required extensions.
Cache Composer dependencies for faster builds.
Install your Laravel app’s dependencies.
Run static analysis and code quality checks.
Run your automated tests.

Let’s break down each step!

1. Workflow Triggers

on:
  push:
    branches: ["main", "dev"]
  pull_request:
    branches: ["main", "dev"]

This tells GitHub to run the workflow every time you push code or open a pull request to the main or dev branches.

2. Define the Job and Environment

jobs:
  tests:
    runs-on: ubuntu-latest

We define a job called tests that runs on the latest Ubuntu Linux environment provided by GitHub.

3. Set Up MySQL Database

services:
  mysql:
    image: mysql:8.0
    ports:
      - 3306:3306
    env:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: test_db
    options: --health-cmd="mysqladmin ping"

We spin up a MySQL 8.0 database in Docker, set the root password, and create a database called test_db. The health check ensures MySQL is ready before tests run.

4. Checkout Your Code

- uses: actions/checkout@v4

This step pulls your repository’s code into the workflow environment so the next steps can work with it.

5. Setup PHP with All Laravel Extensions

- name: Setup PHP with PECL extension
  uses: shivammathur/setup-php@v2
  with:
    php-version: '8.4'
    extensions: mbstring, bcmath, ctype, fileinfo, json, tokenizer, xml, pdo, pdo_mysql, openssl, curl, zip, imagick, swoole

We install PHP 8.4 and all the extensions Laravel and its ecosystem commonly need. This ensures your app runs just like it would in production.

6. Cache Composer Dependencies

- name: Cache Composer dependencies
  uses: actions/cache@v4
  with:
    path: vendor
    key: ${{ runner.os }}-composer-${{ hashFiles('**/composer.lock') }}
    restore-keys: |
      ${{ runner.os }}-composer-

This is “smart caching.” If your dependencies haven’t changed, Composer can skip downloading and installing them, making your workflow much faster.

7. Copy the CI Environment File

- name: Copy .env file
  run: |
    cp .env.ci .env

We copy a special .env.ci file to .env. This file should contain settings for your test database and other CI-specific configs.

8. Install Composer Dependencies

- name: Install dependencies
  run: |
    composer install -q --no-ansi --no-interaction --no-scripts --no-progress

We install all PHP dependencies your Laravel app needs, using flags to make the process faster and quieter.

9. Generate Laravel Application Key

- name: Generate application key
  run: |
    php artisan key:generate

Laravel needs an application key for encryption and sessions. This command generates it.

10. Set Directory Permissions

- name: Directory permissions
  run: |
    sudo chown -R $USER:$USER storage bootstrap/cache
    chmod -R 775 storage bootstrap/cache

Laravel needs write access to storage and bootstrap/cache for logs and cache files. This step ensures the permissions are correct.

11. Run Static Analysis with PHPStan

- name: phpstan
  run: |
    ./vendor/bin/phpstan analyse --level=5 --memory-limit=1G

PHPStan checks your code for bugs and potential issues without running it. This helps you catch problems early.

12. Run Code Quality Checks with PHP Insights

- name: phpinsights
  run: |
    php artisan insights --no-interaction \
    --min-quality=90 --min-complexity=90 \
    --min-architecture=90 --min-style=90 \
    --ansi --format=github-action

PHP Insights analyzes your code for quality, complexity, architecture, and style. The workflow enforces minimum scores for each metric.

13. Show Database Configuration

- name: Show DB config
  run: |
    grep DB_ .env

This step prints out the database settings being used, so you can verify your tests are running against the correct database.

14. Run Your Tests!

- name: Run tests
  run: |
    php artisan test

15. Deployment

Deployment is automated via GitHub Actions and occurs after tests pass:

Main Branch:

When code is pushed to the main branch, the workflow connects to the main server using SSH and runs the deployment script (main_deploy.sh).
- SSH credentials are securely managed with GitHub Secrets.
- The script puts the application into maintenance mode, pulls the latest code, runs migrations, sets permissions, clears and caches configuration, and brings the application back up.
Dev Branch:

When code is pushed to the dev branch, a similar process runs, but targets the development server.

Deployment Steps:

SSH into the target server.
Change directory to /var/www/htm/laravel-cicd.
Execute ./main_deploy.sh main.

You can customize the deployment script (main_deploy.sh) as needed for your environment.

- name: Deployment to Main Server
              if: github.ref == 'refs/heads/main'
              uses: appleboy/ssh-action@master
              with:
                host: ${{ secrets.MAIN_SSH_HOT }}
                username:  ${{ secrets.SSH_USER }}
                password:  ${{ secrets.SSH_PASS }}
                script: |
                  cd /var/www/htm/laravel-cicd && ./main_deploy.sh main
- name: Deployment to Dev Server
              if: github.ref == 'refs/heads/dev'
              uses: appleboy/ssh-action@master
              with:
                host: ${{ secrets.SSH_HOST }}
                username:  ${{ secrets.SSH_USER }}
                password:  ${{ secrets.SSH_PASS }}
                script: |
                  cd /var/www/htm/laravel-cicd && ./main_deploy.sh main

and the main_deploy.sh file with execute permission

chmod +x main_deploy.sh

set -e
echo "Deploying the application..."

php artisan down
echo "Putting the application into maintenance mode..."

git pull origin main
echo "Pulling the latest changes from the main branch..."

php artisan migrate --force
echo "Running database migrations..."

php artisan up
echo "Bringing the application back up..."

chmod -R 775 storage bootstrap/cache
echo "Setting permissions..."

php artisan optimize:clear
echo "Clearing caches..."
php artisan config:cache
echo "Caching configuration..."

echo "Deployment completed successfully!"

Finally, we run all your Laravel tests. These tests will use the MySQL test database you set up earlier.

Conclusion

With this workflow, every push or pull request is automatically tested in a fresh environment, with a real database, and all the tools you need for code quality. This helps you catch bugs early, maintain high standards, and move faster as a team.

Tip:

Make sure your .env.ci file is committed and contains the correct database settings for CI!

Happy automating!

If you have questions or want to see more CI/CD tips for Laravel, let me know in the comments.

Github Link: https://github.com/rafi021/laravel-cicd

Feel free to copy, modify, and use this workflow in your own Laravel projects!

🚀Setting Up Kafka with Docker Compose and Node.js: A Practical Guide

Mahmud Ibrahim — Tue, 13 May 2025 16:36:36 +0000

Apache Kafka is a powerful distributed event streaming platform widely used for building real-time data pipelines and applications. However, setting up Kafka can be daunting, especially when integrating it with a Node.js application. This article explores a GitHub project that simplifies this process by using Docker Compose to set up a Kafka environment and a Node.js Express application to test Kafka's functionality.

Overview of the Project
This project provides a ready-to-use Kafka environment using Docker Compose and a Node.js Express application (kafka-express-app) to test Kafka by producing and consuming messages. It is an excellent starting point for developers looking to integrate Kafka into their applications.

Project Structure
clone this github repo: https://github.com/rafi021/kafka-docker-compose
The repository is well-organized, with the following structure:

kafka-docker/
├── docker-compose.yml       # Docker Compose file for Kafka setup
├── kafka-express-app/       # Node.js Express application
│   ├── src/
│   │   ├── kafka/
│   │   │   ├── producer.ts  # Kafka producer logic
│   │   │   └── consumer.ts  # Kafka consumer logic
│   │   ├── routes/
│   │   │   └── index.ts     # Express routes
│   │   └── app.ts           # Express app entry point
│   ├── package.json         # Node.js dependencies and scripts
│   ├── tsconfig.json        # TypeScript configuration
│   └── .env                 # Environment variables
└── README.md                # Project documentation

Kafka Setup with Docker Compose

The docker-compose.yml file defines the services required to run Kafka, including:

Zookeeper: Manages Kafka brokers.
Kafka Broker: The Kafka server.
Schema Registry: Manages Avro schemas for Kafka topics.
Kafka Connect: Connects Kafka to external systems.
Control Center: A web UI for managing Kafka.
kafka-express-app: The Node.js application for testing Kafka.

Steps to Start Kafka

Start Docker Services: Run the following command to start all services:

   docker-compose up -d

Verify Services: Check if all services are running:

   docker ps

Access Control Center: Open the Confluent Control Center in your browser:

  http://localhost:9021

(If you don't see anything, then wait for 1 min. Let the containers spin up and connect with each other.)

On the Click of this page. It will open the cluster details page.

here you can see numbers of broker running, topics, partitions and other details.

Node.js Application Setup
The kafka-express-app is a Node.js Express application that interacts with Kafka. It includes producer and consumer logic written in TypeScript.

Environment Variables
Create a .env file in the kafka-express-app directory with the following content:

KAFKA_CLIENT_ID=my-app
KAFKA_BROKERS=localhost:9092
KAFKA_GROUP_ID=test-group
KAFKA_TOPIC=test-topic

Install Dependencies
Navigate to the kafka-express-app directory and install the required dependencies:

cd kafka-express-app
npm install

Build the Application
Compile the TypeScript code to JavaScript:

npm run build

Run the Application
Start the application in development mode:

npm run dev

Or start the compiled application:

npm start

Testing Kafka
The Node.js application provides endpoints to test Kafka's producer and consumer functionality.

Produce a Message

Use a tool like curl or Postman to send a POST request to the /api/publish endpoint:

curl -X POST http://localhost:3000/api/publish \
-H "Content-Type: application/json" \
-d '{"topic": "test-topic", "message": "Hello Kafka!"}'

Consume Messages

Send a GET request to the /api/subscribe endpoint to start consuming messages:

curl http://localhost:3000/api/subscribe

You should see the consumed messages logged in the console.

Stopping Services
To stop all Docker services, run:

docker-compose down

Troubleshooting

Kafka Broker Connection Issues: Ensure the KAFKA_BROKERS in .env matches the broker address in docker-compose.yml (e.g., broker:29092).
Port Conflicts: Ensure the ports defined in docker-compose.yml (e.g., 9092, 29092, 9021) are not in use by other applications.

Conclusion
This project simplifies the process of setting up Kafka with Docker Compose and integrating it with a Node.js application. Whether you're a beginner or an experienced developer, this repository provides a solid foundation for building real-time data streaming applications.
If you're looking to dive into Kafka and Node.js, this project is a great place to start. Try it out, and let us know your thoughts in the comments below!

🚀 Set Up RabbitMQ with MQTT and Management UI Using Docker

Mahmud Ibrahim — Tue, 13 May 2025 09:04:52 +0000

RabbitMQ is a powerful message broker that supports multiple protocols, including AMQP and MQTT. If you’re building event-driven microservices or IoT-based apps, having RabbitMQ locally with MQTT support is extremely useful.

In this guide, you’ll learn how to:

Spin up RabbitMQ using Docker
Enable the Management UI
Add MQTT protocol support
Test both MQTT and AMQP pub/sub functionality via terminal scripts

Let’s dive in!

✅ Prerequisites

Before you start, make sure you have the following installed:

Docker
Docker Compose
jq for parsing JSON (used in the subscriber script)

Install jq on Ubuntu:

sudo apt install jq

🧱 Step 1: Docker Compose Setup

Create a file called rabbitmq-docker-compose.yml and paste in the following configuration:

services:
  # RabbitMQ
  rabbitmq:
    image: rabbitmq:4-management
    container_name: rabbitmq
    restart: unless-stopped
    ports:
      - "15672:15672" # RabbitMQ Management UI
      - "5672:5672" # RabbitMQ AMQP
    environment:
      RABBITMQ_HOST: '%'
      RABBITMQ_DEFAULT_USER: user
      RABBITMQ_DEFAULT_PASS: root
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq
    networks:
      - rabbitmq_network
    healthcheck:
      test:
        - CMD
        - rabbitmq-diagnostics
        - '-q'
        - ping
      retries: 3
      timeout: 5s
      interval: 30s

volumes:
  rabbitmq_data:
    driver: local

networks:
  rabbitmq_network:
    driver: bridge

🚀 Step 2: Launch the RabbitMQ Container

Run the following command to spin up the service:

docker compose -f rabbitmq-docker-compose.yml up -d --build

Verify that it’s running:

docker ps

You should see the RabbitMQ container up and listening on ports 5672, 15672, and 1883.

🌐 Step 3: Access the RabbitMQ Management UI

Open your browser and visit:

http://localhost:15672

Username: user
Password: root

You’ll get a full dashboard with queues, exchanges, bindings, and users.

🔌 Step 4: Enable MQTT Plugin

RabbitMQ supports MQTT through its plugin system. To enable it:

docker exec -it rabbitmq rabbitmq-plugins enable rabbitmq_mqtt

Verify that it’s enabled:

docker exec -it rabbitmq rabbitmq-plugins list | grep mqtt

You should see output like this:

[E*] rabbitmq_mqtt

🔄 Step 5: Test MQTT with Mosquitto

✅ Install Mosquitto Clients

On Ubuntu:

sudo apt install mosquitto-clients

After installation. Open a new terminal and type the command to publish a message

📤 Publish a Message

mosquitto_pub -h localhost -p 1883 -t test_mqtt -m "Hello, MQTT!" -u user -P root

📥 Subscribe to a Topic

In a second terminal:

mosquitto_sub -h localhost -p 1883 -t test_mqtt -u user -P root

You should see:

Hello, MQTT!

🖥️ Step 6: Test AMQP Pub/Sub (Optional Bash Scripts)

You can also test RabbitMQ’s core AMQP protocol using publisher.sh and subscriber.sh scripts.

🖋 Sample publisher.sh

#!/bin/bash

RABBITMQ_USER="user"
RABBITMQ_PASS="root"
RABBITMQ_HOST="localhost"
QUEUE_NAME="test_queue"

# Declare the queue
curl -u "$RABBITMQ_USER:$RABBITMQ_PASS" -X PUT \
  -H "Content-Type: application/json" \
  -d '{"auto_delete":false,"durable":true}' \
  "http://$RABBITMQ_HOST:15672/api/queues/%2F/$QUEUE_NAME"

# Publish messages every 5 seconds
while true; do
  MESSAGE="Hello, RabbitMQ, This is a message from docker compose! $(date)"
  curl -u "$RABBITMQ_USER:$RABBITMQ_PASS" -X POST \
    -H "Content-Type: application/json" \
    -d "{\"properties\":{},\"routing_key\":\"$QUEUE_NAME\",\"payload\":\"$MESSAGE\",\"payload_encoding\":\"string\"}" \
    "http://$RABBITMQ_HOST:15672/api/exchanges/%2F/amq.default/publish"
  echo " [x] Sent '$MESSAGE'"
  sleep 5
done

🖋 Sample subscriber.sh

#!/bin/bash  
RABBITMQ_USER="user"
RABBITMQ_PASS="root"
RABBITMQ_HOST="localhost"
QUEUE_NAME="test_queue"

# Continuously fetch messages from the queue
while true; do
  RESPONSE=$(curl -u "$RABBITMQ_USER:$RABBITMQ_PASS" -X POST \
    -H "Content-Type: application/json" \
    -d '{"count":1,"ackmode":"ack_requeue_false","encoding":"auto","truncate":50000}' \
    "http://$RABBITMQ_HOST:15672/api/queues/%2F/$QUEUE_NAME/get")

echo "Response: $RESPONSE"
MESSAGE=$(echo "$RESPONSE" | jq -r '.[0].payload' 2>/dev/null)

  if [ "$MESSAGE" != "null" ] && [ -n "$MESSAGE" ]; then
    echo " [x] Received '$MESSAGE'"
  fi

  sleep 1
done

▶️ Make Scripts Executable

chmod +x publisher.sh subscriber.sh

Then run them in separate terminals:

./publisher.sh  
./subscriber.sh

🧯 Step 7: Stop the Service

When you’re done testing:

docker compose -f rabbitmq-docker-compose.yml down

✅ Summary

GitHub Link: https://github.com/rafi021/rabbitmq-message-broker-docker-compose

Youtube : https://youtu.be/Wld_qudiTeo

You’ve now set up:

RabbitMQ with MQTT and AMQP support
A web-based Management UI
Pub/Sub testing with both MQTT clients and bash scripts

This local setup is great for developing event-driven backends, IoT systems, or microservices without relying on cloud infrastructure.

If you found this helpful, consider bookmarking or sharing it with your team.

🚀 Set Up Redis with RedisInsight Using Docker for Local Development

Mahmud Ibrahim — Tue, 13 May 2025 07:48:34 +0000

🚀 Set Up Redis with RedisInsight Using Docker for Local Development

Redis is a high-performance in-memory data store, widely used for caching, pub/sub, queues, and more. When working locally, inspecting what’s happening inside Redis can be difficult without a user-friendly UI.

That’s where RedisInsight comes in — an official Redis GUI that helps you visualize and manage your Redis instance.

In this tutorial, we’ll use Docker Compose to spin up a Redis container and a RedisInsight UI side-by-side for your local development setup.

✅ Prerequisites

Make sure you have the following tools installed:

Docker
Docker Compose

These work across Linux, macOS, and Windows.

🛠 Step-by-Step Setup

📁 Step 1: Create a project directory

Open your terminal and run:

mkdir redis-docker-setup  
cd redis-docker-setup

📝 Step 2: Create the `docker-compose.yml` file

Now, inside this folder, create a file named docker-compose.yml and paste the following content:

services:
  #redis
  redis:
    image: redis:alpine
    container_name: redis
    restart: unless-stopped
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    networks:
      - redis-network
    healthcheck:
      test:
        - CMD
        - redis-cli
        - ping
      retries: 3
      timeout: 5s
  #redis-insight
  redis-insight:
    image: redis/redisinsight:latest
    container_name: redis-insight
    restart: unless-stopped
    ports:
      - "5540:5540"
    volumes:
      - redis-insight-data:/data
    networks:
      - redis-network
    depends_on:
      - redis

volumes:
  redis-data:
    driver: local
  redis-insight-data:
    driver: local
networks:
  redis-network:
    driver: bridge

🚀 Step 3: Run the containers

In your terminal, execute:

docker compose up -d

Docker will pull the latest Redis and RedisInsight images and start both containers.

✅ Step 4: Open RedisInsight in your browser

Once the containers are running, navigate to:

http://localhost:5540

Check the recommended settings and also check the terms & conditions switch, and then hit the “Submit” button.

RedisInsight will launch in your browser. It may ask you to add a Redis database. Just enter and then hit Add Database:

Host: redis
Port: 6379

RedisInsight will connect to your Redis instance running in Docker.

🔄 More: Redis Persistence

We’ve enabled persistence in Redis using:

command: \["redis-server", "--appendonly", "yes"\]

This ensures that Redis data is stored on disk (in the redis-data volume), not just in-memory, which is perfect for dev environments where data loss during restarts is a concern.

🧼 Step 5: Tear down the containers (optional)

To stop and remove the containers and associated volumes:

docker compose down

🔚 Conclusion

GitHub Link: https://github.com/rafi021/redis-redisinsight-docker-compose

Youtube: https://youtu.be/C7c08gENGLI

Using Docker Compose, you can set up a complete Redis stack with RedisInsight in seconds — no local installation, no config headaches. This is ideal for developers working with caching layers, pub/sub systems, or simply learning Redis.

If you found this article helpful, feel free to bookmark it or share it with your team!

Would you like a similar setup tutorial for RabbitMQ, MongoDB Compass, or PostgreSQL with Adminer? Let me know!

🚀 Set Up PostgreSQL and Adminer Using Docker for Local Web Development

Mahmud Ibrahim — Tue, 13 May 2025 07:44:04 +0000

Setting up a local database environment for development shouldn’t be a hassle. Whether you’re building microservices or monolithic applications, Docker makes it incredibly easy to run PostgreSQL and Adminer locally without polluting your host system.

In this article, you’ll learn how to use Docker Compose to spin up a PostgreSQL container along with Adminer — a lightweight and powerful database management tool, often considered a simpler alternative to pgAdmin.

PostgreSql and Adminer using Docker Compose

✅ Prerequisites

Before we begin, make sure you have the following installed on your machine:

Docker
Docker Compose

These tools work on Windows, macOS, and Linux.

🛠 Step-by-Step Setup Guide

📁 Step 1: Create a project folder

Open your terminal and run the following:

mkdir postgres-docker-setup  
cd postgres-docker-setup

This will be the root folder for your setup.

📝 Step 2: Create the `docker-compose.yml` file

Inside the folder, create a file named docker-compose.yml and paste the following content:

services:
  # PostgreSQL
  postgres:
    image: postgres:17
    container_name: postgres
    restart: unless-stopped
    ports:
      - "5432:5432"
    volumes:
      - postgres-data:/var/lib/postgresql/data
    environment:
      PGPASSWORD: admin
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: admin
      POSTGRES_DB: mydb
    networks:
      - postgres-network
  #adminer
  adminer:
    image: adminer:5.2.1
    container_name: adminer
    restart: unless-stopped
    ports:
      - "8080:8080"
    environment:
      ADMINER_DEFAULT_SERVER: postgres
    networks:
      - postgres-network

networks:
  postgres-network:
    driver: bridge

volumes:
  postgres-data:
    driver: local

What this does:

Sets up a PostgreSQL container with a custom user and password.
Persist your data using a Docker volume.
Launches Adminer for easy database access via your browser.
Exposes PostgreSQL on port 5432 and Adminer on port 8080.

🚀 Step 3: Launch the containers

In the terminal, run:

docker compose up -d

Docker will download the required images and start the containers in the background.

✅ Step 4: Access Adminer in the browser

Go to:

http://localhost:8080

Fill in the login form like this:

System: PostgreSQL
Server: postgres
Username: admin
Password: admin
Database: mydb

Once logged in, you’ll have full access to your PostgreSQL database through a friendly interface.

🧼 Step 5: Stop and clean up (optional)

To shut everything down and remove the volumes:

docker compose down

🔚 Conclusion

GitHub Link: https://github.com/rafi021/postgresql-adminer-docker-compose

YouTube: https://youtu.be/P1u-OtVz96c

With just a single YAML file and a couple of terminal commands, you can have a fully functional PostgreSQL environment for local development. Adminer provides an elegant way to browse and manage your data without having to install extra software on your machine.

If this guide helped you, consider bookmarking it or leaving a comment. Would you like to see similar Docker-based setups for MongoDB, Redis, or Elasticsearch? Let me know!

🚀 How to Set Up MySQL and phpMyAdmin Using Docker for Local Web Development

Mahmud Ibrahim — Tue, 13 May 2025 07:40:17 +0000

MySQL and phpMyAdmin using Docker Compose

As a web developer, having a reliable and isolated environment for your database is crucial. Instead of installing MySQL and phpMyAdmin directly on your system, Docker allows you to set up both tools in containers — quickly, cleanly, and consistently across different projects.

In this guide, we’ll walk through running MySQL with phpMyAdmin using Docker Compose. This setup is perfect for local development and works seamlessly across Windows, macOS, and Linux.

✅ Prerequisites

Before we begin, make sure you have the following installed:

Docker
Docker Compose

🛠 Step-by-Step Guide

📁 Step 1: Create a Project Directory

Open your terminal and create a new directory for your Docker setup:

mkdir mysql-docker-setup  
cd mysql-docker-setup

📝 Step 2: Create a `docker-compose.yml` File

Inside the project directory, create a file named docker-compose.yml and paste the following content:

services:
  #db
  db:
    image: 'mysql/mysql-server:8.0'
    container_name: mysql
    restart: unless-stopped
    ports:
      - '3306:3306'
    volumes:
      - mysqldata:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_ROOT_HOST: '%'
      MYSQL_DATABASE: mydb
      MYSQL_USER: user
      MYSQL_PASSWORD: root
      MYSQL_ALLOW_EMPTY_PASSWORD: 1
    networks:
      - mysql-network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 3
  #phpmyadmin
  phpmyadmin:
    image: phpmyadmin/phpmyadmin
    container_name: phpmyadmin
    restart: unless-stopped
    ports:
      - '8080:80'
    environment:
      PMA_HOST: db
      PMA_PORT: 3306
      PMA_USER: user
      PMA_PASSWORD: root
    depends_on:
      - db
    networks:
      - mysql-network

networks:
  mysql-network:
    driver: bridge

volumes:
  mysqldata:
    driver: local

This configuration does the following:

Sets up a MySQL 8 container with user user and password root
Persist data using a Docker volume
Connects phpMyAdmin to MySQL for easy GUI access via your browser
Exposes MySQL on port 3306 and phpMyAdmin on port 8080

🚀 Step 3: Start the Containers

In the terminal, run:

docker compose up -d

Docker will download the necessary images and start both containers in the background.

✅ Step 4: Access phpMyAdmin

Once the containers are running, open your browser and go to:

http://localhost:8080

Username: user
Password: root

You should now see the phpMyAdmin interface connected to your MySQL database!

🧼 Step 5: Stop and Remove Containers (Optional)

When you’re done, you can stop and remove everything with:

docker compose down

🧩 Conclusion

Github Link: https://github.com/rafi021/mysql-phpmyadmin-docker-compose
Youtube: https://youtu.be/lkR__D9NEYc

Using Docker for local database development is a game-changer. It keeps your environment clean, reproduces setups, and saves time across projects. With just one YAML file and a couple of commands, you’re ready to build and test apps using MySQL with a GUI frontend like phpMyAdmin.

Let me know in the comments if you’d like to see a similar guide for PostgreSQL, MongoDB, or other services!

🚀 Set Up MongoDB with Mongo Express Using Docker for Local Development

Mahmud Ibrahim — Tue, 13 May 2025 07:36:44 +0000

MongoDB is a powerful NoSQL database widely used in modern applications. When building full-stack apps locally, it’s helpful to pair MongoDB with a lightweight admin interface, and Mongo Express is the perfect fit.

In this guide, you’ll learn how to spin up MongoDB with Mongo Express using Docker Compose. No native installs, no config nightmares — just containers working together like magic.

✅ Prerequisites

To follow along, make sure you have:

Docker
Docker Compose

This setup works on Windows, macOS, and Linux.

🛠 Step-by-Step Setup Guide

📁 Step 1: Create your project directory

Open your terminal and run:

mkdir mongo-docker-setup  
cd mongo-docker-setup

📝 Step 2: Create the `docker-compose.yml` file

Inside the folder, create a file named docker-compose.yml and paste this content:

services:
  # MongoDB
  mongodb:
    image: mongodb/mongodb-community-server:latest
    container_name: mongodb
    ports:
      - "27017:27017"
    volumes:
      - mongodb_data:/data/db
    environment:
      - MONGO_INITDB_ROOT_USERNAME=user
      - MONGO_INITDB_ROOT_PASSWORD=root
    networks:
      - mongodb_network
    healthcheck:
      test:
        - CMD
        - mongosh
        - 'mongodb://localhost:27017/admin'
        - '--eval=db.runCommand({ ping: 1 })'
      retries: 3
      timeout: 5s
  # Mongo Express
  mongo-express:
    image: mongo-express:latest
    container_name: mongo-express
    restart: unless-stopped
    ports:
      - "8081:8081"
    environment:
      ME_CONFIG_MONGODB_SERVER: mongodb
      ME_CONFIG_MONGODB_ADMINUSERNAME: user
      ME_CONFIG_MONGODB_ADMINPASSWORD: root
      ME_CONFIG_MONGODB_ENABLE_ADMIN: "true"
    depends_on:
      - mongodb
    networks:
      - mongodb_network

networks:
  mongodb_network:
    driver: bridge

volumes:
  mongodb_data:
    driver: local

🔍 What This Does

Sets up a MongoDB server with a root username/password.
Stores data persistently using a Docker volume.
Launches Mongo Express as a web-based GUI for your database.
Connects the two services over a Docker bridge network.
Exposes ports 27017 for MongoDB and 8081 for Mongo Express.

🚀 Step 3: Start the containers

Run the following command:

docker compose up -d

This will pull the necessary images and start both services in the background.

✅ Step 4: Access Mongo Express

Once the services are up, visit:

http://localhost:8081

(If you see not found page, then run the following command in the terminal)

docker exec -it mongodb mongosh --username user --password root --authenticationDatabase admin

Credential for Admin Login: admin/pass

You’ll see the Mongo Express dashboard, where you can:

Browse databases
Create collections
Add, edit, or delete documents
Run queries using MongoDB syntax

🧼 Step 5: Stop and clean up (optional)

To stop and remove everything:

docker compose down

This stops the services and removes the volumes (i.e., your MongoDB data will be wiped).

🔚 Final Thoughts

Github Link: https://github.com/rafi021/mongodb-mongo-express-docker-compose

Youtube: https://youtu.be/Dj-tQg_srxM

With just a few lines of Docker Compose, you’ve created a full MongoDB development environment — complete with a UI for browsing and managing data. No need to install MongoDB locally or mess with GUIs. Just run, develop, and enjoy!

If you found this guide useful, consider sharing it with your team. Want to see similar Docker setups for Redis, PostgreSQL, RabbitMQ, or Elasticsearch? Let me know in the comments!

🚀 Docker ব্যবহার করে লোকাল মেশিনে PostgreSQL এবং Adminer সেটআপ করুন

Mahmud Ibrahim — Tue, 13 May 2025 06:50:41 +0000

একজন ওয়েব ডেভেলপার হিসেবে ডেটাবেস নিয়ে কাজ করা প্রতিদিনের বিষয়। PostgreSQL একটি শক্তিশালী রিলেশনাল ডাটাবেস, আর Adminer একটি lightweight GUI টুল, যেটা আপনি pgAdmin -এর বিকল্প হিসেবে ব্যবহার করতে পারেন।

Docker ব্যবহার করে আপনি PostgreSQL ও Adminer খুব সহজেই লোকাল এনভায়রনমেন্টে ব্যবহার করতে পারবেন, আলাদা কোনো সফটওয়্যার ইনস্টল ছাড়াই। চলুন দেখে নিই কিভাবে করবেন সেটআপ।

✅ পূর্বশর্ত

নিচের সফটওয়্যারগুলো আপনার সিস্টেমে থাকতে হবে:

Docker
Docker Compose

🛠 Step by Step Guide

📁 ধাপ ১: একটি ফোল্ডার তৈরি করুন

টার্মিনালে গিয়ে নিচের কমান্ডগুলো রান করুন:

mkdir postgres-docker-setup  
cd postgres-docker-setup

📝 ধাপ ২: `docker-compose.yml` ফাইল তৈরি করুন

নতুন একটি ফাইল তৈরি করুন docker-compose.yml নামে এবং নিচের YAML কনফিগারেশনটি পেস্ট করুন:

services:
  # PostgreSQL
  postgres:
    image: postgres:17
    container_name: postgres
    restart: unless-stopped
    ports:
      - "5432:5432"
    volumes:
      - postgres-data:/var/lib/postgresql/data
    environment:
      PGPASSWORD: admin
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: admin
      POSTGRES_DB: mydb
    networks:
      - postgres-network
  #adminer
  adminer:
    image: adminer:5.2.1
    container_name: adminer
    restart: unless-stopped
    ports:
      - "8080:8080"
    environment:
      ADMINER_DEFAULT_SERVER: postgres
    networks:
      - postgres-network

networks:
  postgres-network:
    driver: bridge

volumes:
  postgres-data:
    driver: local

এই কনফিগারেশনটি যা করে:

PostgreSQL ডাটাবেস কনটেইনার সেট করে
ডাটাবেজ ডেটা সংরক্ষণের জন্য Docker ভলিউম ব্যবহার করে
Adminer GUI ইন্টারফেস চালায়, যাতে আপনি GUI দিয়ে ডাটাবেস দেখতে ও ম্যানেজ করতে পারেন
PostgreSQL-কে 5432 পোর্টে এবং Adminer-কে 8080 পোর্টে এক্সপোজ করে

🚀 ধাপ ৩: কনটেইনার চালু করুন

টার্মিনালে নিচের কমান্ডটি চালান:

docker compose up -d

Docker ইমেজগুলো ডাউনলোড করে কনটেইনারগুলো চালু করে দিবে ব্যাকগ্রাউন্ডে।

✅ ধাপ ৪: Adminer এক্সেস করুন

ব্রাউজারে যান:

http://localhost:8080

লগইন Information:

System: PostgreSQL
Server: postgres
Username: admin
Password: admin
Database: mydb

এখন আপনি Adminer GUI ব্যবহার করে PostgreSQL ডাটাবেসে কাজ করতে পারবেন!

🧼 ধাপ ৫: বন্ধ ও রিমুভ করুন (ঐচ্ছিক)

সব শেষ হলে আপনি নিচের কমান্ড দিয়ে কনটেইনার বন্ধ ও ভলিউম ডিলিট করতে পারেন:

docker compose down

🔚 উপসংহার

GitHub Link: https://github.com/rafi021/postgresql-adminer-docker-compose
YouTube: https://youtu.be/P1u-OtVz96c

PostgreSQL এবং Adminer লোকাল মেশিনে Docker দিয়ে চালানো খুব সহজ, দ্রুত এবং ক্লিন। আপনি ডাটাবেস টেস্টিং, ডেভেলপমেন্ট বা মাইগ্রেশন — যেকোনো কিছুতে এটি ব্যবহার করতে পারেন।

এই গাইডটি আপনাকে সহায়ক মনে হলে কমেন্টে জানান — আমরা MongoDB, Redis কিংবা Elasticsearch নিয়েও গাইড বানাতে পারি!

🚀 লোকাল ওয়েব ডেভেলপমেন্টের জন্য Docker ব্যবহার করে MySQL এবং phpMyAdmin সেটআপ করুন

Mahmud Ibrahim — Tue, 13 May 2025 06:44:33 +0000

🚀 লোকাল ওয়েব ডেভেলপমেন্টের জন্য Docker ব্যবহার করে MySQL এবং phpMyAdmin সেটআপ করুন

একজন ওয়েব ডেভেলপার হিসেবে ডাটাবেসের জন্য নির্ভরযোগ্য ও আলাদা একটি এনভায়রনমেন্ট খুবই গুরুত্বপূর্ণ। MySQL ও phpMyAdmin সরাসরি সিস্টেমে ইনস্টল করার বদলে, Docker ব্যবহার করে আপনি এই টুলগুলো কনটেইনারে রান করতে পারেন — দ্রুত এবং প্রত্যেক প্রজেক্টে একইভাবে।

এই গাইডে, আমরা দেখাবো কিভাবে Docker Compose ব্যবহার করে MySQL এবং phpMyAdmin লোকাল মেশিনে Steup করবেন। এটা সব ধরনের অপারেটিং সিস্টেমে — Windows, macOS, Linux কাজ করবে।

✅ Requirement

এই টিউটোরিয়াল শুরুর আগে নিশ্চিত করুন যে আপনার মেশিনে নিচের সফটওয়্যারগুলো ইনস্টল আছে:

Docker
Docker Compose

🛠 ধাপে ধাপে গাইড

📁 ধাপ ১: একটি প্রজেক্ট ফোল্ডার তৈরি করুন

টার্মিনালে নিচের কমান্ড রান করুন:

mkdir mysql-docker-setup  
cd mysql-docker-setup

📝 ধাপ ২: `docker-compose.yml` ফাইল তৈরি করুন

এই ফোল্ডারের ভিতরে docker-compose.yml নামের একটি ফাইল তৈরি করুন এবং নিচের কোড পেস্ট করুন:

services:
  #db
  db:
    image: 'mysql/mysql-server:8.0'
    container_name: mysql
    restart: unless-stopped
    ports:
      - '3306:3306'
    volumes:
      - mysqldata:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_ROOT_HOST: '%'
      MYSQL_DATABASE: mydb
      MYSQL_USER: user
      MYSQL_PASSWORD: root
      MYSQL_ALLOW_EMPTY_PASSWORD: 1
    networks:
      - mysql-network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 3
  #phpmyadmin
  phpmyadmin:
    image: phpmyadmin/phpmyadmin
    container_name: phpmyadmin
    restart: unless-stopped
    ports:
      - '8080:80'
    environment:
      PMA_HOST: db
      PMA_PORT: 3306
      PMA_USER: user
      PMA_PASSWORD: root
    depends_on:
      - db
    networks:
      - mysql-network

networks:
  mysql-network:
    driver: bridge

volumes:
  mysqldata:
    driver: local

এই কনফিগারেশনটি যা করে:

একটি MySQL 8 কনটেইনার সেট উপ করে
ডাটাবেজ ডেটা সংরক্ষণের জন্য Docker ভলিউম ব্যবহার করে
phpMyAdmin GUI এর মাধ্যমে MySQL ম্যানেজ করা যায়
MySQL এর জন্য 3306 এবং phpMyAdmin এর জন্য 8080 পোর্ট ওপেন করে

🚀 ধাপ ৩: কনটেইনার চালু করুন

টার্মিনালে কমান্ড দিন:

docker compose up -d

Docker প্রয়োজনীয় ইমেজগুলো ডাউনলোড করবে এবং কনটেইনার চালু করবে।

✅ ধাপ ৪: phpMyAdmin ব্যবহার করুন

ব্রাউজারে যান:

http://localhost:8080

লগইন করুন:

Username: user
Password: root

এখন আপনি phpMyAdmin ইন্টারফেস দেখতে পারবেন!

🧼 ধাপ ৫: কনটেইনার বন্ধ ও রিমুভ করুন (Optional)

যদি কাজ শেষ হয়ে যায়, কনটেইনার বন্ধ করতে নিচের কমান্ড দিন:

docker compose down -v

🔚 উপসংহার

GitHub Link: https://github.com/rafi021/mysql-phpmyadmin-docker-compose

YouTube: https://youtu.be/lkR__D9NEYc

Docker দিয়ে লোকাল ডাটাবেস ডেভেলপমেন্ট করা খুবই সহজ। মাত্র একটি YAML ফাইল ও কয়েকটি কমান্ডেই আপনি তৈরি করে ফেলতে পারেন একটি সম্পূর্ণ ডাটাবেস Environment। এখন আপনি সহজেই MySQL এবং phpMyAdmin ব্যবহার করে আপনার অ্যাপের ডাটাবেজ অংশ ডেভেলপ করতে পারেন।

কমেন্টে জানান, আপনি PostgreSQL বা MongoDB এর জন্য এরকম গাইড চান কিনা!

DEV Community: Mahmud Ibrahim

Dockerfile Cheat Sheet – বাংলা গাইড

How to Set Up a Monitoring Stack with Prometheus, Grafana, and Node Exporter Using Docker Compose

Project Structure

Understanding the docker-compose.yml File

Service Breakdown

Step-by-Step Guide

1. Clone the Repository

2. Review and Edit Configuration

3. Start the Stack

4. Access the Services

5. Add Dashboards in Grafana

6. Stopping the Stack

Tips & Troubleshooting

Conclusion

Step-by-Step Guide: Laravel CI/CD with GitHub Actions

What is GitHub Actions?

Workflow Overview

1. Workflow Triggers

2. Define the Job and Environment

3. Set Up MySQL Database

4. Checkout Your Code

5. Setup PHP with All Laravel Extensions

6. Cache Composer Dependencies

7. Copy the CI Environment File

8. Install Composer Dependencies

9. Generate Laravel Application Key

10. Set Directory Permissions

11. Run Static Analysis with PHPStan

12. Run Code Quality Checks with PHP Insights

13. Show Database Configuration

14. Run Your Tests!

15. Deployment

Conclusion

🚀Setting Up Kafka with Docker Compose and Node.js: A Practical Guide

🚀 Set Up RabbitMQ with MQTT and Management UI Using Docker

✅ Prerequisites

🧱 Step 1: Docker Compose Setup

🚀 Step 2: Launch the RabbitMQ Container

🌐 Step 3: Access the RabbitMQ Management UI

🔌 Step 4: Enable MQTT Plugin

🔄 Step 5: Test MQTT with Mosquitto

✅ Install Mosquitto Clients

📥 Subscribe to a Topic

🖥️ Step 6: Test AMQP Pub/Sub (Optional Bash Scripts)

🧯 Step 7: Stop the Service

✅ Summary

🚀 Set Up Redis with RedisInsight Using Docker for Local Development

🚀 Set Up Redis with RedisInsight Using Docker for Local Development

✅ Prerequisites

🛠 Step-by-Step Setup

📁 Step 1: Create a project directory

📝 Step 2: Create the docker-compose.yml file

🚀 Step 3: Run the containers

✅ Step 4: Open RedisInsight in your browser

🔄 More: Redis Persistence

🧼 Step 5: Tear down the containers (optional)

🔚 Conclusion

🚀 Set Up PostgreSQL and Adminer Using Docker for Local Web Development

✅ Prerequisites

🛠 Step-by-Step Setup Guide

📁 Step 1: Create a project folder

📝 Step 2: Create the docker-compose.yml file

🚀 Step 3: Launch the containers

✅ Step 4: Access Adminer in the browser

🧼 Step 5: Stop and clean up (optional)

🔚 Conclusion

🚀 How to Set Up MySQL and phpMyAdmin Using Docker for Local Web Development

✅ Prerequisites

🛠 Step-by-Step Guide

📁 Step 1: Create a Project Directory

📝 Step 2: Create a docker-compose.yml File

🚀 Step 3: Start the Containers

✅ Step 4: Access phpMyAdmin

🧼 Step 5: Stop and Remove Containers (Optional)

🧩 Conclusion

🚀 Set Up MongoDB with Mongo Express Using Docker for Local Development

✅ Prerequisites

🛠 Step-by-Step Setup Guide

📁 Step 1: Create your project directory

Understanding the `docker-compose.yml` File

📝 Step 2: Create the `docker-compose.yml` file

📝 Step 2: Create the `docker-compose.yml` file

📝 Step 2: Create a `docker-compose.yml` File

📝 Step 2: Create the `docker-compose.yml` file

📝 ধাপ ২: `docker-compose.yml` ফাইল তৈরি করুন

📝 ধাপ ২: `docker-compose.yml` ফাইল তৈরি করুন