Forem: Abhigyan Gautam

Coding Practices I have learnt as a developer

Abhigyan Gautam — Tue, 04 Jul 2023 11:42:38 +0000

Like a lot of developers, I ignored the importance of following coding practices when I started out. It seemed "cool" to just do stuff that works. But overtime, I have realised that these practices help improve the quality of code by making it more readable and efficient. Properly structured and documented code is easier to understand, debug, and maintain, even when multiple developers are working on the same project. Additionally, coding practices encourage the use of efficient algorithms and data structures, leading to optimised performance and reduced resource consumption. So here are a few things I have picked up over my time coding.

Name your variables

The single most important practice is naming your variables properly, or at least in a way that makes sense to your code. Check out the code below:

The block of code works, but imagine seeing this somewhere in a large codebase and staring at it for very long time. Yes, it would make no sense when you come back. Instead using a readable variable name would solve so much.

The above change makes the code so much more readable. The naming convention can be decided, but follow that consistently

Structure your code

In the above example, we have three different variables which can be thought of properties of one single object, in this case probably invoice. It is highly possible that same structure can be reused later in the code. It is better to make a structure to contain this data.

Using a dictionary to make an object makes it more readable and efficient than creating same variables over and over. A better way to do this is using Class.

However, avoid overuse of this as it makes the code bulky.

Comment your code

Comments are very important. When dealing with large codebases, they become a necessity to understand the underlying architecture. These become very helpful in refactoring code later on and understanding logic. Adding documentation comments in functions increase readability of code.

Code Review

Its important to take suggestions and feedback from peers to maintain the quality of code. Code review also helps adding things one might missed during implementation. Using collaboration, code can also be optimised.

Test your code

This is something that I have recently learnt the importance of. Testing your code against all possible edge cases is important. This ensures the correctness of functionality being implemented against all scenarios. Plus, writing tests means other developers get the opportunity to check their code as per the standard required, so it's a win-win. For an example, check out this series.

What are some practices you use? Let me know in comments.

Get your apps up and running in no time

Abhigyan Gautam — Wed, 28 Jun 2023 08:23:18 +0000

For a lot of developers, the tedious task is to setup the initial project. If you are just starting with a new technology, it becomes a hassle. This might lead to issues in the project repo later on. One way to make sure that things are setup just fine is to use a boilerplate and ASP.NET boilerplate is one of them.
It is a general purpose application framework designed for modern web applications which provides a strong code template to get started.

Advantages of ASP.NET BoilerPlate

The following are some advantages of using ASP.NET BoilerPlate:

It gets your app setup and running in no time. It takes care of all the initial setup required including authentication, authorization, logging, exception handling, auto mapping, localization, multi-tenancy along with features like dependency injection, unit of work etc..
It offers a module based approach, in which the modules can be used in a plug-and-play way.
It has a well written documentation.
It offers compatibility with all modern frameworks like React, Angular, Vue etc...
It is open source and the free version has a lot of features.

Using ASP.NET boilerplate

To download the boiler plate code for your application, visit ASP.NET template. Choose a template as per your requirement. For this article, let's choose React.

Once you download the project, you can see files for both your backend(.NET Core 7) and frontend (React).

From here you can just install the packages for both and run the application. That's it!! Your app is up and running 🎉.

Learn more about this at ABP

Cover Photo by CHUTTERSNAP on unsplash

Arrange.Act.Assert.

Abhigyan Gautam — Mon, 19 Jun 2023 11:59:30 +0000

We will now write tests for the Fruit Controller. As discussed before there are three steps that make up a unit test - Arrange, Act, Assert. We will go through each of these steps in this article. First create an Empty class in RestTestUNIT project, let's call it FruitControllerTest.cs. Add the following to it.

namespace RestTestUNIT;
using RestTest.Service;
using RestTest.Controllers;
public class FruitControllerTest
{
    private FruitBAsketController fruitbasketcontroller;

    [SetUp]
    public void Setup()
    {

    }

    [Test]
    public void GetFruitsTest()
    { 
        Assert.Pass();
    }
}

