How to Deploy an Application on AWS Using Kubernetes

Kubernetes has transformed the way modern applications are deployed, managed, and scaled. As more organizations adopt containerized applications, Kubernetes has evolved as the standard for orchestrating these containers, offering a powerful platform for automating deployment, scaling, and operations. When combined with Amazon Web Services (AWS), Kubernetes becomes even more powerful, leveraging AWS' scalable infrastructure and managed services to provide a seamless and quick deployment experience.

AWS Elastic Kubernetes Service (EKS) simplifies Kubernetes deployment on AWS by managing the control plane, assuring high availability, and integrating smoothly with other AWS services such as IAM, CloudWatch, and Elastic Load Balancers. This guide, "Kubernetes Deployment Guide: Deploying an Application on AWS," explains how to install an application on Kubernetes with AWS EKS. Whether you're a developer, DevOps engineer, or IT professional, this guide will provide you with the knowledge and tools you need to successfully deploy and manage apps on an AWS Kubernetes cluster.

Kubernetes Deployments Explained: What They Are and Why They Matter

A Kubernetes deployment is fundamental to managing applications at scale. When you create a deployment, you define the desired state of your application, specifying details like the number of replicas (pods), the container image to use, and the deployment strategy. Kubernetes then ensures that the system's actual state matches this desired state. This approach is beneficial for handling tasks like scaling, rolling updates, and rollbacks without manual intervention.

Why deployments matter:

1. Automated management: Deployments automate scaling, rolling upgrades, and rollbacks, eliminating the need for human intervention.

2. Consistency and reliability: They ensure that all replicas of an application are consistent and gracefully handle failures by replacing or rescheduling pods as necessary.

3. Version control: Deployments allow for versioned rollouts and rollbacks, making it easier to test new versions or roll back if something goes wrong.

4. Declarative configuration: allows you to specify the desired state of your apps using YAML or JSON files, making them easier to maintain, track, and version control.

Why deploy Kubernetes applications on AWS

AWS's infrastructure is known for its dependability, which perfectly complements Kubernetes's features. AWS provides a robust, scalable, and highly available platform for managing containerized applications, leveraging the extensive features of AWS infrastructure like auto-scaling, security groups, and seamless integration with other AWS services

Deploying Kubernetes applications on AWS provides several advantages:

1. Scalability: Kubernetes on AWS allows for seamless application scaling by dynamically adjusting the number of container replicas based on demand. It employs features such as the Horizontal Pod Autoscaler (HPA) to increase or decrease pods based on resource utilization. AWS's auto-scaling capabilities ensure that these changes are seamless. This configuration enables programs to handle traffic spikes efficiently without manual intervention.

2. Managed Services: AWS EKS streamlines Kubernetes cluster management by automating control plane provisioning, patching, and upgrades, ensuring that the cluster is safe and up to date. It controls the Kubernetes API servers and the etcd database, letting developers concentrate entirely on application deployment and management without regard for the underlying infrastructure.

3. Cost Efficiency: AWS EKS reduces costs by properly managing resources through Kubernetes container orchestration. It schedules pods and allocates CPU and memory based on actual usage, ensuring containers consume only what they require. This strategy reduces resource waste while also helping to control expenditures. Furthermore, with AWS's pay-as-you-go model, you are only charged for your applications' resources, making cost management more predictable and efficient.

4. Security: AWS provides security for your Kubernetes clusters with capabilities such as IAM roles and network security groups. IAM roles enable you to manage access to Kubernetes resources using permissions, ensuring that users and service accounts only have the required access. Network security groups provide additional security by limiting inbound and outgoing traffic and allowing communication only from approved sources. This multi-layered security architecture protects the Kubernetes control plane and the apps running on AWS EKS.

Choosing the right AWS Kubernetes service: EKS vs. Self-Managed Kubernetes on EC2

