Forem: Vrukshali Torawane

Part-2 More about Docker

Vrukshali Torawane — Mon, 27 Feb 2023 10:57:18 +0000

Docker Architecture

Docker uses a client-server architecture. The Docker client talks to the Docker daemon, which does the heavy lifting of building, running, and distributing your Docker containers. The Docker client and daemon can run on the same system, or you can connect a Docker client to a remote Docker daemon.

Docker uses a technology called namespaces to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.

Docker Daemon:

The Docker daemon is a service that runs on your host operating system.
The Docker daemon (dockerd) listens for Docker API requests from client and manages Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with other daemons to manage Docker services.

Docker Client:

The Docker client (docker CLI) is the primary way that many Docker users interact with Docker. When you use commands such as docker run, the client sends these commands to dockerd, which carries them out.
The docker command uses the Docker API.
The Docker client can communicate with more than one daemon.

Docker Registry:

A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker is configured to look for images on Docker Hub by default.
You can even run your own private registry.

Docker objects

When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects.

Images:

An image is a template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization.
For example, you may build an image which is based on the ubuntu image, but installs the Apache web server and your application, as well as the configuration details needed to make your application run.

Containers:

A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI.
By default, a container is relatively well isolated from other containers and its host machine.
When a container is removed, any changes to its state that are not stored in persistent storage disappear.

In next blogs, we will learn more about Docker commands.

Part-1 Overview of Docker

Vrukshali Torawane — Tue, 21 Feb 2023 16:58:32 +0000

What is Docker?

Docker is a platform designed to help developers build, share, and run modern applications.

More simple definition:
Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in same ways you manage your applications. You can ship, test, and deploy code quickly, and significantly reduce delay between writing code and running it in production.

The whole idea of Docker is for developers to easily develop applications, ship them into containers which can then be deployed anywhere.

What is container?

Docker Containers contain binaries, libraries and configuration files along with the application itself.
Docker Container is a standardised unit which can be created on the fly to deploy a particular application or environment. It could be an Ubuntu container, Debian container, etc. to full-fill the requirement from an operating system point of view.
Docker Containers share resources with other containers in the same host OS and provide OS level process isolation.

Then what are Virtual Machines?

Virtual Machines (VMs) run on Hypervisors, which allow multiple Virtual Machines to run on a single Machine along with its own operating system.
Each VM has its own copy of an operating system along with the application and necessary binaries, which makes it significantly larger and it requires more resources.
They provide Hardware-level process isolation and are slow to boot.

Difference between Docker vs Virtual Machine

What is a Dockerfile?

It is a text document that contains necessary commands which on execution helps assemble a Docker Image.
Docker image is created using a Docker file.

What is Container Registry?

Docker Hub is the official online repository where you can find other Docker Images that are available for use.
It makes it easy to find, manage and share container images with others.

Let's create a Docker image using Dockerfile:

Step 1: Make a directory

mkdir test and cd test

Step 2: Now create a file Dockerfile
(File name is hard coded do not change the file name)

touch Dockerfile

Step 3: Create a sample web page with name index.html

Custom docker image created using Dockerfile!!!

Step 4: Edit the Dockerfile using following instructions

FROM centos:7
MAINTAINER Vrukshali
RUN yum install httpd -y
COPY index.html /var/www/html/
CMD [“/usr/sbin/httpd”, “-D”, “FOREGROUND”]
EXPOSE 80

Dockerfile commands explanation:

MAINTAINER — This command is used to give the information about the author or manager who is managing this image. MAINTAINER Vrukshali

RUN — Before building an image if want some configuration that needs to be present in the image. Inside the image we need to install Apache web server image the command to install that image is RUN yum install httpd -y

COPY - This command is used to copy a file from host os to docker container COPY index.html /var/www/html

EXPOSE - This command is used to specify the port number in which the container is running its process. Anybody can come from outside and connect to this port. Apache webserver is launched at port 80 by default that is why we need to expose container at port 80. EXPOSE 80