In .NET, we can associate functions inside the class with different testing tags. Some of these are:

OneTimeSetup - to define logic that run only once while running the Tests.
Setup - to definde code that must be executed before each testcase
Test - marks a function as test function
TestCase() - used to pass parameters to the test functions

Arrange

We need to provide the input parameters and the expected result in this step. We have a very simple api with just static data instead of data from a database, but in real applications this is not the case. For testing there, it is not viable to make database requests for each test. Thus there we use something called as Mock Response. We will try to use the same approach here as well. To mock data, we will use a package called Moq. Go ahead and install Moq from Nuget manager.

Lets create some responses now. We will test the following cases:

When no argument is passed : this should return a list of fruits with no filter
When fruitname is passed: this should only return a list of fruits with this name
When fruitname and sorted is passed: this should return fruit list with the same name and state of sorted
When fruitname is not present : this should return a BadRequest response.

Add the following objects to the FruitControllerTest class

    private string allfruits = @"
[
  {
    'name': 'Apple',
    'price': 43,
    'sorted': false
  },
  {
    'name': 'Litchi',
    'price': 32,
    'sorted': false
  },
  {
    'name': 'Litchi',
    'price': 32,
    'sorted': true
  },
  {
    'name': 'Mango',
    'price': 32,
    'sorted': false
  },
  {
    'name': 'Pineapple',
    'price': 26,
    'sorted': false
  },
  {
    'name': 'Apple',
    'price': 20,
    'sorted': false
  }
]";
    private string onlyapple = @"[
  {
    'name': 'Apple',
    'price': 43,
    'sorted': false
  },
  {
    'name': 'Apple',
    'price': 20,
    'sorted': false
  },
  {
    'name': 'Apple',
    'price': 32,
    'sorted': true
  }
]";
    private string onlytrueapple = @"[
  {
    'name': 'Apple',
    'price': 32,
    'sorted': true
  }
]";
private fruitList = @"";

We will use these as the mocked responses. Since the data is returned from GetFruits() in the FruitService class, We will mock the response for this Service. For that, we will use the interface IFruitService as interface only contains the declaration of the function and not its implementation.

In FruitBasketController add another constructor that initialises the controller with the interface instead of the actual service

    public FruitBAsketController(Object fruitServiceObject)
    {
        fruitservice = (IFruitService)fruitServiceObject;
    }

We will use this constructor for our mocked response. In the Setup() we will setup our controller for testing. Add the following in the Setup()

    private Mock<IFruitService> fruitmock;
    [SetUp]
    public void Setup()
    {
        fruitmock = new Mock<IFruitService>();
        fruitbasketcontroller = new FruitBAsketController(fruitmock.Object);
    }

Here we are setting up such that the fruitbasketcontroller will now refer the fruitmock object now when calling the service, instead of the actual definition.

Act

