🐳 Docker is a required skill for almost every developer in today's world. Learn the basics of Dockerfiles, images, and containers in 100 seconds. https://fireship.io

Docker Docs https://docs.docker.com/

#docker #dev #100SecondsOfCode 

Install the quiz app 🤓

iOS https://itunes.apple.com/us/app/fireship/id1462592372?mt=8
Android https://play.google.com/store/apps/details?id=io.fireship.quizapp

Upgrade to Fireship PRO at https://fireship.io/pro
Use code lORhwXd2 for 25% off your first payment. 

My VS Code Theme

- Atom One Dark 
- vscode-icons
- Fira Code Font
2024-02-04T06:09:33.385Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
323f1a7e-e941-4018-962d-f472f92465a9
fcfc49badd22bd439274b9bbb96f79d6208741f51f20c82ee1d22aa94ba7aec1
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
Docker, a tool that can package software into containers that run reliably in any environment.
But what is a container, and why do you need one?
Let's imagine you built an app with COBOL that runs on some weird flavor of Linux.
You wanna share this app with your friend, but he has an entirely different system.
So the problem becomes, How do we replicate the environment our software needs on any machine?
One way to package an app is with a virtual machine, where the hardware is simulated, then installed with the required OS and dependencies.
This allows us to run multiple apps on the same infrastructure.
However, because each VM is running its own operating system, they tend to be bulky and slow.
Now, a Docker container is conceptually very similar to a VM with one key difference.
Instead of virtualizing hardware, containers only virtualize the OS.
Or in other words, All apps or containers are run by a single kernel, and this makes almost everything faster and more efficient.
There are 3 fundamental elements in the universe of Docker.
The Dockerfile, The image and the container.
The Dockerfile is like DNA.
It's just code that tells Docker how to build an image, Which itself is a snapshot of your software along with all of its dependencies down to the operating system level.
The image is immutable and it can be used to spin up multiple containers, Which is your actual software running in the real world.
Create a Dockerfile and use from to start from an existing template like Ubuntu.
This base image gets pulled down from the cloud, And you can also upload your own images to a variety of different Docker registries.
From there, you might wanna use run to run a terminal command that installs dependencies into your image.
You can set environment variables and do all kinds of other stuff, then the last thing you'll do is set a default command that's executed when you start up a container.
And now we can create the image file by running the Docker build command?
It goes through each step in our Docker file to build the image layer by layer.
We can then bring this image to life as a container with the Docker run command.
As your app demands more resources, you can run it on multiple machines, multiple clouds, on prem, or wherever you want reliably.
This has been Docker in 100 1?
If you enjoyed it, make sure to like and subscribe, and stay tuned for more Docker content coming to this channel soon.
Thanks for watching, and I will see you in the next one.
1?

Speaker 0: Docker, a tool that can package software into containers that run reliably in any environment. But what is a container, and why do you need one? Let's imagine you built an app with COBOL that runs on some weird flavor of Linux. You wanna share this app with your friend, but he has an entirely different system. So the problem becomes, How do we replicate the environment our software needs on any machine?

One way to package an app is with a virtual machine, where the hardware is simulated, then installed with the required OS and dependencies. This allows us to run multiple apps on the same infrastructure. However, because each VM is running its own operating system, they tend to be bulky and slow. Now, a Docker container is conceptually very similar to a VM with one key difference. Instead of virtualizing hardware, containers only virtualize the OS.

Or in other words, All apps or containers are run by a single kernel, and this makes almost everything faster and more efficient. There are 3 fundamental elements in the universe of Docker. The Dockerfile, The image and the container. The Dockerfile is like DNA. It's just code that tells Docker how to build an image, Which itself is a snapshot of your software along with all of its dependencies down to the operating system level.

The image is immutable and it can be used to spin up multiple containers, Which is your actual software running in the real world. Create a Dockerfile and use from to start from an existing template like Ubuntu. This base image gets pulled down from the cloud, And you can also upload your own images to a variety of different Docker registries. From there, you might wanna use run to run a terminal command that installs dependencies into your image. You can set environment variables and do all kinds of other stuff, then the last thing you'll do is set a default command that's executed when you start up a container.

And now we can create the image file by running the Docker build command? It goes through each step in our Docker file to build the image layer by layer. We can then bring this image to life as a container with the Docker run command. As your app demands more resources, you can run it on multiple machines, multiple clouds, on prem, or wherever you want reliably. This has been Docker in 100 1?

