DEV Community: MUHAMMED ARIF

How to Reduce Docker Image Size ? (Part 2)

MUHAMMED ARIF — Fri, 05 Jan 2024 13:40:23 +0000

In my previous post, I discussed the process of building a simple 'Hello, World!' image using Docker, and the support I received was truly awesome. Thanks, guys! If you haven't had a chance to read that post yet, please check it out here.

However, I encountered some significant issues in that project, which I detailed in the last section of the post. One notable problem is the final image size, which ballooned to around 900MB. This is quite surprising for a 'Hello, World!' application.

Today we are try to reduce our image size . Lets Gooooo..

Guys Don't Forget Like this post

before going to code. i have a request to you. if like this blogs. just share your feedback on linkedin or instagram. links on end of the post

Lets Start from our previous post.

# Base Image
FROM golang:latest

# Set the Current Working Directory inside the container
WORKDIR /app

# Copy everything from the current directory to the PWD(Present Working Directory) inside the container
COPY . .

# Download all the dependencies
RUN go mod download

# Build the Go app
RUN go build -o main .

# Expose port 8080 to the outside world
EXPOSE 8080

# Command to run the executable
CMD ["./main"]

This is our last created project's docker file

Let's Change This

# Base Image
FROM golang:latest as builder

# Set the Current Working Directory inside the container
WORKDIR /app

# Copy everything from the current directory to the PWD(Present Working Directory) inside the container
COPY . .

# Download all the dependencies
RUN go mod download

# Build the Go app
RUN go build -o main .

# Start fresh from a smaller image
FROM scratch

# Set the Current Working Directory inside the container
WORKDIR /root

# Copy the Pre-built binary file from the previous stage
COPY --from=builder /app/main .

# Expose port 8080 to the outside world
EXPOSE 8080

# Command to run the executable
CMD ["./main"]

I Changed some parts in our old file. changes is: ✒️

FROM golang:latest as builder
This line creates a new stage named "builder." It's like setting up a separate workspace to build our Go application.

FROM scratch
This line starts a fresh, minimal image from scratch for our final Docker image.

COPY --from=builder /app/main .
Instead of copying everything from the original workspace, we only copy the essential built binary (main) from the "builder" stage.

WORKDIR /root
In the final image, we set a smaller working directory to keep things tidy.

Build the Optimized Docker Image 📦

Finally we will complete our coding part. let's build our optimized Docker image. Open a terminal and navigate to the directory containing your Dockerfile. Run the following command: ⌨️
docker build -t {image_name} .
This command tells Docker to build an image based on the instructions in your Dockerfile and tag it with the name "optimized-hello-world." The . at the end indicates that the Dockerfile is in the current directory.

Verify the Optimized Image Size ✅

After completing the build process, you can verify the size of your optimized Docker image by running the following command in your terminal: ⌨️
docker images
This command will display a list of Docker images on your system. Look for the image with the tag "hello-world". You should see the reduced size, confirming that you've successfully optimized your Docker image.

As you can see in the image, the size of our optimized image is now only 7MB. This is a significant reduction from the initial 900MB size. Great job! 🚀

Finally just run and verify this image. That is your task 😇😇

If you like my posts connect and send your feedback on
Linkedin and Instagram

Happy Codinggggggggg...!👨‍💻👩‍💻

Creating a Simple Hello World Web Application with Docker and Golang (Part 1)

MUHAMMED ARIF — Mon, 25 Dec 2023 20:20:59 +0000

✋ Before going to code ..

- What is Docker 😦 ?
Docker is a free tool that puts your app and all its stuff into a tidy box called a container. This box works the same everywhere on your computer, a server, 🖇️or in the cloud. It stops messy problems like "it works on my machine" and makes your app easy to carry around. Docker, and tools like it, make this container thing simple and super handy for building software.

I assume you understand this 😎. If you have no basic knowledge in Docker, watch this YouTube video. This video is an iconic one I ever saw 🚀.
Video Link 🖇️

Lets Code .. 👩‍💻

⚠️ Deffinitly you installed docker and golang on your system

1. > First Step

First, select any IDE like VSCode, Atom, IntelliJ, or Eclipse – it's completely your choice.
This example i selected vs code.

> Second Step

Open and setup your project basics

My project structure is :



├── Dockerfile
├── go.mod
└── main.go

In main.go i created a basic hello world api using http package

main.go



package main

import "net/http"

func main() {
    http.HandleFunc("/", hellowordhandler)

    http.ListenAndServe(":9000", nil)
}

func hellowordhandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello World"))
}

> Third Step

Finally we completed our basic project setup. next we are going to Dockerfile (A Dockerfile is a set of instructions for creating a Docker container).

Dockerfile



# Base Image
FROM golang:latest

# Set the Current Working Directory inside the container
WORKDIR /app

# Copy everything from the current directory to the PWD(Present Working Directory) inside the container
COPY . .

# Download all the dependencies
RUN go mod download

# Build the Go app
RUN go build -o main .

# Expose port 8080 to the outside world
EXPOSE 8080

# Command to run the executable
CMD ["./main"]

> Forth Step

Build This Docker Image

To build this Docker image, execute the following command:



docker build -t hello-word .

In this command, -t specifies the tag name for our final image (in this case, "hello-world"), and . indicates that the Dockerfile is in the current directory. The period (.) implies that the build context is the current directory, and Docker will use the Dockerfile found there to create the image.

Loading ⭕. This process is may be take >1 mins.

Final Step

After complete that. you exicute another command



docker images

Result is you can see hello-world image on their.

next is run that image



docker run -p 9000:9000 hello-world

