DEV Community: Thwani sithole

Kubernetes on Azure: Part 3 - An Introduction to AKS

Thwani sithole — Fri, 14 Jun 2024 08:30:05 +0000

In the previous, we looked at how to set up a local Kubernetes cluster using Docker Desktop. In this post, we will look at how to set up a managed Kubernetes cluster on Azure using Azure Kubernetes Service (AKS) and deploy the distributed-calculator application.

What is AKS?
Creating and configuring an AKS cluster
Deploy an application to the AKS cluster
AKS Automatic
Conclusion

What is AKS?

Azure Kubernetes Service (AKS) is a managed Kubernetes service provided by Microsoft Azure. AKS allows us to easily deploy and manage containerized applications. Since AKS is a managed service, it reduces the complexity of managing a Kubernetes cluster. Azure is responsible for managing the overhead that comes with managing a Kubernetes cluster. AKS is an ideal solution for applications that have high availability, scalability, and portability requirements.

With AKS, the operational overhead of managing a K8s cluster lies with Azure. Azure is responsible for managing the cluster's control plane. Azure is also responsible for managing cluster operations such as health monitoring and maintenance. The AKS control plane is created automatically at no cost to the developer. The developer is only responsible for provisioning and managing the worker nodes where the application workloads run.

Azure manages the control plane and exposes the Kubernetes API server so we can interact with the cluster and deploy the application workloads. Each AKS cluster has at least one node, an Azure Virtual Machine (VM) that runs the K8s node components (kube-proxy, kubelet, container-runtime). AKS allows us to group multiple nodes into node pools. Node pools allow us to segregate workloads based on resource requirements. For example, we can have a node pool for CPU-intensive workloads and another node pool for memory-intensive workloads.

Creating and configuring an AKS cluster

To create an AKS cluster, we can use either the Azure portal, Azure CLI, or ARM templates. In this post, we will use the Azure CLI to create an AKS cluster. Before we can create an AKS cluster, we need to install the Azure CLI and authenticate with Azure. To install the Azure CLI, follow the instructions here. To authenticate with Azure, run the following command:

You will need to have an existing Azure subscription to create an AKS cluster. If you do not have an Azure subscription, you can create a free account here.

Login and create a resource group to contain the AKS cluster:

az login
az group create --name aks-demo-rg --location eastus

Create an AKS cluster:

We create an AKS cluster with three nodes

az aks create --resource-group aks-demo-rg --name aksDemoCluster --node-count 3 --generate-ssh-keys

Connect to the AKS cluster:

We need to configure kubectl to connect to our AKS cluster

az aks get-credentials --resource-group aks-demo-rg --name aksDemoCluster
# Merged "aksDemoCluster" as current context in <poth-to-kubeconfig>

Verify the connection to the AKS cluster:

We can verify the connection to the AKS cluster by running the following command:

kubectl get nodes
# NAME                                STATUS   ROLES   AGE   VERSION
# aks-nodepool1-32415939-vmss000000   Ready    agent   13m   v1.28.9
# aks-nodepool1-32415939-vmss000001   Ready    agent   13m   v1.28.9
# aks-nodepool1-32415939-vmss000002   Ready    agent   58s   v1.28.9

Deploy an application to the AKS cluster:

We can deploy the distributed calculator application to the AKS cluster by running the following command:

kubectl apply -f https://raw.githubusercontent.com/Thwani47/distributed-calculator/master/src/manifests/nestjs-divider-deployment.yaml
# deployment.apps/nestjs-divider-deployment created
# service/nestjs-divider created

kubectl apply -f https://raw.githubusercontent.com/Thwani47/distributed-calculator/master/src/manifests/go-subtractor-deployment.yaml
# deployment.apps/go-subtractor-deployment created
# service/go-subtractor created

kubectl apply -f https://raw.githubusercontent.com/Thwani47/distributed-calculator/master/src/manifests/csharp-adder-deployment.yaml
# deployment.apps/csharp-adder-deployment created
# service/csharp-adder created

kubectl apply -f https://raw.githubusercontent.com/Thwani47/distributed-calculator/master/src/manifests/flask-multiplier-deployment.yaml
# deployment.apps/flask-multiplier-deployment created
# service/flask-multiplier created

kubectl apply -f https://raw.githubusercontent.com/Thwani47/distributed-calculator/master/src/manifests/calculator-deployment.yaml
# deployment.apps/calculator-deployment created
# service/calculator-service created

We can run kubectl get all to view all the resources that have been created

kubectl get all
# NAME                                               READY   STATUS    RESTARTS      AGE
# pod/calculator-deployment-95956bf4c-rvjhj          1/1     Running   1 (37s ago)   7m7s
# pod/csharp-adder-deployment-79b878dc45-kbqns       1/1     Running   0             7m18s
# pod/flask-multiplier-deployment-67566f5985-dlrph   1/1     Running   0             7m13s
# pod/go-subtractor-deployment-7856c959f7-pz7kr      1/1     Running   0             7m27s
# pod/nestjs-divider-deployment-7b54767779-9hlq7     1/1     Running   0             8m7s

# NAME                         TYPE           CLUSTER-IP     EXTERNAL-IP      PORT(S)          AGE
# service/calculator-service   LoadBalancer   10.0.153.154   48.216.153.102   3000:31252/TCP   7m8s
# service/csharp-adder         ClusterIP      10.0.131.41    <none>           8080/TCP         7m18s
# service/flask-multiplier     ClusterIP      10.0.246.199   <none>           5000/TCP         7m13s
# service/go-subtractor        ClusterIP      10.0.46.207    <none>           8000/TCP         7m28s
# service/nestjs-divider       ClusterIP      10.0.4.218     <none>           3000/TCP         8m8s

# NAME                                          READY   UP-TO-DATE   AVAILABLE   AGE
# deployment.apps/calculator-deployment         1/1     1            1           7m8s
# deployment.apps/csharp-adder-deployment       1/1     1            1           7m19s
# deployment.apps/flask-multiplier-deployment   1/1     1            1           7m14s
# deployment.apps/go-subtractor-deployment      1/1     1            1           7m28s
# deployment.apps/nestjs-divider-deployment     1/1     1            1           8m8s

# NAME                                                     DESIRED   CURRENT   READY   AGE
# replicaset.apps/calculator-deployment-95956bf4c          1         1         1       7m8s
# replicaset.apps/csharp-adder-deployment-79b878dc45       1         1         1       7m19s
# replicaset.apps/flask-multiplier-deployment-67566f5985   1         1         1       7m14s
# replicaset.apps/go-subtractor-deployment-7856c959f7      1         1         1       7m28s
# replicaset.apps/nestjs-divider-deployment-7b54767779     1         1         1       8m8s

We can open the browser to <CALCULATOR-SERVICE-EXTERNAL-IP>:3000 to access our application. We should be able to see the calculator app and be able to interact with it.

Now that we have deployed the application, we can perform actions such as scaling our application, either by adding more instances of the application or adding more nodes to the cluster. We can increase the number of instances of the calculator UI by running the following command:

kubectl scale deployment calculator-deployment --replicas=3
# deployment.apps/calculator-deployment scaled

We can verify that the number of instances has been increased by running kubectl get pods,deploy --selector app=calculator:

kubectl get pods,deploy --selector app=calculator

# NAME                                        READY   STATUS    RESTARTS      AGE
# pod/calculator-deployment-95956bf4c-mqct7   1/1     Running   0             87s
# pod/calculator-deployment-95956bf4c-p2q8g   1/1     Running   0             87s
# pod/calculator-deployment-95956bf4c-rvjhj   1/1     Running   1 (15m ago)   21m

# NAME                                    READY   UP-TO-DATE   AVAILABLE   AGE
# deployment.apps/calculator-deployment   3/3     3            3           21m

We can add more nodes by running

az aks scale --resource-group aks-demo-rg --name aksDemoCluster --node-count 5
kubectl get nodes
# NAME                                STATUS   ROLES   AGE   VERSION
# aks-nodepool1-32415939-vmss000000   Ready    agent   34m   v1.28.9
# aks-nodepool1-32415939-vmss000001   Ready    agent   34m   v1.28.9
# aks-nodepool1-32415939-vmss000002   Ready    agent   21m   v1.28.9
# aks-nodepool1-32415939-vmss000003   Ready    agent   28s   v1.28.9
# aks-nodepool1-32415939-vmss000004   Ready    agent   35s   v1.28.9

Delete the resource group to avoid incurring costs.

az group delete --name aks-demo-rg --yes

AKS Automatic

In May this year, Microsoft introduced Azure Kubernetes Service (AKS) Automatic, which offers a more simplified Kubernetes experience for developers. With AKS Automatic, Azure takes care of the cluster setup, node management, scaling, and security, and offers preconfigured settings that follow the AKS well-architected best practices. AKS Automatic provides developers easy access to production-ready clusters, which allows them to focus on building their applications, and run them on Kubernetes with ease.

AKS Automatic comes with pre-configured features such as:

a managed Prometheus service for metric collection
a managed Grafana service for visualization
a managed Container Insights service for collection
automatic node management. AKS Automatic automatically scales the number of nodes based on the application's resource requirements.
Azure RBAC for cluster access control,

and many more features.

At the time of writing, AKS Automatic is currently in preview and is not generally available.

Conclusion

In this post, we looked at how to create an AKS cluster using the Azure CLI and deploy the application to our cluster. We also looked at how to scale the application and the cluster. We also looked at AKS Automatic, a new feature that simplifies the Kubernetes experience for developers. AKS Automatic provides a production-ready Kubernetes cluster with pre-configured settings that follow the AKS well-architected best practices.

Kubernetes on Azure: Part 2 - Running a local Kubernetes cluster

Thwani sithole — Fri, 14 Jun 2024 08:23:42 +0000

In the previous blog post, we went through the basics of Kubernetes and the Kubernetes architecture. In this blog post, we will explore how to run a local Kubernetes cluster on our machines.

Installing Kubernetes
Deploying a Pod
Replication Controllers and ReplicaSets
Creating a Deployment
Creating a Service
Conclusion

Installing Kubernetes

The easiest way to run a Kubernetes cluster is to install Docker Desktop and enable Kubernetes. On Docker Desktop, we can enable Kubernetes by going to the Docker Desktop settings, clicking on the Kubernetes tab on the left side, and checking the box to enable Kubernetes. Click on the Apply & Restart button to apply the changes.

Another way to run a Kubernetes cluster is to use Minikube. Minikube is a tool that allows you to run a single-node Kubernetes cluster on your local machine. Minikube can be installed on Windows, macOS, and Linux. To install Minikube, follow the instructions here. In this blog post, we will be using Docker Desktop to run our Kubernetes cluster.

