►
Description
Open-Source Contribution helps in being prepared for the industry. Open-Source contribution helps in writing cleaner code and gain recognition in the community. We'll give you a brief into how to dive into Open-source world and start contributing to awesome community. You'll also learn about Kubernetes concepts which would help you to deploy your applications at scale. What we are going to talk about: (i) What is open-source? (ii) How to get started with open-source? (iii) Open-Source communities and events (iv) Get involved in Kubernetes community and SIG + Basic Kubernetes concept (v) Kubernetes components (vi) Deploy your first Kubernetes Cluster (vii) Deploy demo application on Kubernetes cluster.
A
Again,
welcome
you
all
to
this
wonderful
event:
kubernetes
community
days
chennai,
we
are
super
excited
to
be
here.
My
name
is
vinati
mishra,
along
with
akshat
khanna,
we'll
be
talking
about
open
source
and
kubernetes
for
students.
We
are
working
as
an
mts
intern
at
vmware
and
final
year,
student
pursuing
b-tech
in
computer
science
from
sram
university
chennai.
A
So,
let's
begin,
first
of
all,
what
is
open
source
open
source
is
a
term
that
originally
referred
to
open
source
software
open
source
software
is
a
code
that
is
designed
to
be
publicly
accessible.
That
is,
anyone
can
see,
modify
and
distribute
the
code
as
they
see
it.
Open
source
software
is
developed
in
a
decentralized
and
collaborative
way,
relying
on
peer
review
and
community
production
now
comes
the
most
exciting
part
how
to
get
started
with
open
source.
So
these
are
the
few
simple
steps
by
which
we
can
get
started
in
contributing
to
open
source.
A
A
Then
I
have
to
understand
the
project
by
looking
at
the
docs.
There
is
a
contributing
guide
or
you
can
say,
readme
file
in
which
the
list
of
all
the
steps
to
get
started
with
that
project
is
listed
there.
Then,
by
reading
that
you
can
try
to
run
the
project
on
your
local
machine
or
vm,
then
you
can
find
an
issue
on
the
github
from
the
issue.
Tab
on
that
project
to
focus
on
the
good
first
issue,
because
you
are
a
beginner,
then
you
have
to
focus
on
the
good
first
issue
from
the
issue.
A
A
Now
we
look
into
the
open
source,
communities
and
events.
These
all
are
the
open
source
communities
presents
worldwide,
where
you
can
connect,
contribute
and
learn
a
lot
about
open
source
projects.
These
are
the
communities
that
are
super
active
and
that
events
are
conducted
every
year
on
a
specific
time
suppose
there's
digital
ocean.
A
They
conduct
hacktoberfest
every
year
in
the
month
of
october,
where
you
can
contribute
to
open
source.
There
is
google
sound
of
code
in
which
many
startups
are
there
in
which
you
can
contribute.
There
is
major
league
hacking.
They
conduct
a
lot
of
hackathons
every
now
and
then
there
is
outreachy
girlscrip
summer
of
code,
linux
kernel
mentorship
program,
so
these
are
some
open
source
communities
and
events
by
which
you
can
get
started
and
contribute
to
open
source
and
meet
a
lot
of
people
who
are
contributing
in
open
source
communities.
A
Now
that
you
have
learned
about
open
source
communities
and
events
we'll
see
how
to
get
involved
in
kubernetes,
community
and
sid,
so
what
is
sig
6
stands
for
special
interest
groups.
It
is
a
group
of
contributors
who
maintain
and
publish
the
kubernetes
components,
and
the
website
getting
involved
with
sig
is
a
great
way
of
contributing
in
the
kubernetes
to
have
a
large
impact
on
kubernetes
projects.
A
So
head
over
to
this
website,
kubernetes
dot
io
slash
community
to
learn
more
about
kubernetes
community.
Now
we'll
see
the
contributor
guide.
First,
we'll
see
the
prerequisites
you
have
to
create
a
github
account
and
then
sign
the
cla
signing.
The
cla
is
an
automated
step
done
by
the
github
board
to
every
new
contributor.
A
A
Now
your
first
contribution
you
have
to
find
something
to
work
on
related
to
your
interest.
Suppose
in
kubernetes
I
want
to
contribute
in
container
d
or
cni
plugins.
Then
you
can
go
to
that
repo
and
then
you
can
start
looking
in
the
good
first
issue
label.
The
good
first
issue
can
be
like
enhancement
in
the
documents
or
any
small
feature
that
you
want
to
implement.
A
So
you
have
to
look
for
good
first
issue
label.
As
shown
in
the
picture,
there
are
good
first
issue
label
put
in
many
of
the
issues
so
by
clicking
in
any
issue
you
can
assign
that
to
yourself
going
to
that
issue
and
then,
in
the
comments
section
you
can
type
slash
assign,
so
the
github
board
will
assign
that
issue
to
you
so
that
you
can
start
working
on
it.
Then
you
can
contribute
to
special
interest
group
that
is
same
under
sick.
A
There
are
many
projects
that
is
sick,
apps,
cli,
multi,
cluster
storage
and
windows,
and
there
are
many
sub
projects
under
that.
So
you
can
contribute
here
also.
So
this
was
all
about
kubernetes
and
how
to
get
involved
in
kubernetes,
community
and
sig.
Now
akshal
will
take
you
forward
to
know
what
is
kubernetes
and
what
are
kubernetes
components.
B
B
So
kubernetes
is
a
platform
and
a
container
orchestration
tool
which
is
used
for
automating
deployment,
scaling
and
operation
of
your
application
containers,
and
it
is
also
portable
extensible
and
is
open
source
and
have
a
community
of
great
contribution
contributors
around
the
world.
So
it
has
a
rapid
growing
ecosystem
and
kubernetes
services.
Support
tools
are
widely
available
these
days,
so
kubernetes
is
a
container
orchestration
tool,
as
I
told
so.
We
can
automate
deployment,
scaling
and
operation
of
the
application
on
in
the
cluster,
and
it
was
open
sourced
by
google
in
2014
before
that.
B
B
A
port
represents
a
single
instance
of
a
running
process
in
a
cluster
pod
can
have
one
or
multiple
containers,
but
in
regular
cases
it
is
only
one.
Docker
container
then
comes
the
node.
So
node
is
a
worker
machine
in
kubernetes
that
may
be
a
virtual
or
a
physical
machine.
Depending
on
your
cluster,
each
node
is
managed
by
the
control
plane.
A
node
can
have
multiple
pods
and
the
community's
control
pane
automatically
handles
the
scheduling
and
auto
healing
and
these
cases
of
the
pods
across
the
cluster.
B
So
here
comes
the
diagram.
This
diagram
speaks
thousand
words
in
this.
First
we
have
a
node.
This
is
a
worker
node
inside
the
worker
node.
We
have
two
components:
cubelet
and
q
proxy.
So
these
this
is
a
diagram
which
is
these
are
the
basic
components
in
a
kubernetes
cluster.
So,
as
I
told
in
the
worker
node,
we
have
cubelet
and
q
proxy
and
also
the
container
d,
which
is
the
default
runtime
of
the
kubernetes
that
is
running
inside
a
node
worker
node.
B
So
here
in
this
diagram,
we
have
three
worker
nodes
having
the
respective
cubelet
and
q
proxy
and
all
the
requests
are
handled
in
in
a
control
plane
that
is
depicted
here.
All
the
requests
that
are
coming
from
the
nodes
are
received
by
api
server.
So
this
here
is
the
api
server,
which
receives
all
the
requests
and
controls
and
sends
back
the
request
to
the
nodes.
So
we
have
the
api
server
which
interacts
with
all
of
the
nodes
in
the
kubernetes
cluster.
B
Then
we
have
a
scheduler,
so
scheduler
is
used
for
scheduling
of
the
nodes
and
keeping
a
track
of
the
nodes
that
are
running
and
also
we
have
etcd.
That
is
a
key
value
pair
store,
which
stores
the
current
state
of
the
kubernetes
cluster
or
the
nodes
that
are
running
so
in
etcd.
It
is
a
key
value
store
where
we
usually
store
the
state
of
the
cluster,
and
then
we
have
a
controller
manager
which
controls
all
the
things
inside
the
communities
cluster.
B
B
B
So
I'll
walk
you
through
a
step-by-step
guide,
how
you
can
create
your
own
kubernetes
cluster
on
your
local
machine
and
also
deploy
a
simple
application
in
that
cluster,
so
like
setting
up
local
kubernetes
cluster
is
incredibly
simple.
These
days,
all
thanks
to
tools
like
mini
cube,
kind,
cluster
and
even
docker,
provides
quantities
nowadays.
B
B
We
just
need
an
operating
system
and
we
can
have
our
communities
cluster
up
and
running
in
our
local
machine.
So
before
moving
forward,
we
need
to
have
some
install
or
prerequisites
that
should
be
installed
on
our
system.
So
let's
go
ahead
and
see
that
so
at
initially
you
need
a
docker
desktop,
so
you
can
go
ahead
and
download
docker
desktop
from
their
official
website.
B
So
if
you
are
using
a
darwin-based
operating
system,
then
you
can
download
docker
desktop
for
mac
and
similarly
followed
by
a
docker
desktop
for
windows
or-
and
if
you
are
a
linux
user,
then
go
ahead
and
download
docker
for
linux.
You
can
download
the
docker
from
their
official
website
and
the
next
tool
that
we
require
is
cube
ctl.
So
this
is
the
command
line
tool
that
we
use
to
send
commands
to
our
kubernetes
cluster
and
run
commands
on
our
communities
cluster.
B
So
you
can
simply
search
install
cube
ctl
on
google,
and
then
you
can
follow
the
steps
that
are
shown
in
this
documentation
of
kubernetes.
So
again,
based
on
your
open
operating
system,
you
can
go
ahead
and
download
these
and
install
cube,
ctl
command
line
on
your
system
and
the
third
dependency
or
like
prerequisite
that
we
need
to
have
is
the
kind.
So
in
all
these
three,
if
you
are
using
mac,
you
can
directly
go
ahead
and
install
these
three
of
them.
B
Using
brew,
you
can
simply
write
brew,
install
docker,
brew,
install
cube,
ctl
and
also
like
brew,
install
kind
simply-
and
if
you
are
a
window
user,
you
can
install
kind
using
chocolatey
package
manager,
just
write,
choco
install
kind.
So
these
are
the.
These
are
three
prerequisites
that
we
require
before
starting
with
creating
our
own
cluster
communities
cluster
in
our
local
system.
So
please
ensure
that
docker
desktop
is
running
in
your
system.
So
let's
check
that
out.
B
To
check
the
docker
is
running
or
not,
we
need
to
run
the
command
docker
ps
and
we
get
a
empty
list.
That
means
no
docker
container
is
currently
running,
so
we
once
all
these
components
are
installed.
We
are
ready
for
a
local
deployment
of
local
communities
cluster,
so
ensure
we
have
also
ensured
that
docker
is
running
in
our
system.
After
this
we
need
a
simple
configuration
file
that
is
kind
dot
config.yml
file,
so
this
is
a
configuration
file
in
which
we'll
specify
few
of
the
small
things
to
create
our
kubernetes
cluster.
B
So
this
is
the
configuration
file
here
in
this.
We
are
specifying
the
kind
as
cluster.
So
this
is
a
cluster
configuration
and
the
api
version
that
we
have
to
follow,
so
it
is
like
kind
dot,
kx,
dot,
io,
slash,
v1,
alpha
4.
So
this
is
the
version
of
the
kind
cluster
that
we
are
following
and
all
inside
the
notes.
B
We
have
to
specify
the
role
as
control
plane,
and
these
are
few
of
the
extra
port
mappings
that
we
have
done
so
we
are
using
container
port
three
zero,
zero,
eight
zero
and
the
host
port
as
80.
So
this
is
a
port,
so
this
is
optional.
I
have
provided
the
listening,
listen
address.
You
can
also
provide
this,
or
this
is
an
optional
step,
so
you
can
omit
this
by
default.
B
Then
we
have
to
give
the
configuration
so
the
flag,
config,
followed
by
the
name
of
the
file
that
is
kind
of
configured
ml
I'll
hit,
enter
to
run
this
command,
and
we
can
see
that
kind
is
creating
a
node
here,
preparing
nodes
and
writing
the
configuration
starting
control
plane.
We
can
see
the
status
right,
so
our
we
are
getting
the
output
that
cluster
is
being
created.
B
We
need
to
wait
for
some
time.
Okay,
now
we
got
the
response
that
your
cluster
has
been
created
successfully
and
after
this
we
have.
Finally,
we
have
finally
fired
up
our
cluster
kubernetes
cluster.
Now
we
have
a
communities
cluster
running
in
our
system
and
you
can
check
that
by
using
qctl
get
all.
B
Now
that
the
cluster
is
up
and
running
now
we
can
run
the
process
or
deploy
applications
on
the
communities
cluster,
so
we
will
be
deploying
some
simple
web
server
over
our
communities
cluster,
so
communities
describe
all
the
workloads
through
a
simple
ml
file,
so
ml
caller
manifest.
So
in
that
manifest
or
the
ml
file,
we
have
all
the
configuration
to
run
a
deployment
in
a
humanities
cluster,
so
yeah
so
we'll
quickly
create
that
file,
so
that
file
is
known
as
application
underscore
deploy.tml
and
here's
the
file.
B
So
in
this
we
have
defined
the
api
version
as
f
slash
v1,
according
to
the
version
of
our
app
that
we
are
deploying
and
the
kind
is
the
deployment
and
we
can
also
give
the
name.
So
the
name
will
be
kcd
app
and
in
the
spec
we
have
to
specify
a
few
things
like
replicas.
How
many
replicas
do
we
want
like
it
can
be
one
to
as
many
as
you
want
and
also
the
selectors
like.
B
We
have
provided
the
match
label
here
and
also
we
can
provide
a
template
all
the
metadata
and
all
those
things
so
and
the
important
part
here
is
the
spec.
So
here
we
have
to
define
the
container
that
we
want
to
deploy.
So
we
are
deploying
a
nginx
image
inside
our
kubernetes
cluster,
so
we
need
we
can
save
this
configuration
and
now,
let's
go
to
our
terminal
back
and
we'll
write,
qctl
apply,
dash,
f,.
B
B
So
this
is
the
port
that
is
running.
So
this
is
our
kcd
app
and
our
container.
So
we
we
can
check
the
status,
though.
Okay,
though
it
is
still
not
ready,
and
we
can
see
the
status
that
container
creating,
let's
run
cube,
ctl
get
ports
again
and
check
yeah.
Now
you
can
check
the
status,
it
is
ready
now
and
the
status
is
running.
B
So
what
actually
happened?
So
when
you
create
a
deployment
in
kubernetes
there,
you
and
you
also
specify
number
of
replicas
that
we
saw
in
the
configuration
file
yeah.
So
this
is
the
number
of
replicas
that
we
want
to
create
and
you
want
to
set
you
have
already.
We
have
already
set
the
manifest
file,
which
is
this
one,
so
each
replica
copies
the
container
that
are
in
the
spec,
so
we
have
already
defined
the
container
engine
x
and
this
running
instance
is
called
a
pod.
B
Okay,
a
pod
is,
can
have
one
or
more
containers
running
in
a
logical
group
and
also
once
we
init
the
containers,
so
it
runs
a
process
on
each
part.
So
in
this
instance,
if
we
are
running
a
nginx
of
our
own
inside
the
quantities
cluster,
so
one
is
enough,
so
we
don't
need
more
of
them,
so
you
can
write,
cube,
ctl,
cube,
ctl
logs,
and
you
can
paste
this
name
here
to
check
the
logs.
So
here
we
got
the
logs
from
our
node,
so
these
are
few
of
the
logs.
B
So
to
do
that,
we
have
to
make
a
service
in
that
we
can
directly
pass
the
request
to
the
pods
in
where
the
inside
the
container,
where
it
is
running.
So
to
do
that
we
have
to
make
some
changes
in
the
configuration
file,
so
this
is
called
exposing
expose
the
service.
So
the
service
will
be
export
and
that
can
be
accessible
through
a
port
in
the
local
system.
So
we
need
to
make
some
changes
here.
B
B
Now
we
can,
you
can
see
the
age
here,
so
this
means
that
the
deployment
is
updated
here
with
the
new
configuration
once
we
have
made
the
changes
in
the
configuration
of
our
app.
Now
we
have
to
create
a
service
through
which
our
which
will
be
running
in
the
unity's
cluster
through
which
we
can
expose
our
port
and
a
user
can
interact
with
the
application
of
the
web
server.
So
for
doing
that,
we
have
to
create
a
service.
B
In
order
to
create
a
service,
we
have
to
create
a
again
a
configuration
file
that
is
application,
service,
dot,
eml
file.
So
this
is
the
service.ml
file
in
which
we
have
given
the
api
version
as
v1,
and
the
kind
is
the
service.
So
here
we
have
given
service
the
name
that
can
be
kcd
service
because
our
app
is
kcd
app.
So
we
have
given
the
name
convention
for
the
name
convention
as
kcd
service
and
then
in
the
spec.
B
So
this
is
fine,
and
here
we
have
given
the
selector
as
kcd
app
and
the
pro
protocol
that
should
be
followed
is
tcp
and
the
target
port
is
8080,
because
we
have
already
export
exposed
that
in
the
app
configuration
file
and
also
the
port
or
the
docker
port,
that
is
running,
which
is
this
one.
We
can
save
this
configuration
file
and
let's
apply
this
again
so
qctl
apply
dash
f
and
the
application
deployment.tml.
B
B
Services
yeah,
so
this
is
this:
is
the
kcd
service
that
we
have
created
now,
which
is
of
the
type
notepad,
and
this
is
the
default
kubernetes
service
that
is
running.
So
this
is
the
kcd
service
that
we
have
created
just
now.
Now,
let's
check
in
our
browser,
we'll
go
to
the
browser
and
check
localhost.
B
And
we
can
see
welcome
to
nginx,
so
our
nginx
server
is
running.
Now
we
at
the
localhost.
We
can
see
that
we
have
an
engine
x,
deployment
up
and
running,
but
now
what
now?
We
want
a
custom
page
of
our
own
design
right
so
for
doing
that,
these
we
are
creating
a
resource.
So
these
resources
are
useful
for
passing,
config
files
to
process
ins
running
inside
the
port.
So
for
our
instance
like
we
have
to
transfer
a
index.html
file
inside
our
nginx,
so
in
nginx
the
static
files
are
inside
slash
user.
B
B
B
Now,
once
you
have
created
the
config
map
after
creating
a
config
map,
we
have
to
make
some
changes
in
the
application
underscore
deploy.ml
here.
So
in
previous
step,
we
wrote
it
here.
We
have
specified
the
container.
So
after
specifying
the
containers,
we
have
to
write
volume
mounts
in
volume
modes.
We
have
to
give
the
name
as
we
can
give.
The
name
like
I
have
given
here:
html
content
and
the
mount
path.
So
this
mount
path
is
a
path
inside
our
pod
or
the
container,
where
exactly
our
static
files
will
be
so
that
is.
B
This
is
the
path
for
which
nginx
uses
to
read
file
from
so
the
read-only
is
true
and
we
also
have
to
provide
the
volume.
So
so
the
volume
we
can
give
the
name
as
html
content
and
the
config
map
that
we
created
in
the
previous
step.
So
config
map
we
have
provided
here
is
index.html.
We
can
save
this
configuration
go
back
to
our
terminal
and
I'll
run.
The
command
cube,
ctl,
apply,
dash,
f
and
followed
by
the
configuration
file.