When deploying applications in a Kubernetes cluster on AWS, you typically have two options: use Amazon Elastic Kubernetes Service (EKS) or create a self-managed Kubernetes cluster on EC2 instances. When deciding between these solutions, consider operational overhead, control requirements, and the complexity of your deployment approach. Both approaches have advantages, but understanding them in depth will help you make the best decision for your applications.

Amazon EKS

Amazon EKS is a managed service streamlining Kubernetes deployment on AWS by managing control plane maintenance tasks. This includes maintaining the API server, etcd, and other critical components so you can concentrate on building and scaling applications rather than worrying about the underlying infrastructure. EKS is especially appealing for companies that wish to use Kubernetes without getting too deep into its operational complexities.

EKS also connects well with other AWS services. For example, you can use Amazon CloudWatch for monitoring and IAM for security, allowing you to manage Kubernetes clusters more effectively. EKS also enables advanced deployment tactics, such as rolling update deployments, which gradually replace older versions of an application with newer ones to ensure minimal downtime. Kubernetes can immediately roll back to a prior version if something goes wrong during an update, preserving the desired state.

Another feature of EKS is that it allows for horizontal pod autoscaling. This functionality automatically adjusts the number of pod replicas based on CPU utilization or other parameters, ensuring your application can handle varying loads efficiently.

Self-Managed Kubernetes on EC2

If you require more control over your Kubernetes deployment, a self-managed cluster on EC2 is preferable. This approach involves manually configuring the Kubernetes control plane and worker nodes on EC2 instances, allowing you to customize networking, security, and storage to your specific requirements. However, the trade-off is a significantly higher operational overhead. You will be responsible for everything from security fixes to Kubernetes version upgrades.

Self-managed clusters are appropriate for scenarios requiring customized deployment procedures. If you wish to use canary deployments, in which a limited subset of customers are directed to the new version before a full rollout, maintaining your cluster will provide the necessary flexibility. Similarly, if you prefer a recreate deployment method, in which all existing pods are terminated before new ones are produced, a self-managed setup gives you control over deployment operations.

Making the Choice

If you want to balance ease of use and flexibility, EKS can be the best option. It simplifies most of the complexity of operating Kubernetes clusters while providing adequate control for most applications. However, if you require complete control over all aspects of your Kubernetes environment and the competence to manage it, a self-managed cluster on EC2 can provide the customization you need.

Understanding your application's requirements and your team's capabilities is critical for making the proper decision. Whatever your choice, Kubernetes on AWS can provide a stable and scalable environment for your applications.

Setting up Kubernetes on AWS

AWS provides a robust ecosystem for Kubernetes through its Elastic Kubernetes Service (EKS), simplifying deploying and managing Kubernetes clusters. Before setting up Kubernetes on AWS, ensure you have the following:

1. An AWS account with sufficient permissions to create EKS clusters, EC2 instances, and other resources.

2. AWS CLI is installed and configured on your local machine.

3. Kubectl command-line tool installed for interacting with your Kubernetes cluster.

4. eksctl tool installed for simplifying EKS cluster creation.

Step 1: Install and Configure Tools

• Install AWS CLI: Follow the official AWS documentation to install and configure the AWS CLI with your credentials.
• Install kubectl: Download and install kubectl, the Kubernetes command-line tool.
• Install eksctl: eksctl is a CLI tool for creating and managing EKS clusters. Install it using the instructions provided in the eksctl documentation.

Step 2: Create an EKS Cluster

Using eksctl, you can create an EKS cluster with a single command.

```
eksctl create cluster \
  --name my-cluster \
  --region us-west-2 \
  --nodegroup-name my-nodes \
  --node-type t3.medium \
  --nodes 3 \
  --nodes-min 2 \
  --nodes-max 5
```

This command:

• Creates a cluster named my-cluster in the us-west-2 region.
• Sets up a node group with three t3.medium instances.
• Configures auto-scaling for the node group, with a minimum of two nodes and a maximum of five.

Step 3: Configure kubectl

Once the cluster is created, configure Kubectl to interact with your EKS cluster:

``` aws eks update-kubeconfig --name my-cluster --region us-west-2 ```