On Windows and macOS, Docker Desktop comes with kubectl, a command-line tool we use to interact with the Kubernetes cluster. If you prefer installing kubectl on your own, instructions on how to do that can be found here.

To verify that Kubernetes is running, we can run the following command:

kubectl cluster-info

This command will display the address of the Kubernetes control plane. The output should look something like this:

# Kubernetes control plane is running at https://kubernetes.docker.internal:6443
# CoreDNS is running at https://kubernetes.docker.internal:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

# To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

When running Kubernetes locally, the cluster is run on a single node, which means the control (master) node and worker node are the same.

Let's see how we can deploy resources to our cluster. I have created a simple distributed calculator app that we will use to deploy resources to our Kubernetes cluster. The calculator app consists of the following components:

calculator - A React application which is the front end of the app.
go-subtractor - A Golang API that exposes an endpoint to subtract 2 numbers
csharp-adder - A .NET API that exposes an endpoint to add 2 numbers
python-multiplier - A Flask API that exposes an endpoint to multiply 2 numbers
nestjs-divider - A NestJS API that exposes an endpoint to divide 2 numbers

The source code for the calculator app can be found here.

Deploying a Pod

In the previous post, we mentioned that Kubernetes Pods are the smallest unit of deployment. Kubernetes does not run containers directly, but groups one (or more) containers into a single atomic unit called a Pod. We can run a Pod in Kubernetes using the kubectl run command. The below command runs the calculator image in a Pod

kubectl run calculator --image=ghcr.io/thwani47/calculator:v1
# pod/calculator created

We can check that our Pod is running by using the kubectl get command as follows

kubectl get pods
# NAME         READY   STATUS             RESTARTS      AGE
# calculator   0/1     CrashLoopBackOff   3 (25s ago)   62s

The status of the Pod is CrashLoopBack because the **calculator* container needs the other containers to be running for it to work correctly, so it will keep on crashing. We'll fix that a bit later*😀

We can also use kubectl describe to get more information about the Pod such as the image used, the status, and the events that have occurred

kubectl describe pod calculator
# Name:             calculator
# Namespace:        default
# Priority:         0
# Service Account:  default
# Node:             docker-desktop/192.168.65.3
# Start Time:       Sat, 01 Jun 2024 11:23:21 +0200
# Labels:           run=calculator
# Annotations:      <none>
# Status:           Running
# IP:               10.1.0.126
# ... other information

we can get the logs of the Pod using the kubectl logs command

kubectl logs calculator
# ... other logs
# 2024/05/31 20:06:44 [emerg] 1#1: host not found in upstream "csharp-adder" in /etc/nginx/conf.d/default.conf:10
# nginx: [emerg] host not found in upstream "csharp-adder" in /etc/nginx/conf.d/default.conf:10

We can delete our Pod using the kubectl delete command

kubectl delete pod calculator
# pod "calculator" deleted

We can also make use of manifest files, which are either JSON or YAML files, which allow us to use a declarative approach instead of the imperative approach we used above to deploy resources to our cluster. Below is an example of a manifest file that deploys the calculator Pod

# calculator-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: calculator
  labels:
    app: calculator
spec:
  containers:
  - name: calculator
    image: ghcr.io/thwani47/calculator:v1

We can deploy the Pod using the kubectl apply command

kubectl apply -f calculator-pod.yaml
# pod/calculator created

We can use the commands we used above to check the status of the Pod, get the logs, and delete the Pod.

In most cases, we will want to have multiple Pods running in our cluster, and we would like the assurance that the desired number of Pods are running at all times and if a Pod was to crash, it would be restarted. This is where Replication Controllers and ReplicaSets come in.

Replication Controllers and ReplicaSets

Controllers are the brains behind Kubernetes. They are responsible for ensuring that the desired state of the cluster matches the actual state. Controllers are responsible for creating, updating, and deleting resources in the cluster. The Replication Controller helps us run multiple Pods and ensures that the desired number of Pods are running at all times. The Replication Controller is an old technology which is being replaced by ReplicaSets. We can define a ReplicationControler for our calculator Pod as follows

# calculator-replication-controller.yaml
apiVersion: v1
kind: ReplicationController
metadata:
  name: calculator-replication-controller
  labels:
    app: calculator
spec:
  replicas: 2 # the number of Pods we want to be always running
  template:
    metadata:
      labels:
        app: calculator
    spec:
      containers:
      - name: calculator
        image: ghcr.io/thwani47/calculator:v1

We add the Pod definition in the template section of the Replication Controller. The replicas field specifies the number of Pods we want to be running at all times. In this case, we want 2 Pods of the calculator app running at all times.
We can deploy the ReplicationController using the kubectl apply command

kubectl apply -f calculator-replication-controller.yaml
# replicationcontroller/calculator-replication-controller created

We can check the status of the Replication Controller using the kubectl get command

kubectl get replicationcontroller
# NAME                                DESIRED   CURRENT   READY   AGE
# calculator-replication-controller   2         2         0       41s

We can also view the Pods that are running using the kubectl get command

kubectl get pods
# NAME                                      READY   STATUS             RESTARTS      AGE
# calculator-replication-controller-7n9fw   0/1     CrashLoopBackOff   4 (30s ago)   113s
# calculator-replication-controller-z4gbj   0/1     CrashLoopBackOff   4 (17s ago)   113s

The Pods controlled by a ReplicationController are named using the format: <controller-name>-<random-string>.

We can delete one Pod and a new Pod will be created to replace it

kubectl delete pod calculator-replication-controller-7n9fw

If we run the kubectl get pods command, we will see that a new Pod has been created to replace the one we deleted.

kubectl get pods
# NAME                                      READY   STATUS             RESTARTS      AGE
# calculator-replication-controller-76hpd   0/1     CrashLoopBackOff   2 (18s ago)   35s
# calculator-replication-controller-z4gbj   0/1     CrashLoopBackOff   5 (74s ago)   4m12s

We can also use ReplicaSets to manage Pods. ReplicaSets are the next generation of ReplicationControllers. ReplicaSets are more powerful and flexible than ReplicationControllers. We can define a ReplicaSet for our calculator Pod as follows

# calculator-replicaset.yaml
apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: calculator-replicaset
  labels:
    app: calculator
spec:
    replicas: 2
    selector:
        matchLabels:
            app: calculator
    template:
        metadata:
            labels:
                app: calculator
        spec:
            containers:
            - name: calculator
              image: ghcr.io/thwani47/calculator:v1

The selector field helps the ReplicaSet identify the Pods that fall under it. It is a required field for the ReplicaSet but not for the Replication Controller. The ReplicaSet can also manage Pods that were created outside of it.

We can deploy the ReplicaSet using the kubectl apply command

kubectl apply -f calculator-replicaset.yaml
# replicaset.apps/calculator-replicaset created

We can check the status of the ReplicaSet using the kubectl get command

kubectl get replicaset
# NAME                    DESIRED   CURRENT   READY   AGE
# calculator-replicaset   2         2         0       22s

We can also view the Pods that are running using the kubectl get command

kubectl get pods
# NAME                                          READY   STATUS             RESTARTS       AGE
# pod/calculator-replicaset-d4p57               0/1     CrashLoopBackOff   3 (20s ago)    61s
# pod/calculator-replicaset-x2wkb               0/1     CrashLoopBackOff   3 (20s ago)    61s

Kubernetes Deployments allow us to upgrade our application instances, roll back to a previous version, and scale our application instances. Deployments are the recommended way to manage Pods and ReplicaSets. In the next section, we will go through how to create a Deployment for our calculator.

Creating a Deployment

A Deployment is a higher-level abstraction that manages ReplicaSets and Pods. Deployments allow us to define the desired state of our application and Kubernetes will ensure that the actual state matches the desired state. We can define a Deployment for our calculator Pod as follows

# calculator-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: calculator-deployment
  labels:
    app: calculator
spec:
    replicas: 2
    selector:
        matchLabels:
          app: calculator
    template:
        metadata:
          labels:
            app: calculator
        spec:
          containers:
          - name: calculator
            image: ghcr.io/thwani47/calculator:v1

A Deployment automatically creates a ReplicaSet. It also creates a rollout history that allows us to roll back to a previous version of the application. We can deploy the Deployment using the kubectl apply command

kubectl apply -f calculator-deployment.yaml
# deployment.apps/calculator-deployment created

We can run kubectl get all to get all the resources that have been created

kubectl get all
# NAME                                         READY   STATUS   RESTARTS      AGE
# pod/calculator-deployment-6c6cbff8bb-tp4f6   0/1     Error    3 (28s ago)   44s
# pod/calculator-deployment-6c6cbff8bb-tqcfd   0/1     Error    3 (30s ago)   44s

# NAME                                    READY   UP-TO-DATE   AVAILABLE   AGE
# deployment.apps/calculator-deployment   0/2     2            0           44s

# NAME                                               DESIRED   CURRENT   READY   AGE
# replicaset.apps/calculator-deployment-6c6cbff8bb   2         2         0       44s

This created a Deployment, a ReplicaSet, and 2 Pods. We can check the status of the Deployment using the kubectl get command

kubectl get deployment calculator-deployment

We can also check the rollout history using the kubectl rollout command

kubectl rollout history deployment calculator-deployment
# REVISION  CHANGE-CAUSE
# 1         <none>

In Kubernetes, each Pod gets its own IP internal IP address. A Kubernetes cluster has its network with an address range, and the Pods are assigned IP addresses within this range. Pods can communicate with each other using these IP addresses. The only downside is that Pods are very volatile and can be created and destroyed at any time. This means that the IP address of a Pod can change at any time. To solve this problem, Kubernetes has a concept called Services. Services provide a stable IP address and DNS name for a set of Pods. In the next section, we will go through how to create a Service for our calculator app.

Creating a Service

A Service is an abstraction that defines a logical set of Pods and a policy by which to access them. Services allow us to expose our application to the outside world. Kubernetes allows us to create 3 types of Services:

ClusterIP: This is the default type of Service. It exposes the Service on a cluster-internal IP. This means that the Service is only accessible within the cluster. This Service spans across all the Pods assigned to it.
NodePort: This type of Service exposes the Service on each Node's IP address at a static port. This means that the Service is accessible from outside the cluster using the Node's IP address and the NodePort. This Service spans across multiple nodes in the setting of a multi-node cluster.
LoadBalancer: This type of Service exposes the Service externally using a cloud provider's load balancer. This Service creates a load balancer that can distribute traffic to the Pods assigned to it.

We can define a Service for our calculator app as follows

# calculator-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: calculator-service
  labels:
    app: calculator
