DEV Community: Asmi Jafar

Week 7 Outreachy Blog Post. About: The Project progress and its future goals.

Asmi Jafar — Sun, 30 Jan 2022 16:09:41 +0000

My internship got started on 6th Dec, In the first week of the internship, we all discussed how to achieve things and discussed resources. Further, I have gone through the codebase of the FLINT Reporting tool. Where I need to update the code concerning its version and automate some of the tasks in that. All of my dealings were at the backend side of the code.

Goals Achieved:

Discussed what exactly the reporting tool does and how to set up it.
Set up the environment of the Reporting tool.
Written the superscript for setting up the environment over the server and locally.
Updated the Angular version of the code to make it streamline.

At the end of December, I have to set up the CI/CD for the Reporting tool frontend. So After learning about CI/CD I have implemented the Continuous integration pipeline for the reporting tool.

In the start of January, I have to set up the CI/CD for the FLINT Cloud and test its docker file, I have updated the docker files of the FLINT Cloud and implemented the CI/CD pipeline for building and publishing the FLINT Cloud images on the GitHub Container Registry.

In the second week of January, We have discussed the FLINT and its Implementation. How FLINT works and its resources. FLINT doesn’t give outputs unless it gets combined with FLINT implementation. The FLINT is considered a library by itself - it doesn't do much unless we attach modules to it and make it an implementation.

After learning about FLINT and FLINT implementation, Understanding how the base image is built for the FLINT as a part of setting up the CI/CD. I have updated the links and version of the FLINT base image docker file.

Problems faced during building the FLINT Base images:

The image size was too large due to which the image crashes most of the time while building.
The versions and links were not updated in the base image.
Updating the FLINT library image, POCO header file error comes, which unable the image to get built. (Error is still not resolved yet).

In the 3rd and 4th week of January, I have learned about Spring Boot and Angular for containerizing the client of the FLINT reporting tool, after this I have implemented the CI/CD pipeline for building and publishing the client image on the GitHub Container Registry.

FLINT Reporting tool comprises 31 microservices and each microservice has its docker files. After learning about Spring Boot and its containerization, I have updated the docker files of microservices of the reporting tool.

Now, coming to the second half of the internship that has left, My plans for that are:

I have to deploy each microservices of the Reporting tool on the Kubernetes cluster. In order to implement the CI/CD for the reporting tool backend.

I have to learn about the services, deployments, and ingresses

References:-

a) Services
https://kubernetes.io/docs/concepts/services-networking/service/

b) Deployment
https://kubernetes.io/docs/concepts/workloads/controllers/deployment/

c) Ingress
https://kubernetes.io/docs/concepts/services-networking/ingress/

I have to define services, deployments, or ingresses more efficiently or differently with the selection of different plugins.

I have to set up the FLINT and its Implementation for the demo run, for the FLINT implementation we will use the SLEEK (Standard Land extraction and emissions of Kenya).
Firstly, I want to investigate how is it that one should build/implement the SLEEK (flint implementation). I have to update the FLINT Implementation images and produce the docs for future devs and users.

In the end, I have to build and publish all the docker images of the remaining Moja Global repositories on the GitHub Container Registry. I have to produce the docs for all the implementations and changes I made in the Reporting tool and FLINT/FLINT implementation.

Lastly, we have to get results from FLINT extending the FLINT implementation as we know the FLINT extends the FLINT implementation and gives results in the form of flux, metadata, and stocks data. Then we will give this data as the input to the FLINT Reporting tool, gets reports as output, and create the demo run for it.

Dockerize the Spring Boot Application.

Asmi Jafar — Sun, 23 Jan 2022 12:12:21 +0000

Spring Boot is a Java framework for building applications whether you build backend applications or full-stack applications using Java or Kotlin spring boot is a framework to go with.

Another definition: Spring Boot is an open-source Java-based framework used to create a micro Service. It is used to build stand-alone and production-ready spring applications.