Verify that Kubectl is working by listing the nodes in your cluster:
``` kubectl get nodes ```

Understanding Kubernetes deployments

A Kubernetes deployment is essential for managing applications in a Kubernetes cluster. They enable you to define, update, and scale your applications efficiently, ensuring they perform as expected.

What is a Kubernetes deployment?

A Kubernetes deployment is a higher-level abstraction that manages a cluster's pods. It specifies the desired state of your application, such as how many replicas (or instances) of each pod should run, which container images to use, and how to manage updates. Deployments use a declarative model, which means you specify the desired end state, and Kubernetes works to achieve it.

Here’s a simple example of a deployment YAML file for Nginx:

```
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

```

This file does a few things:

1. Defines the desired application state, indicating that three replicas of the Nginx pod should be running.

2. Uses matchLabels to manage pods with the same label (app: nginx).

3. Specifies the container image and version.

You can create this deployment using:

```kubectl apply -f nginx-deployment.yaml```

To view the status of your pods, you can run:
```kubectl get pods```

Key components of a deployment

1. ApiVersion: Specifies the API versioning (apps/v1 is standard for deployments).

2. Kind: indicates that this is a deployment resource.

3. Metadata: Contains the name and labels for the deployment.

4. Spec: defines the desired state, including the number of replicas, labels, and container details.

Deploying an Application to Kubernetes on AWS

Once your EKS cluster is set up and configured, the next step is to deploy your application to Kubernetes. This involves creating a Kubernetes deployment to define your application's desired state and exposing it using a service.

Step 1: Create a Kubernetes Deployment

A Kubernetes deployment defines the desired state for your application, including the number of replicas, container images, and resource limits. Below is an example YAML file for deploying an Nginx web server:

```
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
```

Save this file as``` nginx-deployment.yaml ``` and apply it using the following command:

The above command creates a nginx-deployment deployment with three replicas of the Nginx container.

Step 2: Expose the Deployment

To make your application accessible, you need to create a Kubernetes Service. A Service is a stable endpoint for accessing your application, either internally within the cluster or externally via a load balancer.

Here’s an example YAML file for creating a load balancer service:

```
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer
```

Save this file as

Verifying the deployment

After deploying your application, verifying that everything is working as expected is important.

Step 1: Check the Status of Your Deployment

Run the following command to check the status of your deployment:

You should see the

Step 2: Check the Status of Your Pods

Step 3: Access Your Application

To access your application, retrieve the external IP of the LoadBalancer Service:

Look for the nginx service and note the EXTERNAL IP address. Open a web browser and navigate to this IP address to see your Nginx application running.

Once your cluster is configured, deploying an application to Kubernetes on AWS using EKS is simple. Creating a deployment and exposing it as a service ensures your application is accessible.

Scaling and updating Kubernetes deployments

Kubernetes deployments offer significant capabilities for scaling and upgrading apps within a cluster. Whether you need to handle traffic spikes effortlessly or release new versions without downtime, Kubernetes provides various solutions to make the process easier.

Scaling Kubernetes Deployments

Kubernetes deployments can be scaled manually or automatically using Horizontal Pod Autoscaling (HPA).

1. Manual Scaling

To scale a deployment manually, use the following command:

This command sets the spec replicas field to 5, ensuring that Kubernetes generates or terminates pods at the desired count.

2. Horizontal Pod Autoscaling (HPA)

HPA enables Kubernetes to automatically scale pods based on CPU or memory utilization.

The above command instructs Kubernetes to add or remove pods if CPU usage exceeds 50%.

You can monitor autoscaler status using the following command below:

Updating Kubernetes Deployments

Kubernetes supports a variety of deployment options for updating applications without downtime.

1. Rolling Update Deployment

A rolling update enables a Deployment update to occur with no downtime. It accomplishes this by gradually replacing the existing Pods with new ones. The new Pods are scheduled on Nodes with available resources, and Kubernetes waits for them to start before eliminating the old ones.

Example YAML snippet:

