Forem: Kishor Kc

Importing & Exporting PSQL Database Dump using Docker

Kishor Kc — Fri, 09 Jan 2026 09:40:20 +0000

Before you begin, make sure you have a PostgreSQL Docker image and container ready, along with your SQL dump file. If you don’t already have a PostgreSQL container set up, you’ll need to create one with proper credentials.

$ docker ps

This command lists all active containers. You should see your PostgreSQL container listed. For instance, one named exampledb.

In my case, a friend shared a large dump database with me, and I needed to explore and understand its contents. Since the dataset was quite large, I decided to work with Docker because it offers a faster, persistent, and reusable setup for managing SQL files.

To copy the dump file into your Docker container, use the following command:

$ docker cp path_of_dump_file.sql <container_name>:tmp/<name_stored.sql>

For instance:

$ docker cp ~/Downloads/example_db.sql exampledb:tmp/example_db.sql

If successful, you’ll see a confirmation message like:

Successfully copied 23MB to exampledb:/tmp/example_db.sql

At this point, your SQL file is available inside the container, and you can use it to populate your PostgreSQL database. Once the data is loaded, you can start inspecting, identifying, and debugging your database as needed.

Verify that the file exists inside the container:

$ docker exec -it exampledb ls -lh /tmp

You should see:

$ example_db.sql

If the target database does not exist, create it:

$ docker exec -it exampledb psql -U root -c "CREATE DATABASE example_db;"

Import the Dump into PostgreSQL

$ docker exec -i exampledb psql -U root -d example_db -f /tmp/example_db.sql

The SQL dump was successfully executed, and the data has been imported into the target database.

Export (backup) a PostgreSQL database from a Docker container

If you ever need to export (dump) your PostgreSQL database from Docker back to your local machine, use the following command:

$ docker exec <container_name> pg_dump -U <db_user> <db_name> > file.sql

For instance:

$ docker exec exampledb pg_dump -U root exampledb > example_db_dump.sql

This will create a example_db_dump.sql file on your local system containing the full backup of your database.

Thank you.
Remember to keep learning and exploring new things.

Nodejs | Docker | Multi-stage

Kishor Kc — Wed, 09 Oct 2024 13:05:35 +0000

I am familiar with the single stage docker file, Although when I am writing with the single stage docker file, I never consider the image size, security and optimizing build process.

Using Docker with node.js has always on my mind, and today I want to share my journey of learning about multi-stage Docker. I successfully wrote and ran a Dockerfile, and I'm excited to discuss the process and insights I've gained along the way.

One day, while discussing random topics with another developer, our conversation unexpectedly turned into an exciting topic i.e. Docker, Node.js, Docker security and image size. During the discussion, I was introduced to the concept which I have to research and have to implement while I am working with Docker. After our discussion ended with smiles all around, Then I began my research and I found multi-stage Docker builds where can reduce image size, enhance security and also improved build efficiency, among other benefits.

What I Learned About Multi-Stage Dockerfiles?

A multi-stage Dockerfile allows you to create more efficient images by separating the build process from the final runtime environment. This approach helps in minimizing the size of the final image and improving security. Here’s a basic overview of how a multi-stage Dockerfile works:

Basic Structure of a Multi-Stage Dockerfile

Build Stage: Contains all the tools and dependencies needed to build your application. This stage includes compiling code, installing build tools, and generating artifacts.
Final Stage: Uses a clean base image and copies only the necessary files from the build stage to produce a smaller, more secure final image.

Example
I am sharing an example of a Dockerfile for a Node.js application
create a file name as a Dockerfile

Dockerfile

# Stage 1: Build
FROM node:20.11.0-alpine AS build
WORKDIR /usr/src/app

# Copy package.json and yarn.lock
COPY package.json yarn.lock ./
RUN yarn

# Copy the rest of the application code
COPY . .

# Build the application
# RUN yarn build # Uncomment if you have a build step [TypeScript]

# Stage 2: Production
FROM node:20.11.0-alpine
WORKDIR /usr/src/app

# Copy only the build artifacts and runtime dependencies
COPY --from=build /usr/src/app/ ./
# COPY --from=build /usr/src/app/dist ./dist # Use this line if you have built files [TypeScript]

