Day-20 | GitHub Actions | Actions vs Jenkins | 3 Projects with examples | Configure your own runner

Summary

In this 20th installment of the complete DevOps course, Abhishek introduces GitHub Actions as a CI/CD solution, comparing it with Jenkins and emphasizing its focus on the GitHub platform. He demonstrates setting up a basic Python project with GitHub Actions, showcasing its simplicity and the use of YAML for configuration. Advantages like ease of use, no maintenance overhead, and cost-effectiveness for public projects are highlighted, alongside the limitation of platform specificity. The tutorial includes step-by-step examples and encourages viewers to try GitHub Actions for themselves.

Takeaways

• 📚 The video is part of a complete DevOps course, focusing on day 20 discussing GitHub Actions as a CI/CD solution.
• 🔧 The speaker previously covered Jenkins in detail, including installation, configuration, and live projects, emphasizing the use of Docker to optimize compute resources.
• 📝 GitHub Actions is highlighted as a CI/CD solution that is specifically tailored for GitHub, similar to how GitLab CI is for GitLab.
• 🤔 The choice between GitHub Actions and Jenkins should be based on the organization's platform strategy and potential future migrations.
• 🛠️ GitHub Actions eliminates the need for plugin installations, as it uses a marketplace of pre-installed plugins, simplifying the setup process.
• 📁 The script explains the basic structure of a GitHub Actions workflow file, starting with a '.github/workflows' directory and YAML configuration.
• 🔄 The video demonstrates creating a simple Python addition program and its corresponding GitHub Actions workflow for testing the program.
• 🔑 GitHub Actions provides native support for storing secrets, which is crucial for securing sensitive information like config files and tokens.
• ⚙️ The script compares GitHub Actions with Jenkins, noting that GitHub Actions requires less maintenance and has a simpler user interface.
• 💰 GitHub Actions offers free execution minutes for public projects, which can be a significant cost advantage over self-hosted solutions like Jenkins.
• 🔄 The video concludes by recommending GitHub Actions for open-source projects staying within the GitHub ecosystem and not planning to migrate to other platforms.

Q & A

What is the main focus of the video script?

The main focus of the video script is to introduce and explain GitHub Actions as a CI/CD solution, comparing it with Jenkins and providing examples of how to use it for different tasks such as deploying to Kubernetes, Docker, and building Java applications with Maven and Sonar.

What is the significance of the 'dot GitHub workflows' folder in GitHub Actions?

The 'dot GitHub workflows' folder is significant because it is where all the GitHub Actions workflow files are stored. GitHub automatically looks for this folder to execute the defined pipelines when certain events, like a push or pull request, occur in the repository.

How does GitHub Actions handle the execution of multiple pipelines?

GitHub Actions can handle the execution of multiple pipelines by allowing the creation of multiple workflow files within the 'dot GitHub workflows' folder. Each file represents a separate pipeline that can be triggered by different events or conditions.

What is the advantage of using Docker containers as agents in Jenkins, as mentioned in the script?

Using Docker containers as agents in Jenkins is advantageous because it allows for more efficient use of compute resources. Containers can be spun up for specific tasks and then terminated once the job is done, preventing waste compared to using virtual machines as agents.

What is the primary difference between GitHub Actions and Jenkins in terms of platform focus?

The primary difference is that GitHub Actions is focused only on the GitHub platform, executing pipelines within the context of GitHub repositories. In contrast, Jenkins is a more general CI/CD tool that is not platform-specific.

Why might an organization choose not to use GitHub Actions or GitLab CI?

An organization might choose not to use GitHub Actions or GitLab CI if they anticipate migrating to a different platform in the future, as these tools are platform-oriented solutions. Moving from one platform to another would require significant effort to migrate the CI/CD configurations.

What is the purpose of the 'on' keyword in a GitHub Actions workflow file?

The 'on' keyword in a GitHub Actions workflow file specifies the events that will trigger the execution of the pipeline. It could be set to trigger on events like 'push', 'pull_request', or 'issues'.

How does the script describe the process of writing a basic GitHub Actions workflow for a Python application?

The script describes the process by first creating a Python file with a simple addition function and tests. Then, it outlines writing a workflow file that sets up a Python environment, checks out the code, installs dependencies, and runs the tests using pre-configured plugins available in GitHub Actions.