The -p flag is used for port mapping. It maps the host machine's port to the container's port. In this case, it's mapping port 9000 on the host to port 9000 on the container. So, any traffic coming to the host machine on port 9000 will be redirected to the container's port 9000.

After Exicute This :

Conclusion

We have successfully created a simple Docker Hello World image, which serves as a helpful starting point for beginners. However, it's worth noting that the current approach results in a relatively large image size, approximately 900MB, which may not be optimal. In the spirit of continuous improvement, I am open to providing support and guidance. If you express interest and engagement with this post, I'll gladly share a follow-up on how to significantly reduce the image size to less than 10MB. Let's embark on this journey together for more efficient and streamlined Docker images!

Follow me

Golang Road map in 2023. From beginner to Expert

MUHAMMED ARIF — Wed, 13 Sep 2023 18:55:28 +0000

As we enter the promising year of 2023, the world of software development is buzzing with opportunities, and the Go programming language (often referred to as Golang) beckons as an enticing avenue to explore. Whether you’re a newcomer to coding, eager to embark on your programming journey, or a seasoned developer looking to broaden your horizons, this roadmap will serve as your trusted companion on the path to becoming a proficient Go programmer. Together, we will navigate the essential milestones that will elevate you from a novice to a seasoned expert in Golang.

The Foundation of Mastery: Learning the Basics
At the heart of every successful programmer’s journey lies a strong grasp of the fundamentals. These fundamentals serve as the bedrock upon which your programming prowess is built. So, what exactly do we mean by ‘basics’? In the context of Go programming, it entails delving into key concepts such as basic syntax, variable declaration, data types, and more. You’ll immerse yourself in the world of functions, exploring Go’s unique varieties, including normal, named, and multiple-return functions. You’ll master the art of controlling program flow with loops and gain invaluable insights into error handling. Additionally, we’ll delve into the power of packages and the nuances of import/export mechanisms.

Completing this foundational stage isn’t just a milestone; it’s the creation of your programming bedrock. With these basics firmly in your grasp, you’ll be well-equipped to tackle more complex challenges and explore the limitless possibilities that Go programming offers. So, let’s embark on this enlightening journey together, where each step brings you closer to becoming a Go expert.

Dive into Golang
With a solid grasp of the programming fundamentals under your belt, it’s time to take the plunge into the world of Golang, where a myriad of exciting possibilities awaits. As you progress on this journey, you’ll explore not only the core aspects of the language but also its diverse applications, including the development of command-line interface (CLI) applications and harnessing the power of popular web frameworks.

We’ll start by unraveling the elegance of Go’s syntax, designed for clarity and efficiency, which is not only conducive to building CLI apps but also makes your code highly readable and maintainable. You’ll soon find yourself crafting your own CLI tools, empowering you to automate tasks and simplify your daily workflow.

Venturing deeper into the Golang ecosystem, you’ll dive into the world of JSON manipulation, mastering Go’s native support for encoding and decoding JSON data. This skill will prove invaluable as you work with data interchange in various applications.

When it comes to web development, Golang has a lot to offer. We’ll explore the realm of web frameworks, discovering how Go’s efficient and performant nature makes it an excellent choice for building web applications. Whether you’re drawn to the lightweight simplicity of frameworks like Gin or the robustness of Beego, you’ll be equipped to design web applications that can handle diverse workloads.

Our journey will also lead us to the fascinating world of interfaces, a cornerstone of Go’s philosophy. You’ll learn how to define and implement interfaces effectively, allowing you to write flexible and modular code that can adapt to changing requirements.

And of course, no exploration of Golang would be complete without a deep dive into Goroutines, the language’s superpower for concurrent programming. You’ll uncover the magic behind Goroutines and Channels, mastering the art of building highly concurrent and scalable applications.

Throughout this journey, you’ll discover how Go’s design principles prioritize simplicity, efficiency, and productivity, making it an ideal choice for a wide range of applications. So, get ready to embark on this exhilarating adventure through the intricacies of Golang, where each lesson equips you with the skills to tackle real-world challenges and turn your programming dreams into reality.”

Continue learning
As you keep your Golang journey rolling, here’s a piece of friendly advice: hands-on experience is your best teacher. Don’t just read about it — create! Start by brainstorming small projects or problems you’d like to solve. Building your own programs, even simple ones, is a fantastic way to solidify what you’ve learned.

Additionally, consider collaborating with others in the Go community. Sharing your ideas, asking questions, and contributing to open-source projects can be incredibly rewarding. It’s like joining a team of fellow explorers on this coding adventure.

Lastly, never stop exploring. Golang is a versatile language with applications in various fields. Whether you’re interested in web development, system programming, or data analysis, there’s a Go path for you. So, stay curious, keep coding, and remember: every line of code you write brings you closer to Go mastery.

Happy Coding !

Golang advanced roadmap

Beginner Road Map Of Flutter Developer

MUHAMMED ARIF — Sun, 23 Oct 2022 11:08:41 +0000

Week 1 Setup dev environment and learn Dart programming language

Set dev environment
Learn Dart programming Language (You can use dart's website or other social media for this)

Week 2

Create your first Flutter Project and understand project structure
Understand widgets
Ui widgets
Layouts
Take a walk through everything important in Flutter (ex : Navigation and more..)
Build a good application using the knowledge you have gained so far

Week 3

Use External packages
Networking
Crud(Create, Read, Update, Delete) Operations.
Try making a clone of an app you like

Week 4

Firebase (Auth, FireStore, Storage, Push Notification, Cloud functions)
Develope Complete Grocery App with Firebase Backend.

In the following weeks

Now is to improve your skill. Try to learn many advanced things along with it

Happy Coding 💞😗