In this step, we will call our functions to return functions to return the above responses based on different test cases. Add the following function in FruitControllerTest.cs

    [Test]
    [TestCase("",false)]
    [TestCase("Apple", false)]
    [TestCase("Apple", true)]
    [TestCase("Kiwi", false)]

    public void GetFruitsTest(string fruitname="",bool sorted = false)
    {
        List<Fruit>? a = null;
        if(!sorted)
        {
            if (fruitname.Length == 0) // get all fruits
                fruitList = allfruits;
            else if (fruitname.Length > 0)
                if (fruitname == "Apple" || fruitname == "apple") // get only apples
                fruitList = onlyapple;

        }
        else // sorted is true
        {
            if (fruitname.Length > 0)
                if (fruitname == "Apple" || fruitname == "apple") // only true apple
                    fruitList = onlytrueapple;
                //if the fruit does not exist fruitList is empty

        }

        if(fruitList.Length > 0)
            a = JsonConvert.DeserializeObject<List<Fruit>>(fruitList);
        fruitmock.Setup(x => x.GetFruits("", false)).Returns(a);
        var res = fruitbasketcontroller.GetAllFruits("", false);

The different values for parameters are passed through the TestCase tag. Using this parameters, we populate the list fruitList which is then converted into List<Fruit> using JsonConvert.

Since we are using a mock object for FruitService, we can set it up to return response based on the above steps. This means it does not go into actual definition of functions in FruitService class but just mocks the response.

Assert

In the third stage, we will assert the responses ,i.e, we will validate the response returned from the function. Add the following Assertions just below the above code in GetFruitsTest().

       var res = fruitbasketcontroller.GetAllFruits(fruitname, sorted);
        if(((IStatusCodeActionResult)res).StatusCode == 200)
        {
            var okObject = res as OkObjectResult;
            var fruitList = okObject.Value as List<Fruit>;
            foreach(Fruit obj in fruitList)
            {
                Assert.IsNotNull(obj.name);
                if (fruitname.Length > 0)
                    Assert.True(fruitname.Equals(obj.name, StringComparison.OrdinalIgnoreCase));
                Assert.IsNotNull(obj.price);
                Assert.IsNotNull(obj.sorted);
                if (sorted)
                    Assert.True(obj.sorted == sorted);

            }

        }
        else if(((IStatusCodeActionResult)res).StatusCode == 400)
        {

            var badRequest = (res as BadRequestObjectResult).Value;
            Assert.True(badRequest == "Found Nothing");

        }

Since the Service can return two types of responses with status code 200 and 400, we will make our assertions accordingly. And with that we have successfully written Unit Test for out controller. Go ahead and run these tests from Test Explorer.

Thanks for reading!

Setting up the Project for Testing

Abhigyan Gautam — Mon, 19 Jun 2023 11:59:20 +0000

In this demo, we will setup a basic .NET Project and add Unit Testing to it. To follow along, make sure you have Visual Studio installed on your machine.

The project Setup

You can clone the sample project from Github. When you run it for the first time, it will automatically fetch the packages required and compile the code. It is a simple WebAPI Project with only one API currently. When you run the project, you will see a Swagger Open API screen as this:

This is a simple API which returns a List of Fruits based on the parameters passed to it.
The Fruit Class is defined as:

using System;

public class Fruit
{
    public String? name { get; set; }
    public int price { get; set; }
    public bool sorted { get; set; }
}

The controller for this endpoint is defined as

using System;
using Microsoft.AspNetCore.Mvc;
using System.Xml.Linq;
using RestTest.Service;
using Newtonsoft.Json;
namespace RestTest.Controllers;

[ApiController]
[Route("[controller]")]
public class FruitBAsketController : ControllerBase
{


    private IFruitService fruitservice;


    public FruitBAsketController()
    {
        fruitservice = new FruitService();

    }

    [HttpGet(Name = "GetAllFruit")]
    public IActionResult GetAllFruits(string fruitname="", bool sorted= false)
    {     
         List<Fruit> fruitList = fruitservice.GetFruits(fruitname, sorted);

        if (fruitList.Count == 0 || fruitList == null)
            return BadRequest("Found nothing");
        var metadata = new
        {
            TotalCount = fruitList.Count,
            TotalPrice = fruitList.Sum(item => item.price)

        };
        HttpContext.Response.Headers.Add("metadata", JsonConvert.SerializeObject(metadata));
        return Ok(fruitList);

    }
}

It takes two parameters fruitname and sorted. It returns list of Fruits based on these arguments(if present). The function for that is defined in FruitService.cs as

    public List<Fruit> GetFruits(string fruitname, bool sorted)
    {
        var responseResult = (IEnumerable<Fruit>)fruitList;
        if(fruitname.Length > 0)
        {
            responseResult = responseResult.Where(x => fruitname.Equals(x.name, StringComparison.OrdinalIgnoreCase));
        }
        if(sorted)
        {
            responseResult = responseResult.Where(x=> x.sorted==sorted);

        }
        return responseResult.ToList();
    }

An example response is shown below:

Setting up the Unit Testing Project

Now we will setup the Unit Test Project for this Sample Project. Go to File > Add> Project and choose Nunit Test Project

Add the Projectname, here it is called RestTestUNIT. Now we need to add the reference of the actual project in the test project. Right click on Dependencies in RestTestUNIT and Add Project Reference. Select the original project from this and add the reference. It should now show up under dependencies of RestTestUNIT.

What Exactly is Unit Testing?

Abhigyan Gautam — Mon, 19 Jun 2023 11:59:08 +0000

One of the things that developers don't like doing is writing test cases for their code, yet it is one of the most important steps that ensures code quality of small units of the project. In this series we will look into what Unit Tests are and how can we setup a simple Unit Testing module in C#. Please note that there are several ways to do it, I am just trying to share what I've learnt. Feel free to add to it!

The main objective of unit testing is to isolate and validate each unit of code independently, verifying that it behaves as expected and produces the desired output given specific inputs. Since the units are tested independently, developers can detect the bugs early in the development process making it easier to identify and fix before they have a huge impact on the project.

For example, let's consider a simple function as follows:

...
...
public static int Factorial(int n)
    {
        if (n < 0)
            throw new ArgumentException("Factorial is not defined for negative numbers.");

        int result = 1;
        for (int i = 1; i <= n; i++)
        {
            result *= i;
        }

        return result;
    }
...
...

The above function Factorial() is a unit in this case. For the function to return correct response, the following test cases can be thought of:

Factorial of 0 is 1
Factorial of positive number is correct.Example Factorial(5) should return 120
Factorial of Negative Number should throw Exception, in this case Argument Exception.

The general idea is that test cases like this should return the respective responses. This is called Assertion.

In fact, the three main steps of Unit Test are :

Arrange - The necessary preconditions and inputs for the Unit to be tested are prepared. In the above case the numbers to be tested are a part of this step
Act - The test is called using the above arranged items. In the above case calling the function Factorial() with the numbers represents this step.
Assert - The observed output is compared with the expected output and the test is marked as correct or failed based on the output. In the above case Factorial(5) gives 120 represents this step.

Unit tests should cover various scenarios, including both expected and edge cases, to provide comprehensive coverage of the unit's behaviour. By having a suite of well-designed and thorough unit tests, developers gain confidence in their code and can easily detect regressions or unintended side effects when making changes or refactoring code.

How is this different from Integration Testing?

Unit Test works on small parts of code at one time. Integration Testing is the end to end testing of these units all at once. Integration Testing gives the report of how where these so called units can work together while Unit Test give the accuracy of these individual units.

Understanding Git branches

Abhigyan Gautam — Thu, 15 Jun 2023 20:28:47 +0000

In the last article we talked about internal working of Git. We saw the actual meaning of git commits and how git uses them to track different versions of stuff in the repository.

One of the biggest things git offers is the ability to create branches. These are separate parallel paths carrying different versions of the repository, at times independent from each other. In this article we will look at what actually happens when you use branches.

A new branch

So far we have only had one branch,i.e, master. Go ahead and create a new branch using

> git branch canon
> git checkout canon

If we check the .git folder now, we have a new file called canon in refs

The refs folder basically tracks the different references throughout the repository. The HEAD file contains the path to this canon file as well. Now let's check the contents of the canon file.

We can see that this is the most recent commit in the canon branch. Thus the repository tree looks something like this.

New branch moves forward

Lets make some changes in testfile in the canon branch and commit it. We now have three new files in the objects folder

Using git cat-file, we can deduce the relations between each of these files

This is similar to what we saw in the last article, 5d... is the commit, 51... is the tree originating from the previous commit(f5...) and 23... is the blob where the actual content is present. The repository looks something like this.

Notice that the objects folder only contains this information and not the information of which branch this is on. That is maintained by the HEAD file. Since the HEAD points to the canon and that contains the new commit, the HEAD now points to the latest commit in canon.

Merging the new branch

Let's merge the new branch in the master branch

❯ git checkout master
❯ git merge canon

Now if we check the contents of master in refs, we get 5d6808021c9dfd7bbe88fb8ac450e572982f79b7, which is the latest commit that is merged from the new branch. Thus the repository looks something like this:

Thus we can see how git maintains the reference of the branches along with the contents of it. This is what makes git so powerful. Having a tree structure means git can navigate to any specific commit in any specific branch.

Thanks for reading!

What actually happens when you git?

Abhigyan Gautam — Mon, 29 May 2023 11:17:40 +0000

Git is by far one of the most useful tools if you are a software developer. Git is a version control system used by developers to keep track of changes made to a project's codebase. It allows multiple people to collaborate on the same codebase without overwriting each other's work.

But what’s even interesting is how Git manages to maintain the different versions of the code, down to an individual line. In this article we will take a look into how git actually handles the version control system

The .git folder

Whenever you initialise a project with git init, a hidden folder called .git . This is where git stores information regarding the project, git configurations and information about the versions. Let’s initialise a folder with git and see the contents.

git init

These are the contents of the .git folder.

config contains details about the repository configurations like username and password for the project etc. This file is overwritten with new properties.
description contains the description of the repository
HEAD This file maintains the reference to the current branch. At the moment it must be the master branch.
refs stores references to all the branches.
objects stores the data of the Git objects which contains contents of all the files checked in, commits etc..
hooks contains shell script commands that are executed post git commands.
info contains information about the repository.

Git’s SHA1 hashing

Git stores data in the form of blob objects. Every blob in git is hashed with SHA 1 which are 20 bytes, represented by 40 hexadecimal characters. We can generate hashes for any content. For example, the SHA 1 hash for “Superman” is 5f42cf3e4992beffcd80266227d529427adb7a2d. There is one and only one hash for the content “Superman”. You can check this for yourself using

❯ echo "Superman" | git hash-object  --stdin
5f42cf3e4992beffcd80266227d529427adb7a2d

If we change the content, we get a completely new hash

❯ echo "SuperMan" | git hash-object  --stdin
3b552a73712ce7111a4aa6a600f19700ae378f7a

This is the basis of what git does. It tracks the changes by generating a different hash each tome a change comes in.

A new commit

Now lets add a file called testfile to this repo and commit it

❯ touch testfile
❯ git add testfile
❯ git commit -m "added test file"

Now notice the commit number: c36ed1c. This is the blob object created for this commit. Git maintains the versions using something similar to a file system. It stores the content of the object, the commits in the form of a blob object. The difference between blob and file is that blob stores only the content, while file can store the metadata as well.

c36ed1c is just the first seven letters of the actual hashed name. If we now go to the git folder we see the following:

Here you can see the full hashed name under folder c3 . The string starting with c3 and ending with 2b is the full hash of the commit blob. But what about the other hashes? We did not create them. Well, we did create them… sort of. Let me explain.

Type the following command in the root of the project.

❯ git cat-file c36ed1cabb3565974f8846391f6ed59959f2d02b -p

This command shows the content of the hash, in this case it is the commit object.

As you can see, the content of this blob is added test file which was our content for the commit message. It contains a reference to other hash c6dc3ef... which contains the contents about the tree.

Again if we use git cat-file in this hash, we get the following

This time it contains a reference to the testfile and is stored as hash e69de29... . Thus now we have the filename, the content of the file and the tree all stored in git in their hashed format.

Making changes

Now lets add some content in testfile. Adding a simple text , “this is a test file” in the file. Now when we do git status we see that this file has been modified because the respective generated hashes do not match with what is present in the .git folder. This can be tracked down to individual line as git maintains a hash of the content at the lowest level (as seen above).

Lets commit this change.

❯ git add testfile
❯ git commit -m "second commit"

This time three new subdirectories are added under objects.

Again using git cat-file, we can see the contents of these new hashes.

This time, we have a new property for this hash - parent . Since git commits work in the form of trees and each commit is a node, the previous commit becomes the parent of this commit. Therefore c36ed... is the parent of the commit f51e8... . Thus it becomes easier to track commits and their history is represented in the form of the relation between nodes.

Conclusion

Now we know how git maintains a version report of every single piece of content in the project. Git can then use these generated hashes and the tree to pinpoint exactly the content that is required down to the smallest level.

Thanks for reading! 👋

Cover photo by Photo by Praveen Thirumurugan

Goodbye create-react-app

Abhigyan Gautam — Tue, 21 Mar 2023 18:43:06 +0000

React developer team recently removed create-react-app from the official documentation. This means it is no longer the default method of setting up a new project in React. According to this pull request on Github, create-react-app is finally gone.

The problem with CRA

For far too long,create-react-app or CRA has had problems with its performance. It is slow and bulky compared to the modern methods. The initial setup is quite bulky as there are a lot of dependencies to be installed. It also is outdated as the dependencies themselves suffer from warnings during installation. These problems have troubled developers for far too long. Since CRA was the officially supported way, beginners had a hard time solving these issues.

What are the alternatives?

There are various ways to setup a new React project. In fact, the official documentation now mentions frameworks like NEXT-JS, Remix etc for beginners. In this post however, we will look into using Vite to setup our React app in under a minute.

Why Vite?

Vite is one of the fastest ways to start a project in react. It has faster server start time. It has better compatibility with plugins. It supports TypeScript, has better dependency resolving features out of the box. React projects created from Vite are just 20% the size of that created by CRA. You can read more about Vite here

Creating a new React project using Vite

Let's create a new React project using Vite. Run the following in the folder where you want your new app.



npm create vite@latest

Name your project and select React from the type of project. Next select variant, here we are using JavaScript.

And it is done! Seriously, that's it. All of this takes less than a minute to setup.
You can now run the app using



cd <project-root>
npm i
npm run dev

Your app is up and running

Congratulations!🎉🎉

Connect your local resources from inside your Docker Container

Abhigyan Gautam — Wed, 15 Mar 2023 05:47:40 +0000

Docker containers are like magic, allowing you to run full fledged applications without going through all the steps and dependencies. The best part is that the experience is same throughout. But sometimes you want to connect to the local resources from inside the container.

Use case

If you are new to Docker, check out Creating your first Docker Container - A beginner's Guide. Suppose you have a custom script that creates a database, creates the tables and the relationships and adds data. Since the script may require some dependencies, the best way to ensure that there are no issues for others is to dockerize the entire setup.

Code Folder Structure

The following is a simple code structure for the above use case.



- dbstuff.py
- requirements.txt
- Dockerfile
- requirements.txt
- .env

dbstuff.py contains the custom python script that handles all the DML and DDL parts.
requirements.txt has the dependencies used by the project.
Dockerfile contains the layers required to create the image.
.env contains the environment variables which include database connection details ```

DATABASE_USER=devto
DATABASE_PASSWORD=dbpass
DATABASE_HOST=localhost
DATABASE_NAME=devtotest
...

## Dockerize the image
Once you create a docker image using `docker build` and run the container using `docker run`, you will face an issue connecting tot the database. This is because the container is trying to connect to the database instance inside it and not on the local machine.


![Normal Connection](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3fj5w1jrpqqpu7gv2kww.jpg)

## The solution
We need to tell docker to connect to the host's local resources rather than the container's resources. We can do this by changing the .env as follows

...
DATABASE_HOST=host.docker.internal
...

![Host Connection](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/bclomlpxgr8rqgqzm2ta.jpg)
This will now point to the `localhost` of the host. Problem solved!

Create another image and run the container and this should now work as intended! Congratulations 🎉🎉! You have successfully connected to your local Database from inside your docker container

Photo by [Manuel Geissinger] (https://www.pexels.com/photo/black-server-racks-on-a-room-325229/)

Creating your first Docker Container - A beginner's Guide

Abhigyan Gautam — Sun, 05 Mar 2023 08:57:45 +0000

Picture this, you built a cool homepage for a website and it is working exactly as you want on your machine. You share it with someone else to get their feedback, but it just won't work the same way. Believe it or not, this happens all the time in the software development world. Docker is a tool that helps you solve this.

What is Docker?

Docker is a powerful tool for creating, deploying, and managing software applications in containers. A container is a lightweight, standalone, and executable package that includes everything needed to run the software, such as code, libraries, and dependencies. Think of it as a complete bundle with all the inner working hidden from the outer world. Docker can be used to create these containers which are independent of the host's environment, thus providing the same experience across systems.

How does this work?

Containers have their standalone filesystem thanks to the images they are built on. An Image is a building block of the container and hence houses everything that is required for the container to run - the code, the filesystem, dependencies.
Docker packages these all in one image which can then be used to create the containers.

In this tutorial, we will containerise a simple Python application. Note that the same process can be used to create containers of any size.

Project Structure

Go ahead and create a new folder on your system. We will call this docker-test. Create a python file called pydock.py. Add the following sample code to the python file or feel free to use your own code.

from faker import Faker
from tabulate import tabulate
fake = Faker()

# print 10 fake names and addresses
table = [['name','address']]
# generating the names and addresses
for _ in range(10):
    name = fake.name()
    address = fake.address()
    table.append([name,address])

# print in tabular format
print(tabulate(table,headers='firstrow',tablefmt='fancy_grid'))

This is a simple application that generates fake names and addresses in a tabular format. Notice that we are using external libraries - faker and tabulate for the same.

Now create a .dockerignore file in the root of the project. Use this to add the files that you want to ignore while creating an image. Your folder structure should look like this:

docker-test
-- pydock.py
-- .dockerignore

Docker Setup

Go ahead and install Docker Desktop for your system from here. While you are at it, create an account on dockerhub as well.

Once docker desktop is installed, you can open the application. This will automatically start a docker daemon in background.

Dockerfile - where the magic lives

Next, create a file called Dockerfile in the root of the project. This defines how the image will be created and what will be used to create the image. The project structure should now look like this:

docker-test
-- pydock.py
-- .dockerignore
-- Dockerfile

Edit the contents of the Dockerfile as follows:

FROM python:3.8-slim-buster

WORKDIR /app

COPY . .

RUN pip install Faker tabulate

CMD [ "python3","pydock.py"]

Let's go over the contents of this Dockerfile from top to bottom.

The FROM instruction specifies what kind of image we want to create. We can pull pre-built images from DockerHub, including full-scale Operating Systems. However in this case, we just need to build a python image so we are using python:3.8-slim-buster. You can choose any python image that are mentioned here
The WORKDIR instruction specifies the working directory in the container's filesystem. Think of this as the path where your image will sit and run in the container. In this case it is /app.
The COPY instruction lets you copy files from your machine to the image. The syntax is COPY <source> <target>, where <source> is the file path on your local machine and <target> is the file path on the container starting from the working directory.
RUN instruction is used to execute commands during the build process of a Docker image. Here we are using this to install our dependencies - Faker and tabulate.
The CMD instruction is used to specify the default command to be executed when a container is started from the image. Notice that CMD uses an array format to define the commands while RUN uses a simple string format

IMPORTANT: Docker images are a set of layers. Every instruction in a Dockerfile creates a layer. These layers are cached internally for faster image builds.

Building a Docker image

Once you are done with the Dockerfile, we can move on to create your first Docker image. Open terminal in the root of your project. You can check if Docker is running using

docker --version

To build an image, run the following:

docker build  -t <username>/<image-name>:<tag> .

You can call the image whatever you want, but the following conventions are generally used.

The -t option lets you create a tag for you image.
<username> is your docker hub username.
<image-name> is the name you want to give to the image.
<tag> is like the version number for the image.
. is the path where Dockerfile is present, here we have it in the root of the project

Docker starts creating image layers from the instructions mentioned in the Dockerfile. Once done, you can check your built image in Docker Desktop.

Running the container

To run the image inside a container, we will use the following:

docker run <username>/<image-name>:<tag>

This will run a container from the image that we built in the above process. You should see a similar output once you run the above command.

Congratulations🎉🎉! You have created your first Docker Container successfully. You can check the container in Docker Desktop and even publish this to Docker Hub. You can share this image with others and they can simply run this as a standalone application. No installation fuss, no dependency issues, nothing! They won't even know what's inside the container but the container works as required!

CREDITS
Cover photo by Venti on Unsplash