```
strategy:
type: RollingUpdate
rollingUpdate:
maxSurge: 1
maxUnavailable: 1
```

A rolling update gradually directs traffic to the new version, reducing risk. If an update creates problems, you can revert to a previous version using the command below:

To check the status of the rollout, use the command below:

2. Canary Deployment

Canary deployment is a controlled method of releasing new software versions and testing a new version on a small subset of users to confirm it works well before rolling it out to all users.

Example YAML snippet for a canary deployment:

```
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-canary
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
      version: canary
  template:
    metadata:
      labels:
        app: nginx
        version: canary
    spec:
      containers:
      - name: nginx
        image: nginx:1.15.0
```

This method allows you to test new versions of an application safely and roll back if issues are detected.

Scaling and updating deployments ensure performance and reliability in a Kubernetes cluster. Using rolling updates and canary deployments, you can handle updates without downtime.

Monitoring and logging Kubernetes deployments on AWS

API monitoring and logging are critical components of managing Kubernetes deployments in AWS. They enable you to monitor the health of your applications, spot problems early, and guarantee that your cluster runs smoothly.

Monitoring collects information such as CPU, memory consumption, and pod status to provide insights into the health of your applications. Conversely, logging entails collecting application logs, pod logs, and cluster events to assist with debugging and tracing issues. Both are critical to ensuring your Kubernetes cluster remains in the desired state.

When deploying apps, you create a deployment strategy specifying the number of pods and other details. Monitoring guarantees that these pods remain healthy, whereas logging allows you to diagnose problems when the status varies from the ideal state.

Setting Up Monitoring for Kubernetes on AWS

a. Amazon CloudWatch for Metrics and Alarms

Amazon CloudWatch is the preferred service for monitoring Kubernetes on AWS. It collects metrics from your EKS cluster, including CPU and memory utilization for pods, nodes, and containers.

How to enable CloudWatch monitoring:

1. Create an IAM role for your EKS cluster with permissions to publish metrics to CloudWatch.

2. Install the CloudWatch Agent in your cluster using a Helm chart. Run the command below to install:

``` 
helm install --name cloudwatch-agent \
--namespace amazon-cloudwatch \
-f cloudwatch-agent-config.yaml \
stable/cloudwatch-agent
```

3. Configure the agent to collect metrics and send them to CloudWatch.

Types of metrics to monitor:

• CPU and memory usage: Ensures your pods do not exceed resource restrictions.
• Pod and node status: Determine whether any pods are failing.
• Horizontal Pod Autoscaling (HPA): Check that HPA is scaling your pods as planned.

You can set up CloudWatch Alarms to alert you when a metric exceeds a certain threshold, such as high CPU consumption on a pod.

b. Prometheus and Grafana for Advanced Monitoring

For more detailed monitoring, use Prometheus to collect metrics and Grafana for visualization.

Setting up Prometheus:

1. Deploy Prometheus in your EKS cluster using Helm:

4. Configure Prometheus to scrape metrics from the Kubernetes API and pods.

Types of metrics to monitor

• HTTP request rates and errors: Identify application-level issues.
• Pod restarts and failures: Ensure stability.
• Custom application metrics: Track business-specific KPIs

Logging Kubernetes Deployments on AWS

Logging is critical for knowing what happens within your applications and cluster. Kubernetes logs can be classified as:

• Application logs: logs generated by your containerized applications.
• Pod logs: logs from the Kubernetes infrastructure itself.
• Cluster logs: events and audit logs for security and compliance.

a. Using Amazon CloudWatch Logs.

CloudWatch Logs can collect logs from your Kubernetes cluster through the Fluent Bit or Fluentd agents.

Steps to set up CloudWatch Logs:

1. Create an IAM role for log publishing.

2. Deploy Fluent Bit as a DaemonSet:

``` 
kubectl apply -f https://raw.githubusercontent.com/aws/containers-roadmap/master/preview-programs/eks-logging/fluent-bit.yaml

```

3. Configure Fluent Bit to forward logs to CloudWatch.

Accessing logs:

• Go to CloudWatch Logs in the AWS console.
• Filter logs by namespace, pod name, or container.

You can search for errors or warnings in logs to troubleshoot issues quickly.

Effective monitoring and logging are crucial parts of managing Kubernetes clusters on AWS. Using CloudWatch, Prometheus, Fluentd, and the EFK stack, you can receive extensive visibility into the health of your cluster and troubleshoot issues proactively.

Securing Kubernetes Deployments on AWS

Security is vital to managing Kubernetes deployments on AWS. While Kubernetes is strong, it also exposes various attack surfaces, including the control plane to pods and networking.

Securing access to the Kubernetes API

The Kubernetes API server is your cluster's control center, handling deployments, scaling, and resource allocation. Securing access to this API is a top priority.

a. IAM Authentication

EKS uses AWS Identity and Access Management (IAM) for authentication. IAM roles and policies allow you to control who has access to the Kubernetes API.

Steps to configure IAM authentication:

1. Create an IAM role for each user or service that needs API access.
2. Map IAM roles to Kubernetes users using the aws-auth ConfigMap.

Example: ConfigMap for IAM Role Mapping

```
apiVersion: v1
kind: ConfigMap
metadata:
  name: aws-auth
  namespace: kube-system
data:
  mapRoles: |
    - rolearn: arn:aws:iam::123456789012:role/EKS-Admin
      username: admin
      groups:
        - system:masters
```

This setup ensures that only authenticated IAM roles can access your cluster.

b. Role-Based Access Control (RBAC)

RBAC regulates what users can and cannot do within the cluster once authenticated.

Example of RBAC Role for Read-Only Access

```
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: read-only
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "list"]
```

This role allows users to list and view pods but not modify them. Apply RoleBindings to associate this role with specific users.

C. Implement Network Policies

Use Kubernetes Network Policies to manage traffic between pods. AWS EKS supports the Calico network plugin, which enforces network restrictions.

Example

```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-app
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: my-app
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: trusted-app
```

d. Use Horizontal Pod Autoscaling (HPA)

HPA regulates the number of pods based on CPU or memory utilization. This ensures that your application can handle more traffic while reducing resource waste.

Example

```
apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
  name: my-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50
```

Securing Kubernetes deployments on AWS is a multi-layered procedure that includes access control, secure data management, safe deployment, and continuous monitoring.

CI/CD Pipeline for Kubernetes Deployment on AWS

A well-organized CI CD pipeline guarantees that changes are implemented securely, downtime is reduced, and rollbacks are seamless when delivering applications to Kubernetes on AWS.

Why CI/CD for Kubernetes on AWS?

To deploy an application on a Kubernetes cluster, numerous components must be managed, including containers, pods, services, and configurations. A CI CD pipeline automates these operations, lowering the likelihood of human error and increasing deployment reliability.

The advantages of a CI CD pipeline for Kubernetes on AWS include:

1. Automated Testing and Deployment: Tests the application before deployment to ensure its stability.

2. Scalability: It works with horizontal pod autoscaling to manage workloads dynamically.

3. Faster Rollbacks: If an issue emerges, the pipeline can automatically revert to a previous stable version.

4. Reduced manual effort: Developers can concentrate on writing code instead of managing infrastructure.

Setting up a CI/CD pipeline for Kubernetes on AWS

Step 1: Commit Code to a Repository

The CI/CD process starts when developers push code to a version control system like GitHub or AWS CodeCommit. This triggers the pipeline to start the build process.

Step 2: Build and Push Docker Image to Amazon ECR

Once code is committed, a CI tool (Jenkins, GitHub Actions, or AWS CodeBuild) builds a Docker image and pushes it to Amazon ECR. This ensures that all deployments use containerized applications.

Step 3: Deploy to Amazon EKS using Deployment Strategies

Once the container image is stored, the CD pipeline deploys it to an EKS cluster using one of the following deployment strategies:

Rolling Update Deployment