CMD - To run a command as soon as container is launched. CMD command is different from RUN because RUN is used at the time of building an image and CMD used to run command when container is started.
/usr/sbin/httpd - This command is used to start the web server
-DFOREGROUND— This is not a docker command this is http server argument which is used to run webserver in background. If we do not use this argument the server will start and then it will stop.
CMD [“/usr/sbin/httpd”,” -D”,” FOREGROUND”]

Step 5: Build the image using docker build.

docker build -t webserver:v1 .

. is Dockerfile is present n current location and –t option is to tag or name the image.

Output:
last few lines

...
...
Step 6/6 : EXPOSE 80
 ---> Running in ed9972b66ac1
Removing intermediate container ed9972b66ac1
 ---> 5ca87e671dc1
Successfully built 5ca87e671dc1
Successfully tagged webserver:v1

You can now run docker images command.
Output:

REPOSITORY   TAG       IMAGE ID       CREATED              SIZE
webserver    v1        5ca87e671dc1   About a minute ago   392MB
centos       7         eeb6ee3f44bd   4 months ago         204MB

Step 6: Run a container using docker image created by Dockerfile

docker run –dit –p 1234:80 webserver:v1

-p: This argument is used to port forwarding. Which means anybody from outside who comes for 1234 its request is forwarded to port 80. Port 80 is default port number where apache webserver runs.

Step 7: To See the Result :
curl http://<host ip>:1234/ or on webpage http://<host ip>:1234/

Output:

Custom docker image created using Dockerfile!!!

Now we need to push this image to central repository, here I will be using DockerHub as central registry.

Step 1: You need a DockerHub Account
You can create this on https://hub.docker.com/

Step 2: Login to DockerHub via terminal

docker login --username=yourhubusername --email=youremail@company.com

With your own username and email that you used for the account. Enter your password when prompted. If everything worked you will get a message similar to

WARNING: login credentials saved in /home/username/.docker/config.json
Login Succeeded

Step 3: Tag your image

docker tag <image id or image name>:<version> yourhubusername/<image_name>:<version>

docker tag webserver:v1 vrukshali26/web:v1

You can see using docker images

REPOSITORY        TAG       IMAGE ID       CREATED          SIZE
webserver         v1        5ca87e671dc1   14 minutes ago   392MB
vrukshali26/web   v1        5ca87e671dc1   14 minutes ago   392MB
centos            7         eeb6ee3f44bd   4 months ago     204MB

Step 4: Push your image to the DockerHub

docker push yourhubusername/<image_name>:<version>

Output:

The push refers to repository [docker.io/vrukshali26/web]
a59ac102fa99: Pushed 
951641dc1264: Pushed 
174f56854903: Mounted from library/centos 
v1: digest: sha256:29169ceace4c1c0e29022d77453be7dcc97070d9ab1f5bbb640051ff13178f64 size: 948

Now you can see on DockerHub, your first custom docker image has been pushed.

Create High Availability Architecture with AWS CLI

Vrukshali Torawane — Tue, 17 Jan 2023 03:34:55 +0000

Today's article is on S3 and CloudFront Architecture practical using AWS CLI.

What is Amazon S3?

Amazon Simple Storage Service is storage for the Internet. It is designed to make web-scale computing easier for developers.

Amazon S3 has a simple web services interface that you can use to store and retrieve any amount of data, at any time, from anywhere on the web. It gives any developer access to the same highly scalable, reliable, fast, inexpensive data storage infrastructure that Amazon uses to run its own global network of web sites. The service aims to maximize benefits of scale and to pass those benefits on to developers.

What is Amazon CloudFront?

Amazon CloudFront is a fast content delivery network (CDN) service that securely delivers data, videos, applications, and APIs to customers globally with low latency, high transfer speeds, all within a developer-friendly environment. CloudFront is integrated with AWS — both physical locations that are directly connected to the AWS global infrastructure, as well as other AWS services.