spec:
    selector:
        app: calculator
    ports:
    - protocol: TCP
      port: 3000 # the port the Service will be exposed on
      targetPort: 80 # the port the Service will forward traffic to on the Pods
    type: LoadBalancer

We create a LoadBalancer Service because we want to expose our calculator app to the outside world. The Service will be exposed on port 3000 and will forward traffic to port 80 of the Pods. We can deploy the Service using the kubectl apply command

kubectl apply -f calculator-service.yaml
# service/calculator-service created

We can check the status of the Service using the kubectl get command

kubectl get service
# NAME                         TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
# service/calculator-service   LoadBalancer   10.107.255.80   localhost     3000:32092/TCP   4s

The Service has been created and is accessible on localhost:3000. We can access the calculator app by navigating to localhost:3000 in our browser.

Now that we have covered the major Kubernetes objects we need to run our calculator app, let us run the whole thing to see it in action. In the application source code, we have a manifests folder, which contains YAML files with the definitions of the Deployments and Services of the distributed calculator app. The manifest files define ClusterIP Services for the APIs and a LoadBalancer Service for the calculator app.

We can run the distributed calculator app using the following commands

kubectl apply -f https://raw.githubusercontent.com/Thwani47/distributed-calculator/master/src/manifests/nestjs-divider-deployment.yaml
# deployment.apps/nestjs-divider-deployment created
# service/nestjs-divider created

kubectl apply -f https://raw.githubusercontent.com/Thwani47/distributed-calculator/master/src/manifests/go-subtractor-deployment.yaml
# deployment.apps/go-subtractor-deployment created
# service/go-subtractor created

kubectl apply -f https://raw.githubusercontent.com/Thwani47/distributed-calculator/master/src/manifests/csharp-adder-deployment.yaml
# deployment.apps/csharp-adder-deployment created
# service/csharp-adder created

kubectl apply -f https://raw.githubusercontent.com/Thwani47/distributed-calculator/master/src/manifests/flask-multiplier-deployment.yaml
# deployment.apps/flask-multiplier-deployment created
# service/flask-multiplier created

kubectl apply -f https://raw.githubusercontent.com/Thwani47/distributed-calculator/master/src/manifests/calculator-deployment.yaml
# deployment.apps/calculator-deployment created
# service/calculator-service created

Now if we run kubectl get all, we will see all the resources that have been created.

kubectl get all
# NAME                                               READY   STATUS    RESTARTS   AGE
# pod/calculator-deployment-6dfddc9c56-rmsk4         1/1     Running   0          101s
# pod/csharp-adder-deployment-5945454df8-fhmf8       1/1     Running   0          2m25s
# pod/flask-multiplier-deployment-756d96c7fd-5b9sx   1/1     Running   0          2m4s
# pod/go-subtractor-deployment-5ff5d997db-cvvvt      1/1     Running   0          2m41s
# pod/nestjs-divider-deployment-c8dd85b56-bcqqc      1/1     Running   0          3m14s

# NAME                         TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
# services/calculator-service   LoadBalancer   10.109.13.40     localhost     3000:32277/TCP   101s
# services/csharp-adder         ClusterIP      10.99.71.195     <none>        8080/TCP         2m25s
# services/flask-multiplier     ClusterIP      10.111.134.130   <none>        5000/TCP         2m4s
# services/go-subtractor        ClusterIP      10.109.25.228    <none>        8000/TCP         2m41s
# services/nestjs-divider       ClusterIP      10.97.164.61     <none>        3000/TCP         3m14s

# NAME                                          READY   UP-TO-DATE   AVAILABLE   AGE
# deployment.apps/calculator-deployment         1/1     1            1           101s
# deployment.apps/csharp-adder-deployment       1/1     1            1           2m25s
# deployment.apps/flask-multiplier-deployment   1/1     1            1           2m4s
# deployment.apps/go-subtractor-deployment      1/1     1            1           2m41s
# deployment.apps/nestjs-divider-deployment     1/1     1            1           3m14s

# NAME                                                     DESIRED   CURRENT   READY   AGE
# replciaset.apps/calculator-deployment-6dfddc9c56         1         1         1       101s
# replciaset.apps/csharp-adder-deployment-5945454df8       1         1         1       2m25s
# replciaset.apps/flask-multiplier-deployment-756d96c7fd   1         1         1       2m4s
# replciaset.apps/go-subtractor-deployment-5ff5d997db      1         1         1       2m41s
# replciaset.apps/nestjs-divider-deployment-c8dd85b56      1         1         1       3m14s

We can see that our calculator-service is the only service that has an EXTERNAL-IP, which is localhost in this case. We can access the calculator app by navigating to localhost:3000 in our browser, and we should see the calculator app running:

Conclusion

In this blog post, we covered how to run a local Kubernetes cluster on our machines. We went through how to deploy Pods, Replication Controllers, ReplicaSets, Deployments, and Services. We also ran a distributed calculator app on our local Kubernetes cluster. In the next blog post, we will be going through how to deploy the calculator app on an Azure Kubernetes cluster using the Azure Kubernetes Service (AKS).

Kubernetes on Azure: Part 1 - An Introduction to Kubernetes

Thwani sithole — Fri, 14 Jun 2024 08:18:40 +0000

In the next series of blog posts, we will be learning about Kubernetes. More specifically, we will be learning how to deploy and manage a Kubernetes cluster on Azure. In this first blog post, we will be going through the basics of Kubernetes, what it is, and why it is used.

What is Kubernetes?
Kubernetes Architecture
Conclusion

What is Kubernetes?

Kubernetes, also referred to as K8s (There are 8 letters between K and s) is an open-source container orchestration platform that helps with the automation of deploying, scaling, and managing containerized applications. K8s was developed by Google but is now maintained by the Cloud Native Computing Foundation (CNCF). Kubernetes is used to manage the lifecycle of containerized applications, scaling them up or down, and managing the networking between containers.

Kubernetes offers a set of features that make it an ideal platform for deploying and managing containerized applications. Some of the features include (but are not limited to):

Automated rollouts and rollbacks: K8s seamlessly rolls out and rolls back application updates and config changes, consistently monitoring the app's health to prevent downtime.
Self-healing: Kubernetes automatically restarts containers that fail, replaces and reschedules containers when nodes die, and kills containers that don't respond to user-defined health checks. Kubernetes also prevents traffic from being routed to unhealthy containers.
Secret and config management: Kubernetes allows you to store and manage sensitive information such as passwords, OAuth tokens, and SSH keys. Kubernetes also allows you to deploy and update secrets and application configurations without rebuilding your image.
Horizontal scaling: Kubernetes can scale applications based on CPU usage or other custom metrics. Kubernetes can scale up or down the number of replicas of an application based on the load.

To understand how Kubernetes, we first need to understand the Kubernetes architecture.

Kubernetes Architecture

At a high level, a K8s cluster is a cluster of virtual or on-premise machines. Each machine in the cluster is referred to as a node. A K8s cluster has two types of nodes:

One or more master or control plane nodes. The master node is responsible for managing the K8s cluster.
One or more worker nodes. Worker nodes are responsible for running the applications and workloads.

The control plane runs the components that are responsible for managing the cluster. These components are:

API Server (kube-apiserver): The API Server is the entry point for all REST commands used to interact with the cluster. The API Server intercepts RESTful calls from users, administrators, and other components, and then validates and processes the requests.
Scheduler (kube-scheduler): The Scheduler is responsible for distributing workloads across multiple nodes. The Scheduler selects the optimal node for the workload based on predetermined requirements.
Controller Manager: The Controller Manager runs watch-loop processes that are continuously running and comparing the current state of the cluster with the desired state. If the current state does not match the desired state, the Controller Manager takes corrective action to make the current state match the desired state.
- The kube-controller-manager runs controllers that are responsible for acting when nodes become unavailable, ensuring container pod counts are correct, creating endpoints, etc.
- The cloud-controller-manager runs controllers that interact with the underlying cloud provider's API. For example, the cloud controller manager is responsible for creating and deleting load balancers in the cloud provider.
etcd: This is an open-source distributed key-value data store that is used to store cluster state. The API Server is the only control plane component that can communicate (read and write) with etcd. Any other component that's interested in the cluster state must go through the API Server.

The worker nodes provide a running environment for the applications. The worker nodes run the following components:

Kubelet: The kubelet is an agent that runs on each node in the cluster. The kubelet is responsible for making sure that containers are running in a pod. Each node communicates with the control plane using the kubelet to inform the control plane about any changes in the node.
kube-proxy: The kube-proxy is a network agent that runs on each node, responsible for dynamic updates and maintenance of all network rules on the node. It handles the routing of network traffic in a Kubernetes cluster.
Container Runtime: K8s cannot directly run containers. It needs a container runtime to run the containers on the node where a pod is scheduled. K8s supports container runtimes such as Docker, containerd, CRI-O, etc.

A pod is the smallest deployable unit in Kubernetes. A pod is a group of one or more containers that share the same network and storage. Pods are the atomic unit on the Kubernetes platform. Pods are scheduled on worker nodes by the control plane.

Conclusion

In this blog post, we went through the basics of Kubernetes and the Kubernetes architecture. In the next blog post, we will be going through how to run a local Kubernetes cluster on our machines.

An Introduction to Cloud Computing

Thwani sithole — Fri, 14 Jun 2024 08:15:06 +0000

In the last few years, cloud computing has become a popular choice for many organizations. It offers a wide range of benefits, including cost savings, scalability, and flexibility. In the next series of articles, we'll learn more about cloud computing and take a deep dive into the different services offered by cloud providers, focusing primarily on Microsoft Azure.

In this article, we'll define what cloud computing is and discuss the different types of cloud services available. We'll also explore the benefits of cloud computing and the different deployment models.

What is Cloud Computing?
Benefits of Cloud Computing
Deployment Models
Types of Cloud Services

What is Cloud Computing?

Cloud computing is a way to deliver computing services over the internet. Cloud computing allows organizations to access computing resources such as servers, storage, databases, networking, software, and analytics over the internet. These resources are hosted in data centers that are managed by cloud providers. A cloud provider is a company that offers cloud services to businesses and individuals. Some of the popular cloud providers include Microsoft Azure, Amazon Web Services (AWS), and Google Cloud Platform (GCP). Simply put, cloud computing is a way to rent computing resources from someone else's data center. When you are done utilizing the resources, you give them back. Customers use cloud computing resources on a pay-as-you-go basis. This means that customers only pay for the resources they use.

Building and hosting our applications on the cloud comes with a lot of benefits. Some of these benefits are listed below

Benefits of Cloud Computing

Cost Savings

When organizations think of their IT infrastructure models, they usually consider two types of expenditures:

Capital Expenditure (CapEx): This is the upfront cost to purchase resources such as servers, storage, and networking. CapEx forces the organization to make future estimations of their infrastructure needs at the beginning.
- If the organization overestimates, they end up with unused resources, which is a waste of money.
- If the organization underestimates, they end up with insufficient resources, which can lead to poor performance and unhappy customers.
Operational Expenditure (OpEx): This is the ongoing cost to run and maintain the infrastructure.

Since cloud computing allows customers to use resources on a pay-as-you-go basis, it eliminates the need for CapEx. This means that organizations can avoid the upfront cost of purchasing hardware and software. Instead, they can pay for what they use and scale up or down as needed. This results in cost savings for the organization. Organizations also don't have to pay for the physical infrastructure, the electricity, and the cooling required to run the infrastructure.

Uptime (Availability)

Availability refers to organizations' services and products being available to customers when they need them.

Cloud providers offer Service Level Agreements (SLAs) that guarantee a certain level of uptime. This means that the cloud provider guarantees that the services will be available for a certain percentage of time. For example, a cloud provider might offer an SLA that guarantees 99.9% uptime. This means that the services will be available 99.9% of the time. This is a huge benefit for organizations that need their services to be available 24/7. Azure is a highly available cloud platform with availability guarantees for most of its services.

Scalability

Scalability refers to the ability to adjust computing resources to meet demand. When the demand is high, the organization can add more computing power or more resources to meet demand, and when the demand is low, the organization can scale down to save costs. Cloud computing allows organizations to scale both vertically and horizontally.

Vertical Scaling: This refers to adding more resources to a single server. For example, adding more RAM, CPU, or storage to a single server (Scaling up), or removing excess resources from a single server (Scaling down).
Horizontal Scaling: This refers to adding more servers to the infrastructure (Scaling out), or removing unutilized servers from the infrastructure (Scaling in).

Reliability

Reliability refers to the ability of the cloud provider to deliver the services as promised. Cloud providers have multiple data centers in different geographical locations. This means that if one data center goes down, the services can be moved to another data center. This ensures that the services are always available. Organizations have the confidence that their services can recover from failures and continue being available to their customers

Organizations have the choice of setting up their infrastructure using different cloud models. These models can be chosen based on the organization's business needs. The main cloud models are listed below.

Cloud Models

Deployment Model	Functionality
Private Cloud	A private cloud is a cloud that is used by a single organization. Private clouds can either be hosted in the organization's data center, an offsite data center, or via a 3rd party cloud provider
Public Cloud	A public cloud is built, controlled, and maintained by a 3rd party cloud provider. The cloud provider can offer resources such as servers, storage, and networking to multiple organizations.
Hybrid Cloud	A hybrid cloud is a computing environment that uses both public and private clouds. A hybrid cloud can be used to supplement a private cloud with public cloud resources when demand increases. It can also be used to add a security layer over a private cloud.
Multi-Cloud	A multi-cloud is a cloud environment that uses multiple cloud providers. You can have a computing environment in which you use AWS resources and Azure resources. This can be used to avoid vendor lock-in and to take advantage of the best features of different cloud providers.

When organizations are setting up their services on the cloud, they can also choose the type of cloud resources they want to use. The main cloud resources are listed below.

Types of Cloud Services

Cloud Service	Functionality
Infrastructure as a Service (IaaS)	IaaS provides virtualized computing resources over the internet. Organizations can rent out a wide range of services such as virtual machines, storage, and networking With IaaS, the cloud provider is responsible for maintaining the hardware, the network connectivity to the internet, and the physical security of the hardware. The customer is responsible for the operating system installed on the virtual machines, the configuration, the maintenance, and so on.
Platform as a Service (PaaS)	PaaS provides a platform that allows customers to develop, run, and manage applications without the complexity of building and maintaining the infrastructure. With PaaS, the cloud provider provides ready-to-use platforms that contain most of the tools that developers use. The cloud service provider is responsible for maintaining the hardware, the network connectivity to the internet, and the physical security of the hardware. The cloud service provider is also responsible for the operating system, the development tools, and so on. The customer is only responsible for the services that run on these platforms
Software as a Service (SaaS)	SaaS provides fully developed software applications over the internet. Customers can access the software applications via a web browser or an app. Email such as Outlook, cloud file storage solutions such as DropBox, workflow management solutions such as Trello, and so on are examples of SaaS applications. With SaaS, the cloud provider is responsible for maintaining the provided application. The customer is only responsible for the data and the configuration of the application.

As organizations continue to move their services to the cloud, it is crucial to understand the shared responsibility model. The shared responsibility model dictates that the cloud service provider is responsible for monitoring and responding to security threats to the cloud infrastructure, while the customer is responsible for securing the data and applications that they host on the cloud. This means that the customer is responsible for securing their data and applications, while the cloud provider is responsible for securing the infrastructure that the data and applications are hosted on.

The cloud service provider is responsible for the physical power, cooling, and network connectivity of the data center. The customer does not have physical access to the data center, so it would not make sense to have the customer responsible for that.

The customer is always responsible for the data and information that is stored in the cloud. The customer is also responsible for the accounts and identities of the people, services, and devices that have access to the data.

In the next article, we'll dive deeper into Azure reliability and learn about the different Azure regions and how to leverage availability zones to make our services highly available.

Nested Prompts in Go using promptui

Thwani sithole — Fri, 14 Jun 2024 08:06:58 +0000

I was working on a CLI tool written in Go, using the Cobra tool recently, and I had a use case where I needed a nested prompt for one of the commands. I was using promptui for the prompts and I couldn't find a straightforward way to do this. This short post will show how to create a nested prompt using promptui. The completed code can be found here.

We first need to create an empty Go project. We will call it nested-prompt:

$ mkdir nested-prompt && cd nested-prompt
$ go mod init github.com/Thwani47/nested-prompt

We'll then install the cobra, cobra-cli, and promptui packages:

$ go get -u github.com/spf13/cobra@latest
$ go install github.com/spf13/cobra-cli@latest 
$ go get -u github.com/manifoldco/promptui

We can initialize a new CLI application using the cobra-cli and add a command to our CLI

$ cobra-cli init            # initializes a new CLI application
$ cobra-cli add config      # adds a new command to the CLI named 'config'

We can clean up the cmd/config.go file and remove all the comments. It should be like this:

// cmd/config.go
package cmd

import (
    "fmt"

    "github.com/spf13/cobra"
)

var configCmd = &cobra.Command{
    Use:   "config",
    Short: "Configure settings for the application",
    Long: `Configure settings for the application`,
    Run: func(cmd *cobra.Command, args []string) {
        fmt.Println("config called")
    },
}

func init() {
    rootCmd.AddCommand(configCmd)
}

We first need to create a custom type for our prompt. We do that by defining a promptItem struct as follows

type PromptType int

const (
    TextPrompt     PromptType = 0
    PasswordPrompt PromptType = 1
    SelectPrompt   PromptType = 2
)

type promptItem struct {
    ID            string
    Label         string
    Value         string
    SelectOptions []string
    promptType    PromptType
}

The PromptType enum allows us to collect different types of input from our prompts, we can prompt the user for text, or sensitive values such as passwords or API Keys, or prompt the user to select from a list of defined values

We then define a promptInput function that will prompt for input from the user. The function returns the string value entered by the user or an error if the prompt fails.

func promptInput(item promptItem) (string, error) {
    prompt := promptui.Prompt{
        Label:       item.Label,
        HideEntered: true,
    }

    if item.promptType == PasswordPrompt {
        prompt.Mask = '*'
    }

    res, err := prompt.Run()

    if err != nil {
        fmt.Printf("Prompt failed %v\n", err)
        return "", err
    }

    return res, nil
}

We then define a promptSelect function that will allow the user to select from a list of options. The function returns the string value selected by the user or an error if the prompt fails.

func promptSelect(item selectItem) (string, error) {
    prompt := promptui.Select{
        Label:        item.Label,
        Items:        item.SelectValues,
        HideSelected: true,
    }

    _, result, err := prompt.Run()

    if err != nil {
        fmt.Printf("Prompt failed %v\n", err)
        return "", err
    }

    return result, nil
}

To simulate a nested prompt, we will create a promptNested function that will allow us to prompt the user for a value and the prompt will stay active until the user selects "Done". The function returns a boolean value that indicates that the prompt was a success.

The comments in the function explain what each major block of code is responsible for

func promptNested(promptLabel string, startingIndex int, items []*promptItem) bool {

    // Add a "Done" option to the prompt if it does not exist
    doneID := "Done"
    if len(items) > 0 && items[0].ID != doneID {
        items = append([]*promptItem{{ID: doneID, Label: "Done"}}, items...)
    }

    templates := &promptui.SelectTemplates{
        Label:    "{{ . }}?",
        Active:   "\U0001F336 {{ .Label | cyan }}",
        Inactive: "{{ .Label | cyan }}",
        Selected: "\U0001F336 {{ .Label | red  | cyan }}",
    }

    prompt := promptui.Select{
        Label:        promptLabel,
        Items:        items,
        Templates:    templates,
        Size:         3,
        HideSelected: true,
        CursorPos:    startingIndex, // Set the cursor to the last selected item
    }

    idx, _, err := prompt.Run()

    if err != nil {
        fmt.Printf("Error occurred when running prompt: %v\n", err)
        return false
    }

    selectedItem := items[idx]

    // if the user selects "Done", return true and exit from the function
    if selectedItem.ID == doneID {
        return true
    }

    var promptResponse string

    // if the prompt type is Text or Password, prompt the user for input
    if selectedItem.promptType == TextPrompt || selectedItem.promptType == PasswordPrompt {
        promptResponse, err = promptInput(*selectedItem)

        if err != nil {
            fmt.Printf("Error occurred when running prompt: %v\n", err)
            return false
        }

        items[idx].Value = promptResponse

    }

    // if the prompt type is Select, prompt the user to select from a list of options
    if selectedItem.promptType == SelectPrompt {
        promptResponse, err = promptSelect(*selectedItem)

        if err != nil {
            fmt.Printf("Error occurred when running prompt: %v\n", err)
            return false
        }
        items[idx].Value = promptResponse
    }

    if err != nil {
        fmt.Printf("Error occurred when running prompt: %v\n", err)
        return false
    }

    // recursively call the promptNested function to allow the user to select another option
    return promptNested(idx, items)
}

Now we have all the methods we need and we need to test them out. Inside the Run function of the configCmd command, we will create a list of promptItem and call the promptNested function to prompt the user for input. The Run function should look like this:

// create a list of prompt items
items := []*promptItem{
    {
        ID:         "APIKey",
        Label:      "API Key",
        promptType: PasswordPrompt,
    },
    {
        ID:            "Theme",
        Label:         "Theme",
        promptType:    SelectPrompt,
        SelectOptions: []string{"Dark", "Light"},
    },
    {
        ID:            "Language",
        Label:         "Preferred Language",
        promptType:    SelectPrompt,
        SelectOptions: []string{"English", "Spanish", "French", "German", "Chinese", "Japanese"},
    },
}

// set the starting index to 0 to start at the first item in the list
promptNested("Configuration Items", 0, items)

for _, v := range items {
    fmt.Printf("Saving configuration (%s) with value (%s)...\n", v.ID, v.Value)
}

Build and test the application as follows

$ go build . 
$ ./nested-prompt config

The result is as follows

Introducing Semantic Kernel

Thwani sithole — Fri, 14 Jun 2024 07:59:42 +0000

Semantic Kernel is an open-source SDK that allows us to easily bring AI capabilities to our applications. It allows us to connect to AI services such as OpenAI and Azure OpenAI with ease. If you have worked with LangChain, Semantic Kernel is a Microsoft implementation of a project like LangChain. Semantic Kernel allows us to integrate AI functionality such as text generation, text summarization, chat completion, and image generation in our applications.

In this article, we'll be exploring Semantic Kernel, unraveling its terminology, and demonstrating its capabilities by building practical applications. This article will lay the foundation of the core concepts of Semantic Kernel and will ensure we have a solid understanding of the SDK.

The source code for the completed application can be found here.

What is Semantic Kernel
Glossary of Terms
Getting Started with Semantic Kernel in C#

What is Semantic Kernel

Semantic Kernel is a lightweight open-source SDK that allows developers to build their own copilot experiences. It allows us to easily integrate with AI plugins from Open AI and Microsoft. This means we can integrate our applications with plugins that are built for services such as ChatGPT, Bing, and Microsoft 365 Copilot. Semantic Kernel allows us to integrate with these plugins using programming languages such as Python, C#, and Java (support for TypeScript is not yet available at the time of writing but it is something that is being worked on). This means that we can leverage the power of LLMs in our applications by using the technology we use in our day-to-day development tasks.

Semantic Kernel provides an abstraction over integrating the power of LLMs in our applications. This makes the learning curve of learning and understanding the APIs for AI services such as Azure OpenAI and OpenAI shorter, and since we can use programming languages such as C# and Python, this means we can easily get started and we can easily integrate AI functionality in our applications.

Before we can get started with Semantic Kernel, we need to understand a few terms that will make working with the SDK easier.

Glossary of Terms

Here are some of the terms that are used widely in the world of Semantic Kernel. Understanding them will make your experience with the SDK an easier one.

Term	Description
Ask	This refers to the goal sent to Semantic Kernel that a user or a developer would like to accomplish.
Kernel	The kernel refers to an instance of the processing engine that fulfills a user's ask using a collection of plugins.
Plugin	A plugin refers to a group of functions that can be exposed to AI services. For example, if we had a plugin for sprint planning, we might have a function to summarize the sprint planning meeting, a function to get the planned objectives for the sprint and a function to create work items for those objectives. Semantic Kernel comes with some plugins out-of-the-box such as the TextMemory, ConversationSummary, FileIO, and Time plugins. You can also build custom plugins that suit your requirements. Some Microsoft documentation might still use the term "Skills" for plugins. Plugins were initially called skills but were renamed to Plugins to conform to the OpenAI standard.
Functions	To create your custom plugin, Semantic Kernel allows you two create two types of functions: Semantic Functions → These functions allow your app to listen to users' asks and respond with a natural language response Native Functions → These are functions that are written in Python or C# and the Kernel will call these functions based on users' asks
Planner	Semantic Kernel allows us to chain together different plugins that fulfill different goals. Semantic Kernel uses a function called a Planner that selects one or more functions from the registered plugins to execute based on the user's asks. For example, suppose we have a plugin named WritePlugin with the following functions defined: Brainstorm → Given a goal or a topic, this function generates a list of ideas. ShortPoem → Generates a short poem about a given topic. WriteStory → Generates a short story with sub-chapters. Translate → Translates a piece of text to your language of choice. If the user's ask is "Can you write a short poem in Spanish about living in Durban?", The Planner is responsible for selecting the functions to call and in the order they should be called. Which it will most likely (or should) call the ShortPoem and Translate functions
Prompts	Prompts serve as input to an AI model. Behind the scenes, Semantic Kernel Planner uses prompts to generate a plan (a list of actions to call and the order). A model will generate different output based on the prompt provided.
Model	A model refers to a specific instance of an LLM* AI, such as GPT-3 or Codex. *LLM (large language model) → An artificial intelligence model trained on a large text dataset.

Let's get started with Semantic Kernel below

Getting Started with Semantic Kernel in C

To get started, you'll need an OpenAI API Key. You can obtain one by either creating an OpenAI account or creating an Azure OpenAI Service. At the time of writing, access to the Azure OpenAI Service is only available by application. You can fill out your application here.

Note:
You'll have to load some credits to be able to use the OpenAI models. You can load that on the OpenAI billing page

We'll build a C# console application that accepts a user's ask and can perform a set of actions. The application should be able to

Summarize a piece of text
Write a short poem about a topic
Generate a short story about a topic
Translate a piece of text to another language.

As much as we're using C#, the concepts should be the same in Python or Java if you prefer that. We will cover many of the concepts to get you started with Semantic Kernel, and in a follow-up article we'll learn how to give our applications 'memory';

We first start by creating a new .NET console application



$ dotnet new console --framework net7.0 --name SemanticKernelExample
$ cd SemanticKernelExample

We then have to install a few Nuget packages



$ dotnet add package Microsoft.SemanticKernel --version 0.21.230828.2-preview
$ dotnet add package Microsoft.Extensions.Configuration.UserSecrets

Semantic Kernel is still in preview at the time of writing this article, so we install the preview version.

Define an app secret with your API Key using the command



$ dotnet user-secrets init
$ dotnet user-secrets set "OpenAI:APIKey" "<your-api-key>" #replace <your-api-key> with your Open API Key

We first need to create a kernel. We can create a kernel in two ways:

One, by calling the KernelBuilder.Create() method which returns an IKernel object



var kernel = KernelBuilder.Create();

Two, by using the KernelBuilder.Build() method if we want to set extra configuration for the kernel such as loading the initial plugins, adding custom loggers, etc.



var loggerFactory = NullLoggerFactory.Instance;
var kernel = new KernelBuilder()
    .WithLoggerFactory(loggerFactory)
    .Build();

For the text summarization functionality, we'll create a semantic function that will summarize an input text. We'll call this function SummarizeText. In your project root directory, create a Plugins folder, and inside that folder create a WriterPlugin folder. Inside the WriterPlugin folder, create a SummarizeText folder. Inside the SummarizeText folder create two files, skprompt.txt and config.json. The skprompt.txt file will contain the prompt that will be sent to the AI model, and the config.json file will contain the configuration for the function. The skprompt.txt file should contain the following text:



Summarize this in 3 sentences or less
{{$input}}
+++++

This is the prompt we'll pass to the AI service to summarize the text. During execution, Semantic Kernel will replace the {{$input}} value with the text to be summarized.

Update the config.json file with the following



{
  "schema": 1,
  "type": "completion",
  "completion": {
    "max_tokens": 500
  },
  "input": {
    "parameters": [
      {
        "name": "input",
        "description": "The text to summarize",
        "defaultValue": ""
      }
    ]
  }
}

This config instructs Semantic Kernel to restrict the generated text to 500 tokens and to expect an input parameter named input. The defaultValue property is used to set a default value for the parameter if one is not provided.

We can update our Program.cs file with the following to see the function in action



using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.SemanticKernel;

var configuration = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddUserSecrets<Program>()
    .Build();

var apiKey = configuration.GetSection("OpenAI:APIKey").Value; // Gets the OpenAI API Key from the app secrets

var logger = NullLogger.Instance;
var kernel = new KernelBuilder().WithLogger(logger).WithOpenAITextCompletionService("text-davinci-003", apiKey!)
    .Build(); // Creates a new kernel with the OpenAI Text Completion Service using the text-davinci-003 model

// You can see the list of models here: https://platform.openai.com/docs/models

var pluginsDirectory = Path.Combine(Directory.GetCurrentDirectory(), "Plugins");
var writerPlugin = kernel.ImportSemanticSkillFromDirectory(pluginsDirectory, "WriterPlugin"); // loads the WriterPlugin plugin

var textToSummarize =
    @"The Mars Perseverance Rover, a part of NASA's Mars Exploration Program successfully landed on Mars on February 18, 2021. 
Its mission is to explore the Martian surface, collect samples, and study the planet's geology and climate. 
The rover is equipped with advanced instruments and cameras that allow scientists to analyze the terrain and search for signs of past microbial life. 
This mission represents a significant step towards our understanding of Mars and its potential to support life in the past or present.";

var result = await writerPlugin["SummarizeText"].InvokeAsync(textToSummarize); // calls the SummarizeText function
Console.WriteLine(result);

This outputs something like the following



The Mars Perseverance Rover successfully landed on Mars on February 18, 2021, as part of NASA's Mars Exploration Program. 
Its mission is to explore the Martian surface, collect samples, and study the planet's geology and climate. 
It is equipped with advanced instruments and cameras to analyze the terrain and search for signs of past microbial life.

In the completed solution, I've added the prompts and the config files for the other functions. You can find the completed solution here. The folder structure after adding all the functions looks like this

The updated Program.cs file should look like the following



// ...kernel configuration

var pluginsDirectory = Path.Combine(Directory.GetCurrentDirectory(), "Plugins");
var writerPlugin = kernel.ImportSemanticSkillFromDirectory(pluginsDirectory, "WriterPlugin");

var textToSummarize =
    @"The Mars Perseverance Rover, a part of NASA's Mars Exploration Program successfully landed on Mars on February 18, 2021. 
Its mission is to explore the Martian surface, collect samples, and study the planet's geology and climate. 
The rover is equipped with advanced instruments and cameras that allow scientists to analyze the terrain and search for signs of past microbial life. 
This mission represents a significant step towards our understanding of Mars and its potential to support life in the past or present.";

var summary = await writerPlugin["SummarizeText"].InvokeAsync(textToSummarize);
Console.WriteLine($"Summarized text:\n{summary}");

var poem = await writerPlugin["WritePoem"].InvokeAsync("Being a Software Developer");
Console.WriteLine($"Generated poem:\n{poem}");

