Deploying workloads to AKS in Azure - Commands & Configuration

Introduction

Deploying workloads to AKS means putting your app or service into Azure Kubernetes Service so it can run and be managed easily. This helps you run your app in the cloud with automatic updates and scaling.

When you want to run a web app that can handle more users by adding more copies automatically.

When you need to update your app without stopping it for users.

When you want to run multiple parts of your app separately but together in the cloud.

When you want to use Azure's managed Kubernetes to avoid handling complex setup.

When you want to test your app in a cloud environment similar to production.

Config File - deployment.yaml

deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-deployment
  labels:
    app: my-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app-container
        image: nginx:1.23
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  type: LoadBalancer
  selector:
    app: my-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80

This file has two parts:

• Deployment: It tells AKS to run 2 copies of an Nginx web server container labeled 'my-app'.
• Service: It creates a LoadBalancer to expose the app on port 80 so users can reach it from the internet.

Commands

This command connects your local computer to the AKS cluster so you can control it using Kubernetes commands.

Terminal

az aks get-credentials --resource-group example-resource-group --name example-aks-cluster

Expected Output

Merged "example-aks-cluster" as current context in /home/user/.kube/config

→

--resource-group - Specifies the Azure resource group where the AKS cluster is located

→

--name - Specifies the name of the AKS cluster

This command tells AKS to create the deployment and service defined in the deployment.yaml file.

Terminal

kubectl apply -f deployment.yaml

Expected Output

deployment.apps/my-app-deployment created

service/my-app-service created

→

-f - Specifies the file containing the Kubernetes configuration

This command shows the status of the running app copies (pods) to check if they started successfully.

Terminal

kubectl get pods

Expected Output

NAME                                READY   STATUS    RESTARTS   AGE

my-app-deployment-6d4b75f7b7-abcde 1/1     Running   0          30s

my-app-deployment-6d4b75f7b7-fghij 1/1     Running   0          30s

This command shows the external IP address assigned to your app so you can access it from the internet.

Terminal

kubectl get service my-app-service

Expected Output

NAME             TYPE           CLUSTER-IP    EXTERNAL-IP     PORT(S)        AGE

my-app-service   LoadBalancer   10.0.123.45   52.170.12.34    80:31234/TCP   1m

Key Concept

If you remember nothing else from this pattern, remember: you create a deployment to run your app and a service to expose it to users.

Common Mistakes

Not running 'az aks get-credentials' before kubectl commands

kubectl won't know which cluster to talk to and commands will fail.

Always run 'az aks get-credentials' with the right resource group and cluster name first.

Using a Deployment without a Service to expose the app

Your app runs but cannot be reached from outside the cluster.

Create a Service of type LoadBalancer to get an external IP for your app.

Setting replicas to 0 in the deployment

No app copies will run, so your app will be unavailable.

Set replicas to at least 1 to keep your app running.

Summary

Use 'az aks get-credentials' to connect your local machine to the AKS cluster.

Apply your workload configuration with 'kubectl apply -f deployment.yaml' to create app pods and services.

Check pod status with 'kubectl get pods' to ensure your app is running.

Find your app's external IP with 'kubectl get service' to access it from the internet.

Practice

1. What is the main purpose of using a Deployment in Azure Kubernetes Service (AKS)?

easy

A. To monitor the health of the AKS cluster nodes

B. To manage and maintain a specified number of app copies running

C. To expose the app to the internet

D. To store data persistently for the app

Solution

1. Step 1: Understand Deployment role in AKS

   A Deployment ensures that a specified number of replicas of an app are running and manages updates to those replicas.

2. Step 2: Differentiate from other components

   Persistent storage is handled by volumes, exposure by Services, and monitoring by Azure Monitor, not Deployments.

3. Final Answer:

   To manage and maintain a specified number of app copies running -> Option B

4. Quick Check:

   Deployment manages app replicas = A [OK]

Hint: Deployments keep app copies running smoothly [OK]

Common Mistakes:

• Confusing Deployment with Service for exposure
• Thinking Deployment stores data
• Assuming Deployment monitors nodes

2. Which kubectl command correctly applies a YAML file named app-deployment.yaml to deploy an app to AKS?

easy

A. kubectl create app-deployment.yaml

B. kubectl run app-deployment.yaml

C. kubectl apply -f app-deployment.yaml

D. kubectl deploy app-deployment.yaml

Solution

1. Step 1: Identify correct kubectl syntax for applying YAML

   The command to apply a YAML file is kubectl apply -f filename.yaml.

2. Step 2: Check other options for correctness

   kubectl create requires resource type, kubectl run is for quick pod creation, and kubectl deploy is not a valid command.

3. Final Answer:

   kubectl apply -f app-deployment.yaml -> Option C

4. Quick Check:

   Apply YAML file = kubectl apply -f [OK]

Hint: Use 'kubectl apply -f' to deploy YAML files [OK]

Common Mistakes:

• Using 'kubectl create' without resource type
• Trying 'kubectl deploy' which doesn't exist
• Confusing 'kubectl run' with applying YAML

3. Given this YAML snippet for an AKS Deployment:

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

How many pods will AKS try to run for this Deployment?

medium

A. 3

B. 2

C. 1

D. 0

Solution

1. Step 1: Identify the replicas count in the YAML

   The replicas field is set to 3, meaning AKS will run 3 pods.

2. Step 2: Confirm no other fields override replicas

   There is no override or scaling specified, so the number remains 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   replicas: 3 means 3 pods [OK]

Hint: Check 'replicas' field for pod count [OK]

Common Mistakes:

• Ignoring the replicas field
• Confusing selector labels with pod count
• Assuming default pod count is 1

4. You applied a Deployment YAML but your pods are stuck in 'Pending' state. Which of these is the most likely cause?

medium

A. The container image name is misspelled

B. The Service type is set to ClusterIP

C. The Deployment YAML is missing the 'replicas' field

D. There are not enough cluster resources to schedule pods

Solution

1. Step 1: Understand what 'Pending' pod state means

   Pods in 'Pending' usually wait for resources like CPU or memory to be available on nodes.

2. Step 2: Evaluate options for causing Pending state

   Misspelled image causes ImagePull errors, missing replicas defaults to 1, and Service type doesn't affect pod scheduling.

3. Final Answer:

   There are not enough cluster resources to schedule pods -> Option D

4. Quick Check:

   Pending pods = resource shortage [OK]

Hint: Pending pods often mean no resources available [OK]

Common Mistakes:

• Confusing image pull errors with Pending state
• Thinking missing replicas stops pod creation
• Assuming Service type affects pod scheduling

5. You want to expose your AKS Deployment to the internet with a stable IP and load balancing. Which Kubernetes Service type should you use in your YAML?

hard

A. LoadBalancer

B. NodePort

C. ClusterIP

D. ExternalName

Solution

1. Step 1: Identify Service types and their purposes

   ClusterIP exposes service inside cluster only, NodePort exposes on node ports, LoadBalancer creates cloud load balancer with stable IP, ExternalName maps to external DNS.

2. Step 2: Choose Service type for internet exposure with stable IP

   LoadBalancer is the correct choice to get a cloud-managed IP and load balancing for external access.

3. Final Answer:

   LoadBalancer -> Option A

4. Quick Check:

   Internet exposure with stable IP = LoadBalancer [OK]

Hint: Use LoadBalancer Service for external stable IP [OK]

Common Mistakes:

• Using ClusterIP which is internal only
• Choosing NodePort which uses random ports
• Confusing ExternalName with load balancing