The architecture includes-

Webserver configured on EC2 Instance
Document Root(/var/www/html) made persistent by mounting on EBS Block Device.
Static objects used in code such as pictures stored in S3
Setting up Content Delivery Network using CloudFront and using the origin domain as S3 bucket.
Finally place the Cloud Front URL on the webapp code for security and low latency.

For this follow the steps in my article:

First we have to configure webserver on EC2 instance

The volume that we attached in my previous article on aws cli, we have to mount that volume to the document root (/var/www/html) to make it persistent.

You can find it here: https://dev.to/vrukshali26/lets-work-with-aws-cli-38po

For doing this firstly we have to create partition.

All the below steps are done on Windows Command Prompt.

Here, you can see partition is created:

Now, format the partition:

Now, mount this partition to root document:

Now, Static objects used in code such as pictures stored in S3.

For this first create a bucket

Now upload image in S3 bucket. Here, bucket name is “task-bucket-6”

Now make Bucket & object publicly accessible, Make bucket public:

Make object public:

s3api put-object-acl --bucket task-bucket-6 --key 123.jpg --grant-read uri=http://acs.amazonaws.com/groups/global/AllUsers

Now, Setting up Content Delivery Network using CloudFront and using the origin domain as S3 bucket.

Now, lets create a small HTML code and put the URL in HTML code

Now, lets see our web page

You can read my previous blogs here:

Vrukshali TorawaneFollow

so much to learn, so much to do, and so little time

Let's connect🚀:

Vrukshali Torawane

☕️➡️👩🏻‍💻 • backend engineer • travel • calligraphy • aws community builder

vrukshali.bio.link

Let's work with AWS CLI

Vrukshali Torawane — Mon, 16 Jan 2023 04:42:58 +0000

In this blog, we will learn how to create below resources using AWS CLI

Create a key pair
Create a security group
Launch an instance using the above created key pair and security group.
Create an EBS volume of 1 GB.
The final step is to attach the above created EBS volume to the instance you created in the previous steps.

First we have to create an IAM User.

So Amazon has IAM (Identity and Access Management) service where we can create user and can give limited access to that user.

Step 1: To give user name and here in AWS Access type give programmatic access so that it enables access key & secret key for AWS CLI.

Step 2: Give permissions to that user.

What are Permissions?
Permissions enable you to perform actions on AWS resources. When a new user or group is created, it has no permissions and a policy must be attached to allow actions to be taken on AWS resources.

You can assign permissions to all AWS identities (users, groups, and roles). Permissions are assigned in the following two ways:

Identity-based: Policies attached directly to users, groups, or roles
Resource-based: Policies attached to AWS resources, such as S3 Buckets, ECR Repositories, and more

Step 3: Now AWS, will generate Access Key & Secret Key for that user. We have to use this Access Key & Secret Key (save these) to login into our AWS CLI and then click create and here you can see IAM user is created.

Install AWS CLI: https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html

Now in Windows Command Prompt, there’s a command aws configure to login with aws cli user created above.

🧩 Command syntax is :

aws <command> <subcommand> <options>

Now, firstly we have to create our own key pair for that we take help of AWS so here to take help we write :

aws ec2 help: This gives all the commands available in ec2.

Now, here to create new key pair you can see subcommand:

Now, we can create new key pair by command:

aws ec2 create-key-pair — key-name TaskKeyPair

Now, we can create new security group by command:

aws ec2 create-security-group — group-name TaskSG — description “Task Security Group”

By using this newly created key pair & security group we have to launch new instance:

aws run-instances — image-id ami-0e306788ff2473ccb — instance-type t2.micro — subnet-id subnet-37666f5f — count 1 — security-group-ids sg-082e7e59275801fcd — key-name TaskKeyPair

You can see the created instance using CLI OR GUI:

We have to create an EBS volume of 1 GB.

aws ec2 create-volume — volume-type gp2 — size 1 — availability-zone ap-south-1a

