Terraform and Kubernetes for Deploying Complex Applications
As projects increase in complexity, so do the benefits of using tools to automate parts of the deployment process. Scaling your infrastructure and deploying to multiple platforms and locations can become unmanageable without the right workflows in place.
Fortunately, help is available in the form of the increasing selection of tools and platforms, like Kubernetes and Terraform, that are geared toward solving such problems.
Kubernetes is an open source tool that helps you manage (or orchestrate) containers. Though often associated with Docker, it can be used with any containerization solution.
Terraform is an open source infrastructure management system. You can use it to make versionable declarations of your infrastructure and keep it as closely monitored as your regular codebase.
If you work with containers, using a tool designed to automate their workflows will save you vast amounts of time. Batch deployments and administration tasks can be done quickly and repeatedly. Taking control of your infrastructure also has huge benefits and prevents it from becoming chaotic.
In this article, you’ll learn about what Kubernetes and Terraform can do for you, and how they complement each other. The tools will be compared on scalability, portability, and their ability to support specific workloads.
Provisioning infrastructure often involves minor edits to configuration files—doing small tweaks here and adjusting software versions there—and something that begins simply can soon become complex.
Many of the changes required can get lost. If you don’t document the procedure, you can end up with an unstable edifice dependent on a secret sauce that everyone has forgotten they made. That’s a big problem when you want to repeat the process—something that becomes more common as you scale up.
Terraform’s whole philosophy is geared toward scaling. With its four phases of adoption, it takes you through stages you are likely to encounter as you grow.
With Terraform, your infrastructure adjustment becomes self-documenting and repeatable. Your changes are tracked and can be tuned and repeated as needed. You can also see who made which adjustments, allowing you to ask them why if you need additional information.
It uses declarative files in HashiCorp Configuration Language (HCL) but can also work with other languages.
Like Terraform, Kubernetes is highly scalable and is designed specifically to manage groups of containerized applications. It groups containers into pods, allowing them to be managed simultaneously. At larger scales, pods are grouped into nodes, which could be either a physical or virtual machine.
Kubernetes has some specific limitations in terms of how many pods, nodes, and clusters it can handle. The 300,000 total container limit is an important one for large-scale deployments, like cloud service providers.
Kubernetes is supported by most major cloud providers. In Amazon’s case, there’s a specific tool, Amazon Elastic Kubernetes Service (EKS), which allows you to scale on demand.
Kubernetes includes autoscaling at both pod and node level.
It uses horizontal pod autoscaling to scale pods as required. Users can set the metrics that control this via its resource metrics API. It can also be configured via environment variables.
You can also scale by changing the number of replicas in a deployment.
In contrast, there are different ways to handle scaling with Terraform. It could be farmed out to a service provider. For instance, you can create an Auto Scaling group in AWS to automatically create and adjust a group of EC2 instances, along with a load balancer, allowing you to present a single IP address to the user. In AWS, you have a choice of load balancers. You could use an Application Load Balancer (ALB) for HTTP traffic or a Network Load Balancer (NLB) for TCP and UDP traffic.
Another way to approach scaling with Terraform is to manage your repos and make sure you divide responsibility between chunks of code. For example, you need a single repo to handle your network.
Using both tools means you can scale your infrastructure and applications together. If you have Terraform deploying your Kubernetes nodes to a major cloud provider, you can deliver applications to a worldwide audience.
There are many guides available for using the tools together. Once you understand the process, it’s possible to deploy very quickly.
Encapsulation is an inherent benefit of working with Kubernetes because you’re already using containerization and avoiding all the problems that go hand in hand with deployment.
Kubernetes’s plug-in architecture means it can readily adapt to other technologies, and its virtualized environments offer a high degree of portability.
Terraform uses providers to interface with data sources, such as APIs and other services. Some of these are provided by HashiCorp, while others are from a third party or the community. These provide a great degree of flexibility and make it easy to swap between data sources.
It also uses modules that let you reuse code for specific resources. These make it relatively painless to move identical infrastructure elsewhere.
Having Support for Tools
Terraform supports all kinds of services, with many plug-ins available. You can use it with its own configuration language or via its CLI. However, you don’t have to learn HCL. The Cloud Development Kit for Terraform (CDKTF) works with TypeScript, Python, Java, C#, and Go.
There are dedicated tutorials for using it with major services, including AWS, Azure, Docker, Google Cloud Platform (GCP), and Oracle Cloud Infrastructure (OCI).
Cloud providers offer their own out-of-the-box Kubernetes services. These include Google Kubernetes Engine (GKE), Amazon EKS, and Azure Kubernetes Service (AKS).
Kubernetes works with many different technologies, and its documentation gives guidance on a few specific ones, including WordPress and Cassandra.
Moving a Workload to a New Provider or Platform
Terraform provides templates that let you easily get started with each platform. How much of your existing templates can carry straight over will depend on the specifics of what you’re doing.
Terraform’s workflow is divided into two parts:
terraform plan defines what is provisioned, and
terraform apply actually provisions the infrastructure.
With Kubernetes, it’s easy to switch cloud providers. In fact, that kind of portability is one of its advantages. It’s supported by all major cloud providers, and containers can be deployed on them relatively easily.
Using Kubernetes to run your applications in containers and then using Terraform to provision the infrastructure let you build a workflow that can be carried over to run on other platforms.
Terraform can be used as part of a multi-cloud architecture strategy.
Deploying Portable Terraform Scripts Provisioning Kubernetes Clusters
Terraform can deploy to all kinds of cloud services as well as users’ own servers. If you want to move to another platform, its encapsulation makes that much easier. Things may not run out of the box, but it should be straightforward to identify what needs to change.
Kubernetes is built around containers, which are stored in pods. The containers are typically containerd, but Kubernetes can use anything compatible with its Container Runtime Interface (CRI).
In contrast, Terraform isn’t bound to any specific tool. It uses resources that are generated from providers. There are currently almost 2,000 of these listed in its documentation.
These providers let you create resources on a wide range of platforms, including all the major cloud services, like AWS, Azure, and Google Cloud. Kubernetes is included, too, demonstrating how readily these tools work together.
There are around 200 verified entries, with the rest provided by the community. Of course, you’re free to create your own if what you need isn’t listed.
Migrating a Workload from One Tool To the Other
Kubernetes’s and Terraform’s workloads are distinct, and they don’t run the same workloads. However, you can use them together by utilizing each to set up complementary parts of your system. The infrastructure provisioned by Terraform is then used to run your containerized applications deployed with Kubernetes.
Combining the two gives you access to a wide range of platform combinations.
Knowing the Limitations to What These Tools Can Handle
Because both tools are open source, your engineers have a wide scope for adjusting them to work with the workloads of your choice. Naturally, Terraform is an infrastructure provisioning tool, and Kubernetes is for containers, but beyond that, the sky’s the limit.
Using These Tools Together to Run a Workload
With Terraform used to provision infrastructure and Kubernetes used to manage pods of containers, you can handle both infrastructure and the specifics of your deployment together. In this scenario, you get the benefit of both worlds.
There are plenty of guides to show you how to do this, including the article “Use Kubernetes and Terraform together for cluster management” from Tech Target.
Terraform and Kubernetes cover different areas but dovetail well. In situations where they can work together, you can use Terraform to manage your infrastructure and Kubernetes to deploy your containers.
Terraform’s ability to automate infrastructure management means it becomes proportionally more useful as your infrastructure diversifies, such as if you have Kubernetes running multiple setups.
Both platforms can drastically boost your productivity if they fit your use case, and combining them can be even more effective.
Earthly makes CI/CD super simple
Fast, repeatable CI/CD with an instantly familiar syntax – like Dockerfile and Makefile had a baby.