# Expose the port and define the command to run the application
EXPOSE 3001
# CMD [ "node", "dist/app.js" ] # Use this line if you are working with TS
CMD ["node", "src/app.js"]

Adding a .dockerignore file to your project provides several benefits, helping to streamline the Docker build process and improve efficiency.
Here’s a sample .dockerignore file that excludes common unnecessary files:

# Node modules
node_modules

# Build output
dist
build

# Logs
*.log

# Environment files
.env

# Git files
.git
.gitignore

# Dockerfile and other Docker-related files
Dockerfile*
.dockerignore

To Execute the Dockerfile

$ docker build -t node-app .
$ docker run -p 3001:3001 -e PORT=3001 -e NODE_ENVIRONMENT=development node-app

Benefits of Multi-Stage Builds

Smaller Image Size: Reduces the size of the final image by excluding build tools and intermediate files..
Improved Security: Alpine is designed to be a secure and efficient base, which helps maintain a smaller attack surface.
Better Performance: Faster build times due to effective caching of stages.
Cleaner Dockerfile: Separates concerns and improves readability and maintainability.

Mitigation Strategies

Simplify: Use multi-stage builds only when needed and avoid unnecessary complexity.
Comment: Add comments to explain each stage and step.
Optimize Caching: Use Docker’s caching to speed up builds.
Monitor Resources: Track and optimize resource usage during builds.
Test: Verify each stage individually before combining them.

Research

I am sharing the resources; I have found while learning about multi-stage Docker builds. You can also learn from below resources.
Building Multi-Stage
Start Docker Multi-Stage
Mastering Docker Multi-Stage

Thank you.
Remember to keep learning and exploring new things.

Start Docker - Digging

Kishor Kc — Sun, 14 Jan 2024 15:29:31 +0000

Hello Everyone!

You can find a lot of resources about Docker, and I’m here to share what I’ve learned. Let’s start by going through the basics of Docker, skipping over the details of what Docker is and how it helps in development or production mode.

Here are some keys to know about Docker:

Images (Pictures)
Containers (Boxes)
Dockerfile (Recipe)
Docker Commands (Orders)
Docker Compose (Teamwork)
Docker Registry (Storage)
Volumes (Storage Spaces)

I'll go straight to the point and share what I've done with Node.js and Docker. In my project, I built a simple Node.js server using Docker. In the project repository you will find a Dockerfile. It’s like a set of instructions that we can use to build our Docker image. Check it out, and you'll see a dockerignore file as well. This file helps us to exclude certain files and folders while creating our Docker image.

Take a look at the repository:
https://github.com/devkishor8007/docker-digging

And I'll share you how we can run the repository from docker container
To run, we need some sort of commands

$ docker build -t docker-digging . 
$ docker run -p 4075:4075 --env-file=.env docker-digging

Once your server is running;
Open the browser and hint the api url> http://localhost:4075/api/v1/health

Awesome!
Everything is working perfectly! If we're not familiar with the commands we're using, and I'll help you out.

So, Let's break down each part of above docker container commands

docker build -t docker-digging . :
docker build: Build a new docker image .
-t docker-digging: -t means a flag assigns a name to the image. And we named "docker-digging"
.: This dot represents the current directory as Docker should use the current directory as the build context. It includes all the files in the current directory when building the image.
So this commands represents build a docker new image from a current directory with a name "docker-digging"
docker run -p 4075:4075 --env-file=.env docker-digging
docker run: This command to run a Docker container from a given image.
-p 4075:4075: -p flag maps port 4075 on the host machine to port 4075 inside the Docker container. It allows us to access the service running in the container via http://localhost:4075
--env-file=.env: --env-file flag specifies an environment file (.env) that contains environment variables.
docker-digging: This is the name of the docker image to be used for running the container.
So, this command represents, "Run a Docker container from the 'docker-digging' image, map port 4075, and use environment variables from the .env file"

Resources

Thank you.
Remember to keep learning and exploring new things.

MongoDB With Docker

Kishor Kc — Sun, 21 May 2023 16:19:04 +0000

I am explaining how Docker can be utilized to set up the database and demonstrate its practical applications. In this article, I am focusing on utilizing the MongoDB database and provide instructions on its utilization.