Now, finally we have attach the Volume to the instance that we created now. we can attach the volume by following command:

aws ec2 attach-volume — volume-id vol-0522f336c28172eb1 — instance-id i-07345102940d94e27 — device /dev/sdf

Device name can be “sdf or svdh”

You can see Volume of 1 GB is in use.

You can find me here:

Vrukshali Torawane

☕️➡️👩🏻‍💻 • backend engineer • travel • calligraphy • aws community builder

vrukshali.bio.link

AWS : Leaders of Cloud Computing

Vrukshali Torawane — Sat, 14 Jan 2023 06:03:01 +0000

Let’s begin by understanding

What is cloud computing?

Cloud computing is the on-demand availability of computer system resources (includes RAM/CPU/HD), especially data storage (cloud storage) and computing power, without direct active management by the user.

There are various types of Cloud Computing:-

Amazon Web Services (AWS) is a Public Cloud and a subsidiary of Amazon providing on-demand cloud computing platform.

AWS was officially launched on March 14, 2006, combining the three initial service offerings of Amazon S3 cloud storage, SQS, and EC2. The AWS platform finally provided an integrated suite of core online services and also services offered to other developers, web sites, client-side applications, and companies.

💰 AWS works on the Pay-as you-Go model .i.e., charges are based on a combination of usage hardware, operating system, software, or networking features chosen by the subscriber.

According to Amazon, the number of active AWS users exceeds 1,000,000. AWS is used by some of the most well-known brands in existence, such as Netflix, Uber, and Airbnb and many more. They also support Startups. The services they provided are from every domain from Machine Learning, Block Chain, IOT to AR/VR, Gaming, Quantum Computing, Robotics and many more.

The picture below gives you information about Big Companies that are build on AWS

The top ten AWS users based on EC2 (Elastic Cloud Compute) monthly spend are:

Now that you have a better understanding of the different types of AWS customers, you’re probably wondering how they actually use the platform?

AWS is used by almost all the fields, not only in IT sector but also in agriculture, media telecommunication, travelling, health care, education, marketing and advertising and many more…

✍🏻 AWS Case Study:

Everyone knows Disney!

It’s an American subscription video on-demand streaming service owned and operated by the Direct-to-Consumer & International (DTCI) subsidiary of The Walt Disney Company. The service primarily distributes films and television series produced by The Walt Disney Studios and Walt Disney Televisions, with the service also advertising content from the company’s Disney, Pixel, Marvel, Star Wars, and National Geographic brands in particular.

📝As per the articles, The Walt Disney Company Selects AWS as its Preferred Public Cloud Infrastructure Provider , Disney uses AWS Cloud.

Let’s have a look on How Disney uses AWS?

Disney uses Amazon Pinpoint — along with other AWS services including Amazon Kinesis, AWS Lambda, Amazon S3, and AWS Glue — to target customers, monitor the performance of their campaigns in real time, and gain a deeper understanding of their users’ needs and desires.

How Disney built its streaming analytics pipeline on AWS?

Video streaming is providing content creators direct data on consumer behavior like never before. However, without the proper pipeline from viewer to database, deriving insights about customer preferences and engagement can take days or weeks.

How Disney Streaming Services Uses Amazon Pinpoint to Send Personalized Messages to Millions of Users in Real Time?

Firstly let’s understand Amazon Pinpoint: Amazon Pinpoint is a flexible and scalable outbound and inbound marketing communications service. You can connect with customers over channels like email, SMS, push, or voice. Amazon Pinpoint is easy to set up, easy to use, and is flexible for all marketing communication scenarios. Segment your campaign audience for the right customer and personalize your messages with the right content. Delivery and campaign metrics in Amazon Pinpoint measure the success of your communications. Amazon Pinpoint can grow with you and scales globally to billions of messages per day across channels.

Targeting the right customer at the right time:

