Docker Deep Dive

Course Overview
Containers are white-hot at the moment, especially Docker and Kubernetes. And in this course, Docker Deep Dive, is everything you need to get on the path to container mastery. On the Docker front, you will go from zero to Docker in a single course. I mean, by the end, you'll be brimming with confidence and raring to go. Now on the Kubernetes front, well, Docker and Kubernetes go together all the time, so you'll be primed and ready to crack on with Kubernetes if that's your plan. Anyway, I'm Nigel. I'm a Docker captain and a container addict. And I am really excited about the time we're about to spend together. You see, I'm confident you're about to give your career one of the biggest boosts it could ask for. Like I said, zero to Docker in a single course. So that'll be all the theory and the practical. On the theory front, we'll get down with the fundamentals: name spaces, control groups, union file systems, all the jazz that underpins a modern container. And we'll cover Linux and Windows. We'll also get deep with images, containers, swarms and services, secret stacks, the whole shebang. No stone left unturned. But theory's theory, so we'll be backing everything up with loads of hands-on labs and exercises. And by the end, you'll be skilled up and ready to take your career on to the next level. As well, while it's not an exam cram course, it will cover most of what you need to pass the Docker Certified Associate Exam. Man, I'm excited. So yeah, let's buckle up and let's do some serious Docker.

Installing Docker
Alright then, we're deep-diving here, so we're not about to spend half an hour finding out how to do 50 types of install, but, I do want the course to be as useful as possible to as many of you as possible, so to help make it a bit of a one-stop shop for those of you who want to go from zero to Docker in a single course, we will take a look at a few installs, but the emphasis is going to be on doing this quickly right? If you need more, there's always the Docs and of course Google's your friend. Anyway, this is what we'll do: Play with Docker, without doubt, my favorite way to get my hands on Docker, we'll do Docker for Mac and Docker for Windows, then we'll do a Windows Server install, and then a Linux install, then once we're done with that, we are cracking on with the proper learning, so let's do it.

Containerizing an App
So, we're switching tack a bit in this module. I mean, we're all good with what an image is and the likes. So, now it's time to take an application and containerize it, or put it in an image. So, first up, we'll cover off what the process looks like from a high level. I mean, containerize an app? What does it even mean? So, I figure we better cover that off. Once we're cool with that idea, then we're going to take a web app, like some code, and we're going to make it into a docker image, and we'll run a container from it. Now, to do this, we're going to work with something called a Dockerfile. And we'll see in a second, right? It's just a plain text file with a bunch of pretty simple instructions. But the power of this file is insane! I mean, not only to build an image. I'm talking about the potential to bridge the gap, nay, the chasm between dev and ops. Seriously. This file is a way for developers to describe their apps and how they work, and for ops to read the file and understand. Whew! Anyway, then we'll dig a bit. So we'll get under the covers of what we just did, and I think we'll probably share a few best practices at the same time. Then we'll look at multi-stage builds, which is really taking everything that we're going to learn and making it really production-worthy. Then we'll wrap it all up with a solid recap. Now, again, as we go we'll polish off a bunch of stuff from the exam. And again, all from Domain 2. So, we'll show the main parts of a Dockerfile and we'll describe a bunch of the options. We'll show how to create a production-worthy, efficient image, and use a file to create an image, a Dockerfile, yeah? So let's crack on.

Working with Containers
Containers. We're already hours into the course and it's only now that we're finally getting into containers? Wow! Well here we are and here's the plan. We'll have a quick Big Picture. Then we'll dive in, we'll touch on logging, and then we'll wrap it up. Now of course, as we go about things, we're going to touch on some of the exam stuff. From Domain 1 we'll inspect images, add networks, and publish ports. From Domain 2, we'll look at some of the Docker inspect outputs. And from Domain 4 we'll publish a port, then see how we can find out which port a container is accessible on. That's it, let's do it.

