In this blog, we are discussing the GO programming language, its origin, performance and so on. Let's get started 😇!!!

Go is a statically typed, compiled high-level programming language designed at Google by Robert Griesemer, Rob Pike, and Ken Thompson. It is syntactically similar to C, but with memory safety, garbage collection, structural typing, and CSP-style concurrency. It is often referred to as Golang because of its former domain name, golang.org ( currently go.dev ), but its proper name is Go.

Philosophy

Go was designed at Google in 2007 to improve programming productivity in an era of multicore, networked machines and large codebases. The designers wanted to address criticism of other languages in use at Google, but keep their useful characteristics

Go was publicly announced in November 2009, and version 1.0 was released in March 2012. Go is widely used in production at Google and in many other organizations and open-source projects

Gopher

"Gopher" is the official mascot of the Go programming language, and it has had a significant influence on the development and culture of the language. Firstly, it has helped to give the language a distinct and memorable identity. The Go team has often cited the Gopher's characteristics - including its industriousness, reliability, and adaptability - as guiding principles in the design of the language itself.

The GO developer community says the Gopher has become a symbol of the Go community's shared values and goals, including a commitment to open source, a focus on practical and real-world problems, and a dedication to collaboration and inclusivity.

Features of GO

• It supports different types of datatypes like int, int8, int32.., float32, float64, string, array, slice, etc.

• Only supports one loop statement For.

• Statically typed

• Every built-in function must be imported to use so it's extremely lightweight.

• Support concurrency (goroutine)

• Every variable declared must be used otherwise it will show the error "declared and not used"

• Go support variadic function and closure function

• Go support blank identifier to avoid unwanted variable declaration

Performance

From the above graph, we have a clear picture that the GO programming language has high performance during CPU-intensive operations. When the process becomes more CPU intensive go outperforms other programming languages. To read more about performance read the article.

Packages📦

As other programming languages, GO also provides some packages for developers to work on. Officially released GO packages can be visible on the package website of go pkg.go.dev. You can also find go packages written by developers on GitHub.

PlayGround

Get your hands dirty with GO. If are still confused about whether to learn Go you can try it @ Playground

Community💪🏽

Go is building a strong community. Get in touch with the GO community and attend offline meetups @Meetup. Find go user group on this GitHub repository

OpenSource Projects⏳

Go had made a great change in open-source project contribution. Most trending open-source projects are developed using GO. Some major GO open-source projects are:

• Docker/CLI 🐳

  Docker is a tool that helps developers package and run their applications in a consistent and portable way. It allows you to create a container, which is a lightweight and isolated environment that contains everything needed to run your application.

  GitHub Repository

• Kubernetes

  Kubernetes is an orchestration tool for managing and scaling containerized applications across multiple machines. It automates resource allocation and ensures high availability and scalability.

  GitHub Repository

• Argo

  Argo is a tool for managing and orchestrating complex workflows in Kubernetes. Argo enables you to automate and streamline your workflows, reduce manual errors, and increase productivity.

  GitHub Repository

• Hugo

  Hugo is one of the most popular open-source static site generators out there. Over 29k live websites are built with HUGO and Wappalyzer reports that Hugo serves almost 50% of the static sites. Oh and guess what, Kubernetes’ own site is built using HUGO!

  GitHub Repository

  Find the currently trending GO repository at GitHub.

In this blog, we are discussing how to use MySQL container as a service in a go project with the gorm package.

Below is a docker-compose file which will create a MySQL container. Save it as docker-compose.yaml file.

version: '3'

services:
  mysql_db:
    image: mysql:latest
    restart: always
    ports:
      - 3306:3306
    environment:
      MYSQL_ROOT_PASSWORD: 123
      MYSQL_ROOT_HOST: '%'

  phpmyadmin:
    image: phpmyadmin/phpmyadmin:5.0.2
    restart: always
    ports:
      - 9001:80
    environment:
      PMA_HOST: mysql_db
    depends_on:
      - mysql_db

Run docker-compose up -d to start containers.

In the above example, you can access PhpMyAdmin at http://localhost:9001. Login to the account using username: root and password: 123.

Sample GO program to connect with MySQL service is shown below. Copy and paste the code into the main.go named file.

package main

import (
    "fmt"
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/mysql"
)

type User struct{
    gorm.Model
    Name string `json:"name"`
}

var db *gorm.DB
var err error

func main() {
    db, err = gorm.Open("mysql","root:123@tcp(0.0.0.0:3306)/sample?charset=utf8&parseTime=True")
    if err != nil{
        panic(err)
    }else{
        fmt.Println("Connected DB")
    }
}

Run the above code if you get the print statement Connected DB you have successfully connected your GO project with MySQL docker container.

Note:

• Don't forget to create 'sample' database in MySQL. You can use PhpMyAdmin for creating it.

• Before running the above GO file you should get all the packages you have imported.

It is a way of packaging an application with all necessary dependency files and configuration files. Containerised applications are very easy to move and share in between, for example, applications are shared between the development and operation teams via containers. Containerisation will increase the efficiency of development and deployment.

Why containers?

Application Development