🔺️ Problem: When you consider the use cases for MLB’s suite of apps, you can quickly see why sending the right message to the right customer is a more complicated task than it might seem at first glance. For each of the 30 Major League Baseball teams, users can opt to receive eight different types of messages. Each of these eight message types is available in both English and Spanish. There are thousands of possible segments and combinations of segments to consider with each message sent.

✅ How AWS solves this issue: Disney Streaming Services uses Amazon Pinpoint to dynamically create unique segments and campaigns for every event in milliseconds. In the most demanding usage scenarios, Amazon Pinpoint scales to create over 300 segments and campaigns per hour, and over 20 segments and campaigns per minute.

Monitoring campaign performance in real time:

🔺️ Problem: With the fast-paced nature of Disney Streaming’s notifications and the sheer number of campaigns and segments they are targeting, monitoring their performance directly in the Amazon Pinpoint console is not scalable for their use case. However, they must have real-time notifications to let them know if their campaigns are lagging or not reaching the expected number of recipients.

✅ How AWS solves this issue: Disney Streaming developed a solution that uses AWS Step Functions, Amazon Cloud watch, AWS Lambda, and Amazon Pinpoint. This solution monitors each campaign that is created. When a campaign is executed, their solution streams data about the execution and delivery of that campaign, and sends alerts when the team needs to take a closer look at how their campaigns are performing.

🔺️ Understanding fans: After a campaign has been sent, Disney Streaming analyzes the performance of campaigns. By performing this analysis, they can better understand how customers engaged with notifications, and ensure fans are receiving a compelling experience.

✅ To achieve this, Disney Streaming uses the event streaming and exporting features of Amazon Pinpoint. They stream engagement events by using Amazon Kinesis. These events let them know how fans interacted with the application, and allow them to drill down into various performance metrics on a per-team basis. They then store these metrics in S3, which are picked up by their data lake team for further processing. By using this solution, they can create near-real-time reports for the unique audiences.

Removing unengaged customers:

🔺️ Problem: Disney Streaming also uses a custom solution to engage with customers who are still able to receive messages, and to ensure that reports only include engaged users. For example, if a customer uninstalls the MLB or NHL apps, re-installs an app but doesn’t set their messaging preferences, or starts using a device on a different platform, that customer might not be able to be contacted. Disney Streaming needs to remove these unreachable customers from campaigns so that they can maintain accurate reports on audience sizes, helping keep costs low, and reduce campaign latency.

✅ How AWS solves this issue: To delete unreachable customers in real time, the Disney Streaming team uses Amazon Pinpoint to detect when they attempt to send a push notification to an unreachable customer. Their Kinesis Firehose stream then outputs campaign data to an S3 bucket, and an AWS Glue job filters out the customers who are unreachable. Finally, a Lambda function removes the endpoint by making a call to the Amazon Pinpoint API.

So in this way, Disney uses AWS to solve their problems.

Hopefully, this article may help you know AWS and the way it’s expanding!🌏

Let's connect🚀:

Vrukshali Torawane

☕️➡️👩🏻‍💻 • backend engineer • travel • calligraphy • aws community builder

vrukshali.bio.link

Create Custom Templates in Monokle🚀

Vrukshali Torawane — Sun, 20 Feb 2022 06:05:52 +0000

What is Kubernetes?🎡

⚡ Kubernetes (sometimes shortened to K8s with the 8 standing for the number of letters between the "K" and the "s") is an open-source system to deploy, scale, and manage containerized applications anywhere.

What are Kubernetes Resources? 🚀

⚡ A resource is an endpoint in the Kubernetes API that stores a collection of API objects of a certain kind; for example, the built-in pods resource contains a collection of Pod objects.

More information can be found here : https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/

What is Monokle? 🔰

⚡ Monokle helps you to:

Quickly get a high-level view of your manifests, their contained resources and relationships.
Easily edit resources without having to learn or look up yaml syntax. 3.Refactor resources with maintained integrity of names and references.
Preview and debug resources generated with Kustomize or Helm.
Diff resources against your cluster and apply changes immediately.
Visualize and navigate resources in your clusters.
And much more!