var shortStory = await writerPlugin["GenerateStory"].InvokeAsync("The Lion and the Lamb");
Console.WriteLine($"Generated story:\n{shortStory}");

var translationContext = kernel.CreateNewContext();
translationContext.Variables["input"] = textToSummarize;
translationContext.Variables["target"] = "French";

var translatedText = await writerPlugin["Translate"].InvokeAsync(translationContext);
Console.WriteLine($"Translated text:\n{translatedText}");

Notice we created a translationContext variable, which is a SKContext object. This object allows us, among other things, to be able to pass more than one value to our prompt. We use this since the Translate function needs the text to translate and the target language. Running this outputs something like the following



*****Summarized text:*****

The Mars Perseverance Rover successfully landed on Mars on February 18, 2021, as part of NASA's Mars Exploration Program. Its mission is to explore the Martian surface, collect samples, and study the planet's geology and climate. It
is equipped with advanced instruments and cameras to analyze the terrain and search for signs of past microbial life.


*****Generated poem:*****

My coding skills are ever-growing,
My knowledge ever-expanding,
My work is never slowing,
My code is ever-commanding.

My projects are ever-thriving,
My skills are ever-thriving.

*****Generated story:*****

Once upon a time, there was a lion and a lamb who lived in the same forest. The lion was the king of the forest and the lamb was his loyal companion.

One day, the lion and the lamb went on a journey together. They encountered many obstacles along the way, but they worked together to overcome them.

Eventually, they reached their destination and the lion thanked the lamb for his help. From then on, the lion and the lamb were the best of friends and they lived happily ever after.


*****Translated text:*****

Le Rover Mars Perseverance, faisant partie du Programme d'Exploration de Mars de la NASA, s'est posé avec succès sur Mars le 18 février 2021.
Sa mission est d'explorer la surface martienne, de collecter des échantillons et d'étudier la géologie et le climat de la planète.
Le rover est équipé d'instruments et de caméras avancés qui permettent aux scientifiques d'analyser le terrain et de rechercher des signes de vie microbienne passée.
Cette mission représente une étape significative vers notre compréhension de Mars et de son potentiel pour soutenir la vie dans le passé ou le présent.

Lastly, we can use Planner to chain together different functions to fulfill a user's ask. We can update our Program.cs file with the following



// ... Kernel config
var planner = new SequentialPlanner(kernel);
var ask = "Can you write a poem about being a software developer and translate it to German?";
var plan = await planner.CreatePlanAsync(ask);
var result = await plan.InvokeAsync();
Console.WriteLine(result);

This outputs something like the following



Johns Leidenschaft für Programmierung war wie eine Flamme,

Seine Fähigkeiten und sein Wissen wuchsen stetig.

Er arbeitete hart, um die Welt zu einem besseren Ort zu machen,

Seine Arbeit war eine Quelle des Stolzes und der Anmut.

Er hörte nie auf zu lernen, immer bestrebt, zu wachsen,

Sein Einfluss auf die Welt wird er nie erfahren.

Conclusion

In this article, we introduced Semantic Kernel, covered some of the terminology used, and created a basic C# application that uses Semantic Kernel. We've covered some of the basic terminology to help you get started with Semantic Kernel. In a follow-up article, we'll learn how to give our applications 'memory' using Semantic Kernel and have them remember context.

Semantic Kernel is still in its infancy stage but improvements are being made every day on the SDK and it will be a very powerful and mature tool in no time. We can use Semantic Kernel for a wide range of applications. We can leverage cutting-edge AI models and plugins in our apps, and we can also build our plugins.

Building a CRUD app with React Query, TypeScript, and Axios

Thwani sithole — Fri, 14 Jun 2024 07:54:46 +0000

TanStack Query, also known as React Query is described as the missing data-fetching library for web applications. React Query makes fetching, caching, synching, and updating server state a breeze.

React Query comes with an opinionated way of fetching and updating data. React Query makes it easier to manage complex data fetching and caching scenarios in our React applications while providing a simple and intuitive API as compared to traditional state management libraries. Using React Query also has other benefits such as:

Error handling - React Query provides robust error handling capabilities. This helps with handling errors that occur during data fetching or mutations.
Global state management - React Query provides a central place to manage global state. Making it easy to share data across components and avoid prop drilling
Type safety - React Query is built with TypeScript and provides strong type safety. This makes it easier to catch errors and avoid bugs.
Optimistic updates - React Query allows us to perform optimistic updates, which means we can update the UI immediately after a mutation is performed, before waiting for the server response.
Automatic data re-fetching - React Query can automatically re-fetch data from the server based on several conditions, such as when a mutation is performed, the window is refocused, or a component is mounted.

In this article, we will be learning how to use React Query to fetch and update server data in a React application using Axios.

The complete source code for this article can be found here

Creating the project
Setting up the backend server
Setting up React Query
Setting up Axios
Fetch all Todos
Add a new Todo
Delete a Todo
Edit a Todo
Conclusion

Creating the project

We'll be using Vite for our web app. Run

$ npm create vite@latest react-query-crud-example

and follow the prompts to select React as the framework and TypeScript as the variant. Change the directory into the project directory and run

$ npm i @tanstack/react-query @tanstack/react-query-devtools axios formik yup react-router-dom json-server
$ npm i -D tailwindcss postcss autoprefixer

The above commands install:

React Query
React Query dev tools
Axios - an HTTP client.
formik - a React Form Library.
yup - A form data validation library.
React Router - a React routing library.
JSON Server - a fake REST API. We'll be using this as the backend server to fetch data from and send data to.
Tailwind CSS - A CSS framework we'll use to style our components.

Run

$ npx tailwindcss init -p

to generate a tailwind.config.cjs file. Replace the contents of tailwind.config.cjs with

/*tailwind.config.cjs*/

/** @type {import('tailwindcss').Config} */
module.exports = {
  content: [
    "./index.html",
    "./src/**/*.{js,ts,jsx,tsx}",
  ],
  theme: {
    extend: {},
  },
  plugins: [],
}

Replace the contents of index.css with

/*index.css*/
@tailwind base;
@tailwind components;
@tailwind utilities;

Setting up the backend server

We'll be using json-server to create the REST API that we'll fetch data from. In the root of the project, create a db.json file with the contents

/*db.json*/

    {
        "todos" : [
            {
                "id" : 1,
                "title": "Learn React Query",
                "complete": false
            }
        ]
    }

In the package.json file, add a server script as follows

/*package..json*/

// ...
"scripts": {
    "dev": "vite",
    "build": "tsc && vite build",
    "preview": "vite preview",
    "server" : "json-server --watch db.json --port 5000" // ADD THIS LINE
  }
// ...

In the command line, run

$ npm run server

This exposes a REST API that we can consume from http://localhost:5000/todos. The API exposes these endpoints

Endpoint	Action
`GET /todos`	Get all Todos
`GET /todos?complete=true`	Get all complete Todos
`GET /todos/{id}`	Get a Todo item by its id
`POST /todos`	Create a new Todo item
`PUT /todos/{id}`	Update an existing Todo
`DELETE /todos/{id}`	Delete a Todo item

Setting up React Query

To be able to use React Query in our application, we need to wrap the QueryClientProvider component around our application entry point. Update the main.tsx file as follows

/*main.tsx*/
import React from 'react';
import ReactDOM from 'react-dom/client';
import App from './App';
import './index.css';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { ReactQueryDevtools } from '@tanstack/react-query-devtools';
import { createBrowserRouter, RouterProvider } from 'react-router-dom';

const queryClient = new QueryClient();

const router = createBrowserRouter([
    {
        path: '/',
        element: <App />
    },
    {
        path : '*',
        element : <h1>Page not found: 404</h1>
    }
]);

ReactDOM.createRoot(document.getElementById('root') as HTMLElement).render(
    <React.StrictMode>
        <QueryClientProvider client={queryClient}>
            <RouterProvider router={router}/>
            <ReactQueryDevtools />
        </QueryClientProvider>
    </React.StrictMode>
);

React Query works with zero config and can be customized to meet our application requirements. The above sets up React Query with the default options. We can configure our config options by passing a config object into the query client as follows

... 
const queryClient = new QueryClient({
    queries : { // data fetching config
        refetchOnWindowFocus : false,
        refetchOnMount : false,
        retry: false,
        // ... rest of the config
    },
    mutations : { // mutations config

    }
});
// rest of code...

Setting up Axios

Create a new src/api/client.ts file with the following contents

import axios from "axios";

export const client = axios.create({
    baseURL : 'http://localhost:5000/todos',
    headers: {
        'Content-Type': 'application/json'
    }
})

This creates and exports an axios client with the base URL of our server setup.

Fetch all Todos

In the main page of the app, we want to fetch all todo items from the server.

First, create a src/types/todo.types.ts file with the contents

export interface TodoItem {
    id: number;
    title: string;
    complete: boolean;
}

Create a src/hooks/useFetchTodos.ts file with the contents

/*useFetchTodos.ts*/

import { QueryObserverResult, useQuery } from '@tanstack/react-query';
import { AxiosResponse } from 'axios';
import { client } from '../api/client';
import { TodoItem } from '../types/todo.types';

const fetchTodos = async (): Promise<AxiosResponse<TodoItem[], any>> => {
    return await client.get<TodoItem[]>('/');
};

export const useFetchTodos = (): QueryObserverResult<TodoItem[], any> => {
    return useQuery<TodoItem[], any>({
        queryFn: async () => {
            const { data } = await fetchTodos();
            return data;
        },
        queryKey: [ 'todos' ]
    });
};

This creates a useFetchTodos hook that fetches data from the API server.

We can use our hook in our App.tsx as follows:

/*App.tsx*/

import { useNavigate } from 'react-router-dom';
import './App.css';
import { useFetchTodos } from './hooks/useFetchTodos';

function App() {
  const { data: todos, isLoading, isError } = useFetchTodos();
  const navigate = useNavigate();
    return (
        <div className="w-full mt-2 items-center bg-gray-100 min-h-screen">
            <h1 className="text-4xl font-bold mb-4">Todo List</h1>
      <button className="bg-green-500 hover:bg-green-700 text-white font-bold py-1 px-2 ml-2 rounded mb-4" onClick={() => navigate('/add-todo')}>New Todo</button>
      <hr className="mb-2"/>
      {
        isLoading? <h1>Loading...</h1> : isError ? <h1>Error fetching todos</h1> : (
          <ul>
          {todos?.map(todo => {
            return <li className={`mb-2 text-xl ${todo.complete ? 'line-through' : ''}`} key={todo.id}>{todo.title}
              <button className="bg-blue-500 hover:bg-blue-700 text-white font-bold py-1 px-2 ml-2 rounded">Edit</button>
              <button className="bg-red-500 hover:bg-red-700 text-white font-bold py-1 px-2 ml-2 rounded">Delete</button>
            </li>
          })}
          </ul>
        )
      }
        </div>
    );
}

