►
From YouTube: Lightning Talk Podman Expands to the Desktop - Peter Hunt - Red Hat OpenShift Commons 2022 Detroit
Description
Lightning Talk: Podman Expands to the Desktop
Red Hat OpenShift Commons 2022 @ Kubecon/NA
Detroit, Michigan
October 25, 2022
Speaker:
Peter Hunt (Red Hat)
https://commons.openshift.org/gatherings/kubecon-22-oct-25/
A
A
A
So,
let's,
let's
begin
with
a
problem
statement,
so
local
development
environments
have
become
both
impractical
and
lack
consistency
with
production.
They're
impractical
in
that
there's
a
lot
of
complicated
setup
to
get
a
development
environment
up
and
running,
and
your
laptop
naturally
has
more
limited
resources
than
your
production
servers
have
and
there's
some
third-party
integration
issues
actually
getting
from
local
development
to
production.
In
addition,
there's
lack
the,
as
mentioned
with
the
limited
resources.
There's
lack
of
consistency.
A
The
way
that
you
run
things
in
your
local
environment
are
unlikely
to
be
the
way
that
you
run
it
live,
especially
if
you're
running
in
you
know,
openshift
or
you
know
a
distributed.
Kubernetes
like
system
there's
a
lot
more
pieces
at
work
in
production
environments.
Then
you
can
really
realistically
have
on
your
laptop
and
there's
discrepancies
with
the
way
that
containers
and
composite
applications
are
getting
configured
to
talk
to
each
other.
I
mean
you
know.
I
feel
like
a
lot
of
us
here
know
how
annoying
it
can
be,
sometimes
to
be
configuring.
A
Networking
between
multiple
servers
to
solve
this,
a
lot
of
developers
end
up
using
it.
You
know
tools
like
Docker
compose,
translating
between
local
containers,
to
then
groups
of
containers,
but
this
brings
the
worst
of
Both
Worlds,
where
a
developer
needs
to
translate
their
application
between
local
and
then
into
production
environments.
A
A
At
Red
Hat
we
like
to
make
the
developer
experience
simple
and
easy
when
developers
are
targeting
kubernetes
as
their
runtime
environment,
especially
openshift
as
developers
testing.
Our
applications
on
kubernetes
and
testing
in
an
environment
which
is
going
to
be
as
close
as
possible
to
the
one
used
in
production
could
be
a
challenge.
A
Even
if
we
have
a
commonality
among
containers.
Getting
them
to
run
on
kubernetes
is
a
challenge.
It's
not
as
easy
as
bail
and
refresh
the
turnarounds
are
getting
slower
as
a
developer.
I
only
really
care
about
developing
and
debugging
my
applications
and
then
deploying
them
quickly
and
consistently
across
all
of
the
footprints
that
I
want
them
on.
A
Luckily,
podman
desktop
is
aiming
to
fulfill
all
of
these
gaps.
Popman
desktop
choose
to
simplify,
workflows
and
experiences
with
containers
when
targeting
production
on
openshift
and
kubernetes.
It
brings
kubernetes
closer
to
the
developer
by
leveraging
podman's
pod
functionality
and
then
minimizes
the
discrepancies
between
the
desktop
and
Target
kubernetes
environments
and
tries
to
do
the
translation
steps
along
the
way.
A
So,
let's,
let's
talk
about
a
little
a
little
bit
about
how
we
do
it,
so
everyone
knows
that
podman
can
use
containers
and
also
probably
everyone
knows
that
they
can
use
pods
it's
in
the
name.
If
not
then
podman
uses
manages
pods
a
developer
using
podman
in
podman,
desktop
Can.
It
can
start
with
their
containers
and
then
they
can
group
them.
A
A
These
two
containers
are
separate
and
the
way
that
we
connected
them
is
with
podman's
additional
host
flag,
and
so
they
are
connected
to
each
other,
but
that's
not
really
how
they're
going
to
be
connected
in
kubernetes,
The,
Logical
unit
of
containers
in
kubernetes
and
most
of
the
world
now
are
pods,
so
we
want
them
to
be
grouped
together
as
a
pod.
Luckily,
podman
desktop
allows
us
to
build
pods
directly
from
containers
that
already
exist,
and
it
does
this
opaquely
behind
the
scenes.
A
So
what
we
do
here
is
we
select
our
two
containers
that
we
want
to
potify,
and
then
we
click
this
fancy
potify
button,
and
it
is
now
talking
to
the
podman
server
which,
by
the
way,
is
running
on
this
machine
in
well.
This
is
this
is
being
recorded
on
a
Mac,
but
also
I
intended
on
showing
it
on
Windows,
and
it
does
work
on
Windows
as
well.
A
You
know
in
the
background
as
WSL
and
then
the
podman
server
is
running
in
WSL
and
the
client
is
running
and
the
you
know
in
the
windows,
environment,
the
command,
prompt
and
podman
desktop
talks
through
that.
So
here
we've
created
our
pod.
That
was
easy
and
it
also
while
it
was
creating
that
pod.
It
in
the
background
stopped
the
other
two
containers
for
us
so
that
there
was
no
Port
contention.
So
here
we
can
look
at
our
pod
and
make
sure
everything
looks
good.
A
We
can
see
our
containers
two
of
them
have
exited
because
we
stopped
them
and
then
they're
the
two
pot,
the
two
containers
that
have
been
potified
and
named
as
such
inside
of
that
pod.
Now
we
can
open
up
the
our
application,
our
port
8080,
and
we
can
see
that
our
hello
world
application
we
we
can
track
it
with
the
readers
and
they're
all
connected
they're
talking
to
to
each
other
we're
very
happy,
as
developers
and
I
think
we're
ready
to
ship
in
openshift.
So
we
have
connected
podman.
A
A
Oh,
we
haven't
clicked
deploy
yet
we're
gonna,
though
right
now,
click,
oh
yeah
and
then
so.
This
deploy
screen
allows
us
to
make
a
couple
of
decisions
about
the
way
that
we're
going
to
actually
translate
between
the
Pod
and
the
the
object
that
we're
going
to
be
creating
in
openshift
we're
going
to
be
using
kubernetes
services
and
then
openshift
routes.
A
We
can
also
look
at
this
pod.
This
pod
has
been
deployed
to
openshift,
so
we
can
use
all
of
the
openshift
console
services
that
show
us.
You
know
make
sure
that
our
pod
is
looking
up
to
Snuff
and
is
ready
for
you
know
being
deployed
everywhere
that
our
openshift
is
on.
We
can
also
check
our
logs
and
terminal
just
like
we
could
with
podman
desktop,
so
the
experience
is
very
similar,
so
it'll
reduce
the
cognitive
overhead
for
that
translation
as
well,
and
finally,
we
will
be
done
with
our
demo.
So
in
conclusion,.