⚡ More information can be found here : https://kubeshop.github.io/monokle/

❄ Today's blog is about How can we create our custom Monokle Template!!

What are Monokle Templates? 🔰

A Monokle Template is a mechanism for creating visual forms and interpolating the data from those forms into one or multiple manifests.

⚡ More information can be found here : https://kubeshop.github.io/monokle/templates/

❄ I have created a custom template for Kubernetes Service

What is a Kubernetes Service?

An abstract way to expose an application running on a set of Pods as a network service.
With Kubernetes you don't need to modify your application to use an unfamiliar service discovery mechanism. Kubernetes gives Pods their own IP addresses and a single DNS name for a set of Pods, and can load-balance across them.

⚡ More information can be found here : https://kubernetes.io/docs/concepts/services-networking/service/

❄ Let's start

👉🏻 Step-1: Create a package.json file

{
    "name": "Monokle Custom Templates Plugin",
    "author": "Vrukshali Torawane",
    "version": "1.0.0",
    "description": "This plugin provides the custom resource templates for Monokle",
    "repository": "https://github.com/Vrukshali-26/monokle-templates-plugins",
    "monoklePlugin": {
      "id": "com.github.Vrukshali-26.plugin.templates",
      "helpUrl": "https://github.com/Vrukshali-26/monokle-templates-plugins",
      "modules": [
        {
          "type": "template",
          "path": "service-template" 
        }
      ]
    }
}

❄ In this name, author, version, description, monoklePlugin, helpUrl and modules are required to specify, also we are specifying where we have the template plugin folder e.g., in my case, service-template

👉🏻 Step-2: Create a folder named service-template and add the following content:

1. In monokle-template.json file:

{
    "name": "Basic Kubernetes Service",
    "id": "com.github.Vrukshali-26.plugin.templates.basic-service-template",
    "author": "Vrukshali-26",
    "version": "1.0.0",
    "description": "Creates a Kubernetes Service",
    "repository": "",
    "type": "vanilla",
    "forms": [
      {
        "name": "Service Settings",
        "description": "Specify the settings for your Service",
        "schema": "form-schema.json",
        "uiSchema": "form-ui-schema.json"
      }
    ],
    "manifests": [
      {
        "filePath": "template.yaml"
      }
    ],
    "resultMessage": "Service resource created successfully!",
    "helpUrl": "https://github.com/Vrukshali-26/monokle-templates-plugins"
  }

2. In form-schema.json file:

{
    "type": "object",
    "required": [
      "name",
      "podSelector",
      "targetPort"
    ],
    "properties": {

      "name": {
        "type": "string",
        "default": "my-custom-service"
      },

      "namespace": {
        "type": "string"
      },

      "podSelector": {
        "type": "string",
        "default": "app: my-app"
      },

      "servicePort": {
        "type": "number",
        "default": 80
      },

      "targetPort": {
        "type": "number"
      },

      "serviceType": {
        "type": "string",
        "default": "LoadBalancer",
        "enum": [
          "LoadBalancer",
          "NodePort",
          "ClusterIP"
        ]
      }

    }
  }

3. In form-ui-schema.json file:

{
    "name": {
      "ui:title": "Name",
      "ui:help": "The name of Service"
    },

    "namespace": {
      "ui:title": "Namespace",
      "ui:help": "The target namespace for the created Service",
      "ui:widget": "namespaceSelection"
    },

    "podSelector": {
      "ui:title": "Pod Selector",
      "ui:help": "The label name-value pair to use for selecting target Pod(s) for this Service",
      "ui:widget": "podSelectorSelection"
    },

    "targetPort": {
      "ui:title": "Target Port",
      "ui:help": "The port exposed by the target Pod"
    },

    "servicePort": {
      "ui:title": "Service Port",
      "ui:help": "The port to expose the Service on"
    },

    "serviceType": {
      "ui:title": "Service Type",
      "ui:help": "The type of Service to create"
    }
  }

