►
From YouTube: The Level Up Hour (E47): Containerizing your application
Description
How do you containerize an application? What exactly is "containerization," and why should you care? Join us for this episode for an introductory discussion of Containerization- which is the process of encapsulating an application with its operating system environment and making it capable of running and deploying in containers which provides a foundation for gradually improving the application's design to make it more "cloud-friendly," but it may also introduce new challenges. So join us to learn more about when you should consider this approach and some of the benefits.
Want to containerize your first app? Try it here: https://lab.redhat.com/containerize-app
Follow us:
Scott McBrien https://twitter.com/stabby_mc
What is the Level Up Hour?
Every Wednesday at 9am ET we stream live demos on how Red Hat Enterprise Linux (RHEL) users and admins can benefit their organizations and improve their careers by learning how to use containers, Kubernetes, and Red Hat OpenShift.
Learn more at:
https://red.ht/leveluphour
http://red.ht/3ayHlHI
How to participate in the The Level Up Hour:
Watch on YouTube every Wednesday at 9amET
Chat with us on Discord https://discord.gg/5VMVGJt
Check out our GitHub repo https://github.com/level-up-hour/
About OpenShift:
Red Hat OpenShift is an open source container application platform based on the Kubernetes container orchestrator for enterprise application development and deployment.
https://www.openshift.com/
https://github.com/openshift/
#RedHat #OpenShift #tluh
A
A
A
A
A
Good
time
appropriate
greeting
everyone-
I
am
scott
mcbrian
and
you'll
notice
that
there
is
neither
a
person
to
my
left
or
right
today,
because
I
am
running
the
show
solo,
which
you
should
all
be
extremely
scared
of.
So,
let's
start
off
by
just
talking
about
what
our
show
is
going
to
look
like
today.
A
So
we
are
on
episode,
47
and
we're
going
to
talk
about
containerizing
your
application.
If
you're
interested
in
our
show
notes
from
last
time
where
we
covered
key
lime,
you
can
check
those
out
at
our
show,
notes
or
review
the
episode
on
youtube
all
right.
So
today
I
thought
we
might
kind
of
roll
back
a
little
bit
and
talk
about
containerizing
applications
when
we
started
the
level
up
hour.
A
But
today
I
thought
we
might
kick
it
a
little
bit
old
school
and
talk
about.
Well.
How
do
you
build
a
container,
and
there
are
a
couple
different
ways
that
you
can
do
that
you
could
certainly
use
some
openshift
technologies
like
sourced
image,
where
you
take
your
source
code
and
through
a
ci
cd,
build
pipeline,
build
yourself
a
container
image
all
the
way
down
through
deployment,
but
maybe
you're
not
ready
for
that.
Maybe
you're,
just
starting
your
container
deployment
journey
or
container
engineering
journey.
So
that's
what
we're
going
to
talk
about
today.
A
A
All
right,
so
what
we're
looking
at
here
is
a
virtual
machine
and
on
that
we're
going
to
run
several
of
the
red
hat
container
tools.
So
the
first
thing
I
want
to
do
is
I
want
to
pull
down
a
base
image
now.
I
could
build
this
from
scratch,
but
red
hat
provides
several
really
handy
base
images
for
me
to
use
through
the
universal
base
image
program,
or
we
also
ship,
rel
images.
A
So
what
I'm
going
to
do
is
I'm
just
going
to
use
builda
to
pull
down
a
ubi
8
image?
We
had
scott
mccarty
on
a
couple
shows
ago.
We
talked
about
ubi
micro,
which
is
one
of
the
four
ubi
images
I'm
using
the
standard,
ubi
image
here,
just
ubi,
so
the
others
are
micro,
which
we
talked
about.
It's
really
small
has
about
13
packages
that
make
it
up
a
minimal
which
has
a
micro
dnf
implementation
in
it.
So
you
can
still
install
software
from
it.
A
So
when
I
pulled
it
down,
I
have
this
working
container
created
for
me,
so
build
a
went
ahead
and
pulled
it
from
the
image
registry
and
then
has
mounted
it
into
my
directory
structure
so
that
I
can
place
files
and
work
with
it
because
at
its
core,
a
container
is
really
just
a
collection
of
application
files
right.
So
we're
going
to
run
this
on
our
container
host
and
we'll
see
it
show
up
as
processes
in
the
container
hosts
process
management.
That's
a
little
bit
different
than
how
virtual
machines
act.
A
A
It's
completely
segregated
off
into
a
separate
environment,
but
with
containers
we're
actually
using
the
container
host
and
we're
executing
processes
on
the
container
host,
which
means
the
container
host
is
able
to
get
visibility
into
what's
going
on
inside,
of
the
containers
that
are
running,
but
the
containers
themselves
are
partitioned
off
from
the
host
operating
system.
So
the
inside
of
the
container
image
when
it's
executing
in
its
container
environment,
it's
not
able
to
see
other
containers
or
the
host
operating
system
either.
It's
it
thinks
that
it's
kind
of
a
world
unto
itself.
A
In
reality,
we
can
see
it
from
behind
the
double-sided
mirror
on
the
container
host
operating
system
all
right
anyway.
So
I've
got
this
ubi
working
container
mounted
into
my
directory
and
for
this
first
example,
I'm
just
going
to
take
an
existing
application.
That's
built
into
an
rpm
and
I'm
going
to
install
it
in
the
container
and
then
I'm
going
to
run
it.
A
A
So
I'm
going
to
go
ahead
and
and
install
a
repo
inside
the
container
that
references
where
my
software
is
going
to
come
from
and
the
software
I've
chosen
for
my
example
is
from
people
the
extra
packages
for
enterprise
linux,
which
is
a
huge
repository
of
extra
software,
that
you
can
run
on
top
of
rel
distributions
or
well
based
distributions
includes
things
like
language,
libraries
and
different
applications
and
utilities,
and
here
we're
going
to
install
this
like
doofy
text-based
video
game.
That's
the
application
that
we're
going
to
containerize
today,
all
right.
A
A
That's
been
mounted
for
our
working
integer
and
then
we're
going
to
execute
this
yum
install
inside
that
change
rooted
environment.
So,
when
we're
executing
this
command,
it's
actually
happening
inside
the
container
image
not
outside
on
the
host
of
system,
and
so
you
can
see
that
it
installed
the
epo
release
and
we're
all
good
there,
but
just
to
prove
that
right.
If
I'm
on
the
host
operating
system.
A
A
A
But
before
I
do
so,
I
want
to
make
sure
it's
as
small
as
I
can
make
it
because,
as
I
start
to
ship
this
from
my
local
image
repository
to
either
a
shared
image
repository
for
other
people
to
use
or
other
systems
for
them
to
use,
I
don't
want
to
transfer
around
useless
data.
So
I'm
just
going
to
inside
my
working
container.
Do
a
yum.
A
A
All
right
so
now
I've
got
my
container
image
got
my
software
in
the
container
image,
and
now
I'm
ready
to
make
a
runnable
container
image.
So
I'm
going
to
use
build
a
commit
to
create
from
the
ubi
working
container
that
I've
been
working
with
in
I'm
going
to
create
an
image
called
moonbuggy
and
that's
the
rpm
that
I
had
installed
in
it
all
right.
If
I
do
a
quadman
images.
A
A
So
I'm
going
to
run,
podman
run
and
I'll
go
back
and
talk
about
that
come
in
just
second,
but
this
is
the
container
image
that's
running
and
here's
my
here's.
My
little
application
go
ahead
and
run
it.
It's
a
text-based
moon
patrol
clone,
so
there's
a
crater
coming
up.
Let
me
jump
my
moon
rover,
oh
gotta,
do
it
again
and
again
and
oh
I
didn't
make
it
and
it
blew
up
my
moon
rover
all
right.
So
when
I
close
the
executable.
A
It
finishes
the
application
and
then
it
closes
the
container
because
the
application
running
within
the
container
was
terminated
all
right.
So
when
I
ran
it,
I
ran
it
like
this.
Podman
run
want
to
execute
my
container.
It
means
it's
interactive,
so
I
actually
want
to
use
the
the
terminal
that
I'm
connected
to
to
show
me
the
contents
of
the
running
container,
and
that
was
important
for
moonbuggy,
because
it
was
actually
an
interactive
application
and
then
the
executable
that
I
want
to
run
inside
that
container
is
this
user
bin
moon
buggy
executable.
A
So
I
started
this
interactive
session
with
my
container
and
then
behind
that
I
ran
the
moon.
Boogie
application
all
right
so
that
that's
pretty
much
containerization
in
nutshell.
Right
get
your
container
image
place
your
files
within
it.
We
used
a
rpm
to
make
our
to
position
our
files
right.
We
installed
the
rpm,
which
then
put
the
executable
contents
wherever
and
then
we
ran
it
all
right.
So
I
mentioned
earlier
that
when
we
run
it,
we
actually
get
visibility
into
that
from
the
host
operating
system.
A
A
Okay,
so
that's
if
you
have
an
already
existing
rpm
that
you're
trying
to
run
inside
a
container,
so
if
you've
already
taken
your
software
and
you're
running
it
natively
on
a
linux
distribution.
Today
you
can
take
that
already
packaged
software
and
just
like
install
it
in
a
container
and
there
you
go
you've
containerized
your
application,
but
it's
very
core
containers
are
really
a
file
archive
like
if
you
think
about
it.
What
did
we
do
there?
A
We
took
our
rpm
and
we
installed
the
container,
which
then
sprinkled
files
around
in
this
change-rooted
file
environment
of
inside
of
our
container
and
so
containerization.
One
of
the
reasons
people
cite
to
to
do
containers
is
portability
of
your
application,
because
now,
if
all
your
application
contents
is
in
the
container
and
everything
that
it
needs
is
provided
by
the
container
image,
all
the
libraries
it
needs
all
the
executables,
it
needs
all
the
configuration
files
it
needs.
A
You
can
take
that
bundle
of
stuff
and
execute
it
on
other
host
operating
systems
too,
and
then
you're
not
reliant
on
things
like
what
version
of
some
other
software
is
running
on
the
container
host
system.
Right,
if
you're
bringing
all
of
your
requirements
with
you,
then
you
don't
have
to
worry
about
what
the
host
operating
system
is
providing
because
you've
brought
all
the
things
with
you,
and
so
it's
like.
A
So
you
know
that
goes
beyond
you
know
bringing
cookies
or
whatever.
Maybe
you
bring
a
pinata
too
because
you
enjoy
having
that
at
your
picnic?
So
that's
really
what
containers
are
they're
at
archive
a
file
archive
and
a
way
of
running
executables
to
stay
within
that
archive
of
all
of
the
provided
files?
A
In
order
to
then
have
everything
set
the
way
I
want
and
deploy
it
out
into
the
world
all
right.
So
while
we're
waiting
for
this
just
a
quick
plug,
I
rely
on
you
the
audience
members
to
provide
some
direction
on
what
you
would
like
to
see
happen
here.
So
I'm
doing
some
demos,
but
as
you
have
questions
please
post
in
the
chat,
if
you
would
like
to
see
something,
I'm
not
showing
you,
please
put
it
in
chat,
and
I
see
that
we've
got
a
few
people
watching.
A
A
A
And
then,
unlike
last
time,
where
I
like
told
it
what
thing
to
execute
this
time,
when
I
run
the
container,
I'm
going
to
do
it
in
a
disconnected
mode.
So
when
it's
disconnected,
I
don't
have
a
shell
into
it
by
default,
I'm
just
going
to
start
it
up,
and
I
expect
all
the
stuff
that
it
needs
to
start
up
and
because
this
is
a
web
application
and
it
is
using
apache
as
its
web
server.
A
All
right
so
now
I've
got
my
base
container
image
kind
of
where
I
want
it.
It's
got
the
prerequisite
software
that
I
needed
to
support
my
workload
in
it
because
I'm
just
going
to
be
positioning
a
web
application,
and
so
the
next
thing
I'm
going
to
do
is
I'm
going
to
pull
down
a
copy
of
that
web
application
and
then
move
those
files
over
into
my
container,
so
I'm
going
to
get
actually
hold
on
there's
one
more
thing
I
want
to
do
so.
Bear
with
me,
as
I
redo
a
couple
of
steps
here.
A
A
A
So
what
we're
looking
at
is
this:
this
javascript
based
application
called
the
clumsy
bird,
which
is
just
a
javascript
app
that
you
can
run
it's
a
video
game,
a
really
simple
video
game,
all
right
so
now
here
I've
pulled
it
down
from
github,
and
this
is
on
the
host.
It's
got
all
the
javascript
and
all
the
index
content
all
the
web
content.
I
need,
but
I
need
to
get
this
content
from
my
local
working
directory
into
the
container
image.
A
A
A
All
right,
so,
the
last
time
I
containerized
my
image,
I
had
an
interactive
application
that
I
want
to
run
so
when
I
ran
the
container,
I
used
it
to
indicate
that
it
was
an
interactive
executable
that
I
want
to
run.
I
wanted
to
have
that
terminal
session
and
be
passed
through
to
the
content
inside
the
container
this
time
on
pubmed
running
dash
d,
I'm
detached
from
it
just
going
to
run
out
there
kind
of
like
a
daemon
and
whatever
is
running
in
it
is
going
to
be
running
in
it.
A
Additionally,
because
this
is
a
web
application,
I
need
to
be
able
to
get
traffic
to
that
web
application
in
the
container,
so
dash
p
sets
up
a
port
mapping
so
that
port
8080
on
the
host
operating
system.
When
I
receive
connections
to
port
8080
on
the
host
operating
system,
it's
really
going
to
redirect
that
to
port
80
on
the
container
clumsy
bird.
A
A
A
A
So,
let's
see
if
we
can
figure
out
what's
happening
there,
oh
by
the
way,
is
me
playing
my
video
game
inside
of
my
container
all
right.
So
what
we're
seeing
is
a
differential
between
the
container
image
running
as
a
regular
person
and
the
container
image
running
as
root
as
root
is
working
fine
as
a
regular
person.
It's
not
running
fine.
So
let's
see
what
that
might
be.
A
So
I'm
going
to
try
running
a
sudo
where
I
escalate
the
privileges
as
root
to
see,
if
that
no
longer
has
the
problem.
So
if
I
basically
sudo
run
my
container,
so
the
container
is
running
as
root.
If
that
alleviates
my
problem,
then
I
know
it's
a
rootless
versus
root
container,
instead
of
a
problem
with
the
container
image
that
I
had
built
as
a
non-privileged
user.
A
A
A
A
And
this
is
one
of
the
I
think,
the
challenges
of
doing
rootless
containers,
which
is
pretty
fantastic
from
a
security
perspective,
but
just
like
when
you're
running
services
as
a
route,
you
could
do
what
you
want
and
then
you
switch
over
to
being
a
regular
person.
Also,
you
can't
do
what
you
want.
That's
where
we're,
let's
run
into
some
problems,.
A
A
A
A
A
B
A
Well,
this
is
really
frustrating
all
right.
Well,
let
me
let
me
back
up
and
like
put
a
pin
in
this
and
go
okay.
I
I
clearly
need
to
do
a
little
bit
more
research
on
my
demos
before
I
before
I
run
them,
it's
my
own
fault
for
trying
to
get
fancy
and
do
rootless
containers
without
preparing
or
testing
in
advance,
because
it's
a
live
demo.
What
could
possibly
go
wrong,
but
what
I
was
trying
to
get
to
is
to
show
you
what
it
looks
like
when
people
run
containers
as
non-root
users.
A
So
let
me
reload
this
to
get
a
fresh
box
one
more
time
and
we're
going
to
do
the
rpm
example.
So
I
can
show
you
what
it
looks
like
for
non-root
users
all
right.
Clearly,
my
container
worked
because
at
one
point
I
ran
the
oh
sorry
jonathan.
I
switched
gears
before
I
saw
your
chat
so
that
that
is
a
good
idea.
A
Because
it
should
be
running-
and
I
also
want
to
talk
about
like
offering
ports
to
non-root
users,
because
one
of
the
consistent
problems
with
running
rootless
is
that
you
know.
Inside
our
container
environment,
we
were
attaching
port
8080,
a
non-root
owned
port
to
port
80,
which
is
a
inside
the
container.
That's
where
the
service
is
running
and
a
lot
of
people
want
to
direct
port
mapping
right
port
80
on
the
host
go
to
port
80
in
the
container,
and
that
has
been
a
challenge
for
rootless
containers
for
a
while.
A
A
A
A
Well,
when
you
do
the
running
of
containers
as
a
non-root
user,
it
runs
on
the
host
operating
system
as
the
same
person
as
who's
executing
the
container
right.
So
because
I
executed
this
container
as
the
rel
user.
All
processes
spawned
from
within
the
container
happen
on
the
host
operating
system
as
the
rail
user,
which
means
this
application
only
has
the
permissions
and
capabilities
of
this
person,
and
I
think,
that's
what's
causing
our
problem
that
we're
having
with
my
web
application.
A
One
is
that
we're
running
with
the
rights
and
privileges
of
this
unprivileged
user
and
we're
trying
to
do
something
in
our
container,
not
accounting
for
that
so
either.
If
we're
trying
to
make
make
a
call
to
systemd
on
the
host
which
we're
not
allowed
to
do
as
a
regular
person
or
something
so
I'll
have
to
go
back
and
kind
of
figure
out
what
that
is
not
live
and
with
with
folks
watching
what's
happening
and
I'll
provide
an
update
on
our
next
show.
A
Just
quick
like
what
I
was
able
to
determine
and
why
it
was
a
problem
so
I'll
get
to
doing
that
in
the
next
week.
But
so
one
of
the
other
things
that
we
have
with
with
rootless
running
containers
like
it's
cool
that
we
get
to
run
as
an
unprivileged
user,
because
then,
as
a
systems
administrator
and
operating
in
the
operating
world,
I
don't
have
to
worry
about
container
developers
running
their
apps
as
root
and
not
knowing
what
those
apps
are
doing
on
my
host
operating
system
so
running
as
a
non-privileged
user.
A
But
one
of
the
nagging
problems
is
that
we
have
this
like
port
mapping,
that
we
have
to
do
when
running
it,
because,
if
you're
running
as
a
non-privileged
user,
you
have
to
attach
to
a
non-privileged
port.
So
that
means
that
anything
under
port
number
1024
was
off
limits
for
you
as
an
unprivileged
user.
A
A
A
A
A
Talk
about
sweet,
sweet
internet
points
so
for
those
of
you
who
have
watched
the
show
before
we
have
this
thing
called
sweet,
sweet
internet
points
where
you
can
go
out
to
the
urls
below
and
put
in
your
level
up
our
code,
and
it
will
give
you
the
ability
to
accumulate
sweet,
sweet
internet
points,
and
this
is
our
leaderboard
as
it
stands
today.
So
last
episode,
you
may
recall
that
narendev
and
nlh
acm
were
tied
at
6
300
points
apiece
and
at
one
point,
narendev
was
so
far
ahead
of
everyone.
A
Also,
we
see
that
folks,
like
noah,
friction
and
bacon
fork,
are
starting
to
accumulate
points
and
are
moving
into
a
position
to
maybe
challenge
the
leader.
Bacon
fork
has
moved
up
from
further
down
on
the
in
the
standings,
so
congratulations
bacon
fork
on
that
great
progress
and
making
it
higher
up
on
the
leaderboard.
A
Who
knows
what
sweet
sweet
internet
points
are
good
for,
but
we
we
now,
as
you
may
have
noticed
my
shirt-
have
actual
swag
that
says
level
up
hour.
I
know
that
we
have
been
promising
that
for
years
and
years
it
exists.
We
we
have
it,
but
yes,
so
for
now
we're
still
doing
sweet,
sweet
internet
points
so
join
us
next
week
for
another
episode
of
the
level
up
hour.
Hopefully
at
least
one
of
my
companions.