There are several benefits to setting up MongoDB with Docker instead of installing it directly on your local PC:

Isolation: Docker keeps MongoDB separate from your local system, ensuring stability and consistency.
Deployment: Docker makes it easy to deploy multiple MongoDB instances and manage replica sets or clusters.
Consistency: Docker ensures consistent environments across different machines, avoiding version or configuration conflicts.
Cleanup and Portability: Docker allows easy removal of MongoDB containers and seamless migration to different environments.
Dependency Management: Docker simplifies managing MongoDB versions and dependencies.

I'm ready to help you install MongoDB in a Docker container. Let's get started!

To install mongo in docker

docker pull mongo

To determine if MongoDB is installed within our Docker environment, we need to check whether the Mongo image is present. If the image is found, we can view its ID, tag/version, and size. However, if the image is not available, no information will be displayed.

docker images mongo

Run the first MongoDB container:

docker run -d --name mongo-one -p 27017:27017 mongo

Run the Second MongoDB container:
If you need the multiple container, then you can use it

docker run -d --name mongo-two -p 27018:27017 mongo

In this above example, the container are mongo-one and mongo-two, and the -p option maps port 27017/27018 from the host machine to the container. You can choose a different container name and port mapping if desired.

Show all currently running Docker containers

docker ps

execute a running Docker container: mongo-one

docker exec -it mongo-one bash

after execute a running docker container of mongo, we have to start the MongoDB Shell and interact with the MongoDB database running inside the container

mongosh

Once the MongoDB container is successfully executed, you will obtain the database URL, which can be used with various programming languages such as Node.js, Python, Rust, Go, and more. This URL will enable you to establish a connection to the MongoDB database from your chosen programming environment.

const DB_URL1='mongodb://localhost:27017/<db_name>';
const DB_URL2='mongodb://localhost:27018/<db_name>';

Both DB_URL1 and DB_URL2 are database URLs that can be obtained when running the Docker containers for MongoDB. If you execute the "mongo-one" and "mongo-two" containers as mentioned, both DB_URL1 and DB_URL2 will be operational and can be used to establish connections to the respective MongoDB databases.

Once the database is up and running, I can share a set of commands through the Docker shell to interact with MongoDB. These commands enable us to perform various operations and manipulate the MongoDB database within the Docker environment

show all the databases

show dbs

Feel free to use the help command if you find yourself confused or uncertain about how to proceed.

help

switch to the store database

use store

Get all the collections present in the currently selected database

show collections

Create multiple fruit in the store

db.fruit.insertMany([
{name:"apple", price: 250, color: "red"}, 
{name:"banana", price: 120, color: "yellow"},
{name:"papaya", price: 150, color: "yellowish-orange"}
])

Get all the fruit

db.fruit.find()

Get all the fruits which name contain banana

db.fruit.find({name: "banana"})

Get the single fruit by name

db.fruit.findOne({name: "banana"})

Updates a single document based on the matching name

db.fruit.findOneAndUpdate(
   { name: "banana" },
   { $set: { price : 100 } },
)

Resources

Thank you.
Remember to keep learning and exploring new things.

Common Widgets in Flutter

Kishor Kc — Sat, 29 Apr 2023 05:46:13 +0000

Whatever we build our applications using flutter, these widgets are commonly used in our mobile apps. Although the method of creating a User Interface(UI) can vary, the usage of widgets remains consistent.

I would like to share the commonly used widgets in Flutter. If you are a Flutter developer, you may already be familiar with them.

Stateless and Stateful Widget:
Stateless Widget is static widget as only updates when it is initialized where Stateful Widget is the dynamic widget as the changes dynamically.
Only Stateful Widget can use setState()
Scaffold Widget:
The Scaffold is a widget in Flutter used to implements the basic material design visual layout structure.
With help of Scaffold Widget, we can use other widgets like AppBar, Body, Floating Action Bar, Bottom Navigation Bar and Persistent Footer Buttons, etc.
AppBar: Used to create a navigation bar at the top of the screen.
Text: Used to display text with various styles, such as font size, font weight, color, and alignment.
Container: Used to contain other widgets and customize their appearance, such as setting padding, margin, color, and border
SizedBox: allows you to create a box with a specified width, height, or both
Row & Column: Used to layout widgets vertically and horizontally, respectively.
TextFormField: Used for creating a form input field with validation.
Used to allow users to input text in your app
Card: Used for creating a container with a shadow effect that can be used to display content.
IconButton, MaterialButton, & ElevatedButton: used to create buttons with different styles and properties
Image: Used to display images in your app, either from local resources or from a network.
ListView: Used to display a scrollable list of items, either vertically or horizontally.
ClipRRect: Used to clips its child using a rounded rectangle.