4. In template.yaml file:

apiVersion: v1
kind: Service
metadata:
  name: [[forms[0].name]]
[[ forms[0].namespace ? "  namespace: " + forms[0].namespace + "\n" : ""]]
spec:
  ports:
    - port: [[forms[0].servicePort]]
      protocol: TCP
      targetPort: [[forms[0].targetPort]]
  selector:
    [[forms[0].podSelector]]
  type: [[forms[0].serviceType]]

👉🏻 Push this code to GitHub : https://github.com/Vrukshali-26/monokle-templates-plugins

❄ Download Monokle : https://monokle.kubeshop.io/

Now after installation, we will use our custom template-plugin:

👉🏻 Step-1: Welcome to Monokle!!

👉🏻 Step-2: Install Plugin
you can see a plugin button at top right corner

❄ Click on Install and enter the github URL!!

❄ You can see the plugin is installed

👉🏻 Step-3: Now on Dashboard click Start from a Template:

👉🏻 Step-4: Enter Project Name:

❄ Click Next Select a Template

❄ Now Click Create Project

❄ Click Submit and Resource is Created Successfully!!!!!

We have created our custom Template successfully!!!!
Thanks for Reading !! 🙌🏻😁📃

🔰 Keep Learning !! Keep Sharing !!

🚀 Feel free to connect with me :
LinkedIn : https://www.linkedin.com/in/vrukshali-torawane/
GitHub : https://github.com/Vrukshali-26
Twitter : https://twitter.com/vrukshali26

Terraform Integrated with GitHub Actions to setup Argo CD on Civo

Vrukshali Torawane — Wed, 01 Dec 2021 12:22:46 +0000

My Workflow

Terraform Integrated with GitHub Actions to setup Argo CD on Civo.
Wohho! Wait! What is this? So let me explain a bit about this tools.

Argo CD : ArgoCD is a GitOps tool that helps with your GitOps workflows. ArgoCD can be used as a standalone tool or as a part of your CI/CD workflow. ArgoCD works with Git as a source off truth, with current Kubernetes manifests, or with Helm charts.
Terraform : Terraform is an infrastructure as code (IaC) tool that allows you to build, change, and version infrastructure safely and efficiently.
Civo : Civo is the first cloud native service provider powered only by Kubernetes. Blazing fast cluster launch times in under 90 seconds and simplified developer experience.

So now you have some overview of what does these tools do!

Architecture

Here in my project I have tried to integrate these tools. So, the workflow is created using terraform with github actions which is used to launch the kubernetes cluster on CIVO with Argo CD preconfigured. And after configuration we as developers only need to write Kubernetes manifests file rest work will be done by Argo CD! Seems cool!!

Submission Category:

Wacky Wildcards

Yaml File or Link to Code

GitHub Repository :

vrukshaliii / ArgoCD-setup-on-Civo-using-Terraform-GitHub-Actions

Terraform Integrated with GitHub Actions to setup Argo CD on Civo 🎡🐋💙

🚀 GitHub Actions

GitHub Actions is a continuous integration and continuous delivery (CI/CD) platform that allows you to automate your build, test, and deployment pipeline. You can create workflows that build and test every pull request to your repository, or deploy merged pull requests to production.

GitHub Actions goes beyond just DevOps and lets you run workflows when other events happen in your repository. For example, you can run a workflow to automatically add the appropriate labels whenever someone creates a new issue in your repository.

GitHub provides Linux, Windows, and macOS virtual machines to run your workflows, or you can host your own self-hosted runners in your own data center or cloud infrastructure.

More Information : https://docs.github.com/en/actions/learn-github-actions/understanding-github-actions

🦑 Argo CD

ArgoCD is a GitOps tool that helps with your GitOps workflows. ArgoCD can be used as a…

View on GitHub