What are some of the plugins provided by GitHub Actions for different programming languages?

GitHub Actions provides plugins for various programming languages like 'setup-python' for Python, 'setup-java' for Java, and similar plugins for other languages, which help in setting up the required environment for executing the workflows.

How does GitHub Actions handle the storage of sensitive information like passwords or tokens?

GitHub Actions handles the storage of sensitive information through its native support for secrets. Users can store secrets in the repository settings, and these secrets can be accessed securely within the workflow files.

What are some of the advantages of using GitHub Actions over Jenkins mentioned in the script?

Some advantages include no need for hosting or maintenance effort, a simple user interface for writing pipelines, and cost-effectiveness, especially for public projects which can use GitHub Actions for free up to a certain limit of execution minutes.

Outlines

00:00

📚 Introduction to GitHub Actions in DevOps Course

In the 20th day of the complete DevOps course, Abhishek introduces GitHub Actions as a CI/CD solution, comparing it with Jenkins and emphasizing the importance of aligning the choice of CI/CD tool with organizational goals. He mentions the repository with step-by-step examples and clarifies that GitHub Actions is platform-oriented, best suited for those committed to GitHub. The video also touches on the efficiency of using Docker containers with Jenkins to save compute resources.

05:01

🛠️ GitHub Actions Workflow and File Structure

This section delves into the mechanics of GitHub Actions, explaining how to set up the workflow files within the '.github/workflows' directory of a repository. It discusses the flexibility of having multiple action files and the process of executing pipelines based on events like push or pull requests. Abhishek illustrates this with examples from the Argo CD project, highlighting different types of pipelines for various checks and processes.

10:02

🔧 Writing and Executing a Basic GitHub Actions Pipeline

Abhishek demonstrates how to write a GitHub Actions pipeline for a simple Python addition program. He guides through the process of setting up the environment, checking out the code, and running tests, all within the GitHub Actions framework. The explanation includes the use of YAML formatting, referencing the GitHub Actions documentation for plugin usage, and executing the pipeline with a test commit.

15:02

📝 Understanding GitHub Actions Syntax and Plugins

The script explains the syntax and structure of GitHub Actions files, highlighting the use of YAML and the similarity in configuration across different applications. It emphasizes the ease of writing pipelines with pre-installed plugins, comparing the process with Jenkins and pointing out the limitations of GitHub Actions plugins. The paragraph also covers the steps involved in setting up a Python environment and running tests within a GitHub Actions pipeline.

20:03

🔑 Storing Secrets and Advanced GitHub Actions Configuration

This part of the script discusses the security aspect of storing sensitive information like config files and tokens in GitHub Actions. It shows how to use GitHub's native support for secrets and how to configure custom runners for more specific needs. The comparison with Jenkins continues, focusing on the ease of setup and the reduced maintenance overhead of GitHub Actions.

🤔 Comparing GitHub Actions and Jenkins: Pros and Cons

In the conclusion, Abhishek compares GitHub Actions with Jenkins, outlining the pros and cons of each. He points out the advantages of GitHub Actions for public projects on GitHub, the ease of use, and the reduced maintenance. However, he also mentions the limitations, especially regarding portability and the scope of available plugins. The summary advises on choosing the right tool based on project needs and platform commitment.

Keywords

💡DevOps

DevOps is a set of practices intended to reduce the time between committing a change to a repository and the change being placed into production. In the video, the speaker is teaching a complete DevOps course, which includes various tools and practices like GitHub Actions and Jenkins, to streamline the software development and deployment process.

💡GitHub Actions

GitHub Actions is an automation tool integrated within GitHub that allows users to automate their software development workflows. The video focuses on GitHub Actions as a CI/CD (Continuous Integration/Continuous Deployment) solution, emphasizing its ease of use and integration with the GitHub platform.

💡Jenkins

Jenkins is an open-source automation server that facilitates the automation of all sorts of tasks associated with building, testing, and deploying software. The script contrasts Jenkins with GitHub Actions, discussing their use cases and comparing their features, such as the need for managing plugins and the ease of setup.

💡CI/CD

