Day-20 | GitHub Actions | Actions vs Jenkins | 3 Projects with examples | Configure your own runner
Summary
TLDRIn 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
📚 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.
🛠️ 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.
🔧 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.
📝 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.
🔑 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.
Mindmap
Keywords
💡DevOps
💡GitHub Actions
💡Jenkins
💡CI/CD
💡Docker
💡Repository
💡YAML
💡Workflows
💡Self-hosted Runners
💡Secrets
💡Plugins
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
関連動画をさらに表示
Day-18 | What is CICD ? | Introduction to CICD | How CICD works ? | #devops #abhishekveeramalla
Day-22 | Project Management tools for DevOps | What a DevOps Engineer does in the first week ? #2023
What is DevOps? Understanding DevOps terms and Tools
Day-9 | Git and GitHub | What is GIT ? | What is Version Control ? | #devops #2023 #github #gitlab
Day-25 | Docker Containerzation for Django | #django #python #devops
Laravel deployment with GitHub Actions
5.0 / 5 (0 votes)