►
From YouTube: Microservices and containerization - Ratko Cosic
Description
Using microservices is not necessary for containerization. Still, if you use them right, you will get the most benefits of putting release into a scalable, portable, agile, reliable, and isolated environment. Find out how we use them in building our solutions.
Speaker:
Ratko Cosic
My name is Ratko Cosic and I am a senior developer in Ekobit. I have been leading or contributed to the development of different IT solutions, from accounting, communication, and manufacturing systems. Lecturer and IT researcher in spare time, and a proud father to three kids.
A
Hello,
everyone
welcome,
on
behalf
of
dot
net
foundation
and
bella
beat
user
group,
so
bellabeat
is
actually
one
small
user
group
from
hexagona.
We
have
more
or
less
regular
meetups,
mostly
mostly
regarding
microsoft,
technologies
and
yeah.
We
have
some
interesting
tests
here
and
then,
usually
we
do
these
sessions
live,
but
of
course
the
situation
is
how
it
is
at
the
moment.
So
yeah
we'll
have
an
online
session
now
and
with
us.
We
had.
We
have
our
friend
ratco
from
croatia,
which.
B
A
A
And
then
want
to
ask
some
questions,
etc.
So,
without
further
ado,
let's
just
go
to
two
slides,
so
we
are
doing
this
in
cooperation
with
dotted
foundation,
virtual
user
group
and
yeah.
That
foundation
has
provided
us
with
this
stream
and
all
the
technical
help
needed
for
this,
and
you
can
yeah
you
can
join
you.
Can
you
can
follow
other
events?
There
are
many
events
currently
and
most
of
them
are
online
and
at
the
end,
yeah
this.
B
So,
thank
you
amiroslav.
Thank
you
yelena
for
this
kind
introduction.
Yes,
why
not?
Let's
begin
so.
My
name
is
radka
chosich.
I
work
for
ekubit
as
a
software
developer
and
software
engineer,
senior
and
software
architect,
and
today
I
will
speak
about
microservices
and
containerization,
and
I
thought
about
how
to
present
it,
because
there
are
a
lot
of
topics
today
to
cover,
but
just
in
a
nutshell,
it
would
be
an
introduction
to
building
so-called
cloud
native
applications.
B
B
B
We
will
see
some
of
the
development
tools
for
containerization
at
your
disposal,
we'll
see
how
differ
monolithic
to
the
microservices
approach
to
containerization,
give
a
little
bit
intro
kubernetes.
That
is
definitely
quite
famous
and
later
on.
We
will
move
to
the
devops
workflow
and
I
will
present
you
some
of
the
things
you
can
use
on
the
azure.
B
So,
let's
begin
this
is,
let's
say,
a
canonical
picture
about
what
we
have
as
a
docker
as
if
we
use
the
docker
provider
to
be
that
one
application
be
containerized.
Of
course
we
could
use
some
other
things
like
windows
container,
but
docker
is,
of
course
the
most
popular
docker
is
open
source
project.
It
definitely
used
some
of
other
paradigms
that
virtual
machines
and
hyper-v
etc.
B
I
will
not
go
into
the
details,
but
probably
use
you've
heard
that
that
it's
docker
and
containerization
has
a
lot
of
benefits
that
allows
us
to
build
and
develop
applications
in
isolated
manner
in
containerization
manner.
Regardless
of
the
operating
system
we
use,
albeit
windows,
linux
or
macos,
and
in
docker.
B
The
host
has
everything
that
is
needed,
including
the
infrastructure
in
the
os,
and
the
container
engine
actually
keeps
this
container
and
containers
is
isolated,
but
they
share
the
same
base,
infrastructure
and
operating
system
kernel
et
cetera,
et
cetera.
So
the
first
thing
and
the
first
term
is
container.
What
is
the
container
container
is
actually
a
package
with
all
of
these
things
that
that
application
is
built.
B
So
definitely
that
approach
has
a
lot
of
benefits,
because
it's
benefits
that
differs
between
using
the
application
like
it
is
in
the
process,
because
it
uses
a
scaling
mechanism.
We
can
scale
the
instances
a
container
very
easily,
far
faster
than
and
easier
than,
the
traditional,
vms
or
or
or
services.
B
Here
we
are
touching
only
the
tips
of
the
benefits
and
yes,
but
we
have
to
start
with
something.
So,
let's
begin
with
something,
I
will
show
you
what
you
can
have
and
use
on
your
desktop
to
create
and
start
with
the
with
the
docker.
So
what
I'm
now
having?
I
don't
know
if
you
see
me
see
my
fonts
and
I
using
visual
studio
code
just
for
the
terminal
sake
for
now
and
I'm
have.
B
Let's
say
I
will
run
one
exemplary
container
that
is
available
from
docker
hub.
That
is
just
testing
whether
we
have
everything
installed.
So
it's
it's
run
everything
from
okay,
we'll
not
we
didn't
see
anything
yet,
but
let's
pull
the
image
from
the
docker
hub.
So
it's
public
registry
with
some
exemplary
code,
so
I
will
use
a
docker
run
command
that
will
run
the
container.
For
me,
I
will
use
my
ports.
You
will
see
shortly
why
it
is
important
for
now
just
pay
attention.
B
B
Okay
and
nothing
happens.
Okay,
let's
see
what
we
can
do
and
that
can
be
what
we
can
see
from
the
docker
ui.
Hopefully
we
we
will
trigger
that.
Yes,
you
can
see
here,
I'm
running
the
docker
windows
and
you
can
see
that
I'm
starter
before
this
hello
world
container.
So
it's
it's
gone.
It's
not
active,
but
this
is
active
because
I
just
run
it
and
what
is
great,
that
I
can
control
it
and
just
click
in
there
and
see
the
logs
for
that.
I
can
inspect
the
environment,
see
some
stats.
B
B
What
I
can
do
now.
I
can
just
stop
it
and
okay:
let's,
let's
see
the
containers
once
again,
okay
and
you
can
see
I'm
having
one
run
already.
I
will
just
try
to
wipe
it
out
from
the
docker
by
just
providing
the
id
and
when
I
refresh
the
window
view
can
assume
what
will
happen.
So
no
nothing
is
there
so
that
actually
presents
the
way
the
docker
is
handling
containers.
So
it's
totally
isolated
environment
and
it's
run
when
it's
run.
So
it's
everything
they're
packed.
B
B
Okay
and
let's
see
our
windows
docker
and
you
can
see,
we
have
three
containers
each
actually
originated
from
the
same
image,
so
we
can
also
browse
it
and
yes
see
once
again
that
each
of
that
containers
really
works
so
and
of
course,
if
we
kill
it,
we
will
just
steal
everything.
So
all
the
processes
and
that's
okay.
For
now,
I
could
also
kill
the
images
there
just
to
make
myself
tidy
I'm
using
a
lot
of
things
on
local
okay.
B
B
It's
a
little
bit
slow
there!
Sorry
about
that!
Okay,
okay!
I
will
just
put
some
name
there,
and
what
is
important
to
see
is
this
option
is
the
enabling
of
docker
support.
Of
course
I
have
to
have
it
install
docker
desktop.
As
I
pointed
out,
I
will
choose
the
container.
Let's
say
it's
linux
and
that's
it.
So
we
will
create
a
project
in
visual
studio,
let's
see
how
it
is
looks
like
and
we
will
see
what
will
we
have
with
the
increased
productivity
for
using
the
docker
okay.
B
Okay,
okay,
the
first
thing:
what
I'm
actually
very
fond
of,
is
this
instructory
page
that
you
can
see
the
important
links
and
docus
for
the
using
of
the
docker
inside
the
dotnet
core,
that's
cool,
and
yes,
you
can
also
see
here.
I
don't
know
if
this
is
viewable
by
you.
It
may
be
too
small,
but
something
is
going
on
in
the
in
the
background.
So
we
will
see
what
is
going
on.
Okay,
so
the
visual
studio
for
us
adds
one
special
file.
B
It's
called
docker
file
that
actually
specified
the
manifest
or
the
way
docker
will
build
our
image
from
so
to
build
our
container.
So
we
seen
our
one
hello
world
example
that
is
pre-built,
but
of
course
we
want
to
build
our
own
application,
and
this
is
the
these
are
the
instructions
that
docker
will
use
to
build
our
image,
so
it
will
use
some
pre
existing
image
to
build
upon.
B
So
it's
automatically
built-
and
you
can
see
here
that
this
default
startup
is
changed
from
the
is
express
to
docker
and
if
we
click
on
it,
so
we'll
start
the
docker
container
so
that
let's
see
how
what
is
happening
here
so
visual
studio
already
done
this
job.
Okay,
and
we
will
start
that
you
see
the
red
and
then
the
green
one.
It
is
running
and
it
will
soon
open
the
browser
for
us,
as
always
so
nothing
new.
But
it's
already
running
this.
This
container
is
already
running
it's
kind
of
slow
on
my
side.
B
Sorry
about
that,
and
also
it's
an
interesting
thing
that
we
can
see
so
here.
It
is
nothing
special
just
hello
world
for
now
that
the
container
of
our
application
is
working,
and
we
can
also
see
other
containers
as
well
and
also
with
all
images
that
are
provided
by
us
and
be
pulled
from
before.
I
pulled
a
lot
of
stuff,
as
you
can
see,
and
also
by
the
origin,
for
example,
from
the
docker
hub
from
the
microsoft
for
my
ac
air,
on
something
like
that.
B
B
This
is
the
one
that
we
could
already
have
with
the
vm
scale
sets
with
the
typical
deployment
in
the
azure
app
services
because
they
are
run,
they
could
run
a
monolithic
application
and
they
easily
can
create
instances
without
having
to
manage
vms.
So
there
we
have
already
some
kind
of
advancement
to
the
just
provisioning
fix
so
fixing
provisioning
of
the
of
the
instances
of
our
services.
B
Yes,
in
a
more
let's
say,
microservices
approach,
there
are
a
lot
of
changes,
as
you
can
see
from
the
from
the
diagram
here.
On
the
left
side,
a
traditional
monolith
has
everything
in
one
container
and
that's
about
it.
So
we
just
can
scale
by
the
cloning
of
the
app
to
multiple
vms,
multiple
containers
and
that's
it
though
scaling
is
actually
like
in
in
the
microservices
architecture.
That
is
benefit
is
actually
don't.
B
B
For
example,
if
you
have
some
database
that
will
be
contained,
because
this
is
the
main
database
or
the
message
broker
like
rabbit,
mq
or
or
service
bus
like,
or
we
have
some
kind
of
blob
storage,
redis
cash
or
some
other
stuff
that
are
actually
quite
necessary
to
be
installed
and
deployed
together.
Alongside
with
the
microservice
as
a
sidecar,
we
have
to
have
it
on
the
one
host,
but
we
will
have
a
different
host
so
definitely
need
approach
from
other
perspective
as
well.
B
So
let's
go
forward
and
see
what
actually
visual
studio
can
also
offer
us.
In
that
sense,
I
will
now
shut
down
our
docker
just
see.
What's
going
on
there
also
one
neat
thing:
when
I
close
my
visual
studio,
it
will
eventually,
you
know,
kill
the
process
and
it's
everything
is
clear.
That's
that's
love
about
about
the
visual
studio
and
how
it
manages
the
processes
and
docker
containers.
It's
great.
B
So
once
again,
I'm
opening
the
visual
studio,
I'm
opening
now
my
simple
solution.
It's
it's
really
rather
simple.
I
would
I
didn't
go
into
detail
to
providing
you
know
the
fully
fledged
microservice
architecture,
but
just
imagine
what
it
could
have
and
it
will
be
architect.
The
most
parts
for
containers
will
be
presented.
You
will
be
introduced
shortly.
B
It
has
docker
files,
so
nothing
special
about
it.
It's
more
or
less
the
same
that
we've
seen
before.
So
it's
building
so
restoring
building
and
publishing
thing
so
our
container
we
already
have.
But
yes,
this
is
the
microservices,
so
we
also
have
have
to
have
a
way
to
link
and
build
other
containers
that
are
necessary
for
our
micro
service
as
well,
and
actually
I've
done
it
throughout
the
docker
compose,
and
that
is
the
another
option
that
we
could
pick.
Unfortunately,
it's
not
seen
there
because
I
ordered
big
one.
B
You
can
only
see
the
the
another
one
that
I
didn't
pick.
That
is
helm
and
kubernetes
combination.
There
is
also
one
another
and
that
I
actually
picked
and
that
is
called
docker
compose
docker
compose.
Actually
it's
it's
still
docker
functionality
and
it
actually
compose
the
docker
images
and
put
it
in
the
containers
that
are
actually
hosted
in
one
physical
unit
and
that
is
called
the
host.
So
this
host
actually
as
a
group
of
containers
pack
it
all
together
and
provide
it,
run
it
in
one
insulated
environment,
and
that
is
neat
for
microservices.
B
Definitely,
a
visual
studio
that
I
don't
go.
You
know
manually
everything
I
just
use
visual
studio
actually
creates
herself
this
special
folder
and
presents
us
with
the
docker
compose
yaml.
I
don't
know
about
the
yaml.
It's
used
widely.
I
think
it
does
azure
devops
or
other
things
in
business
application,
because
because
it's
very
human
readable-
and
if
you
see
that-
and
actually
it's
also
manifest-
but
now
we
are
talking
about
a
multiple
containers,
so
multiple
images
that
will
be
built
and
then
upon
instances
as
containers
and
first
one
that
we
already
seen
is
our
application.
B
So
our
application
is
presented
with
the
name.
It
has
an
image
that
is
built
upon
and
that
is
actually
the
docker
file
builds
this
image.
For
us
this
is
the
docker
file
that
builds
it.
It
has
some
context,
that
is
the
folder
of
our
service,
and
it
will
build
the
image
tag
it
for
us,
but
it
also
on
addition,
has
dependencies
on
other
containers
that
I
actually
built
from
the
pre-built
images
found
on
docker
hub.
So
it's
publicly
available,
I'm
using
the
azurite
here.
Azeret
is
great
tool
for
simulating
the
azure
storage.
B
B
So,
in
the
in
even
bus
paradigm,
we
are
using
message
brokers
for
communication
throughout
our
microservices
and
we
we
are
using,
of
course,
in
the
enterprise
grade
azure
service
bus,
but
for
the
controllers
locally
we
just
can
use
some
other
message
broker
at
like
rambit
mq,
so
that
did
that's
about
it
and
if
you
pay
attention
to
this
small
ones,
that
is
something
is
building.
You
know
something
fish
is
going
around
there
that
I'm
talking
between.
B
So
actually
you
can
see
that
visual
studio
in
the
background
runs
the
docker
compose
command
and
provides
this
yaml
file
for
us
and
also
one
another
yaml
file.
That
is
actually
the
configuration
as
we
can
have
our
standard
app
settings
configuration
per
and
per
environment.
Let's
say
development,
qa
testing
stages.
We
also
can
have
the
environments
so
set
through
out
the
environment.
So
I
have
this
on
development.
That's
that's
the
default
one!
The
override-
and
I
have
this
my
environment.
I
will
not
present
it
with
the
whole
key.
B
That's
that's
the
key
that
they
are
using,
but
with
the
ports
open
for
this
container.
So
without
further
ado,
let's
run
it
and
let's,
let's
see
what
is
happening
on
the
docker
windows,
okay,
build
is
succeeded
and
we
are.
We
will
also
be
presented
shortly
with
the
browser
and
that
will
actually
trigger
our
web
api
here.
It
is
so
that
that's
our
application.
B
Basically,
but
what
is
interesting
that
this?
This
is
not
our
the
container.
This
is
just
the
host
that
is
marked
with
the
id,
and
if
we
expand
it,
we
will
see
four
containers
there
all
running
separately,
but
bound
together
with
the
composing
and,
yes,
we
can
see
it
in
action.
So
as
I
see
it
here,
it's
it's
running
that
one.
I
also
can
see
the
okay
that's
running,
but
I
just
cannot
access
it
through
the
http.
B
So
it's
okay
and,
let's
see,
for
example,
rabbit
you
can
see
it's
running,
so
it's
it's
rabbit,
mq
server
running
on
the
container,
so
we
can
play
around
with
it,
of
course,
configure
it
to
the
development
that
the
ports
are
visible
and
you
can
see
the
ports
there.
It's
configured
on
this
compose
file
and
our
micro
service
actually
works
on
a
development
machine.
B
So,
let's
yes,
also
one
thing:
that's
maybe
kind
of
neat
is
visual
studio.
We
don't
need
to
always
open
the
docker
windows
it
doesn't
need
to
be.
We
can
also
see
solution,
containers
and
all
other
containers
that
are
coupled
with
our
containers,
with
our
running
container
and,
for
example,
for
rabbit.
We
can
see
the
settings
that
it
has.
We
had
seen
the
open
ports,
as
you
can
see:
15
000,
also
the
logs
and
especially
the
files.
B
B
So
what
does
it
mean
in
terms
of
the
deployment
you
could
pre
foreseen,
how
we
will
use
these
containers,
so
our
images
and
containers
later
on
and
to
to
deploy
that
in
some
environment
we
could
use
a
simple
docker
host
environment
with
the
docker
compose
task
on
our
devops
to
effectively
deploy
everything.
So
this
host
that
I
showed
you
on
different
stages
and
that's
that
is
simplistic
way
for
doing
that.
There
is
no
harm
done
to
do
that.
B
B
Far
more
sorry
about
that,
rather
than
just
putting
all
together
these
containers,
you
know
in
a
set
in
one
host
because
for
the
microservices,
especially,
we
want
to
have
a
control.
What
is
going
on
with
the
life
cycle
of
our
containers,
because
we
want
to
offer
something
like
a
handling
the
scalability
handling,
handling
the
the
failover
and
re
restarting
the
the
services
when
everything
is
wrong,
making
the
health
check.
So
what
is
called
observability
of
the
our
services
for
for
doing
that?
B
B
So
kubernetes
is
open
source
technology
for
automating
our
deployment
for
scaling
for
management
of
containerized
application
it
she
actually
started
in
12
and
15,
and
in
this
four
or
five
years
it's
getting
traction.
Definitely
it's!
I
think
it
has
a
lot
of
community
support
and
more,
I
think,
one
of
the
larger
competitors
support
on
the
github
and
because
of
its
nature,
it's
definitely
necessary
needed
for
our
scenarios.
On
on
the
cloud
native
applications,
I
will
not
go
into
the
very
a
very
deep
understanding
the
kubernetes.
B
What
is
important
for
today
for
now
is
to
cover
is
that
we
have
some
kind
of
terminology
in
stake
and
how
it
works.
So
it
has
a
so-called
kubernetes
cluster
that
actually
consists
of
set
of
working
machines.
That
is,
that
are
called
nodes.
Nodes
are
the
things
that
actually
lifts
the
pods
and
the
pods
are
the
worker
nodes,
sorry,
the
the
components
and
the
unit
of
the
deployment,
let's
say
deployment
unit
pods
pods
actually
contains
container,
and
that
is
the
the
most
important
unit
for
the
deployment
and
the
control
plane.
B
So
the
control
node
actually
controls
every
other
nodes
that
are
called
worker
nodes.
So
actually
it
spawns
nodes
and
control
them,
and
we
can
see
we
can
control
it
by
the
command
line,
tool
called
cubic
steel
and
we
can
control
it
with
the
dashboard
and
every
everything
about
the
management
of
the
of
the
nodes
is
done
from
the
control
plane.
B
B
Deployment
is
also
the
thing
maybe
to
understand.
Deployment
is
like
in
yaml,
something
that
is
as
a
menace
with
the
dispre
description
of
the
deployment
itself,
and
the
service
is
also
very
important
to
distinguish
it.
The
service
is
something
that
we
will
use
by,
so
we
will
use
or
the
clients
will
use
from
the
outside.
B
It
has
a
static
network
location,
it
has
its
ports
so
exposed
boards,
and
it
also
acts
like
an
load
balancer,
so
it
actually
goes
through
the
nodes
and
picks
the
ones
that
that
is
needed,
etc.
So
it's
it
acts
like
something
like
api
gateway
pattern
if
you're
familiar
with
the
microservices
patterns,
so
I
know
it's
it's
kind
of
tricky
to
present
it
in
in
one
slide,
but
this
is
the
basic,
the
kubernetes.
B
B
B
And
yes
before
that,
I'm
having
the
kubernetes
here
locally,
because
luckily
docker
has
the
option
the
feature
from
the
the
newest
versions
to
enable
the
kubernetes
locally
in
the
deploy
development
machine?
That's
that's
kind
of
great
because
we
could
have.
We
could
use
some
other
tool
like
a
mini,
cube
or
cetera,
but
it's
I
think,
it's
practical
that
we
use
kubernetes
outside
the
docker
and
what
it
actually
does.
It's
actually
kubernetes
in
the
docker
more
or
less
it
packs
the
containers
together
in
the
node.
B
B
Environment
and
what
is
going
on
in
our
local
kubernetes,
we
can
see,
we
have
two
contexts.
One
is
the
default
one,
and
this
is
more
or
less.
We
can
have
it
more
or
less
something
like
namespace
in
the
orchestrator,
we'll
just
use
the
default
one
just
to
see
what
we
have
so,
let's
see
do
we
have
some
nodes?
Okay,
we
don't
have
anything
except
the
master,
so
we
have
also,
let's
see
the
deployments-
okay,
nothing
there.
So
we
have.
B
Let
me
let's
see
services,
okay,
nothing,
but
the
system,
one
so
pods,
sorry,
pods,
okay,
so
nothing
there.
So
we
are
clear:
okay
and
okay.
Let's,
let's
see
how
we
will
build
upon
one
very,
very
simple,
kubernetes
environment.
I
will
use
now
this
one.
This
is
really
really
small
one
to
present
you,
the
structure
of
our
structure
of
our
kubernetes,
manifest
file.
That
is
called.
B
That
is
also
yaml
file
like
the
docker
ones,
but
it's
quite
different
because
they
it
has
a
different
syntax.
First,
one
that
you
will
discover
it
has
some
blocks
that
has
some
kind
of
kind,
no
punitive.
So
in
the
kind
is
the
type
of
the
container
that
will
build
so
the
service
and
deployment.
Let's
switch
to
the
sorry,
I
will
try
to
switch
back
okay
to
this
picture
that
you
know
so.
The
low
balancer
is
the
service
that
is
the
service
node
and
the
worker
now
is
the
deployment.
B
So
the
service
is
something
outside
and
it
has
different
ports
there
wise
different
parts,
because
ports
also
can
communicate
with
each
other,
as
you
can
see
from
the
docker
compose
before
so,
containers
also
can
communicate
internally,
so
also
the
the
deployments,
so
the
nodes
could
communicate
with
each
other
and
also
what
is
more
important
for
us,
of
course,
for
the
low
balancing
is
how
we
will
access
it
outside
the
cluster.
So,
for
example,
inside
the
body
it
will
be
communicated
with
the
at
port.
B
Then
inside
the
cluster
with
8080
and
30
000
one
will
be
our
outside
port
for
my
service
and
that's
that's
just
the
service
and
it
will
select,
and
that
is
some
kind.
Like
a
query.
Let's
say
that
we'll
see
what
is
going
on
sorry,
that
will
actually
pick
the
right
deployment
for
us
to
root
the
calls-
and
this
is
our
simple
deployment.
B
It
has
some
version.
It
has
a
name-
and
that's
that's
kind
of
important
information
here
and
there
are
these
are
replicas,
so
that
is
actually
how
many
pods
we
will
spawn
on
our
node
to
be
resilient,
so
we
could
just
spawn
as
we
can
we
seen
from
before
this.
We
used
three
docker
containers
that
are
all
the
same,
so
why
we
do
use
it
here,
okay
and
that's
it
so
we
label
it
somewhere
and
also
this
one.
B
So
we
need,
of
course,
the
image
to
build
upon,
so
this
image
is
also
available
to
the
docker
hub.
So
I
will
just
use
this
use
this
one.
Sorry
about
that
switch.
You
will.
I
will
just
use
this
one
to
the
to
building
the
our
first
kubernetes
deployment.
How
will
I
do
that?
I
will
create
the
deployment
with
this
file.
Hello,
deployment.
B
B
B
I
have
to
authenticate
to
my
local
one
and
I
will
just
okay.
It
has
some
quirks,
you
know,
but
it
hurts
physically.
Technically
it
works
so
from
the
dashboard
of
the
kubernetes.
You
can
see
here,
it's
it's
local
one.
We
have
one
service
and
this
service.
We
can
also
click
on
that
or
click
on
the
pods.
That's
it's
the
same,
and
here
we
have
the
information
about
our
service.
B
The
text
like
load
balancer-
and
this
is
the
most
important
one,
the
external
endpoints
to
which
we
actually
will
access
all
of
our
containers
from
there,
and
here
are
the
pots.
So
let's
see
that-
and
you
can
see
here-
we
are
having
our
pots
ready.
This
is
one
of
the
parts
that
is
actually
spawn,
and
that
is
the
the
nice
part
of
that.
It's
sorry
about
that.
I
also
already
switched
to
to
my
slides.
Once
again.
I
don't
know
why
it's
happening.
B
B
But
you
have
to
trust
me
on
that.
Yes,
you
can
see
it.
It's
changed
why
it's
changed,
because
it's
really
load
balancing.
So
you
know
it's.
It
came
from
the
f8
and
we
just
trigger
a
lot
of
lot
of
requests
in
one
second
and
service
actually
started
so
route.
The
calls
to
other
ports.
So
that's
actually
what
the
orchestration
is
all
about.
B
What
will
our
service
say?
Okay,
you
have
now
seven
parts
how
many
seconds
it
will
pass.
I
don't
know
I
think
in
a
second,
we
just
spawn
a
couple
of
parts
more,
but
what
we
could
do
we
could
just
delete
the
part,
but
what
is
happening
actually,
the
container
and
service
the
container
the
kubernetes
actually
doesn't.
Allow
us
that
we
don't
have
seven
replicas.
We
will
have
six,
but
it's
actually
automated
automatic
to
creating
one
more
that
the
whole
number
is
seven.
B
So
every
one
every
every
time
there
are
seven
parts
and
that's
that's
kind
of
that's
kind
of
cool
okay
and
we
will
just
change
it
to
one.
Let's
wipe
it
out
a
little
bit
and
just
let's
see
see
how
how
many,
how
how
much
time
it
uses.
You
know
it's
just
creating
removing
that.
And
yes,
it's
done
so
it's
gone.
B
B
B
This
is
a
similar
deployment
to
this
one,
but
the
the
main
reason
they
want
to
show
you
is
that
we
actually
rebuild
it
and
pull
it
on
the
I
don't.
I
will
not
do
that
because
it
takes
some
time
for
doing
that,
but
it's
actually
pulled
on
the
docker
and
let's
see
it
where
it
is
it's
on
the
I
have
it
somewhere,
sorry
territory.
B
So
let's
see
it.
This
is
my
account
on
the
docker
and
yes,
this
is
the
one
and
I've
created
and
pulled
the
image
that
I
built
on
the
docker
by
using
visual
studio
and
it's
there
in
stack
and
it
is
tagged
with
v1.0,
so
it's
available
there.
So
I
can
just
use
that
image
to
build
upon
my
develop
deployment
routine.
So
everything
is
the
same
or
similar.
I
will
just
point
from
my
docker
hub
image,
so
what
is
important
devastate
to
to
know?
B
B
B
There
microservices
service
is
called
okay,
and
this
is
yes,
I'm
pushing
the
image.
Maybe
I
will
use
our
local,
I
mean
I'll
already
push
it,
it
has
a
cache,
so
it
will
not
last
so
long.
So
I
will
just
now
I
have
everything
now
prepared.
I
will
just
create
another
deployment.
It's
called
I'm
calling
you
local
deployment,
yaml
file,
okay
and
yes,
the
service
and
deployments
are
created.
B
So
let's
see
that,
let's
see
that
here
I
will
close
that
one
and
see
our
services
here
and
you
can
see
it's
there.
Why
it's
this
this
time?
It's
it's
not
it's
progressing,
because
it
takes
some
time
to
kubernetes
to
to
build
this
infrastructure,
to
pull
the
image
by
itself
by
make
it
construction
both
of
the
deployment,
pod
and
the
services.
B
B
B
B
B
So
enough
with
the
local
stuff,
let's
base
now
our
talks,
our
discussion
about
the
deployment
process-
and
this
is
the
let's
say,
canonical
in
a
router
loop
workflow
for
the
devops
process
in
azure
by
microsoft.
So
what
we
will
use
in
this
blue
box
we
actually
now
passed,
and
that
is
the
combination
of
the
visual
studio
or
code
with
the
local
aks
dev
cluster.
Just
to
mention
we
also
can
use
docker
with
kubernetes,
but
not
with
the
docker
hub.
We
can
use
it
with
azure
container
registry,
so
we
will.
B
We
could
also
prepare
everything
as
much
as
we
can
to
make
this
migration
fit
to
the
devops
pipeline.
So
in
the
inner
loop
we
do
the
things
as
we
now
pres
now
presented,
and
then
we
are
tested
and
debug
everything
and
everything
is
done.
We
actually
push
the
code
on
the
github
more
or
less
git
flow,
something
like
that
and
we
are
entering
on
the
cicd
process.
So
we
develop
and
test
kubernetes
definitely
easy
with
this
local
local
manner,
but
definitely
we
have
to
deploy
it
somewhere
that
customer
needs.
B
So,
firstly,
we
will
build
the
pipelines,
but
then
we
will
include
the
building
of
the
images
pushing
and
everything
on
the
container
on
the
ac
air
are,
and
this
will
be
used
something
similar.
I
I
hope
you
use
already
as
your
devops
and
some
similar
techniques
to
actually
build
the
artifacts
or
nuget
packages
or
feeds
or
something
that
will
be
important
and
necessary
to
be
used
on
the
release
pipelines
as
well.
B
Yes,
we
could
deploy
it
on
the
aks,
but
also
on
the
interim.
We
could
just
deploy
it
on
the
provisions,
resources.
That
is
also
the
option,
maybe
a
simplest
one
for
the
migration.
That's
that's,
maybe
easiest
way.
Okay,
let's
see
this
outer
loop,
so
the
larger
scope
of
our
discussion
that
includes
the
ci
cd
and
is
acr.
B
B
We
already
done
that
and,
for
example,
we
can
see
that
I
have
only
one
stage
for
this
purpose
just
to
test
it
and
if
you
can
see
on
the
pipeline,
the
release
actually
is
triggered
by
the
by
by
the
billing
of
the
pipeline,
and
then
the
test
stage
runs
with
the
app
service,
deploy,
that's
kind
of
let's
say,
standard
way
that
that
is
deployed.
What
we
could
do
with
the
containers
is
the
first
approach
that
I
showed
you
before
is
building
the
docker
image.
B
So
we
also
have
a
special
azure
devops
test
for
doing
that,
so
it's
docker.
Of
course
we
can
have.
We
can
use
the
bill
images
and
then
we
already
then
specify
the
container
where
we
will
put
it.
So
we
will
put
on
the
azure
container
registry
on
on
this
subscription
and
we
will
specify
the
resource
on
the
azure,
actually
the
container
registry
itself,
and
we
will
build
the
image
with
the
docker
file.
We
will
also
push
it
more
or
less
the
same
here
and
we
will.
B
B
So
whenever
we
build
the
new
container
for
the
acr,
it
will
be
triggered
and
then
for
the
latest
version
only
and
then
we
will
proceed
with
the
deployment
and
it's
already
also
here,
provisioning
on
the
exact
provision,
resources
and
that
is
azure
app
service.
So,
as
I
said,
it
could
be,
it
could
be
deployed
on
the
kubernetes,
but
also
we
we
could
use
as
an
interim
step
and
actually
we
are
using
that
approach
because,
as
you
know,
microservices
approach
architecture
is
anyway
evolutionary
step
there.
B
There
are
a
lot
of
lot
of
things
around,
so
it's
it's
not
a
easy
way
to
migrate
to
all
of
these
concepts.
So
we
we
are
using,
firstly,
containers
as
introduction
and
then
put
it
everything
on
the
sacr
and
then
still
deployed
on
the
resources
that
we
fixed
help
and
then
move
to
the
kubernetes.
That's
maybe
a
more
less
you
know
steep
spot
to
do
devs
and
the
next
also
thing
that
we
could
use
one
variant
of
the
build
just
to
show
you
is
to
build
upon.
B
Sorry,
sorry,
sorry,
the
wrong
one
to
build
the
images
by
using
the
docker
compose.
So
that's
the
difference
between
the
first
exemplary
application
that
we
just
have
one
docker
files,
one
container
and
the
microservices.
That
actually
has
a
different
containers,
and
here
also
we
are
pushing
everything
we
have
on
the
acr,
but
with
providing
the
docker
compose
yaml
and
then
push
everything
on
the
acr.
B
So
that's
the
way
we
are.
I
I'm
just
presenting
you
the
another
thing
I
want
to
show
you
is
my
azure
portal.
Probably
don't
really
are
familiar
with
it
and
let's
cover
some
things
that
we
have
for
the
containerization
user.
The
first
thing
that
I'm
mentioning
now
lately
is
the
container
registry
container
registry
is
something
like
the
registry
of
the
of
our
images,
pre-built
images.
B
B
So
I
built
one
and
two
so
also
this
hello
world,
of
course,
but
I
built
two
one.
Difference
first
is
throughout
the
container
and
the
second
is
through
the
docker
compose,
so
both
of
them
are
actually
container
images,
and
you
can
see
there
are
a
lot
of
versions
there
and
I
can
just
fetch
so
pull
the
latest
and
I
will
go
to
the
latest
code,
but
we
also
have
here
a
versioning
inversion
information
where
it
is
built,
et
cetera,
et
cetera.
B
What
is
also
good
in
this
sense,
and
I
find
it
also
useful-
it's
already
deployed
in
the
escr,
but
we
also
have
one
layer
that
is
maybe
a
very
practical
to
use
to
test
our
services,
whether
it's
working
and
that
is
actually
container
instances
container
instances
is
nothing
more
than
when
we
grab
the
image
and
create
something
like
that.
We
create
some
provision
resource
like
app
service
or
function,
or
something
like
that,
so
we
can
actually
trigger
from
the
container
registry
one
of
the
repositories
and
just
say:
okay.
B
It
has
an
operating
system
type
it
has
where
it
is
gone
where
it
is
belongs
to
which
containers
is
actually
there.
What
is
happening
so
like
activity
logs
et
cetera,
et
cetera,
and
you
can
connect
it
by
by
kudu
or
something.
But
that's
that's
great
thing
about
that.
You
you
see
this
link,
you
can
see
that
and
go
through
the
link.
B
B
B
Here
it
is
presented
one
of
the
workflow
that
we
could
use.
We
already
passed
through
some
of
the
points.
For
example,
we
are
using
the
visual
studio
or
code
to
push
the
code
through
the
source
code
provider
and
then
control
and
then
trigger
the
devops
operation
that
actually
triggers
our
images
into
the
azure
container
registry,
and
then
we
could
continue-
and
that
is
the
new
one
new
stuff
here
continue
to
provision
the
service
into
the
cluster
and
how
it
is
done.
B
B
B
That
is
quite
also,
let's
say
familiar
with
the
process,
because
the
the
difference
between
the
development
stage
and
testing
stage
and
the
production
would
be
probably
on
the
way
that
the
the
the
resources
are
provisioned
and
take
care.
For
example,
we
we
were
using
rabbit,
mq
or
azurite,
but
definitely
on
the
azure
on
some
production.
We
will
not
use
them,
we
will
use
maybe
as
a
rabbit,
but
we
will
use
maybe
a
rather
azure
service
bus,
because
it's
enterprise
level
grade
people,
use
cosmos,
db,
that
scales
on
the
geo,
location,
etc,
etc.
B
So
we
will
use
other
approaches
and
quality
of
services
that
are
not
necessary
but
necessary
on
the
devops
dev
test
subscription.
But
it's
needed
on
the
production
and,
of
course,
administrator
should
always
be
in
control
to
monitor
the
way
through
the
different
ways
that
and
things
that
we
have
offered
have
been
offered
to
use
on
the
azure.
B
That
is
one
of
the
slides
of
the
the
microsoft
ignites
complements
to
the
microsoft.
Definitely,
but
it's
great
slide,
never
I
mean
and
it
it
actually
explains
what
we
are
now
having
in
microservice,
plus
kubernetes
or
containerization,
offering
on
the
azure.
We
have
a
visual
studio
or
in
our
source
control,
plus
the
azure
container
registry
and
monitoring
on
the
tools.
We
have
a
lot
of
platform
resource
ready
for
us
like
security
for
the
id
policy,
key
volts
that
will
sure
use
for
our
passwords,
etc.
B
But
the
center
part
is
for
sure,
kubernetes
service,
container
instances
and
other
stuff
that
that
makes
the
orchestration
available
and
possible.
There
are
a
lot
of
efforts
on
the
community.
We
will
maybe
enlist
some
of
that
later
on
and
the
later
latest
thing-
sorry,
maybe
I'm
too
exhausting
today,
just
a
few
minutes
more,
I
will
just
quickly
show
you
the
kubernetes
services
it.
B
And
how
it
actually
came
to
the
aks-
that's
maybe
more
important
than
the
the
dealing
with
the
preacher,
as
you
can
see,
I'm
using
both
azure
container
repository
here
that
actually
triggers
that
release
like
before,
but
also
I
have
used
the
build
artifacts
in
combination
to
provide
me
with
a
manifest
file
or
other
file
resources
that
are
necessary
for
building
the
image
and
then
I'm
using
that
command
of
the
cube
ctl.
So
it's
also
a
special
azure
devops
task
that
is
available
for
using
for
the
kubernetes,
and
I
just
triggered
the
apply.
B
So
I
just
apply,
as
I
did,
on
the
command
line.
If
you
remember
and
provide
the
kubernetes
service
connection,
it's
all
secured
through
the
azure
device,
of
course,
and
I
just
trigger
the
apply
with
the
manifest
file
that
I
provided
with
the
build
artifact
and
that's
it
so
it
actually
builds
so
as
a
result
of
this
process.
B
It
actually
built
our
kubernetes
deployment.
Let's
see
that
maybe
have
some
details
there,
you
can
see
it
uses
the
cubic
steel
and
then
uses
the
apply
and
applies
this
lengthy,
yaml
and
yes
finished.
So,
let's
see
that
and
where
it
is.
This
is
the
one
so
cat
service
deployment,
and
we
also
can
see
our
load
balancer,
so
the
services-
and
here
we
can
see
you
can
see
the
cad
service.
That
is
the
service
that
is
load
balancing,
it's
okay,
it's
healthy
and
it
has
the
external
ip
address
that
we
can
browse
and
see
it.
B
How
it
looks
like
I
don't
know
if
I'll,
oh
it's
here,
so
we
can
see
it
in
action
so
and
if
we
can,
we
want
to
play
around
with
it
as
we
did
it
before
we
could
drop
the
pod
and
try
to
spoil
everything
and
the
load,
balancing
or
kubernetes
will
take
care
of
that.
He
could
also
scale
up
scale
down
also
with
the
devops
special
tasks
that
are
provided
with
that
etc.
B
So
a
lot
of
options
to
scaling
to
orchestrating
the
things,
also
from
the
build
bill
image.
Why
why
I
mentioned
that?
Maybe
I'm
maybe
not
confusing
that
it's
great
for,
for
example,
qa
or
or
integration
testing.
We
could
also
use
the
kubernetes
cluster
and
nodes,
for
example,
for
just
triggering
the
integration
tests
for
microservices.
So
we
don't
have
to
have
this.
You
know
fixed
and
all
the
time
active
because
it's
you
know
it
is
not
relevant
and
it's
it's
not.
You
know.
We
just
spend
the
resources
there.
B
What
we
could
do
we
could
apply
and
create
the
deployment
throughout
our
azure
devops
cycle.
So
you
set
up
everything
the
the
low
balancer,
the
parts
and
everything
maybe
run
some
integration
tests
and
everything
is
fine.
We
just
kill
it.
You
know
we
just
scale
it
down
or
or
make
some
suggestion
suggestions.
B
B
One
of
the
instances
instance
of
our
container,
together
with
the
already
deployed
instances,
and
that's
great.
Let's
consider
that
we
have
a
lot
of
microservices
that
are,
let's
say
in
the
test
stage
deployed
on
the
aks,
but
we
have
some
changes
into
our
code
and
that
we
don't
want
to.
You
know,
start
everything
in
in
the
local
or
doing
something
and
this
what
is
great
about
this
is
also
is
isolated
and
it
is
achieved
by
the
a
special
url
that
is
actually
available.
B
We
can
also
use
the
visual
studio
integration-
it's
so
called
bridge
to
kubernetes,
to
allow
this
this
great
productivity
tool
and
for
for
maybe
for
let's
say
for
the
homework
hello
for
next
steps.
I
will
just
mention
a
lot
of
things
is
going
on
on
the
on
the
area
of
the
microservices,
containerization,
etc,
and
one
of
the
things
that
I'm
pretty
interesting
about.
B
I
don't
know
much
about
that,
but
I'm
definitely
interested
in
service
mesh,
because
service
mesh
is
actually
also
in
the
area
of
communicating
with
the
microservices
that
actually
don't
communicate
directly,
but
then
it's
definitely
very
important
to
orchestrate
everything
else.
It's
also
some
of
the
side
car
proxy
patterns
paradigm
that
we
could
use,
and
in
this
also
paradigm,
as
service
mesh,
the
kubernetes
are
definitely
used
for
orchestration
of
our
services.
B
There
are
a
lot
of
topics
to
cover,
as
you
now
can
imagine
like
docker
containerization
kubernetes,
the
offering
that
azure
has
like
azure
kubernetes
services
or
as
your
container
registry
etc,
and
I
use
this
documentation
to
make
it
make
this
session
available.
So
that's
it.
Thank
you
for
your
attention
and
I'm
looking
forward
to
answer
your
question.
If
you
have
any.
A
Thanks
radco
for
a
great
talk,
we
had
several
questions.
Actually
youtube
is
about
15
seconds
late
in
case
for
streaming,
so
we
had.
The
first
question
was
from
dmitry.
Is
it
usually?
Is
it
just
a
regular
docker
desktop
application
that
has
all
of
these
beautiful
images,
containers
list
or
is
a
separate
application,
so.
A
B
B
A
B
B
But
then
you
will
not,
you
know,
do
it
efficiently
and
out
to
the
end,
and
also
this
is
also
the
the
same
thing
about
the
containerization,
so
you
perfectly
want
you
can
use
containerization
without
any
microservices
paradigm.
You
just
need
to.
If
you
want
you
just
can
host
your
monolithic
application.
I
don't
know
vpn
everything,
what
you
want
to
be
containerized
and
it
will
be
containerized
in
a
way
that
you
will
provide,
so
it
doesn't
have
to
be
microservices.
B
B
Well,
it's
just
a
matter
of
the
yes,
it's
just
matter
of
the
balancing.
So
if
you
want
to
put
more
parts
that
balance
your
request,
that
is
usually
paradigm
that
is
usually
used
with
the
web
servers
so
web
services
that
actually
constantly
being
attacked
with
the
clients
it
all
sorts.
Then
you
will
use
a
a
rapid
moral
replicas
on
your
on
your
development,
the
deployment.
So
that's
the
way.
B
B
Yes,
there
are
a
lot
of
ways
if
you
recall
our
this
diagram.
The
first
angry
I
provided
there
are
a
lot
of
containers
available
and
there
are
a
lot
of
flavors
of
the
same
containers
as
well.
So,
for
example,
you
can
also
have
the
containers
that
are
not
on
the
net,
so
it's
not
on
the
cloud.
You
can
also
deploy
it
on
premise.
So
then
you
have
your
own.
Basically,
a
docker
container.
A
Okay,
I
don't
see
any
more
questions.
I
guess
that's
it.
I
have
already
written
their
contact,
vadim
and
dmitry
about
jetbrains
licenses,
since
they
were
the
first
ones
to
to
actually
ask
questions
so
yeah
thanks
once
again
for
the
great
session
and
hope
to
see
you
in
person
soon,
you
are
welcome
so.