CI/CD stands for Continuous Integration/Continuous Deployment, which are practices in software development designed to improve the process of integrating changes from multiple contributors into a single software project. The video discusses how GitHub Actions and Jenkins serve as tools for implementing CI/CD practices.

💡Docker

Docker is a platform that uses containerization technology to make it easier to develop, ship, and run applications. In the script, Docker is mentioned as a way to use as an agent in Jenkins, allowing for efficient resource use by creating containers for pipeline execution that can be terminated after use.

💡Repository

A repository in the context of the video refers to a location where all the files for a project or software product are stored. The speaker mentions creating a repository for the course, which includes examples and step-by-step explanations of the topics covered, including GitHub Actions.

💡YAML

YAML is a human-readable data serialization standard used in programming languages and software applications. The video explains that GitHub Actions uses YAML formatting for its configuration files, which makes it easy for those familiar with YAML, such as in Kubernetes, to write GitHub Actions.

💡Workflows

In GitHub Actions, a workflow is a way to automate tasks within a repository. The script describes creating a 'workflows' directory in the '.github' folder of a repository to define the steps that GitHub Actions should execute when certain conditions are met, such as a push to the repository.

💡Self-hosted Runners

Self-hosted Runners in GitHub Actions are custom runners that you can host on your own infrastructure. The video mentions the option to configure custom Runners if the default runners provided by GitHub do not meet specific needs, such as when more compute resources are required for tasks like load testing.

💡Secrets

Secrets in the context of GitHub Actions are sensitive information that you store in your repository to be used by your workflows. The script explains that GitHub Actions provides native support for storing secrets, such as configuration files or tokens, ensuring they are kept secure and not exposed.

💡Plugins

Plugins in the video refer to the add-on tools provided by GitHub Actions to extend its functionality. The speaker explains that GitHub Actions has a marketplace of plugins that are automatically installed and can be easily used in workflows, simplifying the process compared to managing plugins in Jenkins.

Highlights

Introduction to GitHub Actions as a CI/CD solution on day 20 of the complete DevOps course.

Comparison of GitHub Actions with Jenkins, emphasizing GitHub Actions' focus on the GitHub platform.

Explanation of the benefits of using Docker as an agent in Jenkins to save compute resources.

GitHub Actions' ease of use with no need for plugin installation, unlike Jenkins.

Demonstration of creating a GitHub Actions workflow for a Python addition program.

Showcasing the simplicity of writing GitHub Actions using YAML formatting.

Discussion on the flexibility of GitHub Actions to run multiple pipelines for different tasks.

Introduction to the GitHub Actions Marketplace for plugins and how they simplify the CI/CD process.

Explanation of how to use GitHub Actions for various programming languages by changing plugins.

Guide on storing secrets in GitHub Actions for secure handling of sensitive information.

Comparison of the cost-effectiveness and maintenance overhead between GitHub Actions and Jenkins.

Advantages of GitHub Actions for open-source projects due to free execution minutes.

The potential downside of GitHub Actions being platform-specific and the implications for future platform migrations.

GitHub Actions' native support for storing CI/CD secrets, enhancing security.

How to set up self-hosted runners in GitHub Actions for customized execution environments.

Recommendation to use GitHub Actions for projects staying within the GitHub platform and open-source projects.

Invitation for feedback and engagement from viewers in the comment section.

Transcripts

hello everyone my name is Abhishek and

welcome back to my channel so today we

are at day 20 of our complete devops

course and in this video I am going to

talk about GitHub actions so if you

haven't watched our previous videos so

in the last class we talked about

Jenkins so we typically looked at

Jenkins Zero to Hero where we talked

right from installation of Jenkins to

configuring it then you know we also

looked at three live projects on Jenkins

we saw how to use Docker as an agent

like you know if you use a virtual

machines as agent you are wasting a lot

of compute resources on Jenkins so I

explained you how to use Docker

container so that your pipelines gets

executed on this Docker agents and once

your job is completed or once your job

is done this containers gets deleted or

you know this container gets terminated

or killed so that there is no waste of

computer right so if you haven't watched

that video you can click on this link or

you know you can look look into this

repository or else you can also go to my

channel and watch those videos perfect

so today's topic is completely about

GitHub actions

so as usual I've created a repository

for you in case somebody is not able to

follow the video or let's say somebody