Building a Secure Swarm
Managing a single docker node and maybe a couple of containers on your laptop, well, that's one thing, right? But managing a bunch of nodes and tens or hundreds of containerized apps, wow, that is a whole other thing, believe me. Well, enter Docker Swarm, and Kubernetes. Here's the plan. We'll paint a big picture, so what's all this orchestration about, and what's a Swarm, and what's Kubernetes. Then, we'll do a bit of a deeper dive into a Swarm cluster. Then we'll build one and proper secure, right, with encryption, Mutual TLS and all of that jazz. Then we'll look at Orchestration, but just a bit, right, because we've got a whole module on that later. But it'll be a good primer. Then we'll finish up by doing our usual of reminding ourselves the stuff we've forgotten. Now then, if you're studying for the Docker Certified Associate Exam, you're going to pick up the following, right? In Domain 1 under Orchestration, complete the setup of a Swarm cluster, with managers and worker nodes. Demonstrate steps to lock a Swarm cluster, and paraphrase the importance of quorum within one. Then under Domain 5 Security, describe Mutual TLS. Alright, buckle up.

Container Networking
Networking. Now, networking's vast, and it's complex, and to be honest, probably deserves its own course. Well about that, it's got one. How about that? So in this module of this course, I'm giving you the CliffsNotes version. If you want deeper knowledge, and who doesn't right? Well, hit this other course here, it's got all the details. And if you're following along in the container management learning path that we've got, kudos, right? It's already a part of that. Anyway, here's the plan for now. Wait? No big picture? That's right, no big picture. I like to keep you on your toes. We're straight in with networking types, then it's network services, and then it's a recap. But remember, we're scratching the surface here, right? Enough to get you going. Get over to the full Docker networking course for the gory technical details. Now then, if you're studying for the Docker Certified Associate exam, we're going to nail these objectives. And they're all from Domain Four: Networking. So, create a Docker bridge network for a developer to use for their containers, publish a port so that an application is accessible externally, identify which IP and port a container is externally accessible on, describe the different types and use cases for the built-in network drivers, and deploy a service on a Docker overlay network. Now, we're going to cover more than that. These are just the bits from the exam. Let's go.

Working with Volumes and Persistent Data
Okay, containers are the bomb when it comes to non-persistent. They're here today, gone tomorrow and they do immutable as well, where they roll one out and then we never touch it. If we do need to touch it, we don't, we create a whole new one instead and push that out. And that's all great, only it's not great if you've got data that you need to change and you need to persist and let's face it, who doesn't have at least some of that? So this is where volumes come into play. Volumes are a great way to store persistent data and they're nicely decoupled from containers. Anyway, here's the plan. We'll do a big picture, what's all this persistent and non-persistent stuff anyway yeah? Then we'll look closely at volumes, create them, list them, delete them. Then we'll see how to hook them into containers and we'll finish up with a recap. Now as we crack on, we'll cover some stuff from the DCA exam, in particular from domain one orchestration, mount volumes. And domain six, storage and volumes, describe how volumes are used with Docker for persistent storage. Okay, let's do this.

Working with Secrets
You know what? I'd love to talk to you about this, what's on the slide there, but I can't. It's a secret. Sorry, that was bad. I know, really bad. Anyway, secrets, here's the plan. We'll start out with a big picture. I mean, what even is a secret and how do they work? All the theory stuff, yeah? Then we'll do a demo on the command line to reinforce that theory. After that, we'll deploy a secret into a WordPress app, but we'll do it with Universal Control Plane, the Docker web UI. Now, that's part of Docker Enterprise Edition. The commercial, "stick your hand in your wallet" edition, yeah? And I fully appreciate that not all of you are going to have access to that. But the focus is not on the UI, it's going to be on the app and how the secret fits in. I think you'll like it. Then, we'll do a recap 'cause repetition is the mother of learning. Now then, as usual, we'll touch on some exam stuff. From Domain 1, we'll add networks and publish ports. And from Domain 4, we'll deploy a service on an overlay network and make it available on an external port. Let's crack on.

Deploying in Production with Stacks and Services
We've said a few times already, containers are all about the apps. Magic. But we need a way to deploy and manage them in production. Enter stacks. This is like the icing on the top of the cake, it's almost like everything so far has been building to this point. Anyway, here's the plan. We'll set the scene with a quick big picture, then, we'll inspect the stack file, and that'll be a full on microservices app fully-defined in a single declarative file. Then we'll take that file and we'll deploy the app and manage it. Then we'll recap. Now then, we're going to cover some Docker certified associate exam stuff while we're at it. Specifically, we'll cover the following from domain one orchestration. Extend the instructions to run individual containers into running services under swarm. Convert an application deployment into a stack file using a YAML compose file with docker stack deploy. Manipulate a running stack of services, increase the number of replicas, and mount volumes. Let's go.