If you enjoyed it, make sure to like and subscribe, and stay tuned for more Docker content coming to this channel soon. Thanks for watching, and I will see you in the next one. 1?
Docker, a tool that can package software into containers that run reliably in any environment. But what is a container, and why do you need one?
Let's imagine you built an app with COBOL that runs on some weird flavor of Linux. You wanna share this app with your friend, but he has an entirely different system. So the problem becomes, How do we replicate the environment our software needs on any machine? One way to package an app is with a virtual machine, where the hardware is simulated, then installed with the required OS and dependencies. This allows us to run multiple apps on the same infrastructure.
software
infrastructure
software development
modeling
However, because each VM is running its own operating system, they tend to be bulky and slow. Now, a Docker container is conceptually very similar to a VM with one key difference. Instead of virtualizing hardware, containers only virtualize the OS. Or in other words, All apps or containers are run by a single kernel, and this makes almost everything faster and more efficient. There are 3 fundamental elements in the universe of Docker. The Dockerfile, The image and the container. The Dockerfile is like DNA. It's just code that tells Docker how to build an image, Which itself is a snapshot of your software along with all of its dependencies down to the operating system level. The image is immutable and it can be used to spin up multiple containers, Which is your actual software running in the real world. Create a Dockerfile and use from to start from an existing template like Ubuntu. This base image gets pulled down from the cloud, And you can also upload your own images to a variety of different Docker registries. From there, you might wanna use run to run a terminal command that installs dependencies into your image. You can set environment variables and do all kinds of other stuff, then the last thing you'll do is set a default command that's executed when you start up a container. And now we can create the image file by running the Docker build command? It goes through each step in our Docker file to build the image layer by layer. We can then bring this image to life as a container with the Docker run command. As your app demands more resources, you can run it on multiple machines, multiple clouds, on prem, or wherever you want reliably. This has been Docker in 100 1? If you enjoyed it, make sure to like and subscribe, and stay tuned for more Docker content coming to this channel soon. Thanks for watching, and I will see you in the next one. 1?
Docker, a tool that can package software into containers that run reliably in any environment. But what is a container, and why do you need one? Let's imagine you built an app with COBOL that runs on some weird flavor of Linux. You wanna share this app with your friend, but he has an entirely different system. So the problem becomes, How do we replicate the environment our software needs on any machine? One way to package an app is with a virtual machine, where the hardware is simulated, then installed with the required OS and dependencies. This allows us to run multiple apps on the same infrastructure. However, because each VM is running its own operating system, they tend to be bulky and slow. Now, a Docker container is conceptually very similar to a VM with one key difference. Instead of virtualizing hardware, containers only virtualize the OS. Or in other words, All apps or containers are run by a single kernel, and this makes almost everything faster and more efficient. There are 3 fundamental elements in the universe of Docker. The Dockerfile, The image and the container. The Dockerfile is like DNA. It's just code that tells Docker how to build an image, Which itself is a snapshot of your software along with all of its dependencies down to the operating system level. The image is immutable and it can be used to spin up multiple containers, Which is your actual software running in the real world. Create a Dockerfile and use from to start from an existing template like Ubuntu. This base image gets pulled down from the cloud, And you can also upload your own images to a variety of different Docker registries. From there, you might wanna use run to run a terminal command that installs dependencies into your image. You can set environment variables and do all kinds of other stuff, then the last thing you'll do is set a default command that's executed when you start up a container. And now we can create the image file by running the Docker build command? It goes through each step in our Docker file to build the image layer by layer. We can then bring this image to life as a container with the Docker run command. As your app demands more resources, you can run it on multiple machines, multiple clouds, on prem, or wherever you want reliably. This has been Docker in 100 1? If you enjoyed it, make sure to like and subscribe, and stay tuned for more Docker content coming to this channel soon. Thanks for watching, and I will see you in the next one. 1?
Docker,
docker
a
a
tool
tool
that
that
can
can
package
package
software
software
into
into
containers
containers
that
that
run
run
reliably
reliably
in
in
any
any
environment.
environment
But
but
what
what
is
is
a
a
container,
container
and
and
why
why
do
do
you
you
need
need
one?
one
Let's
let's
imagine
imagine
you
you
built
built
an
an
app
app
with
with
COBOL
cobol
that
that
runs
runs
on
on
some
some
weird
weird
flavor
flavor
of
of
Linux.
linux
You
you
wanna
wanna
share
share
this
this
app
app
with
with
your
your
friend,
friend
but
but
he
he
has
has
an
an
entirely
entirely
different
different
system.
system
So
so
the
the
problem
problem
becomes,
becomes
How
how
do
do
we
we
replicate
replicate
the
the
environment
environment
our
our
software
software
needs
needs
on
on
any
any
machine?
machine
One
one
way
way
to
to
package
package
an
an
app
app
is
is
with
with
a
a
virtual
virtual
machine,
machine
where
where
the
the
hardware
hardware
is
is
simulated,
simulated
then
then
installed
installed
with
with
the
the
required
required
OS
os
and
and
dependencies.
dependencies
This
this
allows
allows
us
us
to
to
run
run
multiple
multiple
apps
apps
on
on
the
the
same
same
infrastructure.
infrastructure
However,
however
because
because
each
each
VM
vm
is
is
running
running
its
its
own
own
operating
operating
system,
system
they
they
tend
tend
to
to
be
be
bulky
bulky
and
and
slow.
slow
Now,
now
a
a
Docker
docker
container
container
is
is
conceptually
conceptually
very
very
similar
similar
to
to
a
a
VM
vm
with
with
one
one
key
key
difference.
difference
Instead
instead
of
of
virtualizing
virtualizing
hardware,
hardware
containers
containers
only
only
virtualize
virtualize
the
the
OS.
os
Or
or
in
in
other
other
words,
words
All
all
apps
apps
or
or
containers
containers
are
are
run
run
by
by
a
a
single
single
kernel,
kernel
and
and
this
this
makes
makes
almost
almost
everything
everything
faster
faster
and
and
more
more
efficient.
efficient
There
there
are
are
3
3
fundamental
fundamental
elements
elements
in
in
the
the
universe
universe
of
of
Docker.
docker
The
the
Dockerfile,
dockerfile
The
the
image
image
and
and
the
the
container.
container
The
the
Dockerfile
dockerfile
is
is
like
like
DNA.
dna
It's
it's
just
just
code
code
that
that
tells
tells
Docker
docker
how
how
to
to
build
build
an
an
image,
image
Which
which
itself
itself
is
is
a
a
snapshot
snapshot
of
of
your
your
software
software
along
along
with
with
all
all
of
of
its
its
dependencies
dependencies
down
down
to
to
the
the
operating
operating
system
system
level.
level
The
the
image
image
is
is
immutable
immutable
and
and
it
it
can
can
be
be
used
used
to
to
spin
spin
up
up
multiple
multiple
containers,
containers
Which
which
is
is
your
your
actual
actual
software
software
running
running
in
in
the
the
real
real
world.
world
Create
create
a
a
Dockerfile
dockerfile
and
and
use
use
from
from
to
to
start
start
from
from
an
an
existing
existing
template
template
like
like
Ubuntu.
ubuntu
This
this
base
base
image
image
gets
gets
pulled
pulled
down
down
from
from
the
the
cloud,
cloud
And
and
you
you
can
can
also
also
upload
upload
your
your
own
own
images
images
to
to
a
a
variety
variety
of
of
different
different
Docker
docker
registries.
registries
From
from
there,
there
you
you
might
might
wanna
wanna
use
use
run
run
to
to
run
run
a
a
terminal
terminal
command
command
that
that
installs
installs
dependencies
dependencies
into
into
your
your
image.
image
You
you
can
can
set
set
environment
environment
variables
variables
and
and
do
do
all
all
kinds
kinds
of
of
other
other
stuff,
stuff
then
then
the
the
last
last
thing
thing
you'll
you'll
do
do
is
is
set
set
a
a
default
default
command
command
that's
that's
executed
executed
when
when
you
you
start
start
up
up
a
a
container.
container
And
and
now
now
we
we
can
can
create
create
the
the
image
image
file
file
by
by
running
running
the
the
Docker
docker
build
build
command?
command
It
it
goes
goes
through
through
each
each
step
step
in
in
our
our
Docker
docker
file
file
to
to
build
build
the
the
image
image
layer
layer
by
by
layer.
layer
We
we
can
can
then
then
bring
bring
this
this
image
image
to
to
life
life
as
as
a
a
container
container
with
with
the
the
Docker
docker
run
run
command.
command
As
as
your
your
app
app
demands
demands
more
more
resources,
resources
you
you
can
can
run
run
it
it
on
on
multiple
multiple
machines,
machines
multiple
multiple
clouds,
clouds
on
on
prem,
prem
or
or
wherever
wherever
you
you
want
want
reliably.
reliably
This
this
has
has
been
been
Docker
docker
in
in
100
100
1?
1
If
if
you
you
enjoyed
enjoyed
it,
it
make
make
sure
sure
to
to
like
like
and
and
subscribe,
subscribe
and
and
stay
stay
tuned
tuned
for
for
more
more
Docker
docker
content
content
coming
coming
to
to
this
this
channel
channel
soon.
soon
Thanks
thanks
for
for
watching,
watching
and
and
I
i
will
will
see
see
you
you
in
in
the
the
next
next
one.
one
1?
1
success
The speaker explains the concept of Docker, a tool that can package software into containers and share it with a friend. They explain the three elements of Docker, including the Dockerfile, image, and container, and how each step can be used to create a Docker file. The speaker also explains how to set environment variables and run a command to install dependencies into images.
Docker in 100 Seconds
Docker, a tool that can package software into containers that run reliably in any environment. But what is a container, and why do you need one? Let's imagine you built an app with COBOL that runs on some weird flavor of Linux. You wanna share this app with your friend, but he has an entirely different system. So the problem becomes, How do we replicate the environment our software needs on any machine? One way to package an app is with a virtual machine, where the hardware is simulated, then installed with the required OS and dependencies. This allows us to run multiple apps on the same infrastructure. However, because each VM is running its own operating system, they tend to be bulky and slow. Now, a Docker container is conceptually very similar to a VM with one key difference. Instead of virtualizing hardware, containers only virtualize the OS. Or in other words, All apps or containers are run by a single kernel, and this makes almost everything faster and more efficient. There are 3 fundamental elements in the universe of Docker. The Dockerfile, The image and the container. The Dockerfile is like DNA. It's just code that tells Docker how to build an image, Which itself is a snapshot of your software along with all of its dependencies down to the operating system level. The image is immutable and it can be used to spin up multiple containers, Which is your actual software running in the real world. Create a Dockerfile and use from to start from an existing template like Ubuntu. This base image gets pulled down from the cloud, And you can also upload your own images to a variety of different Docker registries. From there, you might wanna use run to run a terminal command that installs dependencies into your image. You can set environment variables and do all kinds of other stuff, then the last thing you'll do is set a default command that's executed when you start up a container. And now we can create the image file by running the Docker build command? It goes through each step in our Docker file to build the image layer by layer. We can then bring this image to life as a container with the Docker run command. As your app demands more resources, you can run it on multiple machines, multiple clouds, on prem, or wherever you want reliably. This has been Docker in 100 1? If you enjoyed it, make sure to like and subscribe, and stay tuned for more Docker content coming to this channel soon. Thanks for watching, and I will see you in the next one. 1?
The speaker explains the concept of Docker, a tool that can package software into containers and share it with a friend. They explain the three elements of Docker, including the Dockerfile, image, and container, and how each step can be used to create a Docker file. The speaker also explains how to set environment variables and run a command to install dependencies into images.

        [INST]
        You are youtuber called Fireship you make engaging high-intensity and entertaining coding tutorials and tech news. 
        you covers a wide range of topics relevant to programmers, aiming to help them learn and improve their skills quickly.
        
        Given the title of the video : Docker in 100 Seconds 
        and a small summary : The speaker explains the concept of Docker, a tool that can package software into containers and share it with a friend. They explain the three elements of Docker, including the Dockerfile, image, and container, and how each step can be used to create a Docker file. The speaker also explains how to set environment variables and run a command to install dependencies into images.
        [/INST]
        
        Generate the video : Docker, a tool that can package software into containers that run reliably in any environment. But what is a container, and why do you need one? Let's imagine you built an app with COBOL that runs on some weird flavor of Linux. You wanna share this app with your friend, but he has an entirely different system. So the problem becomes, How do we replicate the environment our software needs on any machine? One way to package an app is with a virtual machine, where the hardware is simulated, then installed with the required OS and dependencies. This allows us to run multiple apps on the same infrastructure. However, because each VM is running its own operating system, they tend to be bulky and slow. Now, a Docker container is conceptually very similar to a VM with one key difference. Instead of virtualizing hardware, containers only virtualize the OS. Or in other words, All apps or containers are run by a single kernel, and this makes almost everything faster and more efficient. There are 3 fundamental elements in the universe of Docker. The Dockerfile, The image and the container. The Dockerfile is like DNA. It's just code that tells Docker how to build an image, Which itself is a snapshot of your software along with all of its dependencies down to the operating system level. The image is immutable and it can be used to spin up multiple containers, Which is your actual software running in the real world. Create a Dockerfile and use from to start from an existing template like Ubuntu. This base image gets pulled down from the cloud, And you can also upload your own images to a variety of different Docker registries. From there, you might wanna use run to run a terminal command that installs dependencies into your image. You can set environment variables and do all kinds of other stuff, then the last thing you'll do is set a default command that's executed when you start up a container. And now we can create the image file by running the Docker build command? It goes through each step in our Docker file to build the image layer by layer. We can then bring this image to life as a container with the Docker run command. As your app demands more resources, you can run it on multiple machines, multiple clouds, on prem, or wherever you want reliably. This has been Docker in 100 1? If you enjoyed it, make sure to like and subscribe, and stay tuned for more Docker content coming to this channel soon. Thanks for watching, and I will see you in the next one. 1?
        