Docker Deep Dive

THIS COURSE IS NO LONGER UP TO DATE. Please see the updated version of the course entitled, Docker Deep Dive, published on January of 2018.
Course info
Rating
(1886)
Level
Intermediate
Updated
Jan 28, 2015
Duration
5h 38m
Table of contents
Course Overview
Course Introduction
Introducing Containers
Installing Ubuntu Linux and CentOS Linux
Installing and Updating Docker
Major Docker Components
A Closer Look at Images and Containers
Container Management
Building from a Dockerfile
Working with Registries
Diving Deeper with Dockerfile
Docker Networking
Troubleshooting
Lightning Fast Recap
Next Steps
Description
Course info
Rating
(1886)
Level
Intermediate
Updated
Jan 28, 2015
Duration
5h 38m
Description

THIS COURSE IS NO LONGER UP TO DATE. Please see the updated version of the course entitled, Docker Deep Dive, published on January of 2018.

About the author
About the author

Nigel is a popular figure in the tech industry, renowned for his love of storage and deep technical knowledge. Nigel writes a popular long-running storage blog as well as having hosted many popular technology podcasts, all of which are which are known for their excellent treatment of technical topics.

More from the author
Docker Deep Dive
Intermediate
4h 40m
4 Jan 2018
Getting Started with Kubernetes
Beginner
2h 53m
22 May 2017
Docker Networking
Intermediate
1h 49m
8 Feb 2017
More courses by Nigel Poulton
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi, and welcome to Pluralsight. So I'm Nigel, and I am containerized software running on top of top-spec biological hardware. Yeah, that's me. I'm all over containers and Docker and stuff like that. So I create awesome Docker and container courses here at Pluralsight, and I do work with a team over at Docker, Inc. as well. And you know what, to cut a long story short, I pretty much live and breathe containers. Anyway, Docker and containers are hot. I mean, it's rare that I'll have a technical conversation these days without somebody asking me about containers. And more and more, those people are actually using them. Yeah, most people have them in a lab somewhere, but increasingly, people are rolling out business-critical production apps that are based on containers. And when we're talking line of business apps in production, we really want to get this stuff right, yeah? So with that in mind, I am really excited to be bringing you this Docker Deep Dive course, a course that I honestly designed to be able to take you from, and I know this sounds cheesy, but from zero to hero. You really can start from the most basic level of IT experience, and by the end of the course, you will have Docker knowledge coursing through your veins. We cover the theory and the hands-on, starting with the basics and building up a solid knowledge. So good luck with the course, and live long and prosper in the coming world of containers.

Installing Ubuntu Linux and CentOS Linux
Okay, so our first bit of lab work with plenty more to come. In this module, we'll walk through downloading and installing a couple of Linux distros. In fact, we won't be walking through it, we'll actually be racing through it. The idea of this module is really just as a quick and dirty module to show us how to get some Linux machines up and running, ready to rock and roll with Docker. So, the machines we're building in this module, we'll use throughout the course. Anyway, the way that we'll be cutting this module is like this. We'll skip through downloading and installing Ubuntu, then do the same again, but this time with CentOS, and then for the rest of the course we'll be doing most of the demes with Ubuntu, but pointing out where things are obviously different on CentOS, you know, where there are significant differences. So things like union file systems versus device mapper, stuff like that. Now Docker will work on just about any Linux distro out there, in fact, CoreOS is a common one too. So you totally don't have to run with Ubuntu or CentOS, but if you want to follow the script closely, yeah, you might want to go with Ubuntu. Now then, yes we'll be working with virtual machines, despite the fact that I've just been ranting on about how bloated and overweight they are. But this is just a lab, right? We're not after mega-efficiencies and mega-performance. If we were, then yeah, we'd probably be going with a bare metal core OS, but Docker works fine on virtual machines and it's totally practical for our lab work. Anyway, that's enough jibber jabber, let's see how we download Ubuntu.

Installing and Updating Docker
Okay, so I think this is going to be a good module. It's time to introduce ourselves to Docker. We're going to start to get up close and personal. So, we'll find out how to install Docker, get updates from official channels, perform some basic daemon config, and then if we've got time, I think we'll just have a good old fashioned play around for a few minutes. Take a break from all the official, let's learn this and make sure we remember that. We'll just have a quick mess around, a bit of fun with containers. First off though, a really quick bit of theory. We're going to be messing around with the Docker client and daemon that we sometimes refer to as the Docker engine. It's a basic client server model where the Docker client sends commands to the Docker daemon and the daemon responds. The daemon does the hard work of creating containers and constructing all the kernel namespaces, cgroups, capabilities, all that good stuff required to instantiate a container. The client and daemon get downloaded and installed as a single package, so we can obviously run the client and the daemon on the save server if we want to and we will do that or they can talk over the network and we'll do that too. Anyway, let's not waste anymore time here, let's crack straight on.

Major Docker Components
And welcome back. What we're going to do in this module is we're going to look at the major components that make up a common single host, non-clustered Docker environment, specifically, right. And this is still going to be moderately high level, the deeper stuff is coming in the next module, but here we're going to learn about the Docker engine, Docker images, Docker containers, and also registries and repositories. And no doubt, right, we'll cover off one or two of the things as and when necessary if we need to provide a bit of context. But those right there are our main objectives. So, by the end of this module, if you're not totally cool with what all of this stuff is, honestly please come and throw rocks at me on Twitter. Genuinely, I need to know when I'm not hitting the mark and I like a bit of pressure. Anyway, with that in mind, I guess we better crack on.

