Azure Kubernetes Service (AKS) Community Blog

Azure Kubernetes Service (AKS) is a powerful managed container orchestration service that simplifies deploying, managing, and scaling containerized applications. In this post, we'll dive deep into two fundamental concepts of Kubernetes and AKS: Deployments and Services, exploring how they work together to ensure your applications are highly available and accessible.

Understanding Deployments

Deployments are Kubernetes objects that describe the desired state for your applications. They allow you to manage the rollout of your application updates by defining how many replicas of your application should be running and how they should be updated. When you create a Deployment, you specify a Pod template that defines the containers to run, their images, ports, and other configurations.

Key benefits of using Deployments include:

• Declarative Updates: You declare the desired state, and Kubernetes works to achieve it.
• Rollback Capabilities: Easily revert to a previous version of your application if a new deployment causes issues.
• Scaling: Increase or decrease the number of application instances with simple commands.

Introducing Services

While Deployments manage your application's pods, Services provide a stable network endpoint to access your application. Pods in Kubernetes are ephemeral; they can be created, destroyed, and rescheduled. A Service acts as an abstraction layer, providing a consistent IP address and DNS name that clients can use to connect to your application, regardless of the underlying pods' lifecycle.

There are several types of Services, each serving a different purpose:

• ClusterIP: Exposes the Service on a cluster-internal IP address, making it reachable only from within the cluster.
• NodePort: Exposes the Service on each Node's IP at a static port, allowing external access.
• LoadBalancer: Exposes the Service externally using a cloud provider's load balancer. In AKS, this typically provisions an Azure Load Balancer.
• ExternalName: Maps the Service to the contents of the externalName field (e.g., my.database.example.com), returning a CNAME record.

Putting it Together: Deployments and Services

A typical pattern involves using a Deployment to manage your application's pods and then defining a Service to expose those pods. The Service uses a selector to identify the pods it should route traffic to, based on labels defined in the Deployment's Pod template.

Here's a simplified example of a Deployment and a Service in YAML:

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

In this example, the Deployment ensures three instances of an Nginx container are running, labeled with app: web. The Service, also named my-web-app-service, targets pods with the label app: web and exposes them on port 80 as a LoadBalancer type, making it accessible from outside the cluster.

Conclusion

Deployments and Services are cornerstone concepts for building robust and scalable applications on AKS. By understanding and effectively utilizing them, you can ensure your applications are reliable, easy to manage, and accessible to your users. Stay tuned for more advanced topics in our AKS series!