Forem: arafatruetbd

How I Built a Production-Ready Image CDN Using AWS S3 + CloudFront (and Eliminated Vercel Image Costs)

arafatruetbd — Mon, 13 Apr 2026 13:29:26 +0000

I recently optimized my app’s image delivery by moving from direct storage / Vercel handling to a scalable CDN setup using AWS. Here’s the complete step-by-step breakdown.

🧠 Problem

Images were slow to load globally
Vercel image optimization was becoming costly
Direct S3 access wasn’t efficient or secure

🎯 Goal

Build a system like:

User → CloudFront (CDN) → S3 (Private Storage)

🏗️ Architecture

Amazon S3 → stores images
Amazon CloudFront → CDN layer
Route 53 → DNS
ACM (SSL) → HTTPS

⚙️ Step-by-Step Setup

1. Upload images to S3

Organize structure like:

/banner
/products
/users

2. Create CloudFront Distribution

Origin: S3 bucket
Origin Access: ✅ Private (recommended)
Cache: Default optimized settings
Protocol: Redirect HTTP → HTTPS

3. Configure Custom Domain

Add: cdn.yourdomain.com
Attach SSL certificate (ACM)
Create CNAME in Route 53 → CloudFront

4. Test CDN

Example:
https://cdn.yourdomain.com/banner/image.jpg

⚡ Performance Optimization (IMPORTANT)

Add Cache Headers in S3

Set:
Cache-Control: public, max-age=31536000, immutable

This ensures:

1-year caching
Instant repeat loads
Reduced AWS costs

Bulk Update (CLI)

aws s3 cp s3://your-bucket/banner/ s3://your-bucket/banner/ \
--recursive \
--metadata-directive REPLACE \
--cache-control "public, max-age=31536000, immutable"

Invalidate CloudFront Cache

After changes:

/*

🔥 Results

⚡ Faster global image delivery
💸 Reduced Vercel costs
🔒 Secure (private S3 via CloudFront)
📈 Scalable for production

⚠️ Lessons Learned

Don’t use root domain (use subdomain like cdn.domain.com)
Always invalidate cache after metadata changes
Never reuse image filenames (use versioning)

🧩 Bonus (Next.js Config)

module.exports = {
  images: {
    domains: ['cdn.yourdomain.com'],
    unoptimized: true
  }
};

🎉 Conclusion

S3 + CloudFront is one of the most cost-efficient and scalable ways to serve images in production. Once set up, it just works.

If you're building a startup or scaling your app — this setup is a must.

Happy building 🚀

How to Drop a PostgreSQL Database from a Docker Container (Without Breaking Things)

arafatruetbd — Mon, 13 Apr 2026 13:27:19 +0000

If you're working with PostgreSQL inside Docker, at some point you’ll need to reset your database.

Maybe:

You want a clean start
You imported the wrong data
Or something just went wrong (it happens 😅)

Dropping a database sounds simple — but there’s one important rule that can trip you up.

⚠️ The Rule Most People Miss

👉 You cannot drop a database while you're connected to it

So if your database is my_database, you must connect to a different one (usually postgres) before dropping it.

🚀 The Correct Command

Here’s the safe and correct way to drop your database from a Docker container:

docker exec -i postgres_container psql -U postgres -d postgres -c "DROP DATABASE my_database;"

🧠 What’s Happening Here?

docker exec → runs a command inside your container
postgres_container → your container name
psql → PostgreSQL CLI
-d postgres → connect to default database (not the one you're deleting)
DROP DATABASE my_database; → removes the database

👉 In simple terms:

“Connect to a safe database and delete the target database from there.”

🔄 Drop and Recreate (Clean Reset)

If you want a fresh database:

docker exec -i postgres_container psql -U postgres -d postgres -c "DROP DATABASE IF EXISTS my_database;"
docker exec -i postgres_container psql -U postgres -d postgres -c "CREATE DATABASE my_database;"

🔥 Full Reset (Docker Way)

If you want to completely wipe everything:

docker-compose down -v
docker-compose up -d

This removes:

All databases
Volumes
Stored data

👉 You get a completely fresh start.

🧩 When You’ll Need This

Resetting development databases
Fixing broken migrations
Cleaning test environments
Re-importing fresh data

🏁 Final Thoughts

Dropping a PostgreSQL database inside Docker is straightforward — once you understand the connection rule.

The key takeaway:

Always connect to a different database before dropping the target one.

It’s a small detail, but it saves a lot of confusion.

How to Export a PostgreSQL Database from a Docker Container (pg_dump Guide)

arafatruetbd — Tue, 07 Apr 2026 23:22:36 +0000

If you're working with PostgreSQL inside Docker, sooner or later you'll need a backup.

Maybe you're about to change something risky.
Maybe you want to move your database somewhere else.
Or maybe you just don’t want to lose your data (we’ve all been there 😅).

The good news? It’s actually much simpler than it looks.

In this guide, I’ll show you the easiest way to export your PostgreSQL database from a Docker container using pg_dump.

🚀 The One-Liner (Quick Answer)

docker exec -i postgres_container pg_dump -U postgres my_database > dump.sql

That’s it.

Run this, and you’ll get a file called dump.sql on your machine containing your entire database.

🧠 What’s Really Happening Here?

At first glance, this command looks a bit intimidating. But it’s actually doing something very logical.

docker exec → “Run this command inside my container”
-i → “Keep the connection open so data can stream out”
postgres_container → Your Docker container name
pg_dump → PostgreSQL’s built-in backup tool
my_database → Your database name
> dump.sql → “Save whatever comes out into a file on my computer”

👉 In plain English:

You’re telling Docker:
“Run pg_dump inside the container and send the result directly to my local file.”

No need to manually enter the container. No extra steps.

📦 What Do You Get in `dump.sql`?

The file you get is a full logical backup of your database. It includes:

All tables (structure)
All data (INSERT statements)
Indexes, constraints, relationships

Basically, everything you need to rebuild the database later.

✅ Why This Approach Is So Useful

I like this method because it’s:

✔ Simple — just one command
✔ Fast — no unnecessary steps
✔ Practical — works in almost any Docker setup
✔ Flexible — perfect for backups, migrations, and debugging

⚠️ Common Issues (And Quick Fixes)

❌ Authentication error

If your database uses a password, you might see an error.

Just pass it like this:

docker exec -e PGPASSWORD='your_password' -i postgres_container \
pg_dump -U postgres my_database > dump.sql

❌ Container not running

Make sure your container is up:

docker ps

❌ Wrong container name

Double-check the name:

docker ps --format "table {{.Names}}\t{{.Image}}"

💡 Pro Tip: Compress the Backup

If your database is large, you probably don’t want a huge .sql file.

You can compress it on the fly:

docker exec -i postgres_container pg_dump -U postgres my_database | gzip > dump.sql.gz

This saves space and is great for uploads or CI/CD pipelines.

🔄 How to Restore the Backup

When you need your data back:

psql -U postgres -d my_database < dump.sql

Simple and reliable.

🧩 When You’ll Actually Use This

This command becomes super handy when you:

Need a quick local backup
Are moving data between environments
Want to debug production issues locally
Plan to make risky schema changes

Docker Cheatsheet: Quick Reference for Developers

arafatruetbd — Sat, 20 Sep 2025 21:48:59 +0000

Introduction
Docker is a containerization platform that allows you to package applications and their dependencies into lightweight, portable containers. Here’s a quick cheatsheet to get started and work efficiently with Docker.

1. Docker Basics

Check Docker version:

docker --version

List running containers:

docker ps

List all containers (running + stopped):

docker ps -a

List all images:

docker images

Stop a container:

docker stop <container_id>

Remove a container:

docker rm <container_id>

Remove an image:

docker rmi <image_name>

2. Working with Images

Pull an image from Docker Hub:

docker pull <image_name>:<tag>

Build an image from Dockerfile:

docker build -t <image_name>:<tag> .

Run a container from an image:

docker run -d --name <container_name> <image_name>:<tag>

Run container with port mapping:

docker run -d -p 8080:80 <image_name>

3. Dockerfile Essentials

Basic structure:

# Use a base image
FROM node:18

# Set working directory
WORKDIR /app

# Copy package files and install dependencies
COPY package*.json ./
RUN npm install

# Copy app source code
COPY . .

# Expose port and start app
EXPOSE 3000
CMD ["node", "index.js"]

4. Docker Compose Basics

docker-compose.yml example for Node.js + MongoDB:

version: '3'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - .:/app
    depends_on:
      - mongo

  mongo:
    image: mongo:6
    ports:
      - "27017:27017"

Commands:

docker-compose up        # Start all services
docker-compose down      # Stop all services
docker-compose logs -f   # Follow logs

5. Useful Docker Commands

View container logs:

docker logs -f <container_id>

Execute a command in running container:

docker exec -it <container_id> bash

Remove all stopped containers:

docker container prune

Remove unused images:

docker image prune -a

Conclusion:
Docker simplifies deployment, ensures consistency, and makes scaling easier. Keep this cheatsheet handy while developing and experimenting with containers.

Managing Old Node.js Versions on Windows: My Problem & Solution

arafatruetbd — Mon, 15 Sep 2025 21:39:01 +0000

Problem

I needed to install and switch between older Node.js versions (like 10.12.0 and 12.19.0) on Windows.

I first tried using nvm-windows, but every time I installed an old version, it failed with errors like:

error installing 10.12.0: The system cannot find the file specified.

The issue was that nvm-windows tries to download matching npm zip files, and those archives no longer exist for many old Node releases. This meant I couldn’t get the versions I needed without messy manual fixes.

Solution: Use Volta

Instead of fighting with nvm-windows, I switched to Volta, a modern JavaScript toolchain manager that works perfectly on Windows.

Here’s the complete process I followed:

1. Install Volta

Using winget (recommended):

winget install Volta.Volta

Or download the latest .msi installer from Volta releases.

After installation, restart your terminal so Volta is added to your PATH.
Verify it works:

volta --version

2. Install Old Node Versions

Now I could install older Node.js versions without errors:

volta install node@10.12.0
volta install node@12.19.0

Check versions:

node -v
npm -v

3. Pin Versions Per Project

For projects that depend on specific Node versions, Volta can “pin” the version:

cd my-legacy-project
volta pin node@10.12.0

This adds the Node version to the project’s package.json. Now whenever I enter this folder, Volta automatically switches to Node 10.12.0.

Another project can have Node 12.19.0 pinned the same way, without conflicts.

✅ Final takeaway:
If you’re on Windows and need to run old Node.js versions, skip nvm-windows.
With Volta, installation is simple, switching is automatic, and everything just works.

🚀 How to Set Up SSH Keys for GitLab (Step by Step)

arafatruetbd — Mon, 15 Sep 2025 21:12:48 +0000

When working with GitLab, using SSH is the most secure and convenient way to interact with your repositories. Instead of typing your username and password every time, SSH keys let you connect with just a command.

In this guide, I’ll show you how to set up SSH keys for GitLab from scratch.

🔑 Step 1: Check if you already have SSH keys

Open a terminal and run:

ls -al ~/.ssh

If you see files like id_rsa.pub or id_ed25519.pub, you may already have a key. Otherwise, let’s generate a new one.

🛠️ Step 2: Generate a new SSH key

Run this command (replace the email with yours):

ssh-keygen -t ed25519 -C "your.email@example.com"

Press Enter to accept the default file path.
Optionally set a passphrase for extra security.

This creates two files:

id_ed25519 → your private key (keep it secret!)
id_ed25519.pub → your public key (this goes to GitLab).

⚙️ Step 3: Add your SSH key to the ssh-agent

Start the agent:

eval "$(ssh-agent -s)"

Then add your key:

ssh-add ~/.ssh/id_ed25519

📋 Step 4: Copy your public key

Run:

cat ~/.ssh/id_ed25519.pub

Copy the output (the whole line starting with ssh-ed25519).

🔗 Step 5: Add the key to GitLab

Log in to GitLab.
Go to User Settings → SSH Keys.
Paste your public key.
Add a title and click Add key.

✅ Step 6: Test the connection

Run:

ssh -T git@gitlab.com

If successful, you’ll see:

Welcome to GitLab, @yourusername!

📥 Step 7: Clone repositories with SSH

Now you can clone any repo without typing passwords:

git clone git@gitlab.com:groupname/reponame.git

🎯 Final Notes

Always keep your private key safe and never share it.
If you work on multiple machines, you’ll need to add a key for each one.
You can use SSH for both GitLab.com and self-hosted GitLab instances.

🔥 That’s it! You’re ready to use SSH with GitLab.
I’d love to hear your thoughts—drop a comment if you tried this or faced any issues.

How I Built an AI-Powered Transcript Summarizer Using n8n

arafatruetbd — Sun, 14 Sep 2025 14:05:46 +0000

1. Intro

Do you ever find yourself buried under mountains of meeting transcripts or interview notes? What if summarizing them could be completely automated? I just built a workflow with n8n to automatically pull transcript files from Google Drive, summarize them via an LLM, and push the results into Google Sheets—with zero manual effort.

I’m publishing the full workflow on GitHub, and in this post, I'll walk you through how it works, why I built it, and how you can apply it to your own projects.

2. Problem Statement

Large organizations or content creators often generate long-form transcripts—calls, podcasts, interviews, lectures.
Manually summarizing these is time-consuming and inconsistent.
Valuable insights get lost in walls of unstructured text.

3. Enter n8n + LLMs

With n8n, an open-source workflow automation tool, and modern large language models (via OpenRouter/OpenAI), you can automate:

Detecting new transcript files in Google Drive
Decoding and cleaning the text
Chunking large transcripts into manageable pieces (≤4000 characters)
Summarizing each chunk consistently into:

A 3-sentence executive summary
A list of pain points
A list of feature requests
1. Merging & deduplicating chunk summaries
2. Format results for clarity
3. Save or update results in Google Sheets by matching CallID

No coding except for simple JavaScript cleaning—just drag, configure, and run.

4. How the Workflow Works (Step-by-Step)

Google Drive Trigger
Watches a specific Drive folder (e.g., “Transcripts”) and triggers when a new file is added.
Download
Fetches the file binary so it can be processed.
Decode Binary → rawText
Detects if the file is UTF-8 or UTF-16, strips out BOMs, and converts it into readable text.
Load Transcript
Moves the decoded text into a variable for downstream processing.
Preprocessing

Normalizes line breaks
Replaces [inaudible] with “unclear audio”
Redacts email addresses and phone numbers for privacy

Chunk Transcript

Splits by trimmed lines into chunks under ~4000 characters
Handles long lines by slicing them

Basic LLM Chain Sends each chunk to the LLM with a prompt to return strict JSON with:

summary: exactly 3 sentences
pain_points[]
feature_requests[]

Merge Summaries

concatenates all chunk summaries
deduplicates pain points & feature requests

Format for Sheet

Generates:
- CallID (either passed-in or generated)
- Multi-line summary (one sentence per line)
- Bulleted lists for pain points / feature requests

Append or Update in Google Sheets

* Matches on `CallID` to avoid duplicates
* Adds or updates the row in your specified sheet

(Add a screenshot or diagram of the workflow if available.)

5. Why This Matters

Save Time – No more slogging through transcripts manually
Consistency – A structured prompt ensures uniform output
Privacy – Sensitive info is redacted automatically
Scalable – Chunking means the solution works on long transcripts
Customizable – Want 5-sentence summaries or extra metadata? Just tweak the prompt or chunk code node.

6. How to Use It

Clone & import the repo:

   git clone https://github.com/arafatruetbd/n8n-transcript-summarizer.git

In n8n:

Workflows → Import from File, choose the JSON
Reconnect your credentials:
- Google Drive
- Google Sheets
- OpenRouter or another LLM provider
Configure:
- Drive folder ID
- Sheet ID & GID
- Model name if needed

Activate and test. Upload a transcript to Drive and watch the summary appear in the sheet!

7. Customization Ideas

Add a Slack node to post summaries to a channel automatically
Send email summaries
Archive transcripts after summarizing
Use a different LLM (e.g., local model or Llama on a self-hosted server)
Include additional metadata, like speaker names, timestamps, call duration, etc.

8. Call to Action

The full workflow and README are on GitHub:
https://github.com/arafatruetbd/n8n-transcript-summarizer

Feel free to clone it, tweak it, or fork it. I’d love to see what you build on top of it or how you'd improve it—drop a comment, issue, or pull request!

Summary

This workflow turns the mundane task of summarizing transcripts into a click-and-go automation powered by n8n and LLMs. Whether you're in research, product, customer support, or content creation—if you want a smarter way to turn transcripts into insight, give this a spin.

🚀 React 19 – Optimistic UI with `useOptimistic`

arafatruetbd — Sat, 16 Aug 2025 23:34:12 +0000

When you click Send in a chat app, you don’t want to wait for the server to respond before seeing your message appear.
React 19 introduces useOptimistic, a hook that lets you update the UI immediately while a background action (like sending a message) is in progress.

This makes apps feel fast and responsive.

✅ What is `useOptimistic`?

useOptimistic lets you show a temporary state (optimistic state) while an async action is underway.

Syntax:

const [optimisticState, addOptimistic] = useOptimistic(
  state,          // confirmed state
  (current, val) => newState // function to compute optimistic state
);

state → the confirmed state.
optimisticState → what is shown while the async action runs.
addOptimistic(val) → call this to update the UI optimistically.

🔥 Simple Chat Example

import React, { useState } from "react";
import { useOptimistic, startTransition } from "react";

export default function App() {
  const [messages, setMessages] = useState([]);
  const [optimisticMessages, addMessage] = useOptimistic(
    messages,
    (state, newMsg) => [...state, { text: newMsg, sending: true }]
  );

  function handleSend(msg) {
    addMessage(msg); // show instantly

    startTransition(async () => {
      await new Promise((resolve) => setTimeout(resolve, 1000)); // fake API
      setMessages(prev => [...prev, { text: msg }]); // confirm
    });
  }

  return (
    <div style={{ padding: "2rem", fontFamily: "sans-serif" }}>
      <h2>Chat</h2>
      <ul>
        {optimisticMessages.map((m, i) => (
          <li key={i}>
            {m.text} {m.sending && "(Sending...)"}
          </li>
        ))}
      </ul>
      <button onClick={() => handleSend("Hello!")}>Send Message</button>
    </div>
  );
}

🧠 How it works

addMessage("Hello!") → immediately shows the message in the UI with (Sending…).
startTransition → simulates sending the message in the background.
setMessages → confirms the message once the async task finishes.

🎯 Why use `useOptimistic`?

Makes UI feel instant.
Great for likes, comments, forms, or chat messages.
Users see immediate feedback even if the server is slow.

This small hook makes your React apps snappy and responsive with minimal code.

Smooth UI Updates in React 19 with `useTransition`: A Simple Example

arafatruetbd — Tue, 12 Aug 2025 19:13:59 +0000

Introduction

Context: React 19 introduced built-in support for async functions inside transitions, enabling automatic handling of loading states, errors, and form submissions by leveraging the useTransition hook.
Why it matters: This feature dramatically reduces boilerplate and helps your app remain responsive during asynchronous updates.

Quick Explanation of `useTransition`

useTransition returns a tuple:

  const [isPending, startTransition] = useTransition();

startTransition: wrap your state updates to mark them as low-priority (transitional)
isPending: a boolean indicating when the transition is in progress, perfect for showing a loader

Core Example: Updating a Profile

import React, { useState, useTransition } from "react";

function App() {
  const [name, setName] = useState("");
  const [message, setMessage] = useState("");
  const [isPending, startTransition] = useTransition();

  function updateName(newName) {
    // Simulate an async API call
    return new Promise((resolve) => {
      setTimeout(() => {
        if (newName.trim() === "") {
          resolve("Name cannot be empty");
        } else {
          resolve(null);
        }
      }, 1500);
    });
  }

  const handleSubmit = () => {
    setMessage(""); // clear old message
    startTransition(async () => {
      const error = await updateName(name);
      if (error) {
        setMessage(error);
        return;
      }
      setMessage(`✅ Name saved: ${name}`);
    });
  };

  return (
    <div style={{ padding: "2rem", fontFamily: "sans-serif" }}>
      <h2>React 19 – useTransition Demo</h2>
      <input
        value={name}
        onChange={(e) => setName(e.target.value)}
        placeholder="Enter your name"
        style={{ padding: "0.5rem", marginRight: "0.5rem" }}
      />
      <button onClick={handleSubmit} disabled={isPending}>
        {isPending ? "Saving..." : "Save"}
      </button>
      {message && <p>{message}</p>}
    </div>
  );
}

export default App;

How it works:

As soon as startTransition is called, isPending becomes true → you can disable the button and show a “Saving…” state.
The async logic runs inside the transition.
Once complete, isPending returns to false, and the UI responds accordingly.

What Makes This Cleaner Than Before?

Before React 19, you’d manage isPending, error, and redirection manually via useState. Now, useTransition wraps it all smartly, letting you focus on what matters—just the logic, without UI stutter.

Wrap-Up & React 19 Context

In React 19, useTransition now supports async logic inside transitions, simplifying UX patterns like pending states, error handling, and optimistic updates.
These improvements reduce boilerplate and elevate app responsiveness.

How I Accidentally Pushed Extra Folders to GitHub — And How to Fix It

arafatruetbd — Wed, 23 Jul 2025 00:04:08 +0000

Introduction

If you've ever worked with Git repositories, you might have experienced an odd situation where you pushed your code to GitHub — only to realize that not just your intended project folder got uploaded, but some unexpected folders or files appeared too.

This usually happens because of a confusion about where your Git repository is actually initialized (the “Git root”) versus where your project folder lives on your computer.

In this blog post, I’ll share my experience with this issue, how I diagnosed it, and the steps I took to fix it, so you can avoid this headache.

The Problem: Extra Folders Uploaded Alongside Your Project

I was working on a project called job_email_classifier inside a directory called MISC. I thought I was pushing only the job_email_classifier folder to GitHub.

But when I checked the remote repository, I noticed another unrelated folder inside MISC was also uploaded!

How did this happen?

Diagnosing the Issue: Understanding Your Git Root

The key to solving this problem is to understand that Git tracks files starting from a repository root folder — the folder where you run git init or clone a repo.

I ran this command inside my job_email_classifier folder:

git rev-parse --show-toplevel

It returned:

C:/Users/arafa/projects/MISC

This meant the actual Git root was the MISC folder, not job_email_classifier!

All files and folders under MISC are part of the same Git repository, so when I pushed changes, everything under MISC (including other unrelated folders) got pushed to GitHub.

Why Did This Happen?

Probably, I ran git init in the MISC folder earlier, making it the root of my Git repository.

Even though I worked inside job_email_classifier, Git sees it as a subfolder within the repo, and tracks all siblings alongside it.

The Solution: Create a Git Repo Only in Your Project Folder

To fix this, I wanted only the job_email_classifier folder to be a Git repository.

Steps I followed:

Remove the old Git repo initialized at MISC:

cd C:/Users/arafa/projects/MISC
rm -rf .git

On Windows PowerShell, you can use:
Remove-Item -Recurse -Force .git

This deletes the Git tracking data for MISC.

Go into the project folder and initialize a new Git repo there:

cd job_email_classifier
git init
git add .
git commit -m "Initial commit"

Add the remote GitHub repository:

git remote add origin https://github.com/arafatruetbd/job_email_classifier.git

Push the project to GitHub:

git push -u origin main

Verifying Your Git Repository Root

To avoid confusion in the future, you can always check your Git root folder by running:

git rev-parse --show-toplevel

Make sure it points to your intended project folder before pushing changes.

Best Practices to Avoid This Issue

Always initialize your Git repository inside the specific project folder, not a parent folder that contains multiple projects.
Use .gitignore to exclude files or folders you don't want to push.
Regularly check your repo root with git rev-parse --show-toplevel.
Use git status to review what files are staged or tracked before committing.

Conclusion

Git is a powerful tool, but understanding how the repository root works is crucial to avoid pushing unintended files or folders.

By keeping your repository initialized only in the folder you want to track, you prevent accidentally including unrelated files.

I hope this story helps you troubleshoot and fix similar issues in your Git workflow!

How to Import a SQL File into a Dockerized PostgreSQL Database

arafatruetbd — Sun, 01 Jun 2025 12:22:28 +0000

If you’re running PostgreSQL inside a Docker container, importing a SQL dump file is a common task when setting up or migrating databases. In this quick guide, I’ll show you how to copy your SQL file into the container and import it easily.

Prerequisites

A running PostgreSQL container (e.g., named demo_db)
Your SQL dump file ready on your host machine (e.g., demo.sql)
Basic knowledge of Docker commands

Step 1: (Optional) Create the Database

Before importing, make sure your target database exists. If not, create it using:

docker exec -i demo_db psql -U postgres -c "CREATE DATABASE demo_database;"

Step 2: Copy the SQL file into the container

Use the docker cp command to copy the SQL file from your local machine into the PostgreSQL container:

docker cp demo.sql demo_db:/demo.sql

This copies the file to the root directory / inside the container.

Step 3: Import the SQL file into the database

Run the psql command inside the container to execute the SQL file against your target database:

docker exec -i demo_db psql -U postgres -d demo_database -f /demo.sql

demo_db is the container name.
postgres is the PostgreSQL user.
demo_database is your database name.
-f /demo.sql points to the SQL file inside the container.

Troubleshooting tips

Ensure your container is running (docker ps).
Verify database name and user credentials.
Large files might take time, so be patient.

Conclusion

Importing SQL files into a Dockerized PostgreSQL database is straightforward once you get familiar with the commands. Using docker cp and docker exec, you can easily manage your database dumps without leaving your containerized environment.

If you found this helpful, feel free to clap and follow for more Docker and database tips!

How to Copy Files from AWS EC2 to Windows Using SCP

arafatruetbd — Sun, 01 Jun 2025 12:03:19 +0000

If you’ve been working with AWS EC2 instances, you might often need to transfer files from your Linux-based EC2 instance to your local Windows machine. For example, you might want to download a database dump, logs, or any project files.

In this post, I’ll show you simple and effective way to copy files from your AWS EC2 instance to Windows:

Using the command-line tool scp

Prerequisites

An AWS EC2 instance running Linux (like Ubuntu)
Your EC2 private key file (.pem file) downloaded from AWS
The public IP address or DNS of your EC2 instance
Basic knowledge of using terminal on Windows

Using SCP from Windows Terminal or PowerShell

scp (secure copy) allows you to securely copy files between a remote server and your local machine.

Step 1: Open PowerShell or Command Prompt

Windows 10 and 11 come with OpenSSH client installed by default, which includes the scp command. If you don’t have it, you can install it from Windows Features.

Step 2: Run the `scp` command

Use the following syntax to copy your file from EC2:

scp -i C:\path\to\your-key.pem ubuntu@<EC2-IP>:/home/ubuntu/demo.sql C:\path\to\save\

Replace C:\path\to\your-key.pem with the full path to your .pem file.
Replace <EC2-IP> with your EC2 instance’s public IP or DNS.
/home/ubuntu/demo.sql is the path to the file on the EC2 server.
C:\path\to\save\ is the destination folder on your Windows PC.

Example:

scp -i C:\Users\YourUser\Downloads\mykey.pem ubuntu@18.222.33.44:/home/ubuntu/demo.sql C:\Users\YourUser\Desktop\

You will get the file copied directly to your desktop.

Troubleshooting Tips

Make sure your EC2 security group allows SSH (port 22) from your IP.
Your .pem file permissions should be secure (e.g., chmod 400 on Linux/macOS). On Windows, just keep it safe.
Use the correct username: most Ubuntu EC2 instances use ubuntu, Amazon Linux uses ec2-user.

Conclusion

Transferring files between AWS EC2 and Windows is straightforward once you know the tools. Use scp for quick command-line transfers. This Method relies on SSH, which ensures secure and encrypted file transfers.

Happy coding and cloud managing! 🚀

If you liked this guide or want me to cover more AWS and Docker tips, follow me for updates!

Forem: arafatruetbd

How I Built a Production-Ready Image CDN Using AWS S3 + CloudFront (and Eliminated Vercel Image Costs)

🧠 Problem

🎯 Goal

🏗️ Architecture

⚙️ Step-by-Step Setup

1. Upload images to S3

2. Create CloudFront Distribution

3. Configure Custom Domain

4. Test CDN

⚡ Performance Optimization (IMPORTANT)

Add Cache Headers in S3

Bulk Update (CLI)

Invalidate CloudFront Cache

🔥 Results

⚠️ Lessons Learned

🧩 Bonus (Next.js Config)

🎉 Conclusion

How to Drop a PostgreSQL Database from a Docker Container (Without Breaking Things)

⚠️ The Rule Most People Miss

🚀 The Correct Command

🧠 What’s Happening Here?

🔄 Drop and Recreate (Clean Reset)

🔥 Full Reset (Docker Way)

🧩 When You’ll Need This

🏁 Final Thoughts

How to Export a PostgreSQL Database from a Docker Container (pg_dump Guide)

🚀 The One-Liner (Quick Answer)

🧠 What’s Really Happening Here?

📦 What Do You Get in dump.sql?

✅ Why This Approach Is So Useful

⚠️ Common Issues (And Quick Fixes)

❌ Authentication error

❌ Container not running

❌ Wrong container name

💡 Pro Tip: Compress the Backup

🔄 How to Restore the Backup

🧩 When You’ll Actually Use This

Docker Cheatsheet: Quick Reference for Developers

1. Docker Basics

2. Working with Images

3. Dockerfile Essentials

4. Docker Compose Basics

5. Useful Docker Commands

Managing Old Node.js Versions on Windows: My Problem & Solution

Problem

Solution: Use Volta

1. Install Volta

2. Install Old Node Versions

3. Pin Versions Per Project

🚀 How to Set Up SSH Keys for GitLab (Step by Step)

🔑 Step 1: Check if you already have SSH keys

🛠️ Step 2: Generate a new SSH key

⚙️ Step 3: Add your SSH key to the ssh-agent

📋 Step 4: Copy your public key

🔗 Step 5: Add the key to GitLab

✅ Step 6: Test the connection

📥 Step 7: Clone repositories with SSH

🎯 Final Notes

How I Built an AI-Powered Transcript Summarizer Using n8n

1. Intro

2. Problem Statement

3. Enter n8n + LLMs

4. How the Workflow Works (Step-by-Step)

5. Why This Matters

6. How to Use It

7. Customization Ideas

8. Call to Action

Summary

🚀 React 19 – Optimistic UI with `useOptimistic`

✅ What is useOptimistic?

🔥 Simple Chat Example

🧠 How it works

🎯 Why use useOptimistic?

Smooth UI Updates in React 19 with `useTransition`: A Simple Example

Introduction

Quick Explanation of useTransition

Core Example: Updating a Profile

What Makes This Cleaner Than Before?

Wrap-Up & React 19 Context

📦 What Do You Get in `dump.sql`?

✅ What is `useOptimistic`?

🎯 Why use `useOptimistic`?

Quick Explanation of `useTransition`

Step 2: Run the `scp` command