A Closer Look at Images and Containers
Okay, now that we know the basics, let's dive deeper into images and containers. And I think we'll pick the pace up a bit as well now. So without further ado, let's get down with images.

Container Management
Hi and welcome back. So it's starting to feel like we're getting the hang of containers, yeah. Well in this module we'll bring together a bunch of the stuff that we've seen about containers and we'll add a bunch more and we'll step through it fairly quickly, but in a very methodical fashion because I think so far we've kind of been here, there, and everywhere with stuff like images, union mounts, kernel namespaces, the Docker engine, loads of stuff with a bit of containers and a bit of container management thrown in every once in a while. Well in this module we're going 100% containers. We'll cover basic container management, some stuff about container configs, how to peer inside of containers, and how to get different shell access to them, plus some other stuff too. So, let's crack on.

Building from a Dockerfile
Okay, welcome to this module. In this module, we're going to look at how we build Docker images using something called a Dockerfile. Earlier in the course we created a new image with the docker commit command. And that works just fine, but the more flexible and powerful way to build Docker images is definitely via a Dockerfile. And I love this because despite being really flexible and really powerful, it's also really simple, and I think we all love simple. So I think what we're going to do is walk quickly through the high level to give us an idea of the overall process, so when we dig a bit deeper we've got a bit of context. Then, we'll dive a little bit deeper on the Docker file itself, where it lives, what it's named, and any other major things that we need to know about it. Then we'll look at the format of the Docker file and we'll even write one ourselves. After that, we'll see how we build images from it. Looks like a good line up to me. Let's rock and roll.

Working with Registries
Hi and welcome to this module on pulling and pushing images to registries. Now this is a bit of an area where it feels like there's a bunch of change going on in the Docker world. It's not that long since Docker Hub Enterprise was announced and the current stable private Docker registry, so the one that we can easily spin up inside of our own corporate network, well that version is currently written in Python and it's about to be superseded by a new version written in Go, but we're not scared, right. There's still plenty to be learned here. So this is the plan, we'll start out by looking at Docker Hub, the default public Docker registry. You know the one, we've seen it once or twice already in the course. Anytime we've pulled an image, we've been pulling it from the public Docker registry, Docker Hub. So while we talk about this, we'll discuss the differences between public and private repositories on Docker Hub. Then, we'll look at configuring a private Docker repo of our own, so not out in the wild west of the internet, like Docker Hub, no, our own private registry inside of the corporate firewall where we can push and pull images without having to be out on the internet. And then we'll wrap things up with a brief mention of Docker Hub Enterprise. So let's go look at Docker Hub.

Diving Deeper with Dockerfile
Okay, so this is our second look at Dockerfiles and this time we're going to go deeper. So, as a result, we won't be hanging around talking about any of the basics that we already covered in the earlier module titled Building From a Dockerfile. So if you're just joining us on the course here and you're not cool with the basics of Dockerfile, then I suggest you go back and watch that module first where we go through fundamental stuff like, how do we name the Dockerfile? How the syntax works. How we then build from it, and stuff like that. Still with us? Magic. Now this is how we're going to slice and dice this module. We're going to kick things off by looking at a couple of important concepts, the build cache and layers. And both of these become extremely important when we start using Docker in any kind of serious way. Because as we start to scale, if you don't grock these concepts, you're going to be putting yourself through unnecessary pain. So we'll tackle them right at the top of the module. Once we're cool with these, then we'll start learning some more Dockerfile instructions, things like CMD, ENTRYPOINT, ENV, VOLUME. First up then, the build cache.

Docker Networking
Okay, time to get familiar with the fundamental concepts of Docker Networking and I'm sure it comes as no surprise to you, right, that there's an absolute ton of advanced networking changes under proposal and in the works as this course is being produced, but don't let that put you off one bit, the same is true for the entire networking industry. Networking is just a complex beast and the industry as a whole is in a royal mess of major changes right now, things like software defined networking and network function virtualization, are ripping through the industry. And Docker doesn't escape any of it. But you know what? The entire technology world is now under constant development, it's just the new way of things, and I doubt it's ever going to change. In fact, I hope it doesn't. Innovation is awesome. And any technology that's going to be successful needs to move with the times and be at least on the curve or ahead of it. So, Docker's playing in that space and there's a ton of change under proposal. So, what we're going to do here is go through the core fundamental stuff, just the core Docker stuff, no third party products or technologies. The things we'll cover will be the docker0 virtual bridge, virtual Ethernet interfaces, exposing ports and services, and linking containers. So, let's go and learn about the docker0 bridge.

Troubleshooting
Okay so in this module I think we're going to look at a few things that might help us when it comes time to troubleshoot issues and along the way we'll throw in a few best practices. So we'll tackle things in this order, we'll take a look at Docker Daemon logging, so not logging from containers, but the actual log messages we get from the Docker Daemon running on our Docker host. Then we'll have a quick reminder about container login. After that, we'll switch our attention and look at images and how we can troubleshoot potential issues with image builds. And we'll finish the module up by talking a bit about networking and how we might avoid some potential network related issues. Alright, let's go have a look at logging from the Docker Daemon.

Lightning Fast Recap
Right then, I thought it might be a good idea here at the end of the course to have a lightning fast run through some of the major things that we've learned. My thinking being, now that we know all of the detail and how stuff works behind the scenes, a quick super fast recap might remind us of the bigger picture, but we'll just run through some of the practical stuff and no stopping off to explain the theory like we've been doing in the rest of the course. Ready. Buckle up.