How to Set Up a CI/CD Pipeline for Docker and Kubernetes on Azure
In today's fast-paced development landscape, Continuous Integration and Continuous Deployment (CI/CD) are essential for ensuring that software is delivered quickly and reliably. Combining CI/CD with Docker and Kubernetes on Azure can streamline your deployment process, enhance scalability, and improve resource management. This article will guide you through setting up a CI/CD pipeline on Azure for applications running in Docker containers orchestrated by Kubernetes.
What is CI/CD?
Continuous Integration (CI) is the practice of automatically testing and merging code changes to a shared repository. Continuous Deployment (CD) takes this a step further by automating the deployment of these changes to production environments. Together, CI/CD helps teams deliver software faster while maintaining high quality.
Why Use Docker and Kubernetes?
- Docker allows developers to package applications into containers, ensuring consistency across different environments.
- Kubernetes is an orchestration tool for managing these containers, providing features like scaling, load balancing, and automated deployments.
Why Azure?
Azure offers robust services for hosting both Docker containers and Kubernetes clusters, along with integrated tools for CI/CD. Leveraging Azure DevOps, you can automate the build, test, and deployment pipeline seamlessly.
Setting Up Your CI/CD Pipeline
Prerequisites
Before diving into the setup, ensure you have the following:
- An Azure account (you can sign up for a free account).
- Azure CLI installed on your local machine.
- Docker installed.
- Kubernetes CLI (kubectl) installed.
- Access to an Azure DevOps organization.
Step 1: Create a Docker Image
First, you need to create a Docker image of your application. Here’s a simple example using Node.js.
- Create a
Dockerfile:
```dockerfile # Use the official Node.js image FROM node:14
# Set the working directory WORKDIR /usr/src/app
# Copy package.json and install dependencies COPY package*.json ./ RUN npm install
# Copy the rest of the application code COPY . .
# Expose the application port EXPOSE 3000
# Command to run the application CMD ["node", "app.js"] ```
- Build the Docker Image:
Navigate to your project directory and run:
bash
docker build -t my-node-app .
- Run the Docker Image:
bash
docker run -p 3000:3000 my-node-app
Step 2: Push Your Image to Azure Container Registry (ACR)
- Create an Azure Container Registry:
bash
az acr create --resource-group myResourceGroup --name myContainerRegistry --sku Basic
- Login to ACR:
bash
az acr login --name myContainerRegistry
- Tag and Push Your Image:
bash
docker tag my-node-app myContainerRegistry.azurecr.io/my-node-app:v1
docker push myContainerRegistry.azurecr.io/my-node-app:v1
Step 3: Set Up Azure Kubernetes Service (AKS)
- Create an AKS Cluster:
bash
az aks create --resource-group myResourceGroup --name myAKSCluster --node-count 1 --enable-addons monitoring --generate-ssh-keys
- Connect to Your AKS Cluster:
bash
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
Step 4: Deploy Your Application to AKS
- Create a Kubernetes Deployment YAML file (
deployment.yaml):
yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-node-app
spec:
replicas: 2
selector:
matchLabels:
app: my-node-app
template:
metadata:
labels:
app: my-node-app
spec:
containers:
- name: my-node-app
image: myContainerRegistry.azurecr.io/my-node-app:v1
ports:
- containerPort: 3000
- Apply the Deployment:
bash
kubectl apply -f deployment.yaml
- Expose Your Deployment:
Create a service to expose your application:
yaml
apiVersion: v1
kind: Service
metadata:
name: my-node-app-service
spec:
type: LoadBalancer
ports:
- port: 80
targetPort: 3000
selector:
app: my-node-app
Apply the service:
bash
kubectl apply -f service.yaml
Step 5: Set Up CI/CD with Azure DevOps
-
Create a New Project in Azure DevOps.
-
Set Up a Pipeline:
- Go to Pipelines > Create Pipeline.
-
Select your repository (where your code and Dockerfile are located).
-
Configure the Pipeline: Use the following YAML configuration for your pipeline (
azure-pipelines.yml):
```yaml trigger: branches: include: - main
pool: vmImage: 'ubuntu-latest'
steps: - task: Docker@2 inputs: command: 'buildAndPush' repository: 'myContainerRegistry.azurecr.io/my-node-app' dockerfile: '**/Dockerfile' containerRegistry: 'myContainerRegistry' tags: | $(Build.BuildId)
-
task: Kubernetes@1 inputs: azureSubscription: 'Your Azure Subscription' azureResourceGroup: 'myResourceGroup' kubernetesCluster: 'myAKSCluster' command: 'apply' useConfigurationFile: true configuration: 'deployment.yaml' ```
-
Run Your Pipeline: Save and run your pipeline. Upon completion, your application should be deployed to your AKS cluster.
Troubleshooting Tips
- Ensure your Docker and Kubernetes configurations are correct.
- Check logs using
kubectl logs <pod-name>to diagnose issues. - Use Azure Monitor for deeper insights into application performance.
Conclusion
Setting up a CI/CD pipeline for Docker and Kubernetes on Azure is a powerful way to automate your software delivery process. With the steps outlined above, you can create a reliable pipeline that supports rapid development cycles and scalable deployments. Embrace the efficiency of CI/CD, and watch your development team thrive!