Each widget has its own unique properties, and we can utilize the properties of the widget that are required to our application.

If you need more widgets, Please Have a look on flutter official docs - flutter widgets

I would like to share the UI that I created using these widgets in Flutter, and the code is available on GitHub. This provides you with an idea of how you can use these commonly used widgets to create simple UI apps.

Each widget has its own roles and responsibilities but the important things is to identify which widget is suitable for our application and will make it visually appealing.

Screenshots

If you create your own Flutter UI app using these widgets and share your code on GitHub, you can post the UI repository link in the comment section of this post. I would be delighted to review your code and provide suggestions on how to improve it.

Bonus
If you check my code, I used MediaQuery where MediaQuery do create responsive and adaptive UI that can adjust their layout and behavior based on the device's screen size and other attributes
example

  SizedBox(
                height: MediaQuery.of(context).size.height * 0.02,
          )

I hope that this information proves to be helpful, and I look forward to sharing more in my future posts. Thank you.

Flutter Custom Widget

Kishor Kc — Sun, 16 Apr 2023 04:21:26 +0000

Namaste Everyone

I hope that you are doing well

Have you ever thought about making a custom widget to make your code more straightforward? If not, allow me to guide you through the process and show you how it can reduce redundancy in your code.

In this post, I will be sharing a custom widget that you can create. Custom widgets are great for making your code reusable and avoiding duplicate code.

Below is a snippet of a Login UI Page where you can see the repetitive code of TextField. However, the email and password TextField widgets have different controller names, obscureText, and hintText values.

// pages/login.page.dart
class LoginPage extends StatefulWidget {
  const LoginPage({super.key});

  @override
  State<LoginPage> createState() => _LoginPageState();
}

class _LoginPageState extends State<LoginPage> {
  late final TextEditingController _email;
  late final TextEditingController _password;

  @override
  void initState() {
    super.initState();
    _email = TextEditingController();
    _password = TextEditingController();
  }

  @override
  void dispose() {
    super.dispose();
    _email.dispose();
    _password.dispose();
  }

  @override
  Widget build(BuildContext context) {
    Size size = MediaQuery.of(context).size;
    return SafeArea(
      child: Scaffold(
        body: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text(
              'Login',
              style: TextStyle(
                fontSize: Theme.of(context).textTheme.headlineSmall!.fontSize,
              ),
            ),
            SizedBox(
              height: size.height * 0.01,
            ),
            TextFormField(
              controller: _email,
              obscureText: false,
              decoration: const InputDecoration(
                hintText: 'Enter your email..',
                hintStyle: TextStyle(
                  color: Colors.grey,
                ),
                border: OutlineInputBorder(
                  borderSide: BorderSide(
                    color: Colors.green,
                    width: 1.0,
                  ),
                  borderRadius: BorderRadius.all(
                    Radius.circular(9),
                  ),
                ),
                focusedBorder: OutlineInputBorder(
                  borderSide: BorderSide(
                    color: Colors.green,
                    width: 1.0,
                  ),
                  borderRadius: BorderRadius.all(
                    Radius.circular(9),
                  ),
                ),
                enabledBorder: OutlineInputBorder(
                  borderSide: BorderSide(
                    color: Colors.green,
                    width: 1.0,
                  ),
                  borderRadius: BorderRadius.all(
                    Radius.circular(9),
                  ),
                ),
              ),
            ),
            SizedBox(
              height: size.height * 0.01,
            ),
            TextFormField(
              controller: _password,
              obscureText: true,
              decoration: const InputDecoration(
                hintText: 'Enter your password..',
                hintStyle: TextStyle(
                  color: Colors.grey,
                ),
                border: OutlineInputBorder(
                  borderSide: BorderSide(
                    color: Colors.green,
                    width: 1.0,
                  ),
                  borderRadius: BorderRadius.all(
                    Radius.circular(9),
                  ),
                ),
                focusedBorder: OutlineInputBorder(
                  borderSide: BorderSide(
                    color: Colors.green,
                    width: 1.0,
                  ),
                  borderRadius: BorderRadius.all(
                    Radius.circular(9),
                  ),
                ),
                enabledBorder: OutlineInputBorder(
                  borderSide: BorderSide(
                    color: Colors.green,
                    width: 1.0,
                  ),
                  borderRadius: BorderRadius.all(
                    Radius.circular(9),
                  ),
                ),
              ),
            ),
            SizedBox(
              height: size.height * 0.025,
            ),
            ElevatedButton(
              onPressed: () {},
              child: const Text('Login'),
            ),
            SizedBox(
              height: size.height * 0.06,
            ),
          ],
        ),
      ),
    );
  }
}