feels that I'm going uh very fast or in

the video what you can do is you can

either watch this repository for this

repository or start this repository and

I have step by step step by step

explanation of what I am going to talk

today okay so now just a disclaimer this

repository is not complete I'm going to

add more and more things to this

repository for now in the examples

folder I just have three three examples

one is deploy to kubernetes deploy to

Docker spam and uh deploy one Java

application by building it through Maven

testing the code quality using Sonar and

then deploying to kubernetes but in

future I'll add more examples to it or

even if you want to contribute to me uh

to my GitHub repository you can also do

that okay so now quickly jump on to the

topic for today that is GitHub actions

so what is GitHub actions so GitHub

actions is yet another cicd solution

okay so if you want to compare it with

Jenkins they do similar tasks like you

know they uh execute your continuous

integration and continuous delivery but

the primary difference is GitHub actions

is focused only on GitHub okay just like

gitlab Ci gitlab CI is also a CI CD

solution that gitlab is offering you but

it is only focused on gitlab platform so

one big thing to understand or you know

whenever you want to consider GitHub

actions or gitlab CI the primary thing

you have to understand is what your

organization's goal is so do you want to

continue on GitHub do you want to

continue on gitlab or in the future you

might want to migrate to different

Platforms in such cases GitHub actions

or gitlab CI is not the right solution

for you okay because again they are

platform oriented Solutions just like

why we choose terraform over cloud

formation templates because terraform is

a tool that can work on multi-cloud or

it can work on the hybrid Cloud

environments so similarly GitHub actions

although it is very powerful although it

is like you know the tool that I am

suggesting better than Jenkins uh like

I'm going to explain you the pros and

cons uh even in the first class of cicd

I explained you why GitHub actions is

better than Jenkins but saying that if

you are platform or if your application

is going to move from GitHub to gitlab

in the future or GitHub to AWS in the

future or any self-hosted git

repositories or Azure devops do not use

GitHub accents because you will waste a

lot of time and then in future you will

put lot of efforts from I mean in

migrating your actions files to Jenkins

files or something else

okay perfect now

so GitHub actions basically you don't

have to install the plugins like for

example uh if I want to write uh one

GitHub actions file like my first GitHub

actions file what you need to do is you

just need to go to the root of your

repository like you know the uh Parent

Directory of your repository and just

create dot actions sorry dot GitHub

slash workflows folder okay so once you

create dot GitHub workflows folder

whatever action like you know let's say

uh this is my GitHub actions file and in

the first line I said on push okay so

this will say GitHub that okay whenever

there is a push action or whenever there

is a commit that is created into this

Repository

by default you have to execute this

pipeline okay whatever I write in this

pipeline irrespective of what action is

done like you know it can be a small

commit it can be a big commit or you

know you're you're modifying test

related files you are modifying like

irrespective of that once you define

that on push action or on pull request

action on issue action so what GitHub

will do is it will look into the action

like somebody has done a commit then it

will come here and watch for the CI

files and it understood okay there is a

push uh request like whenever there is a

push request the user has said that I

need to execute this pipeline or actions

file so GitHub will start executing the

action file now is there a restriction

like do I have to put only one action

files here or I can put 10 action files

for 10 20 action files so there is no

limitation at all like you know

depending upon the number of action

files that you want to run for example

uh uh in one action file you you might

want to verify if a user has provided

all the details in the pull request or

not for example organizations have a

like you know conditions like whenever

you are creating a pull request you have

to provide proper description you have

to provide uh which issue is it solving

so you can also validate those things in

one actions file or in one pipeline in

the other pipeline you can verify if

there is formatting or linking issues in

the third pipeline you can verify if

your CI is passing in the fourth

pipeline you can do your CD so it

depends on how do you want to do for

example let me show you one popular

project uh let me show you uh Argo CD

you can take any other projects that is

using GitHub actions so if you see here

similarly uh there is a DOT GitHub

folder and if you go to dot GitHub

folder again there is workflows folder

okay if you go to a workflows folder

you'll see that there are a bunch of

pipelines here right one is CI build so

it is building the CI then it is

checking the code okay then image.aml

after that uh like I mentioned you PR

title check.yaml that means they are

just verifying if the pr title is

perfect or not then release.ml which

will release and finally the sync which