Advantages:

Security
Logging
Connecting to DB
Dependency Injection
Configuration
Microservices
Production-ready

What are Microservices?

Microservice is an architecture that allows developers to develop and deploy services independently. Each service running has its own process and this achieves the lightweight model to support business applications.

Now the most important term that we need to know why spring boot is so useful and easy to use is because of dependency injection, Now What is Dependency injection?

So before we know about dependency injection let’s first define What is loose coupling?
So, loose coupling is when one object doesn’t totally depend on another object it may get replaced. When two classes, modules, or components have low dependencies on each other, it is called loose coupling.

Dependency injection is a fundamental aspect of a spring framework, through which the spring container injects objects into the other objects or “dependencies” Basically the dependency injection containers (spring containers) are responsible to create the objects and then they will inject it inside the class.
Simply put, this allows for loose coupling of components and moves the responsibility of managing components onto the container.

Using: https://www.baeldung.com/spring-boot-docker-images

Let’s start with containerizing our spring boot application (Reporting tool). Since our FLINT reporting tool has 31 microservices and each microservice has its own docker file, the structure of every docker file of the microservices is almost the same. So without any further ado let’s begin.

FROM eclipse-temurin:17.0.1_12-jre-alpine as builder
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} application.jar
RUN java -Djarmode=layertools -jar application.jar extract

Spring Boot JAR file has “layers”. When unpacks “jar file” it has internal and external dependencies packaged together. That’s why we have used the multi-stage build for the docker image. So when any line changes in the code only one layer would get affected by it.

ARG instruction defines a variable that can be passed at build time. The JAR_FILE could be passed in as part of the docker command. So here we are using for Maven.
A jarmode is a special system property that you can set when you launch the jar. It allows the bootstrap code to run something entirely different from your application. For example, something that extracts the layers. Here’s you can launch jar with a layertools jar mode.

Now we will step into the next part of the docker file.

FROM eclipse-temurin:17.0.1_12-jre-alpine
COPY --from=builder dependencies/ ./
COPY --from=builder snapshot-dependencies/ ./
COPY --from=builder spring-boot-loader/ ./
COPY --from=builder application/ ./
ENTRYPOINT ["java","-Dspring.datasource.url=jdbc:postgresql://${POSTGRES_HOST}:5432/pools", "org.springframework.boot.loader.JarLauncher"]

Now we will extract and copy each layer.

All being well, we should now have a layered jar with jarmode support.
These are the layers and order that they should be added.

dependencies
snapshot-dependencies
resources
application

The builder stage extracts the folders that are needed later. Each of the COPY commands relates to the layers that we listed. We can see each layer from the layered jar get added to the Docker image as its own layer.

Outreachy Blog #1: Introduce Yourself.

Asmi Jafar — Sun, 12 Dec 2021 08:29:03 +0000

I’m a Computer Science graduate from Aligarh Muslim University, India. I have been profoundly influenced by technology and the various ways it can be used to express art. I love to do coding and creating projects and have the curiosity to learn and contribute to projects. Almost every field of Computer Science piques my interest, more specifically development (Web development) and research. I have proficiency in languages such as Python, Java, JavaScript, and C programming language.

My core values are I'm always up for learning new things which helps me grow and makes me a better person than yesterday. I'm an honest person, I love honesty. Integrity is always been an eye-catcher for me. I'm a very integrated person. A person's values and integrity is what makes them different from others and valuable nothing can change that. My interests are painting and reading. I paint to view the world and read to visualize it. I want to mention one of my favorite quotes from my favorite book "The Last Lecture": The Brick walls are there for a reason, they are not there to keep us out. The brick walls are there to give us a chance to show how badly we want something.