After examining a lengthy code snippet of a Login UI Page, how do you feel?
Take a deep breath and don't worry.

Let me pause for a moment to think about how you could potentially simplify your code and design a custom widget for a TextFormField.

Don't worry if you're not sure, I'm here to share with you the steps you can take to create a custom widget.

// widgets/custom_textfield.dart
class CustomTextField extends StatelessWidget {
  final TextEditingController controller;
  final String hintText;
  final bool obscureText;
  const CustomTextField({
    super.key,
    required this.controller,
    required this.hintText,
    this.obscureText = false,
  });

  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: const EdgeInsets.all(10.0),
      child: TextFormField(
        controller: controller,
        obscureText: obscureText,
        decoration: InputDecoration(
          hintText: hintText,
          hintStyle: const TextStyle(
            color: Colors.grey,
          ),
          border: const OutlineInputBorder(
            borderSide: BorderSide(
              color: Colors.green,
              width: 1.0,
            ),
            borderRadius: BorderRadius.all(
              Radius.circular(9),
            ),
          ),
          focusedBorder: const OutlineInputBorder(
            borderSide: BorderSide(
              color: Colors.green,
              width: 1.0,
            ),
            borderRadius: BorderRadius.all(
              Radius.circular(9),
            ),
          ),
          errorBorder: const OutlineInputBorder(
            borderSide: BorderSide(
              color: Colors.red,
              width: 1.0,
            ),
            borderRadius: BorderRadius.all(
              Radius.circular(9),
            ),
          ),
          enabledBorder: const OutlineInputBorder(
            borderSide: BorderSide(
              color: Colors.green,
              width: 1.0,
            ),
            borderRadius: BorderRadius.all(
              Radius.circular(9),
            ),
          ),
        ),
      ),
    );
  }
}

That's great! So you have created the CustomTextField widget. Do you know how to utilize the CustomTextField widget that you have created?

Also, regarding the snippet of CustomTextField widget, it's good to know that you can use it on any UI page wherever a form is needed.

// pages/login.page.dart
  CustomTextField(
                controller: _email,
                hintText: 'Enter your email..',
              ),
  CustomTextField(
                controller: _password,
                hintText: 'Enter your password..',
                obscureText: isVisible,
              ),

Bonus
We can create the another custom widget of Text.

// widgets/custom_text.dart
class CustomText extends StatelessWidget {
  final String text;
  final double? fontSize;
  final Color? color;
  final FontWeight? fontWeight;
  const CustomText(
      {super.key,
      required this.text,
      this.fontSize,
      this.fontWeight,
      this.color});

  @override
  Widget build(BuildContext context) {
    return Text(
      text,
      style: TextStyle(
        fontSize: fontSize,
        fontWeight: fontWeight,
        color: color,
      ),
    );
  }
}

Once you have created the CustomText widget, it can be utilized wherever it is required in your code.

// pages/homepage.dart
  CustomText(
       text: 'example',
       fontWeight: FontWeight.w800,
       fontSize: Theme.of(context)
            .textTheme
            .titleMedium!
            .fontSize,
          ),

I hope you have found it helpful and enjoyable to learn how to create a custom widget in Flutter.
Thank you.