will verify like you know if your code

has any if it is creating any

vulnerabilities or if it is not adhering

to any security standards so this

pipeline will validate similarly you can

also do n number of pipelines in your

GitHub I mean dot GitHub Dot workflows

and whatever actions that you configure

so here you can say push comma pull

request push comma pull request comma

issues so GitHub does not mind executing

your pipelines on the actions that that

you are providing okay if you provide

three actions it will just verify that

okay either of the action has to be

matched if either of the action is

matched or if one of the actions is

matched then your GitHub will start

executing this pipeline okay now let us

see how easy is it to write GitHub

actions so you can also like I mentioned

copy this repository and execute your

first actions file so because many of

our subscribers or viewers are familiar

with python what I have decided is I'll

write a very basic python uh addition

example okay so what I have done is this

is my srj folder and inside the SRC I

created addition.py file okay so in this

edition.py file what is there it's just

a addition function and here I am

testing the addition functionality okay

so this is unit testing and this is your

uh basic like you know addition program

where it is saying addition function

where it is saying uh past two variables

and return the addition of two variables

so I have tested this here now let me

write a GitHub action so let me write a

pipeline what this pipeline has to do is

whenever there is a new commit that is

getting created okay let's say let me do

it in life okay what I'll do is I'll

just modify something here I'll add a

new comment

this is a test commit now as soon as I

commit what should happen is GitHub

actions should check out this program

okay or it has to check out this code

and then it has to create a python

environment for me right because uh

there is no server that I did not

configure any server in Jenkins you have

your servers pre-configured right what

you will do is either you'll use uh

Docker containers which I explained in

your previous class or else what you'll

do is you will create your worker nodes

and inside your worker nodes you will

install Python and you will set up all

the required environment and then

finally what you'll do is you will run

this program and then you will run your

test so now I want everything to happen

in GitHub actions let us see what GitHub

actions does as soon as I click on the

commit changes okay now what happens is

just go to your root directory and you

will see this hello button once you

click on it it will say that your

actions is running let me click on one

of this I'll tell you why there are two

actions but before that let us see what

is happening

okay firstly it set up the job now it

said that it is checking out the code

okay where is it getting this

information from I wrote all of them in

the CI file or in the pipelines file

I'll show you that okay so run action

slash checkout at the rate V3 what is

this and what is it doing okay so it is

basically a plugin that I am configuring

in the uh pipeline.yaml or the ci.aml

and I am saying GitHub that okay check

out the repository after that I said set

up python okay where it set up the

python then I said install the

dependencies if at all there is

something but in my specific case there

are no dependencies it's just a simple

addition Dot py finally it has to run

the test where it has to just execute

the test that I showed you and then it

says that the job is complete now let us

see how did I do all of these things is

it a big deal or does it take uh you to

master GitHub actions no not at all so

you can and just write all of these

things in first five minutes like you

know even if you watch this video you

can after this video you can directly

create your own GitHub repository and

you can write this file it is that

simple okay so it follows the yaml

standard or yaml formatting so if you

are aware of kubernetes or you know if

you are already aware of yaml

indentation and syntaxing then uh you

it's a cakewalk for you so firstly

provide the name of your GitHub action

where I said this is my first GitHub

actions after that like I mentioned you

I said that on every commit okay I can

change this event as well but I said on

every comment just execute this GitHub

actions then here start your actual

execution okay job you can correlate it

with as pipeline in Jenkins okay so here

if you create three jobs that means you

are running three Jenkins pipelines okay

so even in one file you can write

multiple jobs like you know in one file

you are executing multiple pipelines

it's up to you but here I just used uh I

mean I just created one job and what I'm

saying is use Ubuntu latest as the

container image okay like if you

remember previously what we have done is

we configured uh in Jenkins pipeline

that okay I have to use Docker as agent

and once I use Docker as agent use this

image okay it can be Ubuntu or it can be

python or something like that so

similarly here for GitHub actions also

you will say Okay use Ubuntu latest

image and inside that set up a python

environment so now what I am saying is

my addition functionality has to be

verified on python 3.8 as well as python

3.9 okay so that is the reason why you

saw two jobs that were getting executed

if I mention here Python 2.7 okay what

will happen is now your python uh like