• Updates pods gradually without downtime.
• It uses apiversion apps/v1 kind of deployment metadata named nginx deployment to define the deployment.
• Ensures the desired number of pods remain available during updates.

Canary Deployment

• Routes a small percentage of traffic to the new version before a full rollout.
• Allows testing in production without affecting all users.

Recreate Deployment

• Deletes all existing pods before creating new ones.
• Not recommended for high-availability applications.

Step 4: Apply Kubernetes Configuration

The pipeline uses kubectl to apply the Kubernetes deployment file, defining how many replicas should be created:

```
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
```

This ensures that Kubernetes maintains the desired state of the application, scaling pods as needed.

By leveraging AWS services like EKS, ECR, CloudWatch, and CodeBuild, teams can automate the process and focus on application development rather than infrastructure management.

Cost Optimization and Best Practices for Kubernetes Deployments on AWS

Deploying an application in an AWS Kubernetes cluster allows for greater flexibility, scalability, and availability. However, expenses can quickly spiral out of hand without effective cost management measures. Understanding cost optimization strategies and applying best practices ensures that Kubernetes installations are efficient, cost-effective, and reliable.

Understanding Kubernetes Costs on AWS

Kubernetes costs on AWS are influenced by several factors, including

• Compute Resources: The number and size of EC2 instances or Fargate tasks that run your pods.
• Storage: persistent volumes and backups stored in Amazon EBS or S3.
• Networking: Data transfer between clusters and external services.
• Management Tools: Monitoring, logging, and CI/CD tools costs.

To cut costs, you must align your Kubernetes resource utilization with your application's requirements.

Cost Optimization Strategies

Right-sizing your cluster

Ensure that your Kubernetes cluster is not over- or under-provisioned. Overprovisioning wastes resources, while underprovisioning can cause performance issues. Use tools like Kubernetes' Vertical Pod Autoscaler (VPA) and Horizontal Pod Autoscaler (HPA) to alter resource allocations based on usage.

Use spot instances.

Spot instances can cut compute costs by up to 90 percent. These instances are appropriate for stateless, fault-tolerant workloads that can withstand interruptions. Using Spot instances for non-critical components of your application allows you to reduce your overall compute costs dramatically. However, be sure that your application is built to manage the occasional termination of Spot Instances gracefully.

Use Efficient Deployment Strategies

Choosing the appropriate deployment approach can help to reduce downtime and resource utilization. Rolling updates gradually replace old pods with new ones, resulting in no downtime during deployments. Recreate deployments and end all old pods before producing new ones, which is advantageous for applications that cannot run several versions concurrently but causes downtime. Canary deployments direct a small portion of traffic to the new version of an application, allowing you to test it prior to a full rollout. Each technique includes trade-offs, so select the one that best meets your application's needs.

Best Practices for Cost Optimization

Utilize Namespaces and Resource Quotas

Namespaces organize resources in your Kubernetes cluster, making them easier to manage and monitor. Resource quotas prevent overprovisioning by restricting the amount of CPU, memory, and storage available inside a namespace. Setting suitable quotas ensures that your apps receive the resources they require while staying within your budget.

Implement Autoscaling

Autoscaling ensures that your Kubernetes cluster can manage a variety of workloads without overprovisioning resources. Cluster Autoscaler can automatically adjust the size of your cluster in response to workload demands. This guarantees that you only pay for the resources you use while also being able to handle traffic spikes.

Consistently Clean Up Unused Resources

Over time, unwanted pods, services, and volumes can gather in your Kubernetes cluster, eating resources and increasing costs. Clean up unwanted resources on a regular basis to free up capacity and minimize costs. Use automated tools or scripts to detect and remove resources that are no longer required.

Conclusion

Kubernetes on AWS provides a powerful, flexible, and scalable platform for deploying and managing applications. By following the steps and best practices outlined in this guide, you can confidently deploy your applications, optimize performance, and ensure security and reliability. Whether you’re running a simple web application or a complex microservices architecture, Kubernetes and AWS provide the tools and infrastructure you need to succeed in the cloud.