Swarm is Docker, Inc.’s orchestrator. It started development five years ago. It’s built into the Docker Engine, which makes it the same to run it on development machines as in production servers.
In my opinion, it is much less powerful than Kubernetes, and I would vote against using it in a business environment.
That said, I’m a happy admin of a single-node Swarm running all of my personal services at home. But that’s it. I wouldn’t use it for anything with more than 1-2 nodes, but for those applications, I feel is the right tool for the job.
Alexey Nizhegolenko has an excellent 3-part series of articles that cover the setup of Kubernetes on the bare metal servers. Here are the parts:
If that’s not a hand-holding walk-through guide, then I don’t know what is.
Kraken by Uber:
Kraken is a P2P-powered Docker registry that focuses on scalability and availability. It is designed for Docker image management, replication and distribution in a hybrid cloud environment. With pluggable backend support, Kraken can easily integrate into existing Docker registry setups as the distribution layer.
Kraken has been in production at Uber since early 2018. In our busiest cluster, Kraken distributes more than 1 million blobs per day, including 100k 1G+ blobs. At its peak production load, Kraken distributes 20K 100MB-1G blobs in under 30 sec.
I came across this blog post – “Goodbye Docker and Thanks for all the Fish” – which talks about the not-so-eminent, but very predictable death of Docker as both the technology, and the company. The gist of it is that container orchestration kicked in, and made Docker very replaceable with alternative container solutions. So much so, that in the upcoming release of the Red Hat Enterprise Linux 8 Docker has been replaced by Podman and a few other tools.
While I don’t know enough to have a strong opinion on the subject, the logic expressed in the blog post kind of makes sense to me.
All that reminded me of the recent interview with Simon Wardley, with the title providing the oversimplified summary:
Containers won the battle, but will lose the war to serverless.
Serverless concepts have been getting a lot of hype recently as well. And while I like where it’s going, I don’t think serverless will become a reality any time soon. Sure, it’s very applicable to smaller and simpler applications and well-engineered environments. But I think it’s more of a dream for the medium and large enterprise sector.
The thing is that the world moves at a much slower pace than we, in technology, would like to think. This Forbes article quotes some numbers from the study by IDG that shows that even the cloud adoption in the enterprise is far from complete yet.
The benefits of the cloud computing are obvious, but it takes time, and often a lot of it, to adopt the new technology and rip those benefits.
Once the cloud dust settles a bit, containers are the next on the list. I don’t have any hard numbers for container adoption in the enterprise, but my gut feeling is telling me that they are way below the cloud numbers (have a look at this study to get the feeling).
Serverless, in my mind, is the step after the containers. So even if that’s the future, it will take a long long time to get there.
Or maybe it won’t. Sometimes, the world gets so far behind the technology curve, that it jumps ahead by skipping steps. An example of that would be telephony in China, which went from almost nothing directly to mobile telephony, practically skipping the landlines.
In the “How to Bootstrap Kubernetes the hard way!” Yair Etziony shows how to setup a local Kubernetes cluster without using the tools like Minikube or Google Kubernetes Engine. He says it’s probably somewhat more difficult in the beginning, but eventually provides better understanding and knowledge, especially so for those who are just getting their feet wet in Kubernetes and container orchestration.
“How To Build a Serverless CI/CD Pipeline On AWS” is a nice guide to some of the newer Amazon AWS services, targeted at developers and DevOps. It shows how to tie together the following:
- Amazon EC2 (server instances)
- Docker (containers)
- Amazon ECR (Elastic Container Registry)
- Amazon S3 (storage)
- Amazon IAM (Identity and Access Management)
- Amazon CodeBuild (Continuous Integration)
- Amazon CodePipeline (Continuous Delivery)
- Amazon CloudWatch (monitoring)
- Amazon CloudTail (logs)
The examples in the article are for setting up the CI/CD pipeline for .NET, but they are easily adoptable for other development stacks.
There is plenty of documentation, tutorials, and guides online, explaining Docker containers, Kubernetes container orchestration, and microservices. Here are a few that I found useful for the quick and simple introduction into these technologies and how to tie them together.
Firstly, some basic 101s:
- Docker 101: Fundamentals & The Dockerfile
- Kubernetes 101: Pods, Nodes, Containers, and Clusters
- Running Kubernetes Locally via Minikube
- Clustered computing on Fedora with Minikube
- Kubernetes Glossary
Secondly, “Introduction to Microservices, Docker, and Kubernetes” YouTube video nicely puts all the things together, with complete code and configuration examples, some glue, and extra tips.
And finally, a few bits that you might need to solve on the way, which are not necessarily related, but can throw you off:
- Some of the virtualization bits (such as VirtualBox) might fail to run properly if you have Secure Boot enabled. To solve this problem, reboot the machine, go to the BIOS, and disable Secure Boot (enable Legacy Mode).
- Additionally, while you are there, check for the Virtualization Technology settings. Enable Virtualization Technology in the BIOS to further smooth out VirtualBox and friends.
- While working on your first minikube cluster (sorting out VirtualBox and such), it helps to completely remove and start again, after sorting out any issues that prevent Kubernetes to start (proxy timeouts, etc). A quick “minikube delete && minikube start” will save you some time on troubleshooting weird issues, than just “minikube start” after a failure.
“7 ways to do containers on AWS” covers a variety of different ways to run containers on the Amazon AWS cloud infrastructure. These include most of the usual suspects, like Amazon Elastic Container Service (ECS), Amazon Elastic Container Service for Kubernetes (EKS), and hand-rolled vanilla containers on EC2, as well as a few lesser known ones like templated Kubernetes and Amazon Fargate.
“A Practical Introduction to Container Terminology” is at the same time two things for me:
- The longest blog post that I’ve seen in a long time, if not ever.
- The best introductory tutorial into containers.