I always wanted to participate in some open source program and I love to contribute to free and open-source projects. And Outreachy is the best platform for it. Outreachy is an incredible initiative for promoting open source and diversity all over the world. I’m always excited to get onto new projects and am motivated to learn new stacks. With my contributions at Moja global, I found it very comfortable working with a talented team. I found the idea or purpose of Moja Global very insightful. The mission of Moja Global is to support ambitious climate action by developing open-source software. My interest in Moja Global grew as I interacted with the team and got to know more about its projects and future goals. I’m very excited to work on the project of this community by improving it and making it more efficient. Along the way, I will also learn new skills. That's what motivated me to apply to Outreachy.

Ops Docker it is #2: Build a Docker Image for Flask Application

Asmi Jafar — Wed, 08 Dec 2021 11:24:32 +0000

Let's first start with creating the Docker file where we will pull Python 3.9 image.

Flask Dockerfile template

FROM python:3.9.7
COPY . /app
WORKDIR /app
RUN pip install -r requirements.txt
EXPOSE 5000
ENTRYPOINT ["python3"]
CMD ["app.py"]

Here we are pulling Python 3.9.7 image from the Python dockerhub repository.

COPY
Copy the current directory contents into the container at /app.

WORKDIR
It's a directory inside container image that can be set with the WORKDIR instruction in the Dockerfile.

RUN command will install all the required packages for the Dockerfile.

EXPOSE
The EXPOSE instruction tells Docker to get all its information required during the runtime from a specified Port.

ENTRYPOINT
The initiating point for the dockerfile while we run it. ENTRYPOINT command and parameters will not be overwritten from the command line. Instead, all command-line arguments will be added after ENTRYPOINT parameters.

CMD
CMD instruction is used to define what command the container should execute when launched and CMD sets default command and/or parameters, which can be overwritten from the command line when the docker container runs.

Now Let's run the Docker command for building the image

docker build -t asmi-flask .
This will build the image(asmi-flask) for the flask application. Give it a tag -t called asmi-flask.

docker run -p 5000:5000 asmi-flask
In this command we tell docker to run an image called asmi-flask. -p Publish a container's port(s) to the host. Since Flask is running on port 5000 by default, the second part of this flag needs to be 5000.

After this, we can run docker ps command to check if the image has been built or not.

Output:

ubntu@asmijafar20:~/Flask-App$ docker images
REPOSITORY              TAG          IMAGE ID       CREATED       SIZE
asmijafar20/dockerhub   asmi-flask   2e155e2820a0   3 days ago    922MB

In the next blog, we can build CI/CD pipelines and configure them using GitHub Actions.

Till then Happy Coding!

Ops Docker it is! #1

Asmi Jafar — Tue, 07 Dec 2021 13:14:46 +0000

This the very first Blog of this series.

Let's start with some definitions and concepts.

Docker is a platform that uses OS-level virtualization to deliver software in packages called Containers.

What is a Container?

A container is a way to package an application with all the necessary dependencies and configurations or you can say layers of images packaged together.

Advantages:

Portable Artifact
Easily shared
Easily moved around the development team and the development-operations team.
And due to the portability of containers and everything packaged in one isolating environment makes the Development and Deployment more efficient.
No environmental configuration is needed on the server except the docker runtime.

Now here comes the question, Where do these containers live?
So, Containers live in a container repository, private or public repository.

If we don't have containers then there could be a version conflict or misunderstandings between the development team and operations team.

What is the difference between a Docker image and a Docker container?

So, Image is the actual package with all the dependencies and configurations, an artifact that can be moved around whereas when we pull the image and start it and applications start that creates the container environment. So containers are the running image only.

What is the difference between Docker and Virtual Machines?

As we know, Docker and VM are both virtualization tools. Docker virtualizes the Application layer in the OS (operating system) and it uses the kernel of the host whereas the virtual machines virtualize the whole OS, it has an application layer and its own kernel.

The size of the docker images are smaller than VM.
Docker containers start and run fast.
Compatibility: Virtual Machines are more compatible. They can run on any OS host of the Operating System.

Next blog of this series: Building of docker image for Flask Application.