your pipeline will be executed on three

uh versions okay so that is again a

flexibility that GitHub is offering you

even if you don't want all of these

things you can get rid of all of these

things and just say that okay here in

the python version just say python 3.8

okay so what is the next step that I am

doing is I am basically checking out the

code okay so till here I did nothing I

just said that okay uh use one of the

environments that is Ubuntu latest that

has python 3.8 and 3.9 like you know I

want two environments after that here

starts your steps where you write your

actual code okay it's like stages in

Jenkins right so in Jenkins you define

multiple stages right you want your

build stage you want your test stage you

want your sash stage Dash stage and

finally you say your deploy stage

similarly you can also segregate your

GitHub actions into multiple steps

wherein first step I am saying the first

step has to be to check out the code now

where did I get this information from so

this is a standard that you can follow

if you don't know uh how to figure out

these things like every time just go to

your GitHub actions documentation

okay so if you go to GitHub actions

documentation so the documentation

itself will tell you what are the

plugins that GitHub actions provides

okay so for example if you want to check

out the code okay so go to your uh just

click on the Kickstart and you will have

bunch of plugins and bunch of examples

in each example they'll explain you like

you know for example to build and test

okay so build and test go Application

building test Java application with ant

build and test uh Java application with

Maven just open this one okay build and

test Java application with Maven here

you will see that you know what they are

doing is firstly they are checking out

the code so in this example and in my

example the step is the same actions

hyphen checkout version three the reason

why is it same is because it's a plugin

okay so it is not a configuration that

you are writing by yourself it is just a

plugin that you are using like I told

you GitHub actions has a Marketplace of

plugins and you can just use these

plugins uh unlike in Jenkins what you

will do you will go to your Jenkins

manage plugins and you will install the

plugins and you will do all of those

things right but in GitHub actions the

plugins are Auto installed like you know

they are installed by default all that

you need to do is whichever plugin that

you want to use like in my case I said

action setup python uh iterate version

2. it doesn't mean python 2 it means uh

like you know whenever you see at the

rate it is the version of the plugin but

it is not the version of your

programming language or your tool okay

so setup hyphen python at the Red

Version 2 does not mean that you are

installing python 2 but it means that

you are using setup hyphen python plug

in the version 2 of the plugin okay so

if you compare it here it says setup

hyphen Java at the rate V3 that means it

is installing version 3 of the Java

plugin okay so even if you see the

syntax and you know the naming

convention is quite similar if tomorrow

you want to build a node.js application

or let me take Ruby application here

okay so all that that changes is you

just have to modify setup Java to set up

Ruby okay and you want to Define which

version of the plugin that you want to

use so so the biggest advantage of

GitHub action is you will have to write

very very less code okay because the

configuration is quite similar for uh

different applications whether it is

python application Java application node

application you are only playing with

the plugins and those plugins are

already installed but the only

disadvantage is that these plugins are

very limited in scope

okay because GitHub action is very uh

new right even though it is there for

last three to four years but if you try

to compare it with Jenkins or any other

CD tools that CI CD tools that are

available in the market so GitHub

actions is still a budding tool if you

compare it with it after you do this

okay so setup python is done then you

said actions python okay that means you

just configured a python environment

inside your Ubuntu latest what happens

after that is you know you can write

your steps what I am saying just install

pip then install the pi test which

through which I am going to test my

application and finally just run the pi

test

so this is very simple way of writing

GitHub actions so you can use this same

example just like I told you for this

repository clone it try it try it by

yourself then look into the logs see

what is happening you know this way you

can understand GitHub actions in a

better way and the other thing is that

if you go to the settings okay so you

have options for uh you know just go to

actions here and then you can configure

your custom Runners as well like let's

say you don't want to use uh you know

you can just click on it and say new

self-hosted Runners using which you can

create your own runners okay so uh

similar to Jenkins right either you can

use Docker containers or you can create

your own host runners or you know you

can create your own worker nodes and you

can use on it let's say you are not

happy with the default Runners that

GitHub is providing because you can

understand that these Runners are light

in nature or you know they don't have

enough compute resources you might want

to do some load testing uh which GitHub

access is not providing you that much

compute so in such cases you can create

your new self-hosted Runners even if you

have issues with the security or

something create your own self-hosted

