Working With Containers
Introduction to Docker
Containers are taking the industry by storm--from production microservices architectures to reworking development environments. Docker is empowering teams to start using containers today.
This course comes from my two years of running Docker in production, and more importantly teaching people how to use Docker. Docker changed everything for me when I started. It enabled my team and I to create portable and similar workflows across the different languages we used. Docker also enabled us to deploy new services in any language. It really felt light years ahead of where we where before. Hopefully the course captures some of the power and helps you take a step in this direction.
The high level goal for the course is to give your first taste of Docker and container technologies. Docker is not the first container technology, but it's the one that hit critical mass and is changing everything. Containerization changes how we need to think about developing and shipping software. This course should give you enough bearing to understand things you can start using today, then wider technical topics for coming months.
We'll start off with an introduction to container technologies. It may surprise you, but the underlying bits have actually been around for some time. Docker is new and making them accessible to teams of all shapes and sizes. Next we'll cover what I call the "Container Fundamentals". This will teach you the basics of interacting with containers, starting, stopping, networking, and docker volumes. Then we move onto building Docker images and how to apply Docker to your development process. The final lessons demonstrates building a microservices application using Docker Compose and deploying it with Docker Machine.
The course capstones with a summary and more importantly items that could not make into the course and points for further investigation. Hint, the next step is to look out different ways to run Docker in production.
All sound good? Check the first video and happy shipping!
By the end of this course, you'll know:
- The purpose and value of Docker
- How to create a container
- How to create multiple containers
- What tools are available to orchastrate containers in production
This is a beginner level course though it assumes:
- You have at least a basic understanding of containers
- You’re at least familiar with building and deploying code
What You'll Learn
A review of the course
|Lecture||What you'll learn|
|Intro||What will be covered in this course|
|Container Technologies||A review of the evolution of containers|
|Fundamentals 1||A review of Docker fundamentals|
|Fundamentals 2||A wrap up of our review on Docker fundamentals|
|Building Images||How to build docker images|
|Docker Toolchain||What tools exist in the Docker toolchain|
Do you have questions on this course? Contact our cloud experts in our community forum.
Hello, and welcome back to this Introduction to Docker course from Cloud Academy. I'm Adam Hawkins and I'll be your instructor for this lesson.
This is the course capstone. Given that this is a capstone lesson, we'll focus on reiterating what we learned in understanding this course in a wider context. So first we'll cover the course summary, also go into future learning objectives, and the jumping off points. The objective for this lesson is to show you the next steps to take in your docker journey. Let's move on to the course summary. I've had a blast teaching you during this course. I hope it has been enjoyable and you have learned some new skills and can start applying today.
Let's take a look through the high low points in this course. First, container technologies and docker. A docker is a culmination of many different technologies, and makes the accessible via a docker file and the docker tool chain. Running docker containers, we've covered the fundamentals of ports, volumes, networking, and the life cycle. Building docker images, we've covered key docker file concepts, such as base images, exposing ports, adding files, and setting the default commands.
Then we learned how to build better docker images using the official library. Multi-container applications with Docker Compose. We applied what we had learned about individual containers to build multi-container applications.
Finally, Docker Machine, we topped it all off by using Docker Machine to create a docker house and deployed our application. This section covers some things that didn't make it into the course, and others that were simply out of scope. First up in the fundamentals section, applying resource constraints. Docker Run accepts all sorts of arguments CPU of memory and IO. These things are more relevant to production environments. Local volume permissions, this can be a tricky bit to grok but it's important to understand. Docker containers run as root. This can be a problem when the containers write files to the volume mount. You should learn how these work on different docker setups. Hint, look into the docker's CP command. Docker exec, here is another useful feature that didn't make it into the course. Docker exec allows you to execute a command in existing container, this is useful for debugging. Docker stats, the memory, cpu, network stats on running containers. This is the first step down the road to container monitoring. Next on building images, build arguments. Build arguments allow you to parameterize a docker built. These are especially useful for setting things like build numbers or who or what built a particular image. Labels, images and containers may also have labels. These may be useful down the line. Think labeling image for what environment has been deployed to or if any critical bugs were found.
Next up, working with Docker. Dockerizing your Entire Development process. We build docker images after the fact in this course. It's possible to do everything with Docker to create a truly portable workflow. Blue/Green Docker Compose Deployments. There is a project out there to coordinate blue/green deploys. This will be more useful for anyone using Docker Compose in production. Overlay Networks, we use links in this course, but the future is networking. Investigate how to create a network and deploy containers to a particular network.
Now for the jumping off points, let's start with Docker itself. Docker Swarm is a first party clustering orchestration tool. It's an answer to building and scaling service applications. Swarm mode became official in a big way in Docker one point one two, along with a new feature called Distributive Application Bundle. I opted not to cover it in this course, because it required an experimental Docker version. Instead I wanted to focus on what we could accomplish right now. All that being said, you should definitely investigate Docker Swarm after this course.
Now Third Party Orchestration, orchestration is a huge deal. Every one has built of containers but something has to run them. There are a bunch of third party tools, some are docker specific, others are intended to run any type of application. There can be an entire course just on these tools, however I recommend you look into Mesos, DCOS, Kubernetes, Amazon ECS, and Rancher. This should give you a good overview of what's happening in this space, and what direction you may want to take.
Log Aggregations, this is an oft neglected point, so I think it's good to call it out here. Log aggregation is key for production environments. Dockers change how we think about logging. Check out our latest log drivers has to offer.
These two courses may be interesting for you, if you're looking on how to apply Docker to other technical areas. Also remember to check the course library every month or so. New relevant content is being added all of the time. Well, what can I say, most of the jumping off points are about orchestration, that's just where things are heading since Docker in Development is pretty much a solved. Now it's all about Docker in production.
I hope you've enjoyed my course. Please fee free to email, tweet me, or find me on the Cloud Academy community forum for any question or feedback. My door is always open, so good luck out there and happy shipping.
Adam is backend/service engineer turned deployment and infrastructure engineer. His passion is building rock solid services and equally powerful deployment pipelines. He has been working with Docker for years and leads the SRE team at Saltside. Outside of work he's a traveller, beach bum, and trance addict.