Before containers during the development of an application, if team members are using different OS the installation of different services like mongo, mongo-express for the application development will be different. It will be also a time-consuming step.

With Containers, you are installing each service not directly to your OS rather the images of each service are pulled. Since it doesn't depend on your host OS the service will be the same for each team member. Also, each service can be installed with a simple command docker run <image> .

Application Deployment

Before the container, the developer team will send the application to the operation team with a set of instructions. The operation team has to set the environment suitable for the application to run according to the instruction. The problem is there is a chance of misunderstanding between the operation and developer teams which will result in back forth communication and delays deployment of the application. Also if the developer team miss any configuration step this can cause big trouble.

Now the developer and operation team can collectively containerise the application. The Containerised application will be easy to deploy on the server. The only task to deploy an application is to pull the containerised application to the server.

Also, users can run different versions of the same application in the same system with the help of containers.

Layers in container

A container contains different layers of images. The base layer of the container will be a Linux image which provides the container with an isolated OS. The Application image will be at the top. The container will contain many intermediate layers of images. Each layer of the image is identified by a unique id.

The major advantage of layers in the container is shown in the above example, firstly I have pulled MariaDB:10.4 since my local repository doesn't have MariaDB it pulled all different layers of image from the docker hub. Later I pulled MariaDB:10.5 but now rather than pulling all layers of images from the docker hub it checked locally for similar images and it only pulled image layers that are not present locally.

Storage for Containers

Containers are stored in a container repository. Mainly there are 2 types of container repositories, private repositories and public repositories.

Private repositories are owned by companies and are used to store the containerised application of the company. Amazon has amazon ECR to store docker images in a private repository. Whereas a public repository is available to all, the public repository for docker is DockerHub. Containerised applications present in the public repository are free to use.

Container vs Image

The actual package that contains the application along with all its dependencies and configuration files is called Image. Images can be moved around between team members.

When an image is pulled to a computer and the image is started, now this creates a container. Shortly, if the package is not running it's called an image, if running it's called a container.

Docker vs VM

An operating system can be classified into 2 layers kernel and application layer. The kernel layer is used to communicate with hardware components whereas, the application runs over the OS kernel layer. Docker virtualises the application layer of the OS, which means it uses the host OS kernel. Whereas Virtual Machine virtualises both the application and kernel layer of the operating system.

The Size of the docker image will be less as compared to VM. Docker image starts and runs fast as compared to VM. Older versions of Mac and Windows may not support docker.

Docker installation

To install docker, head over to Docker's official website and download the suitable docker desktop for your OS. You can learn docker with fun through docker playground.

Basic commands in Docker

• docker pull <image>:

  This command is used to pull an image of an application to your local repository

• docker run <image>:

  This command runs an image and creates an instance(container) of it.

• docker ps:

  This list all the containers running instantly.

• docker images:

  The above command will list all the image files in the local storage.

• docker stop <container id>:

  Above command is used to stop a running container.

• docker start <container id>:

  This command can be used to restart a stopped container.

• docker ps -a:

  This command displays all the containers running and not running.

• docker run -p<host-port>:<container-port> <image>:

  The above command is used to bind a host port and a container port of an instance of an image.

• docker logs <container-id/unique-name>

  This command displays all the logs of the corresponding image.

• docker run --name <unique name> <image>

  --name flag can be used to give a custom name to the container.

• docker exec -it <container-id> /bin/bash

  The above command is used to get into the terminal of the running container.

Workflow of Docker in Development

In the development phase, the application is built. Code is commited using version controller git. Jenkins is a Continuous Integration tool which will build the application and generate an image of the same using Dockerfile. Companies use private container repositories to store images. Further, the image is pulled from the Container repository to the server and it is deployed.

Docker compose vs Docker run

We can use both docker-compose or docker run to run a container. Containers created through YAML files (docker-compose) will be more structured and easier way to edit. Below show what docker-compose and docker run looks like. Both of the operations end up creating containers.

In Docker compose (LHS) we mention port binding under the property ports in yaml file whereas in Docker-run we use the flag '-p' to specify port binding. Also, we can see on the right-hand side we are explicitly mentioning the container network for mongo-express and mongo so that both containers can communicate with each other, but the containers created by docker-compose are relaying in the new container network by default.

Docker file

Dockerfile is a blueprint for creating docker images. We can create custom images for our application using Dockerfile.

FROM node:13-alpine

ENV MONGO_DB_USERNAME=admin \
    MONGO_DB_PWD=password

RUN mkdir -p /home/app
COPY ./app /home/app

CMD ["node","/home/app/server.js"]

Major contents of Dockerfile

• FROM: we always need a base image with which our application image can be created like Node, PHP, Ubuntu etc...

• ENV: Used to define environmental variables. Not recommended method for creating environmental variables.

• RUN: Used to execute any Linux command inside the container.

• COPY: Used to copy files from host to container.

• CMD: CMD is an entry point command.

docker build -t my-app:1.0 .

The above build command is used to generate your custom image. -t flag is used for mentioning the Image name (my-app) followed by its tag(1.0). The . indicate that Dockerfile is present in the current working directory.

To get practical experience in creating Docker Images for your application head over to git repository demo. Docker-Container-Demo