export default App;

Add a new Todo

First, we create a TodoItemForm.tsx component with the contents

import React from 'react';
import { ErrorMessage, Field, Form, Formik } from 'formik';
import * as yup from 'yup';
import { TodoInput, TodoItem } from './types/todo.types';

type Props = {
    action: string;
    todoItem: TodoItem | undefined;
    handleSubmit: (values: TodoInput) => void;
};

export default function TodoItemForm({ todoItem, handleSubmit, action }: Props) {
    return (
        <Formik
            initialValues={{
                title: todoItem? todoItem.title : '',
                complete: todoItem ? todoItem.complete: false
            }}
            validationSchema={yup.object({
                title: yup.string().required('Title is required')
            })}
            onSubmit={(values: TodoInput) => handleSubmit(values)}
        >
            <Form>
                <div className="mb-2">
                    <label htmlFor="title" className="mr-2">
                        Title
                    </label>
                    <Field
                        name="title"
                        type="text"
                        id="title"
                        className="shadow appearance-none border rounded py-1 px-2 text-gray-700 leading-tight focus:outline-none focus:shadow-outline"
                    />
                    <ErrorMessage name="title" component="span" className="text-red-500" />
                </div>
                <div>
                    <label htmlFor="complete" className="mr-2">
                        Complete
                    </label>
                    <Field name="complete" type="checkbox" id="complete" />
                </div>
                <button className="bg-blue-500 hover:bg-blue-700 text-white font-bold py-1 px-2 ml-2 rounded">
                    {action}
                </button>
            </Form>
        </Formik>
    );
}

We're creating a reusable component that will come in handy when we want to edit our Todos

Then we create an src/AddTodo.tsx component with the following contents

import React from 'react';
import { useAddTodo } from './hooks/useAddTodo';
import TodoItemForm from './TodoItemForm';

export default function AddTodo() {
    const { mutate: addTodo } = useAddTodo();

    return (
        <div className="w-full mt-2 items-center bg-gray-100 min-h-screen">
            <h1 className="text-4xl font-bold mb-4">New Todo</h1>
            <TodoItemForm todoItem={undefined} handleSubmit={addTodo} action="Add Todo" />
        </div>
    );
}

We then add the component to our router in main.tsx as follows

import AddTodo from './AddTodo';
// ...

const router = createBrowserRouter([
    {
        path: '/',
        element: <App />
    },
    {
        path: '/add-todo',
        element: <AddTodo/>
    },
    {
        path : '*',
        element : <h1>Page not found: 404</h1>
    }
]);

// ...

We then need to create a src/hooks/useAddTodo.ts hook, the one we reference in our AddTodo component. Create a src/hooks/useAddTodo.ts with the following contents


import { UseBaseMutationResult } from '@tanstack/react-query';
import { useMutation, useQueryClient } from '@tanstack/react-query';
import { AxiosResponse } from 'axios';
import { useNavigate } from 'react-router-dom';
import { client } from '../api/client';
import { TodoInput } from '../types/todo.types';

const addTodo = async (todo: TodoInput): Promise<AxiosResponse<TodoInput, any>> => {
    return await client.post<TodoInput>('/', todo);
};

export const useAddTodo = (): UseBaseMutationResult<AxiosResponse<TodoInput, any>, unknown, TodoInput, unknown> => {
    const queryClient = useQueryClient();
    const navigate = useNavigate();
    return useMutation({
        mutationFn: (todo: TodoInput) => addTodo(todo),
        onSuccess: () => {
            queryClient.invalidateQueries([ 'todos' ]);
            navigate('/', { replace: true });
        }
    });
};

Add the following TodoInput definition to src/types/todo.types.ts

export interface TodoInput {
    title: string;
    complete: boolean;
}

Delete a Todo

To delete a todo we first add a src/hooks/useDeleteTodo.ts hook file with the contents

import { UseBaseMutationResult } from '@tanstack/react-query';
import { useMutation, useQueryClient } from '@tanstack/react-query';
import { AxiosResponse } from 'axios';
import { client } from '../api/client';

const deleteTodo = async (todoId: number): Promise<AxiosResponse<any, any>> => {
    return await client.delete(`/${todoId}`);
};

export const useDeleteTodo = (): UseBaseMutationResult<AxiosResponse<any, any>, unknown, number, unknown> => {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: (todoId: number) => deleteTodo(todoId),
        onSuccess: () => {
            queryClient.invalidateQueries([ 'todos' ]);
        }
    });
};

Then update App.tsx and add an onClick event handler to the delete button as follows

// ...
import {useDeleteTodo} from './hooks/useDeleteTodo'

function App(){
    // ...
    const {mutate : deleteTodo} = useDeleteTodo()

    return (
        //...
        {todos?.map(todo => {
            return 
                <li className={`mb-2 text-xl ${todo.complete ? 'line-through' : ''}`} key={todo.id}>{todo.title}
                    <button className="bg-blue-500 hover:bg-blue-700 text-white font-bold py-1 px-2 ml-2 rounded">Edit</button>
                    <button 
                        className="bg-red-500 hover:bg-red-700 text-white font-bold py-1 px-2 ml-2 rounded" 
                        onClick={() => deleteTodo(todo.id)}>
                        Delete
                    </button>
                </li>
            })}
    )
}

Edit a Todo

We first create an EditTodo.tsx component with the contents


import React from 'react';
import { useParams } from 'react-router-dom';

import { useFetchTodo } from './hooks/useFetchTodo';
import { useEditTodo } from './hooks/useEditTodo';
import TodoItemForm from './TodoItemForm';


export default function EditTodo() {
    const { id } = useParams();
    const { data: todoItem, isLoading } = useFetchTodo(id ? parseInt(id) : 0);

    const { mutate: editTodo } = useEditTodo(id ? parseInt(id) : 0);
    return (
        <div className="w-full mt-2 items-center bg-gray-100 min-h-screen">
            <h1 className="text-4xl font-bold mb-4">Edit Todo</h1>
            {isLoading? <h1>Fetching todo...</h1> : <TodoItemForm todoItem={todoItem} handleSubmit={editTodo} action="Edit Todo"/> }
        </div>
    );
}

We then add the component to our router in main.tsx as follows

import EditTodo from './EditTodo';
// ...

const router = createBrowserRouter([
    {
        path: '/',
        element: <App />
    },
    {
        path: '/add-todo',
        element: <AddTodo/>
    },
    {
        path: '/edit-todo/:id',
        element: <EditTodo />
    },
    {
        path : '*',
        element : <h1>Page not found: 404</h1>
    }
]);

// ...

Then update App.tsx and add an onClick event handler to the edit button as follows

{isLoading? <h1>Loading...</h1> : isError ? <h1>Error fetching todos</h1> : (
    <ul>
    {todos?.map(todo => {
        return <li className={`mb-2 text-xl ${todo.complete ? 'line-through' : ''}`} key={todo.id}>{todo.title}
        <button className="bg-blue-500 hover:bg-blue-700 text-white font-bold py-1 px-2 ml-2 rounded" onClick={() => navigate(`/edit-todo/${todo.id}`)}>Edit</button>
        <button className="bg-red-500 hover:bg-red-700 text-white font-bold py-1 px-2 ml-2 rounded" onClick={() => deleteTodo(todo.id)}>Delete</button>
        </li>
    })}
    </ul>
)}

We then create two hooks, a useFetchTodo hook that allows us to fetch data for a single Todo item and a useEditTodo hook that allows us to edit a Todo item

Create a src/hooks/useFetchTodo.ts file with the following contents

import { QueryObserverResult, useQuery } from '@tanstack/react-query';
import { AxiosResponse } from 'axios';
import { client } from '../api/client';
import { TodoItem } from '../types/todo.types';

const fetchTodo = async (todoId: number): Promise<AxiosResponse<TodoItem, any>> => {
    return await client.get<TodoItem>(`/${todoId}`);
};

export const useFetchTodo = (todoId: number): QueryObserverResult<TodoItem, any> => {
    return useQuery<TodoItem, any>({
        queryFn: async () => {
            const { data } = await fetchTodo(todoId);
            return data;
        },
        queryKey: [ 'todo', todoId ]
    });
};

Then add a src/hooks/useEditTodo.ts file with the following contents

import { UseBaseMutationResult } from '@tanstack/react-query';
import { useMutation, useQueryClient } from '@tanstack/react-query';
import { AxiosResponse } from 'axios';
import { useNavigate } from 'react-router-dom';
import { client } from '../api/client';
import { TodoInput } from '../types/todo.types';

const editTodo = async (todoId: number, todo: TodoInput): Promise<AxiosResponse<TodoInput, any>> => {
    return await client.put<TodoInput>(`/${todoId}`, todo);
};

export const useEditTodo = (
    todoId: number
): UseBaseMutationResult<AxiosResponse<TodoInput, any>, unknown, TodoInput, unknown> => {
    const queryClient = useQueryClient();
    const navigate = useNavigate();
    return useMutation({
        mutationFn: (todo: TodoInput) => editTodo(todoId, todo),
        onSuccess: () => {
            queryClient.invalidateQueries([ 'todos' ]);
            navigate('/', { replace: true });
        }
    });
};

Conclusion

React Query is a powerful library that makes data fetching and state management in React applications easy and efficient. It provides a simple and intuitive API for managing server state and has features such as caching, re-fetching, polling, and more.

In this article we saw how to create a new React application, set up React Query, and fetch data from a REST API using Axios. There is a lot of React Query that we haven't touched on in this article, such as configuration, testing, etc, as it is outside the scope of this article.

Deep Dive Into .NET Minimal APIs

Thwani sithole — Fri, 14 Jun 2024 07:48:36 +0000

The release of .NET 6 introduced minimal APIs, which allows us to develop small and functional single-file web APIs. Minimal APIs were motivated by the amount of code required to produce a simple .NET API compared to producing an API providing similar functionality in other languages such as Python or Go. In this blog post, we will be taking a deep dive into minimal APIs, exploring how they differ from controller-based APIs, and seeing how to configure logging and dependency injection for a minimal API.

The complete source code for this article can be found here.

Overview of .NET Minimal APIs
Creating a Minimal API
Configuring a Minimal API
CRUD methods in a Minimal API
Summary

Overview of .NET Minimal APIs

Minimal APIs are designed to create web APIs with minimal dependencies. Minimal APIs are an ideal way for creating microservices and lightweight applications that include the minimum files, configuration, and dependencies required to build a functional API. Minimal APIs allow us to create an API with very few lines of code. We can create an API with the following lines of code

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/", () => "Hello World!");
app.Run();

