Deploy an Azure Kubernetes Service (AKS) cluster using the Azure portal

Create an AKS cluster

1. Sign in to the Azure portal.
2. On the Azure portal menu or from the Home page, select Create a resource.
3. Select Containers > Kubernetes Service.
4. On the Basics page, configure the following options:
   • Project details:
     • Select an Azure Subscription.
     • Select or create an Azure Resource group, such as myResourceGroup.
   • Cluster details:
     • Ensure the the Preset configuration is Standard ($$).
     • Enter a Kubernetes cluster name, such as myAKSCluster.
     • Select a Region for the AKS cluster, and leave the default value selected for Kubernetes version.
     • Select 99.5% for API server availability.
   • Primary node pool:
     • Leave the default values selected.
       

    

5. Select Next: Node pools when complete.
6. Keep the default Node pools options. At the bottom of the screen, click Next: Access.
7. On the Access page, configure the following options:
   • The default value for Resource identity is System-assigned managed identity. Managed identities provide an identity for applications to use when connecting to resources that support Azure Active Directory (Azure AD) authentication.
   • The Kubernetes role-based access control (RBAC) option is the default value to provide more fine-grained control over access to the Kubernetes resources deployed in your AKS cluster.
8. Click Review + create. When you navigate to the Review + create tab, Azure runs validation on the settings that you have chosen. If validation passes, you can proceed to create the AKS cluster by selecting Create. If validation fails, then it indicates which settings need to be modified.
9. It takes a few minutes to create the AKS cluster. When your deployment is complete, navigate to your resource by either:
   • Selecting Go to resource, or
   • Browsing to the AKS cluster resource group and selecting the AKS resource. In this example you browse for myResourceGroup and select the resource myAKSCluster.
     

Connect to the cluster

To manage a Kubernetes cluster, use the Kubernetes command-line client, kubectl. kubectl is already installed if you use Azure Cloud Shell.

1. Open Cloud Shell using the >_ button on the top of the Azure portal.
   
2. Configure kubectl to connect to your Kubernetes cluster using the az aks get-credentials command. The following command downloads credentials and configures the Kubernetes CLI to use them.

   az aks get-credentials --resource-group myResourceGroup --name myAKSCluster

3. Verify the connection to your cluster using kubectl get to return a list of the cluster nodes.

   kubectl get nodes

Deploy the application

A Kubernetes manifest file defines a cluster’s desired state, like which container images to run.

In this quickstart, you will use a manifest to create all objects needed to run the Azure Vote application. This manifest includes two Kubernetes deployments:

• The sample Azure Vote Python applications.
• A Redis instance.

Two Kubernetes Services are also created:

• An internal service for the Redis instance.
• An external service to access the Azure Vote application from the internet.

1. In the Cloud Shell, use an editor to create a file named azure-vote.yaml, such as:

   code azure-vote.yaml
   or
   nano azure-vote.yaml
   or
   vi azure-vote.yaml

2. Copy in the following YAML definition:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: azure-vote-back
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: azure-vote-back
     template:
       metadata:
         labels:
           app: azure-vote-back
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: azure-vote-back
           image: mcr.microsoft.com/oss/bitnami/redis:6.0.8
           env:
           - name: ALLOW_EMPTY_PASSWORD
             value: "yes"
           resources:
             requests:
               cpu: 100m
               memory: 128Mi
             limits:
               cpu: 250m
               memory: 256Mi
           ports:
           - containerPort: 6379
             name: redis
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: azure-vote-back
   spec:
     ports:
     - port: 6379
     selector:
       app: azure-vote-back
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: azure-vote-front
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: azure-vote-front
     template:
       metadata:
         labels:
           app: azure-vote-front
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: azure-vote-front
           image: mcr.microsoft.com/azuredocs/azure-vote-front:v1
           resources:
             requests:
               cpu: 100m
               memory: 128Mi
             limits:
               cpu: 250m
               memory: 256Mi
           ports:
           - containerPort: 80
           env:
           - name: REDIS
             value: "azure-vote-back"
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: azure-vote-front
   spec:
     type: LoadBalancer
     ports:
     - port: 80
     selector:
       app: azure-vote-front
   

3. Deploy the application using the kubectl apply command and specify the name of your YAML manifest:

   kubectl apply -f azure-vote.yaml

Test the application

1. When the application runs, a Kubernetes service exposes the application front end to the internet. This process can take a few minutes to complete.
   To monitor progress, use the kubectl get service command with the --watch argument.

   kubectl get service azure-vote-front --watch

2. To see the Azure Vote app in action, open a web browser to the external IP address of your service.
   
3. Delete cluster

   az group delete --name myResourceGroup --yes --no-wait