Runners and you can execute on your cell

phone start Runners and there are things

like GitHub actions provides integrated

is you can also store your secrets if

you go to my next example and see so

again go to the examples folder so here

I have one example which says how to

deploy the Java application configure

Maven sonar and finally deploy to

kubernetes so one doubt that you should

that you should get is okay so if I am

doing the entire thing on GitHub actions

where will I store the passwords like

you know the cube config file so Cube

config file has to be extremely secure

you cannot share the cubeconfig file

with someone else so what GitHub access

does is it provides you the native

support to store the secrets like you

can go to the settings and you know you

have an option to store your CI CD

secrets and using that CI CDC Secrets

what I've done is I have stored my

cubeconfig file I've stored the sonar

token any any secure information you can

store and if you try to compare my

previous example with this example there

is not much difference okay so similarly

I'm checking out code I am using one

more plugin for kubernetes okay so this

plugin information you can get from

GitHub docs and you know I'm using the

same steps okay so this step I am

executing the payment Target in this

step I am just executing the sonar

related actions and finally I am using

kubernetes

tomorrow if you want to set up the same

thing for your organization okay

irrespective of any additional steps

that you have the basic configuration or

the basic skeleton you can just copy

from my repository or you can just copy

from the examples that I have shown you

so that is the advantage of using GitHub

actions now let me try to compare it

with Jenkins because that is one of the

important things that many people have

the question like you know should I

start with GitHub actions or should I

start with Jenkins or should I Implement

GitHub actions or Jenkins in my project

so to fundamentally explain you one uh

major disadvantage with GitHub actions

is it is very uh scoped to the platform

so in tomorrow I mean tomorrow if you

want to move from one platform to

another platform let's say GitHub to uh

AWS code commit or from GitHub to you

want to move to

uh Azure devops okay so in such cases do

not use GitHub access that is one of the

disadvantage but if you come to the

advantages like it can be an interview

question so even I have provided the

details here so if somebody is asking

you what are the advantages of GitHub

actions over Jenkins so you can simply

say that the hosting okay so why what I

mean by hosting is uh if you have to

create your Jenkins instance uh like

yesterday's class I showed you you have

to create a ec2 instance then you have

to install install Jenkins and then you

have to expose your inbound traffic like

you know you have to do bunch of the

things you have to install the plugins

you have to configure it and tomorrow if

there is new version of Jenkins you also

have to update it right if you don't

update it you will run into security

issues so this entire thing is gone with

GitHub I mean the GitHub actions so you

don't have maintenance effort you don't

have hosting effort if your platform is

only GitHub then the best thing that you

can do is simply migrate to GitHub

actions for all the open source projects

that you will see 90 of the people use

GitHub actions because of this

flexibility that GitHub is providing so

you don't need a uh another engineer who

has to work as a Jenkins maintenance

engineer

okay after that the user interface like

I showed you user interface and writing

a Jenkins sorry GitHub actions uh

pipeline is very very simple after that

coming to the cost uh if you create a

easy to instance if you create a worker

nodes you configure Auto scaling groups

all of these configurations is not cost

effective right if you are using GitHub

accents what am I doing GitHub actions

is providing you free execution for

public projects okay so if your code is

open source and if you are a public

project you don't even have to worry

about it like GitHub actions is

completely free whereas if you are a

private project like let's say if I make

this repository private so in such cases

I think there is a limitation for 2000

minutes of execution I don't remember

exactly but there is a limitation on the

private repositories if your

organization is using private

repositories then yeah you must also

evaluate it in in terms of the cost but

still uh even the cost will be less and

you will not have the maintenance

overhead of maintaining Jenkins okay not

Jenkins just taking Jenkins because I'm

trying to compare it with our previous

video

so these are some pros and cons you can

also look into the details uh in the

GitHub repository and finally what I

wanted to tell you is uh like you know

if you uh want to use a GitHub actions

over Jenkins then if you are only public

project open source project and if your

project is not deciding to move from one

place to another place in the future

like from GitHub to any other VCS

platforms then GitHub action is the

right tool for you I hope you like the

video if you have any feedback for me

definitely uh put that in the comment

section and don't forget to like and

share this video with your friends thank

you so much I'll see in the next video

take care everyone bye