Once we run the code above, we should see Hello World! in the browser. The minimal API code above is analogous to creating a hello world in Express JS.

Minimal APIs consist of:

New hosting APIs
WebApplication and WebApplicationBuilder
New routing APIs

Creating a minimal API

There are multiple ways to create a .NET minimal API. You can create a minimal API from Visual Studio (version > 2022) or the command line. We'll use the command line in this article. Run the following command to create a minimal API (You need to have the .NET 6 SDK installed for this command to work.)

$ dotnet new web --name MinimalApiExample --framework "net6.0"

This command creates a new .NET 6 web project, named MinimalApiExample, with the following files created in the project

appsettings.json
appsettings.Development.json
Program.cs

Minimal APIs allow us to write our APIs in fewer files. We no longer have separate folders (and files) for controllers. We do not have the Startup.cs file anymore. We only have the Program.cs file for the API logic.

We can replace the lines

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

with the line

var app = WebApplication.Create(args);

if we want to create the application with preconfigured default values.

Configuring a Minimal API

When a minimal API is created, the port the API application will respond to is specified inside the Properties/launchSettings.json file. We can specify the port(s) the app will respond to as follows:

We can set a single port:

// ... app configuration
app.MapGet("/", () => "Hello World!");
app.Run("http://localhost:3000");

Visiting http://localhost:3000 should print Hello World! on the browser.

We can set multiple ports as follows:

// ... app configuration
app.Urls.Add("http://localhost:3000");
app.Urls.Add("http://localhost:4000");
app.MapGet("/", () => "Hello World!");
app.Run();

Visiting http://localhost:3000 or http://localhost:4000 should print Hello World! on the browser.

We can also specify the port when we run the app via the command line:

$ dotnet run --urls="http://localhost:3000"
# dotnet run --urls="http://localhost:3000;http://localhost:4000" for multiple ports

We can also specify the port from the environment variables as follows

var app = WebApplication.Create(args);
var port = Environment.GetEnvironmentVariable("PORT") ?? "3000";
app.MapGet("/", () => "Hello World!");
app.Run($"http://localhost:{port}");

We can configure Swagger as follows. From the command line:

$ dotnet add package Swashbuckle.AspNetCore --version 6.2.3

In Program.cs add the following code

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI(options =>
    {
        options.SwaggerEndpoint("/swagger/v1/swagger.json", "v1");
        options.RoutePrefix = string.Empty;
    });
}

app.MapGet("/", () => "Hello World!");
app.Run();

CRUD methods in a Minimal API

For example, we are going to create a simple Todo API, using an EF Core In-Memory DB.

The API will have the following endpoints

Endpoint	Description	Request Body	Response Body
`GET /todos`	Get all Todos	None	List of Todos
`GET /todos/complete`	Get all complete Todos	None	List of Todos
`GET /todos/{id}`	Get a Todo item by its id	None	Todo item
`POST /todos`	Create a new Todo item	Todo item	Todo item
`PUT /todos/{id}`	Update an existing Todo	Todo item	None
`DELETE /todos/{id}`	Delete a Todo item	None	None

To install the in-memory DB provider, run the following command in the command line

$ dotnet add package Microsoft.EntityFrameworkCore.InMemory

In the Program.cs file, add the following code to configure the Todo model and the DbContext

// ... app configuration

app.Run();

public class Todo
{
    public Guid Id {get; set;}
    public string? Name {get; set;}
    public bool IsComplete {get; set;}
}

class TodoDb : DbContext
{
    public TodoDb(DbContextOptions<TodoDb> options) : base(options)
    {
    }

    public DbSet<Todo> Todos => Set<Todo>();
}

Add the following code to register the DbContext with the DI container

//... builder configuration 

builder.Services.AddDbContext<TodoDb>(options => options.UseInMemoryDatabase("Todos"));

var app = builder.Build();

// ... rest of code

We add the following code to add endpoints for our API

// .. app configuration

var app = builder.Build();

app.MapGet("/todos", async (TodoDb db) => await db.Todos.ToListAsync());
app.MapGet("todos/{id:guid}", async (Guid id, TodoDb db) =>
{
    var todo = await db.Todos.FindAsync(id); 
    return todo == null ? Results.NotFound() : Results.Ok(todo);
});
app.MapGet("/todos/complete", async (TodoDb db) => await db.Todos.Where(todo => todo.IsComplete).ToListAsync());
app.MapPost("todos", async (Todo todo, TodoDb db) =>
{
    db.Todos.Add(todo);
    await db.SaveChangesAsync();

    return Results.Created($"/todos/{todo.Id}", todo);
});

app.MapPut("todos/{id:guid}", async (Guid id, Todo update, TodoDb db) =>
{
    var todo = await db.Todos.FindAsync(id);

    if (todo == null)
    {
        return Results.NotFound();
    }

    todo.Title = update.Title;
    todo.IsComplete = update.IsComplete;

    await db.SaveChangesAsync();
    return Results.NoContent();
});

app.MapDelete("todos/{id:guid}", async (Guid id, TodoDb db) =>
{
    var todo = await db.Todos.FindAsync(id); 
    if (todo == null)
    {
        return Results.NotFound();
    }

    db.Todos.Remove(todo);
    await db.SaveChangesAsync();
    return Results.NoContent();
});

app.Run();

// ... rest of code

Summary

Minimal APIs are an ideal way of building .NET APIs without much of the ceremony involved with controller-based APIs. They are good when we are writing applications in a microservices-based solution. They do not, however, replace controller-based APIs. As the complexity increases and we need more features in our APIs, controller-based APIs are more suitable to use.

Using Vite for React Applications

Thwani sithole — Fri, 14 Jun 2024 07:27:19 +0000

For a while, I have been using Create React App (CRA) to create React applications, which is an officially supported way to create single-page React applications.

CRA was created for React beginners who have a limited understanding of Webpack and it was not meant to be used in production. CRA also makes it very difficult to add custom build configurations. It also comes with many unnecessary dependencies, resulting in a bloated package.json when the app is ejected. Out of all these drawbacks, one that is very annoying is that CRA takes longer to build when your codebase increases and even longer to deploy our applications. One alternative is to set up a React project without using CRA. Another option is to use a development tool such as Vite.

You can find the source code for the examples in this article here

What is Vite
Creating a React App With Vite
Pros and Cons of Vite
Summary

What is Vite?

Vite (pronounced "veet") is a development tool for scaffolding and bundling web projects. Vite has grown popular due to its blazing fast compilation and hot module replacement. To understand what makes Vite fast, you can read more on this page.

Vite supports a list of template presets, and as of writing, these template presets include:

vanilla / vanilla-ts
vue / vue-ts
react / react-ts
preact / preact-ts
lit / lit-ts
svelte / svelte-ts

Creating a React App With Vite

To create a new Vite project, you run the command

$ npm create vite@latest

Enter the project name and follow the prompts to select React (JavaScript), as shown below.
You can also scaffold the project using this one-liner:

$ npm init vite@latest vite-react-example --template react

After the project is scaffolded, cd into it, install the dependencies, and start the dev server as follows:

$ cd vite-react-example
$ npm install
$ npm run dev

The default server port is 5173. Visit http://127.0.0.1:5173/. You should see something like:

Setting Environment Variables

Vite exposes environment variables on the import.meta.env object. Some built-in variables include:

import.meta.env.MODE → The mode the app is running in
import.meta.env.BASE_URL → The base URL from which the app is served
import.meta.env.PROD → A boolean value indicating whether the app is running in production
import.meta.env.DEV → A boolean value indicating whether the app is running in development mode (An opposite of import.meta.env.PROD)
import.meta.env.SSR → A boolean value indicating whether the app is running on the server

Vite uses dotenv to load any additional environment variables from the following files

.env
.env.local
.env.[mode]
.env.[mode].local

Any environment variable loaded via dotenv is exposed to the import.meta.env object as strings. To prevent any environment variables from leaking to the client accidentally, Vite will only expose variables prefixed with the VITE_ prefix. For example, for the following environment variables,

VITE_APP_USER=Thanos
APP_PASSWORD=gamora

only VITE_APP_USER will be exposed as import.meta.env.VITE_APP_USER to the client source code, APP_PASSWORD will not be exposed

console.log(import.meta.env.VITE_APP_USER); // Thanos
console.log(import.meta.env.APP_PASSWORD); // undefined

Pros and Cons of Vite

Pros	Cons
Blazingly fast	Lack of first-class support for Jest
Ease of use	Different tooling for dev and production environments
Out of-the-box Typescript support
Vite is framework agnostic

Summary

Vite is a good tool to scaffold web applications very fast and it helps save a lot more time than CRA. It is great too to create small projects and demos but it is recommended to not build any large-scale projects that will go into production using Vite as yet.

DEV Community: Thwani sithole

Kubernetes on Azure: Part 3 - An Introduction to AKS

Table of Contents

What is AKS?

Creating and configuring an AKS cluster

Login and create a resource group to contain the AKS cluster:

Create an AKS cluster:

Connect to the AKS cluster:

Verify the connection to the AKS cluster:

Deploy an application to the AKS cluster:

AKS Automatic

Conclusion

Kubernetes on Azure: Part 2 - Running a local Kubernetes cluster

Table of Contents

Installing Kubernetes

Deploying a Pod

Replication Controllers and ReplicaSets

Creating a Deployment

Creating a Service

Conclusion

Kubernetes on Azure: Part 1 - An Introduction to Kubernetes

Table of Contents

What is Kubernetes?

Kubernetes Architecture

Conclusion

An Introduction to Cloud Computing

Table of Contents

What is Cloud Computing?

Benefits of Cloud Computing

Cost Savings

Uptime (Availability)

Scalability

Reliability

Cloud Models

Types of Cloud Services

Nested Prompts in Go using promptui

Introducing Semantic Kernel

Table of Contents

What is Semantic Kernel

Glossary of Terms

Getting Started with Semantic Kernel in C

Conclusion

Building a CRUD app with React Query, TypeScript, and Axios

Table of Contents

Creating the project

Setting up the backend server

Setting up React Query

Setting up Axios

Fetch all Todos

Add a new Todo

Delete a Todo

Edit a Todo

Conclusion

Deep Dive Into .NET Minimal APIs

Table of Contents

Overview of .NET Minimal APIs

Creating a minimal API

Configuring a Minimal API

CRUD methods in a Minimal API

Summary

Using Vite for React Applications

Table of Contents

What is Vite?

Creating a React App With Vite

Setting Environment Variables

Pros and Cons of Vite

Summary