Introduction & Overview

What is GitOps and Why Use It?

GitOps is a modern approach to Continuous Deployment (CD) that uses Git as a single source of truth for managing application deployments. Instead of manually applying Kubernetes configurations, GitOps tools like Argo CD automatically sync your cluster state with your Git repository.

What is Argo CD?

Argo CD is a declarative, GitOps-based continuous delivery tool designed for Kubernetes. It enables teams to manage application deployments using Git as the single source of truth. This ensures that deployments are automated, consistent, and easily auditable.

Why Use Argo CD?

• GitOps Workflow: Uses Git repositories as the source of truth for Kubernetes deployments.
• Automated Deployments: Ensures applications are always running the desired state.
• Self-Healing: Detects and corrects configuration drifts automatically.
• Rollback Capabilities: Easily roll back to previous versions in case of failure.
• Multi-Cluster Support: Deploy applications across multiple Kubernetes clusters.
• Declarative Configuration: Uses YAML manifests, making deployments predictable and maintainable.

Benefits of Argo CD

• Increased Deployment Speed: Automates the deployment pipeline, reducing manual intervention.
• Improved Security: Uses Git as the central source of truth, minimizing configuration drifts.
• Enhanced Observability: Provides a UI and CLI to monitor deployments and sync status.
• Scalability: Supports complex, large-scale deployments with ease.

Real-World Use Cases of Argo CD

• Fintech Applications: Ensuring compliance-driven infrastructure management.
• E-commerce Platforms: Handling frequent updates and high traffic.
• AI/ML Models: Deploying and updating machine learning models in production environments.

What Will We Achieve in This Article?

Below are the things will look into as part of this article.

• A .NET application deployed on Azure Kubernetes Service (AKS)
• Argo CD syncing the app with a Git repository
• GitHub Actions automating build and deployment

High-Level Architecture

• Developer pushes code to a GitHub repository.
• GitHub Actions builds the Docker image and pushes it to Azure Container Registry (ACR).
• Argo CD detects the new image and updates the Kubernetes deployment.
• AKS pulls the updated image and runs the application.

Fig Ref- URL

Prerequisites

Before diving in, ensure you have:

• An Azure Account with AKS (Azure Kubernetes Service) set up
• Azure Container Registry (ACR)
• Basic understanding of Docker, Kubernetes & GitHub Actions

Installation of Argo CD on AKS

Argo CD must be installed on AKS before using it. Here’s how:

Step 1: Install Argo CD in AKS

//Creating namespace for argo cd
kubectl create namespace argocd

//Installation of argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yam

This creates an argocd namespace and installs all necessary Argo CD components.

check if all the pods are running for argocd

kubectl get all -n argocd

Step 2: Expose the Argo CD UI

check if all the pods are running for argoCd

kubectl port-forward svc/argocd-server -n argocd 8080:443

Now, you can access Argo CD UI at: https://localhost:8080

Step 3: Login to Argo CD CLI

Get the default admin password:

kubectl get secrets -n argocd argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 --decode

Login using CLI:

argocd login <ARGOCD_SERVER> --username admin --password <PASSWORD> --insecure

Now, you can use Argo CD to manage Kubernetes deployments.

Setting Up the Application Codebase

Step 1: Setting Up the .NET Weather API App

Our application follows a simple structure, with a Dockerfile used to containerize the app.

Dockerfile (ArgoWorkflowDemo/ArgoWorkflowDemo/Dockerfile)

# Use the official .NET Core SDK as a parent image
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /app
# Copy the project file and restore any dependencies (use .csproj for the project name)
COPY *.csproj ./
RUN dotnet restore
# Copy the rest of the application code
COPY . .
# Publish the application
RUN dotnet publish -c Release -o out
# Build the runtime image
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS runtime
WORKDIR /app
COPY --from=build /app/out ./
# Expose the port your application will run on
EXPOSE 80
# Start the application
ENTRYPOINT ["dotnet", "ArgoWorkflowDemo.dll"]

• Base Image: Uses the official .NET 8 runtime image.
• Working Directory: Sets the working path inside the container.
• Copy Files: Copies the app files into the container.
• Entry Point: Runs the application inside the container.

Step 2: Writing Kubernetes Manifests

We define two primary Kubernetes manifests:

• application.yaml (Argo CD Application)
• deployment.yaml (Kubernetes Deployment and Service)

Argo CD Application Manifest (k8s/application.yaml)

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: weatherapi
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/Jaydeep-007/argo-cd-demo
    path: k8s
    targetRevision: main
  destination:
    server: https://kubernetes.default.svc
    namespace: default
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true

• Auto-sync & Self-heal: Ensures the app is always deployed correctly.
• Source Repository: Links to the GitHub repository.
• Namespace: Defines the target Kubernetes namespace.

Deployment YAML (k8s/deployment.yaml)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: weatherapi
  namespace: argocd
spec:
  replicas: 2
  selector:
    matchLabels:
      app: weatherapi
  template:
    metadata:
      labels:
        app: weatherapi
    spec:
      containers:
        - name: weatherapi
          image: jddemoacr.azurecr.io/weatherapi:63c6e53528b0f817980212a121b7a73830c3664a
          ports:
            - containerPort: 80
          env:
            - name: ASPNETCORE_ENVIRONMENT
              value: "Production"
---
apiVersion: v1
kind: Service
metadata:
  name: weatherapi
  namespace: argocd
spec:
  type: LoadBalancer
  ports:
    - port: 80
      targetPort: 80
  selector:
    app: weatherapi

Deployment Resource (Deployment — apps/v1)

• Name: weatherapi
• Namespace: argocd
• Replicas: 2 (Ensures high availability)
• Labels: app: weatherapi (Used for identifying resources)
• Container Image: jddemoacr.azurecr.io/weatherapi:63c6e53528b0f817980212a121b7a73830c3664a
• Port: Exposes container on port 80
• Environment Variable:
• ASPNETCORE_ENVIRONMENT=Production (Sets production environment)

Service Resource (Service — v1)

• Type: LoadBalancer (Exposes service externally)
• Ports: Maps port 80 on the cluster to 80 inside the container
• Selector: Matches app: weatherapi to link the service with the pods

Step 3: GitHub Actions Workflow for Deployment

This workflow automates:

• Building and pushing the Docker image to ACR.
• Updating the Kubernetes manifest with the latest image.
• Triggering Argo CD to sync changes.

Workflow File: .github/workflows/deploy.yml

Note: Please configure all your secrets under github action from the repository setting.

name: Deploy to AKS via Argo CD

on:
  push:
    branches:
      - main

env:
  IMAGE_NAME: weatherapi
  REGISTRY: jddemoacr.azurecr.io  # Replace with your ACR or Docker Hub URL
  TAG: ${{ github.sha }}

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout Code
        uses: actions/checkout@v3

      - name: Login to Azure Container Registry
        run: echo "${{ secrets.ACR_PASSWORD }}" | docker login ${{ env.REGISTRY }} -u ${{ secrets.ACR_USERNAME }} --password-stdin

      - name: Build and Push Docker Image
        run: |
          docker build -t ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ env.TAG }} -f ArgoWorkflowDemo/ArgoWorkflowDemo/Dockerfile ArgoWorkflowDemo/ArgoWorkflowDemo
          docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ env.TAG }}

      - name: Update Kubernetes Deployment YAML
        run: |
          sed -i "s|image: .*|image: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ env.TAG }}|" k8s/deployment.yaml
          git config --global user.email "github-actions@github.com"
          git config --global user.name "GitHub Actions"
          git add k8s/deployment.yaml
          git diff --quiet && git diff --staged --quiet || git commit -m "Update image to ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ env.TAG }}"
          git push origin main || echo "No changes to push"

      - name: Setup Kubeconfig
        run: |
          mkdir -p $HOME/.kube
          echo "${{ secrets.KUBE_CONFIG_DATA }}" | base64 --decode > $HOME/.kube/config
          chmod 600 $HOME/.kube/config
          export KUBECONFIG=$HOME/.kube/config
          kubectl config view --minify
          kubectl get nodes

      - name: Check if Argo CD CLI is Installed
        id: check-argocd
        run: |
          if command -v argocd &> /dev/null; then
            echo "Argo CD is already installed"
            echo "installed=true" >> $GITHUB_ENV
          else
            echo "Argo CD is not installed"
            echo "installed=false" >> $GITHUB_ENV
          fi

      - name: Install Argo CD CLI
        if: env.installed == 'false'
        run: |
          curl -sSL -o /usr/local/bin/argocd https://github.com/argoproj/argo-cd/releases/latest/download/argocd-linux-amd64
          chmod +x /usr/local/bin/argocd

      - name: Login to ArgoCD
        run: |
          argocd login ${{ secrets.ARGOCD_SERVER }} --username admin --password ${{ secrets.ARGOCD_PASSWORD }} --insecure

      - name: Sync Argo CD Application
        run: |
          argocd app sync weatherapi

      - name: Wait for Deployment to Complete
        run: |
          argocd app wait weatherapi --health --timeout 180

Overview of the Workflow
This GitHub Actions workflow automates:

• Building a Docker image for the .NET Weather API.
• Pushing the image to Azure Container Registry (ACR).
• Updating the Kubernetes deployment YAML to use the new image.
• Syncing with Argo CD to deploy the updated application to AKS.

Step-by-Step Breakdown

1. Workflow Trigger

on:
  push:
    branches:
      - main

This workflow runs whenever code is pushed to the main branch.

2. Environment Variables

env:
  IMAGE_NAME: weatherapi
  REGISTRY: jddemoacr.azurecr.io
  TAG: ${{ github.sha }}

Defines global variables:

• IMAGE_NAME: The Docker image name (weatherapi).
• REGISTRY: The container registry where images are stored.
• TAG: Uses Git commit SHA as the image version (ensures each image is unique).

3. Job: build-and-deploy

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest

Runs the workflow on an Ubuntu-based GitHub Actions runner.

4. Checkout Repository

- name: Checkout Code
  uses: actions/checkout@v3

Fetches the latest source code from the repository.

5. Login to Azure Container Registry (ACR)

- name: Login to Azure Container Registry
  run: echo "${{ secrets.ACR_PASSWORD }}" | docker login ${{ env.REGISTRY }} -u ${{ secrets.ACR_USERNAME }} --password-stdin

Authenticates with Azure Container Registry (ACR) using GitHub Secrets.

6. Build and Push Docker Image

- name: Build and Push Docker Image
  run: |
    docker build -t ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ env.TAG }} -f ArgoWorkflowDemo/ArgoWorkflowDemo/Dockerfile ArgoWorkflowDemo/ArgoWorkflowDemo
    docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ env.TAG }}

• Builds a Docker image using the .NET Weather API’s Dockerfile.
• Tags the image with the commit SHA and pushes it to ACR.

7. Update Kubernetes Deployment YAML

- name: Update Kubernetes Deployment YAML
  run: |
    sed -i "s|image: .*|image: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ env.TAG }}|" k8s/deployment.yaml
    git config --global user.email "github-actions@github.com"
    git config --global user.name "GitHub Actions"
    git add k8s/deployment.yaml
    git diff --quiet && git diff --staged --quiet || git commit -m "Update image to ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ env.TAG }}"
    git push origin main || echo "No changes to push"

• Updates k8s/deployment.yaml to use the newly built image.
• Commits and pushes the updated YAML file back to the repository.

8. Setup Kubeconfig (Access AKS Cluster)

Note: Here I used pre-configured kube config secrets, but in real-time you should use azure ad and managed identity for better security.

- name: Setup Kubeconfig
  run: |
    mkdir -p $HOME/.kube
    echo "${{ secrets.KUBE_CONFIG_DATA }}" | base64 --decode > $HOME/.kube/config
    chmod 600 $HOME/.kube/config
    export KUBECONFIG=$HOME/.kube/config
    kubectl config view --minify
    kubectl get nodes

• Authenticates with the Kubernetes cluster (AKS) using a pre-configured kubeconfig file stored as a GitHub Secret.
• Runs kubectl get nodes to confirm connectivity.

9. Check if Argo CD CLI is Installed

- name: Check if Argo CD CLI is Installed
  id: check-argocd
  run: |
    if command -v argocd &> /dev/null; then
      echo "Argo CD is already installed"
      echo "installed=true" >> $GITHUB_ENV
    else
      echo "Argo CD is not installed"
      echo "installed=false" >> $GITHUB_ENV
    fi

• Checks if Argo CD CLI is already installed.
• Saves the result (installed=true/false) as an environment variable.

10. Install Argo CD CLI (If Not Installed)

- name: Install Argo CD CLI
  if: env.installed == 'false'
  run: |
    curl -sSL -o /usr/local/bin/argocd https://github.com/argoproj/argo-cd/releases/latest/download/argocd-linux-amd64
    chmod +x /usr/local/bin/argocd

Downloads and installs the Argo CD CLI tool if it’s missing.

11. Login to Argo CD

- name: Login to ArgoCD
  run: |
    argocd login ${{ secrets.ARGOCD_SERVER }} --username admin --password ${{ secrets.ARGOCD_PASSWORD }} --insecure

Logs in to Argo CD using GitHub Secrets.

12. Sync Application with Argo CD

- name: Sync Argo CD Application
  run: |
    argocd app sync weatherapi

Triggers Argo CD to deploy the updated Kubernetes manifests.

13. Wait for Deployment to Complete

- name: Wait for Deployment to Complete
  run: |
    argocd app wait weatherapi --health --timeout 180

• Waits for the deployment to reach a healthy state in Argo CD.
• Timeout is set to 180 seconds.

Testing and Verification

We’ll add a new “Hello World” API endpoint in the .NET Weather API controller, push the changes, and verify if it gets deployed automatically.

Step 1: Modify the .NET Controller

Open the existing WeatherForecastController.cs and add a new HelloWorld method.

Path: ArgoWorkflowDemo/ArgoWorkflowDemo/Controllers/WeatherForecastController.cs

[HttpGet("hello")]
public IActionResult HelloWorld()
{
    return Ok("Hello, Argo CD Deployment is Successful!");
}

Step 2: Commit and Push Changes to GitHub

Save the file.
Open Terminal / Command Prompt in the repository folder.
Run the following commands to commit and push:

git add ArgoWorkflowDemo/ArgoWorkflowDemo/Controllers/WeatherForecastController.cs
git commit -m "Added Hello World endpoint for Argo CD test"
git push origin main

Step 3: Verify GitHub Actions Execution

• Go to your GitHub repository
• Navigate to Actions -> Deploy to AKS via Argo CD workflow
• Ensure all steps run successfully:

Step 4: Verify the Build and Publish Image

You can verify the updated weather api docker image which got publishd with latest updated change.

Step 5: Verify Argo CD Deployment

• Open Argo CD UI
• Check if the weatherapi application is in Synced & Healthy state.

If you click on any above kubernetes resource then you can check events, logs and any configuration file.

Step 6: Test the Deployed API on AKS

• Get the external IP of the weatherapi service

kubectl get services -n argocd

• Access the Hello World API in a browser

Conclusion

In this article, we’ve successfully built a GitOps-powered CI/CD pipeline for deploying a .NET application to AKS using Argo CD and GitHub Actions. By leveraging modern CI/CD practices, we automated the entire process from code changes to deployment, ensuring a seamless and scalable solution for any software engineer.

Key Takeaways:

1. GitOps enables automated, reliable, and consistent deployments to Kubernetes using Argo CD.
2. GitHub Actions acts as the CI/CD tool, automating tasks like building, testing, and deploying our .NET application.
3. With AKS, we set up a scalable Kubernetes cluster that runs the app and handles traffic efficiently.

Introduction

Argo Workflows is a Kubernetes-native workflow engine that helps to automate complex workflows in a cloud-native environment. It is useful for CI/CD pipelines, data processing, and machine learning workflows. GitHub Actions is a powerful automation tool that helps in continuous integration and deployment directly from GitHub repositories.

In this article, we will integrate Argo Workflows with GitHub Actions step-by-step

Benefits of Using Argo Workflows with GitHub Actions

1. Scalability: Argo Workflows run natively on Kubernetes, making it highly scalable.
2. Reusability: Workflow templates can be reused across multiple projects.
3. Parallel Execution: Supports DAG (Directed Acyclic Graph) for executing tasks in parallel.
4. Automation: Seamlessly integrates with GitHub Actions for automated deployments and testing.
5. Observability: Provides a UI and CLI for monitoring and managing workflows.
6. Cost-Effective: Utilizes Kubernetes resources efficiently, reducing infrastructure costs.

Real-Time Use Cases

1. CI/CD Pipelines: Automate application build, test, and deployment across multiple environments.
2. Machine Learning Pipelines: Orchestrate data preprocessing, model training, and deployment workflows.
3. Data Processing: Process large-scale ETL (Extract, Transform, Load) jobs efficiently.
4. Backup and Disaster Recovery: Automate periodic backups and recovery workflows for cloud-native applications.
5. Event-Driven Workflows: Trigger workflows based on GitHub events, cloud storage changes, or API calls.

Prerequisites

Before we begin, ensure that you have the following:

• A Kubernetes cluster (Minikube, AKS, EKS, or GKE)
• kubectl installed and configured
• Argo Workflows installed on your Kubernetes cluster
• A GitHub repository with workflows enabled

Argo Workflow Setup on AKS Cluster

Step 1: Install Argo Workflows on Kubernetes

First, install Argo Workflows using kubectl:

$ kubectl create namespace argo
$ kubectl apply -n argo -f https://github.com/argoproj/argo-workflows/releases/download/v3.4.4/install.yaml

Use below command to check if Argo Workflows is installed correctly:

$ kubectl get pods -n argo

If you see running pods, that means the installation is successful.

Note:
Here I am disabling the authentication by patching the ‘argo-server’ deployment to use ‘ — auth-mode=server’. This allows access without authentication, useful for debugging in local environments.

Warning: This exposes the Argo UI without authentication, so use it cautiously in secured environments.

$ kubectl patch deployment argo-server -n argo --type='json' -p='[{"op": "add", "path": "/spec/template/spec/containers/0/args/-", "value": "--auth-mode=server"}]' $ kubectl rollout restart deployment argo-server -n argo

Step 2: Expose the Argo UI

To access the Argo Workflows UI, run:

kubectl -n argo port-forward deployment/argo-server 8080:2746

Now, open http://localhost:8080 in your browser.

Step 3: Create a Simple Workflow

Create a workflow definition file sample_deploy.yml in the root folder of your repository.

apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: github-triggered-workflow-
  namespace: argo
spec:
  entrypoint: main
  templates:
    - name: main
      container:
        image: python:3.8
        command: ["python", "-c"]
        args: ["print('Hello from Argo Workflow...')"]

Step 4: Integrate Argo Workflows with GitHub Actions

Note: Here I am using AKS admin credentials provides direct cluster access via kubeconfig, bypassing Azure AD authentication, making it simple for full control and troubleshooting. but below are some best and alternate approch for your reference.
Azure AD Authentication (RBAC-based): For controlled access with role-based permissions.
Service Principal or Managed Identity- For automated deployments with least-privilege access.
Static Kubeconfig with Certificates- For long-term, non-AAD authentication in isolated environments.

To Generate Base64-Encoded Kubeconfig

$ az aks get-credentials --resource-group jd-practice --name aks-argo-cluster --admin --file kubeconfig $ cat kubeconfig | base64 -w 0

Store in GitHub Secrets:

Go to GitHub Repository — Settings — Secrets and variables — Actions.

Click New repository secret and set:

Name: KUBE_CONFIG_DATA

Value: (Paste the base64 output)

Now, let’s automate workflow execution using GitHub Actions.

Create a .github/workflows/argo-workflow.yml file

Add the following content:

name: Deploy to AKS without Azure AD

on:
  push:
    branches:
      - main
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Code
        uses: actions/checkout@v3
      - name: Verify File Exists
        run: |
          if [ ! -f sample_deploy.yml ]; then
            echo "Error: sample_deploy.yml not found!"
            exit 1
          fi
          echo "Found sample_deploy.yml"
      - name: Setup Kubeconfig
        run: |
          mkdir -p $HOME/.kube
          echo "${{ secrets.KUBE_CONFIG_DATA }}" | base64 --decode > $HOME/.kube/config
          chmod 600 $HOME/.kube/config
          export KUBECONFIG=$HOME/.kube/config
          kubectl config view --minify
          kubectl get nodes
      - name: Deploy Argo Workflow
        run: |
          kubectl create -f sample_deploy.yml -n argo || true
          kubectl get workflows -n argo

Commit and push this file to your GitHub repository.

This workflow:

• Runs on every push to main.
• Sets up kubectl to use AKS credentials.
• Deploys an Argo Workflow from sample_deploy.yml.

View Deployment in GitHub Actions:

• Go to GitHub Repository — Actions — Deploy Argo Workflow.
• Click on the latest workflow run to see logs.
• Ensure kubectl apply ran successfully.

Step 6: View the workflow details on Argo UI:

Find your workflow name

Click on it to see logs, status, and execution details.

Conclusion

In this article, we successfully set up and deployed a simple “Hello World” workflow using Argo Workflows on AKS. We also explored how to authenticate, deploy workflows via GitHub Actions, and view executions in the Argo UI.

This was just a basic example to get started with Argo Workflows, you can automate complex workflows, build CI/CD pipelines, process large datasets, and integrate event-driven automation. As you move forward, you can experiment with multi-step workflows, parameterized executions, and advanced scheduling to enhance automation in your Kubernetes environment.

By leveraging Argo Workflows, you unlock powerful orchestration capabilities that simplify DevOps and data workflows in cloud-native environments.

What is GitHub?

GitHub is a web-based platform that helps developers store, manage, and collaborate on code using Git version control. It allows multiple developers to work on a project simultaneously, Also it elps to track changes, and maintain code history.

What are GitHub Actions?

GitHub Actions is an automation tool that allows developers to create CI/CD (Continuous Integration/Continuous Deployment) pipelines. It helps automate various development tasks like testing, building, and deploying applications.

What is a GitHub Workflow?

A GitHub Workflow is a set of automated tasks defined in a YAML file. It runs when triggered by specific events, such as pushing code to a repository, creating a pull request, or setting up a schedule. Workflows help in automating repetitive tasks like testing, code analysis, and deployment.

What is a GitHub Runner?

A GitHub Runner is a virtual machine that executes jobs specified in a GitHub Actions workflow. GitHub provides both hosted runners (free-tier available) and self-hosted runners (custom machines for private execution).

If you want to learn more about GitHub Action then please check out the official documentation.

Why Use GitHub Actions and Workflows?

GitHub Actions and Workflows help automate software development, making the process faster and easier. Here’s why they are useful:

Saves Time — Runs tests, builds, and deploys applications automatically.
Boosts Productivity — Reduces manual work, so developers can focus on coding.
Improves Teamwork — Helps teams work together smoothly without conflicts.
Flexible & Scalable — Can be customized to work with cloud platforms like Azure, AWS, and Google Cloud.

Step-by-Step Guide to Setting Up a GitHub Action with a Runner

Step 1: Create a GitHub Repository

• Go to GitHub and log in.
• Click on New Repository.
• Enter a name (e.g., github-actions-demo).
• Select Public or Private, and click Create Repository.

Step 2: You need the host to deploy and run the GitHub Runner which is needed to excute the jobs of our workflow. So, for that we gonna create a new VM for the same.

Create an Azure Virtual Machine (VM)

• Go to Azure Portal → Virtual Machines → Click Create → Virtual Machine.
• Choose Basic Configuration:

• Click Review + Create → Create.

Connect to the VM

Click on the VM instance in azure and there in the side navbar you can see connect option. So, using that option to connect with your VM.

Step 3: Set Up a GitHub Self-Hosted Runner

By default, GitHub provides free hosted runners, but here we’ll set up a self-hosted runner on your local machine.

1. Navigate to Runner Settings

• Go to GitHub Repository → Settings → Actions → Runners.
• Click New self-hosted runner.

2. Choose the Operating System

• Select your OS (Windows, macOS, or Linux).

3. Download and Configure the Runner

To download and configure the GitHub Runner. First, you have to connect with the VM that we created previously and once the connection is successful then you can execute the commands which are visible on the runner creation page.

Follow the provided commands.

mkdir actions-runner && cd actions-runner
curl -o actions-runner-linux-x64.tar.gz -L https://github.com/actions/runner/releases/download/v2.308.0/actions-runner-linux-x64-2.308.0.tar.gz
tar xzf ./actions-runner-linux-x64.tar.gz

4. Configure the Runner
Use the provided command with your repository’s token:

./config.sh --url https://github.com/your-username/github-actions-demo --token YOUR_TOKEN

5. Start the Runner

./run.sh

Your self-hosted runner is now active and ready!

Step 4: Create the Terraform Workflow in GitHub Actions

In your GitHub repository, create a file:

.github/workflows/terraform-azure.yml

Add the following workflow file:

Note: You might get some errors due to unavailablity of az cli and node on your VM. So, please install those things one by one and restart the runner.

name: Terraform Azure Deployment

on:
  push:
    branches:
      - main
jobs:
  terraform:
    runs-on: self-hosted  # Runs on your Azure VM runner
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4

      - name: Authenticate with Azure using Managed Identity
        run: az login --identity --username <MANAGED_IDENTITY_CLIENT_ID>

      - name: Install Terraform
        uses: hashicorp/setup-terraform@v3
        with:
          terraform_version: 1.6.0

      - name: Terraform Init
        run: terraform init
        working-directory: ./terraform

      - name: Terraform Plan
        run: terraform plan
        working-directory: ./terraform

      - name: Terraform Apply
        if: github.ref == 'refs/heads/main'
        run: terraform apply -auto-approve
        working-directory: ./terraform

Step 5: Create Terraform Code to Deploy an Azure Resource

In your GitHub repository, create a folder named terraform.
Inside the terraform folder, create a file:

main.tf

Add the following Terraform code to create a Storage Account in your existing resource group:

Note: Please add your VM’s managed identity inside the existing resource group with contributer rights.

provider "azurerm" {
  features {}
  use_msi           = true  # Enables Managed Identity Authentication
  subscription_id   = "YOUR_AZURE_SUBSCRIPTION_ID"
}

resource "random_string" "suffix" {
  length  = 6
  special = false
  upper   = false
}

resource "azurerm_storage_account" "example" {
  name                     = "mystorage${random_string.suffix.result}"
  resource_group_name      = "jaydeep-rg"
  location                 = "East US"
  account_tier             = "Standard"
  account_replication_type = "LRS"
}

Step 5: Push the Changes and Deploy

Add and commit your Terraform code:

git add .
git commit -m "Added Terraform for Azure Storage Account"
git push origin main

Go to GitHub Actions → See the workflow running on your self-hosted runner.

Once completed, check Azure Portal → Resource Group to confirm the new Storage Account is created.

Conclusion

GitHub Actions and Workflows simplify CI/CD automation for Terraform deployments. By following the steps above, you can easily set up an automated Terraform workflow to manage Azure resources.

Introduction of GitHub, GitHub Actions, GitHub Workflows, and GitHub Runner

What is GitHub?

GitHub is a web-based platform that helps developers store, manage, and collaborate on code using Git version control. It allows multiple developers to work on a project simultaneously, Also it elps to track changes, and maintain code history.

What are GitHub Actions?

GitHub Actions is an automation tool that allows developers to create CI/CD (Continuous Integration/Continuous Deployment) pipelines. It helps automate various development tasks like testing, building, and deploying applications.

What is a GitHub Workflow?

A GitHub Workflow is a set of automated tasks defined in a YAML file. It runs when triggered by specific events, such as pushing code to a repository, creating a pull request, or setting up a schedule. Workflows help in automating repetitive tasks like testing, code analysis, and deployment.

What is a GitHub Runner?

A GitHub Runner is a virtual machine that executes jobs specified in a GitHub Actions workflow. GitHub provides both hosted runners (free-tier available) and self-hosted runners (custom machines for private execution).

If you want to learn more about GitHub Action then please check out the official documentation.

Why Use GitHub Actions and Workflows?

GitHub Actions and Workflows help automate software development, making the process faster and easier. Here’s why they are useful:

Saves Time — Runs tests, builds, and deploys applications automatically.
Boosts Productivity — Reduces manual work, so developers can focus on coding.
Improves Teamwork — Helps teams work together smoothly without conflicts.
Flexible & Scalable — Can be customized to work with cloud platforms like Azure, AWS, and Google Cloud.

Step-by-Step Guide to Setting Up a GitHub Action with a Runner

Step 1: Create a GitHub Repository

• Go to GitHub and log in.
• Click on New Repository.
• Enter a name (e.g., github-actions-demo).
• Select Public or Private, and click Create Repository.

Step 2: You need the host to deploy and run the GitHub Runner which is needed to excute the jobs of our workflow. So, for that we gonna create a new VM for the same.

Create an Azure Virtual Machine (VM)

• Go to Azure Portal → Virtual Machines → Click Create → Virtual Machine.
• Choose Basic Configuration:

• Click Review + Create → Create.

Connect to the VM

Click on the VM instance in azure and there in the side navbar you can see connect option. So, using that option to connect with your VM.

Step 3: Set Up a GitHub Self-Hosted Runner

By default, GitHub provides free hosted runners, but here we’ll set up a self-hosted runner on your local machine.

1. Navigate to Runner Settings

• Go to GitHub Repository → Settings → Actions → Runners.
• Click New self-hosted runner.

2. Choose the Operating System

• Select your OS (Windows, macOS, or Linux).

3. Download and Configure the Runner

To download and configure the GitHub Runner. First, you have to connect with the VM that we created previously and once the connection is successful then you can execute the commands which are visible on the runner creation page.

Follow the provided commands.

mkdir actions-runner && cd actions-runner
curl -o actions-runner-linux-x64.tar.gz -L https://github.com/actions/runner/releases/download/v2.308.0/actions-runner-linux-x64-2.308.0.tar.gz
tar xzf ./actions-runner-linux-x64.tar.gz

4. Configure the Runner
Use the provided command with your repository’s token:

./config.sh --url https://github.com/your-username/github-actions-demo --token YOUR_TOKEN

5. Start the Runner

./run.sh

Your self-hosted runner is now active and ready!

Step 4: Set Up GitHub Actions Workflow

In your GitHub repository, create a file:

.github/workflows/test-runner.yml

Add this simple workflow to verify the runner:

name: Test Self-Hosted Runner
on: [push]
jobs:
  test:
    runs-on: self-hosted
    steps:
      - name: Print Hello
        run: echo "Hello from Azure VM Runner!"

Push a change to your repository and check the Actions tab in GitHub.

You should see the job running on your Azure VM!

Note: You might get some errors initially in the workflow due unavailibility of node js and few other things. So, please installated that on by one on your VM.

Conclusion:

GitHub Actions and Workflows provide a seamless way to automate software development processes, reducing manual effort and improving efficiency. By using self-hosted runners, developers can execute workflows on their own infrastructure, ensuring better control over resources. With GitHub Actions, teams can enhance collaboration, streamline CI/CD pipelines, and deploy software with greater reliability and security.

Introduction

In today’s world, cloud infrastructure is essential for deploying applications and managing resources efficiently. Because manually setting up and maintaining infrastructure can be time-consuming, error-prone, and difficult to reproduce. This is where Terraform comes into picture.

Terraform, developed by HashiCorp, is a powerful Infrastructure as Code (IaC) tool that allows you to define, provision, and manage your infrastructure using simple, readable configuration files. It supports multiple cloud providers like Azure, AWS, Google Cloud, and more, making it a versatile choice for multi-cloud environments.

This guide will take you through the basics of Terraform, its key components, and how to use it to create and manage cloud resources effortlessly. We will also build a practical example by creating a Virtual Network in Azure using Terraform.

Prerequisites

Before you start working with Terraform, make sure you have the knowledge of the following:

Basic Knowledge of Cloud Platforms: Understanding of cloud concepts and familiarity with Azure or any other cloud provider is helpful.
Command Line Experience: You should be comfortable using the terminal or command prompt.
Azure Account: If you are following the example, you’ll need an active Azure account. You can create a free account at Azure Portal.
Text Editor or IDE: Use any code editor like Visual Studio Code, Sublime Text, or Notepad++.

What is Terraform?

Terraform is a free tool made by HashiCorp that helps you create and manage your computer systems and cloud resources using code. Instead of clicking around in cloud platforms like AWS, Azure, or Google Cloud, you write instructions in a file, and Terraform builds everything for you.

Why Should You Use Terraform?

1. Infrastructure as Code:
   You can write your infrastructure (like servers and databases) as code, just like writing a program. This makes it easy to repeat the setup anytime.
2. Works with Many Cloud Providers:
   Terraform supports almost all cloud providers, so you can use it for AWS, Azure, Google Cloud, and more.
3. Easy to Understand:
   You write what you want, and Terraform figures out how to create it.
4. Version Control:
   Since it’s code, you can track changes using tools like Git.
5. Consistent Setups:
   You can ensure the same setup from testing to production.

How Does Terraform Work?

Terraform has a simple process:

1. Write: Write what you want in configuration files using a language called HCL (HashiCorp Configuration Language).
2. Plan: Check what changes Terraform will make without actually changing anything yet.
3. Apply: Make the changes and create the infrastructure.
4. Destroy: Delete the infrastructure when you don’t need it anymore.

Important Parts of Terraform

Providers: These are like plugins that help Terraform talk to cloud services like Azure or AWS.
Resources: These are the things you create, like virtual machines or databases.
Modules: These are reusable pieces of code to keep your setup organized and easy to manage.
State: Terraform keeps track of your infrastructure using a state file, so it knows what has been created.
Variables: These are placeholders for values, making your code flexible and reusable.
Output Values: These show you useful information after creating resources, like the name of a server.

How to Install Terraform

1. Go to the Terraform website and download the version for your computer.
2. Extract the file and add it to your system’s PATH, so you can use it in the terminal.
3. Check if it’s installed by running: terraform -version

Setting Up Terraform for Azure

In this article, we are going to create azure resources with the help of terraform.

Example: Creating a Resource Group in Azure Using Terraform
Let’s create a Resource Group in Azure using Terraform with very simple steps. We will use the Azure Dashboard for authentication, not the Azure CLI.

Step 1: Set Up Azure Service Principal

Since we’re using the Azure Dashboard, we need to create a Service Principal for Terraform to authenticate.

• Go to the Azure Portal.
• Navigate to Azure Active Directory → App registrations → New registration.
• Enter a name (e.g., TerraformApp) and select Accounts in this organizational directory only.
• Click Register.
• Go to Certificates & Secrets → New client secret. Copy the secret value somewhere safe (you won’t see it again).
• Go to Overview and copy the Application (client) ID, Directory (tenant) ID, Assign required roles.
• Go to Subscriptions → Select your Subscription → Access control (IAM) → Add role assignment.
• Choose Contributor role and select your registered application.

Step 2: Create Terraform Configuration File

Create a folder for your project and open your preferred text editor.

main.tf

provider "azurerm" {
  features {}
client_id       = var.client_id
  client_secret   = var.client_secret
  subscription_id = var.subscription_id
  tenant_id       = var.tenant_id
}
resource "azurerm_resource_group" "example" {
  name     = var.resource_group_name
  location = var.location
}
output "resource_group_name" {
  value = azurerm_resource_group.example.name
}

variable.tf

variable "client_id" {
  description = "Azure Client ID"
}
variable "client_secret" {
  description = "Azure Client Secret"
  sensitive   = true
}
variable "tenant_id" {
  description = "Azure Tenant ID"
}
variable "subscription_id" {
  description = "Azure Subscription ID"
}
variable "resource_group_name" {
  description = "Name of the Resource Group"
  default     = "terraform-demo-rg"
}
variable "location" {
  description = "Azure Region"
  default     = "East US"
}

terraform.tfvars

client_id           = "YOUR_CLIENT_ID"
client_secret       = "YOUR_CLIENT_SECRET"
tenant_id           = "YOUR_TENANT_ID"
subscription_id     = "YOUR_SUBSCRIPTION_ID"

Step 3: Initialize Terraform

Open a terminal, go to the project folder, and run:

terraform init

This downloads the Azure provider plugin.

Step 4: Preview Changes

Check what Terraform will do before actually creating the resource:

terraform plan

Step 5: Apply Changes

Create the Resource Group in Azure:

terraform apply

Step 6: Verify in Azure Dashboard

Go to the Azure Portal → Resource Groups and check if the Resource Group is created.

Step 7: Clean Up (Optional)

To delete the Resource Group and all associated resources:

terraform destroy

Conclusion:

In this article, we went through the basics of terraform and it’s installation. Later on, we looked into the step-by-step creation of azure resouce group with the help of terraform.

Introduction

In this article, we gonna create a sample product application using the.NET Core Web API and React JS. Also, will containerize the same with the help of Azure Kubernetics Services.

Agenda

• Sample Product Application Backend (.NET Core Web API)
• Sample Product Application Frontend (React JS)
• Docker Files for Application
• Containerize the Application

Prerequisites

• Visual Studio
• Docker Runtime and AKS
• NPM
• .NET Core SDK
• React JS

Sample Product Application: Backend (.NET Core Web API)

Step 1. Create a new Product Management.NET Core Web API.

Step 2. First, install the following NuGet packages that we used for the in-memory database.

Step 3. Add the product class inside the entities folder.

namespace ProductManagementAPI.Entities
{
    public class Product
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public decimal Price { get; set; }
    }
}

Step 4. Create an AppDbContext class inside the data folder with an in-memory connection and a DB set property.

using Microsoft.EntityFrameworkCore;
using ProductManagementAPI.Entities;
namespace ProductManagementAPI.Data
{
    public class AppDbContext : DbContext
    {
        public DbSet<Product> Products { get; set; }
public AppDbContext(DbContextOptions<AppDbContext> options)
            : base(options)
        {
        }
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            // This check prevents configuring the DbContext if options are already provided
            if (!optionsBuilder.IsConfigured)
            {
                // Configure the in-memory database here, if needed
                optionsBuilder.UseInMemoryDatabase("InMemoryDb");
            }
        }
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            // Optionally configure entity mappings here
        }
    }
}

Step 5. Add a product repository inside the repositories folder.

IProductRepository

using ProductManagementAPI.Entities;
namespace ProductManagementAPI.Repositories
{
    public interface IProductRepository
    {
        Task<List<Product>> GetAllProductsAsync();
        Task<Product> GetProductByIdAsync(int id);
        Task AddProductAsync(Product product);
        Task UpdateProductAsync(Product product);
        Task DeleteProductAsync(int id);
    }
}

ProductRepository

using Microsoft.EntityFrameworkCore;
using ProductManagementAPI.Data;
using ProductManagementAPI.Entities;
namespace ProductManagementAPI.Repositories
{
    public class ProductRepository : IProductRepository
    {
        private readonly AppDbContext _context;
        public ProductRepository(AppDbContext context)
        {
            _context = context;
        }
        public async Task<List<Product>> GetAllProductsAsync()
        {
            return await _context.Products.ToListAsync();
        }
        public async Task<Product> GetProductByIdAsync(int id)
        {
            return await _context.Products
                .AsNoTracking()
                .FirstOrDefaultAsync(p => p.Id == id);
        }
        public async Task AddProductAsync(Product product)
        {
            if (product == null)
            {
                throw new ArgumentNullException(nameof(product));
            }
            _context.Products.Add(product);
            await _context.SaveChangesAsync();
        }
        public async Task UpdateProductAsync(Product product)
        {
            if (product == null)
            {
                throw new ArgumentNullException(nameof(product));
            }
            _context.Entry(product).State = EntityState.Modified;
            await _context.SaveChangesAsync();
        }
        public async Task DeleteProductAsync(int id)
        {
            var product = await _context.Products.FindAsync(id);
            if (product == null)
            {
                throw new KeyNotFoundException("Product not found.");
            }
            _context.Products.Remove(product);
            await _context.SaveChangesAsync();
        }
    }
}

Step 6. Create a new product controller with different action methods that we used to perform different operations using our front-end application after invoking the same.

using Microsoft.AspNetCore.Mvc;
using ProductManagementAPI.Entities;
using ProductManagementAPI.Repositories;
namespace ProductManagementAPI.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ProductsController : ControllerBase
    {
        private readonly IProductRepository _repository;
        public ProductsController(IProductRepository repository)
        {
            _repository = repository;
        }
        [HttpGet]
        public async Task<IActionResult> GetAllProducts()
        {
            var products = await _repository.GetAllProductsAsync();
            return Ok(products); // Returns only the list of products
        }
        [HttpGet("{id}")]
        public async Task<IActionResult> GetProductById(int id)
        {
            var product = await _repository.GetProductByIdAsync(id);
            if (product == null)
            {
                return NotFound();
            }
            return Ok(product); // Returns only the product data
        }
        [HttpPost]
        public async Task<IActionResult> AddProduct([FromBody] Product product)
        {
            if (product == null)
            {
                return BadRequest();
            }
            await _repository.AddProductAsync(product);
            return CreatedAtAction(nameof(GetProductById), new { id = product.Id }, product);
        }
        [HttpPut("{id}")]
        public async Task<IActionResult> UpdateProduct(int id, [FromBody] Product product)
        {
            if (product == null || id != product.Id)
            {
                return BadRequest();
            }
            await _repository.UpdateProductAsync(product);
            return NoContent();
        }
        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteProduct(int id)
        {
            await _repository.DeleteProductAsync(id);
            return NoContent();
        }
    }
}

Step 7. Register our services inside the service container and configure the middleware.

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;
using ProductManagementAPI.Data;
using ProductManagementAPI.Repositories;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddScoped<IProductRepository, ProductRepository>();
builder.Services.AddDbContext<AppDbContext>();
builder.Services.AddCors(options => {
    options.AddPolicy("CORSPolicy", builder => builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
});

// Configure in-memory database
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseInMemoryDatabase("InMemoryDb"));
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var app = builder.Build();
// Configure the HTTP request pipeline.
app.UseCors("CORSPolicy");
app.UseSwagger();
app.UseSwaggerUI();
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();

Step 8. Finally, run the application and use Swagger UI to execute different API endpoints.

Sample Product Application: Frontend (React JS)

Let’s create a client application using React JS and consume the above API endpoints within it.

Step 1. Create a new React JS application with the help of the following command.

npx create-react-app react-netcore-crud-app

Step 2. Navigate to your project directory.

cd react-netcore-crud-app

Step 3. Install Axios to consume and hit backend API and bootstrap for designing purposes.

npm install axios
npm install bootstrap

Step 4. Add the following components and services.

Product list component

// src/components/ProductList/ProductList.js
import React, { useState, useEffect } from 'react';
import ProductListItem from './ProductListItem';
import productService from '../../services/productService';
const ProductList = () => {
    const [products, setProducts] = useState([]);
    useEffect(() => {
        fetchProducts();
    }, []);
    const fetchProducts = async () => {
        try {
            const productsData = await productService.getAllProducts();
            setProducts(productsData);
        } catch (error) {
            console.error('Error fetching products:', error);
        }
    };
    const handleDelete = async (id) => {
        try {
            await productService.deleteProduct(id);
            fetchProducts(); // Refresh product list
        } catch (error) {
            console.error('Error deleting product:', error);
        }
    };
    const handleEdit = () => {
        fetchProducts(); // Refresh product list after editing
    };
    return (
        <div className="container">
            <h2 className="my-4">Product List</h2>
            <ul className="list-group">
    {Array.isArray(products) && products.length > 0 ? (
        products.map(product => (
            <ProductListItem key={product.id} product={product} onDelete={() => handleDelete(product.id)} onEdit={handleEdit} />
        ))
    ) : (
        <p>No products available</p>
    )}
</ul>
        </div>
    );
};
export default ProductList;

Product list item component

// src/components/ProductList/ProductListItem.js
import React, { useState } from 'react';
import productService from '../../services/productService';
const ProductListItem = ({ product, onDelete, onEdit }) => {
    const [isEditing, setIsEditing] = useState(false);
    const [editedName, setEditedName] = useState(product.name);
    const [editedPrice, setEditedPrice] = useState(product.price);
    const handleEdit = async () => {
        setIsEditing(true);
    };
    const handleSave = async () => {
        const editedProduct = { ...product, name: editedName, price: parseFloat(editedPrice) };
        try {
            await productService.updateProduct(product.id, editedProduct);
            setIsEditing(false);
            onEdit(); // Refresh product list
        } catch (error) {
            console.error('Error updating product:', error);
        }
    };
    const handleCancel = () => {
        setIsEditing(false);
        // Reset edited values
        setEditedName(product.name);
        setEditedPrice(product.price);
    };
    return (
        <li className="list-group-item">
            {isEditing ? (
                <div className="row">
                    <div className="col">
                        <input type="text" className="form-control" value={editedName} onChange={e => setEditedName(e.target.value)} required />
                    </div>
                    <div className="col">
                        <input type="number" className="form-control" value={editedPrice} onChange={e => setEditedPrice(e.target.value)} required />
                    </div>
                    <div className="col-auto">
                        <button className="btn btn-success me-2" onClick={handleSave}>Save</button>
                        <button className="btn btn-secondary" onClick={handleCancel}>Cancel</button>
                    </div>
                </div>
            ) : (
                <div className="d-flex justify-content-between align-items-center">
                    <span>{product.name} - ${product.price}</span>
                    <div>
                        <button className="btn btn-danger me-2" onClick={onDelete}>Delete</button>
                        <button className="btn btn-primary" onClick={handleEdit}>Edit</button>
                    </div>
                </div>
            )}
        </li>
    );
};
export default ProductListItem;

Product service

// src/services/productService.js
import axios from 'axios';
const baseURL = 'https://localhost:7202/api/products';
const productService = {
    getAllProducts: async () => {
        try {
            const response = await axios.get(
              baseURL,
              {
                timeout: 3000,
                headers: {
                  Accept: 'application/json',
                },
              },
            );
            return response.data;
          } catch (err) {
            if (err.code === 'ECONNABORTED') {
              console.log('The request timed out.');
            } else {
              console.log(err);
            }
          }
    },
    addProduct: async (product) => {
        const response = await axios.post(baseURL, product);
        return response.data;
    },
    deleteProduct: async (id) => {
        const response = await axios.delete(`${baseURL}/${id}`);
        return response.data;
    },
    updateProduct: async (id, product) => {
        const response = await axios.put(`${baseURL}/${id}`, product);
        return response.data;
    }
};
export default productService;

App component

// src/App.js
import React, { useState } from 'react';
import ProductList from './components/ProductList/ProductList';
import ProductForm from './components/ProductForm/ProductForm';
function App() {
    const [refresh, setRefresh] = useState(false);
    const handleProductAdded = () => {
        setRefresh(!refresh); // Toggle refresh state to trigger re-render
    };
    return (
        <div>
            <ProductList key={refresh} />
            <ProductForm onProductAdded={handleProductAdded} />
        </div>
    );
}
export default App;

Step 5. Run the application using the following command and perform the different CRUD operations with the help of the same.

Docker Files for Application

Docker file for backend application (.NET Core).

# Use the official .NET Core SDK as a parent image
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build

WORKDIR /app

# Copy the project file and restore any dependencies (use .csproj for the project name)
COPY *.csproj ./
RUN dotnet restore

# Copy the rest of the application code
COPY . .

# Publish the application
RUN dotnet publish -c Release -o out

# Build the runtime image
FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS runtime
WORKDIR /app
COPY --from=build /app/out ./

# Expose the port your application will run on
EXPOSE 80

# Start the application
ENTRYPOINT ["dotnet", "ProductManagementAPI.dll"]

• Line 1–2: Uses the official .NET Core SDK image (mcr.microsoft.com/dotnet/sdk:6.0) as a base.
• Line 4: Sets the working directory to /app.
• Line 6–7: Copies the project file(s) (*.csproj) into the container.
• Line 8: Runs dotnet restore to restore dependencies specified in the project file(s).
• Line 10–11: Copies the rest of the application code into the container.
• Line 13–14: Publishes the application in Release configuration (dotnet publish -c Release -o out), outputting to the out directory.
• Line 16–17: Uses the official .NET Core ASP.NET runtime image (mcr.microsoft.com/dotnet/aspnet:6.0) as a base.
• Line 19–20: Sets the working directory to /app and Copies the published output from the build stage (from /app/out) into the /app directory of the runtime stage.
• Line 22–23: Exposes port 80 to allow external access to the application.
• Line 25–26: Specifies dotnet ProductManagementAPI.dll as the entry point command to start the application.

Docker file for frontend application (React JS).

FROM node:16-alpine
WORKDIR /app
COPY . .
RUN npm install
RUN npm run build
EXPOSE 3000
CMD ["npm", "start"]

• Line 1: specifies the base image, using Node.js version 18.
• Line 2: sets /app as the working directory for subsequent commands.
• Line 3: Copies the contents of your local directory into the container’s working directory.
• Line 4: Installs the project dependencies inside the container.
• Line 5: Build the production version of your React app.
• Line 6: This exposes port 3000, which is where the application will run.
• Line 7: The command starts the React application using serve to serve the build folder.

Next, modify your backend hard-coded URL in the product service.

// src/services/productService.js
import axios from 'axios';
const baseURL = `${process.env.REACT_APP_API_URL}/api/products`;
const productService = {
    getAllProducts: async () => {
        try {
            const response = await axios.get(
              baseURL,
              {
                timeout: 3000,
                headers: {
                  Accept: 'application/json',
                },
              },
            );
            return response.data;
          } catch (err) {
            if (err.code === 'ECONNABORTED') {
              console.log('The request timed out.');
            } else {
              console.log(err);
            }
          }
    },
    addProduct: async (product) => {
        const response = await axios.post(baseURL, product);
        return response.data;
    },
    deleteProduct: async (id) => {
        const response = await axios.delete(`${baseURL}/${id}`);
        return response.data;
    },
    updateProduct: async (id, product) => {
        const response = await axios.put(`${baseURL}/${id}`, product);
        return response.data;
    }
};
export default productService;

Containerize the front-end and back-end application

Step 1:

Open the azure portal and create a new resource group. (Note: this is the optional step. if you already have your own resource group then you can use the same.)

Step 2

Create a new Azure Container Registry to store the application dcoker images.

Step 3

Build and push the application docker images inside the newly created azure container regsitry.

Note: Make sure docker runtime is running on your machine to build an image before pushing it into the container registry.

//build the frontend and backend application image
docker build -t frontendapp -f Dockerfile
docker build -t backendapp -f Dockerfile

//create a new image as per acr standards for pushing image to acr
docker tag frontendapp:latest jddemo.azurecr.io/frontentdapp:latest
docker tag backendapp:latest jddemo.azurecr.io/backendapp:latest

//azure login
az login
az acr login --name jddemo

//push the images
docker push jddemo.azurecr.io/frontendapp:latest
docker push jddemo.azurecr.io/backendapp:latest

If you want more details about how to push and pull the images from ACR then please check this microsoft document.

Step 4:

Now we want azure kubernetes service to create and manage our application instances. So, for that open your azure resource group and create a new azure kubernetes service.

Step 5

Next, we are going to create kubernetes manifest files and using that we pull our application images from the ACR and for that we have to add ACR PULL access.

For that first open the IAM of ACR.

Click on Role Assignments.

Then under the mebers tab select managed identities and enabled ACR Pull access to our AKS Cluster.

Step 6:

Create a new kubernetes manifest files for both our front end and backend application.

Backend Application Files:

Deployment.YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: product-management-api
  labels:
    app: product-management-api
spec:
  replicas: 1
  selector:
    matchLabels:
      app: product-management-api
  template:
    metadata:
      labels:
        app: product-management-api
    spec:
      containers:
      - name: product-management-api
        image: jddemo.azurecr.io/backendapp:latest
        imagePullPolicy: Always
        ports:
        - containerPort: 80

Service.YAML

(Note: As a part of this article we have put service type as Load Balancer because we want to exposed and use backend service inside the front end application. But, In upcoming articles we are going to use Cluster IP and using DNS, Ingress configuration we gonna manage those things.)

apiVersion: v1
kind: Service
metadata:
  name: product-management-api-service
  labels:
    app: product-management-api
spec:
  type: LoadBalancer
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  selector:
    app: product-management-api

Client Application Files:

Deployment.YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: react-client-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: react-client
  template:
    metadata:
      labels:
        app: react-client
    spec:
      containers:
      - name: react-client
        image: jddemo.azurecr.io/frontendapp:latest
        imagePullPolicy: Always
        ports:
        - containerPort: 80
        env:
        - name: REACT_APP_API_URL
          valueFrom:
            configMapKeyRef:
              name: backend-config
              key: REACT_APP_API_URL

Service.YAML

apiVersion: v1
kind: Service
metadata:
  name: react-client-service
spec:
  selector:
    app: react-client
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: LoadBalancer

Backend-Configmap.YAML

apiVersion: v1
kind: ConfigMap
metadata:
  name: backend-config
data:
  REACT_APP_API_URL: "http://4.186.34.13" //external ip of backend service

Step 7:

Apply all the K8S files on to the AKS Cluster.

kubectl apply -f deployment.yml
kubectl apply -f service.yml
kubectl apply -f backend-configmap.yml

Step 8

Verify all the deployments, pods and service are in the running mode with the help of following commands.

kubectl get deployments
kubectl get pods
kubectl get services

Step 9

Use the external IP Address to use the client application.

Note: As a part of this article we are not configuring the DNS and Ingress Controoller because of that we have expose external IP’s of application service but in upcoming artcile we are gonna configure and learned about the same.

Conclusion:

In this article, we created backend and client application with the help of .NET Core API and React JS. Later on, generated and pushed docker images of the application onto the ACR and then lastly with the help K8S Manifest files we deploy our application on the AKS Cluster.

Overview

Azure Logic Apps is a cloud service provided by Microsoft that simplifies and automates workflows across applications and services. It helps create workflows to connect different systems, services, and applications, making it easy to automate repetitive tasks and integrate services without writing complex code. With Logic Apps, users can easily connect legacy systems, cloud services, APIs and on-premises data, which is very beneficial for business process automation and system integration.

What is Azure Logic App?

• Azure Logic Apps is part of Microsoft’s integration services in Azure and enables developers and IT professionals to automate workflows and business processes.
• It provides a visual designer for creating workflows that consist of different steps (called actions) and connectors that integrate with services such as Azure Blob Storage, Office 365, SQL Server, and more.
• Users can create workflows that run on pre-defined schedules or are triggered by specific events, making it easy to integrate and automate processes without in-depth programming skills.

Benefits of Azure Logic App

Scalability and reliability:

As a managed service, it automatically scales and processes large volumes of data with minimal setup.

Easy integration:

Logic Apps provides a wide range of built-in connectors for seamless integration with various services such as SharePoint, Dynamics 365 and external services such as Google, Twitter, and more.

Rapid development:

Logic Apps offers a no-code/low-code platform with a visual designer that enables the creation of workflows quickly and efficiently.

Security:

Logic Apps provides integration with Azure Active Directory for authentication and conforms to enterprise security standards, ensuring data security.

Cost-effective:

Users only pay for the actions and triggers they use, making it a cost-effective process automation solution.

Components of Azure Logic App

Triggers:

Triggers determine how a workflow starts. This can be an event (such as a new item in the database) or a scheduled trigger (such as a recurring task).

Actions:

are actions or steps that a workflow performs, such as sending an email, updating a database, or making an API call.

Connectors:

Connectors provide pre-built functionality to connect to other services (such as Office 365, SQL Server, Azure Storage) and APIs.

Workflow:

The main element that represents the logic and sequence of actions to be performed according to defined conditions.

Conditions and loops:

Logic Apps supports conditional branching and loops. It allows the workflow to make repeated decisions or actions. based on data

Types of Azure Logic App

Usage-based logic applications:

Billed based on the number of trigger and connector operations used. Suitable for most use cases This is especially the case when the workflow is event-driven.

Standard Logic Apps:

Used within Azure Functions apps, this allows for more control over network configuration. and is suitable for complex workflows with more customized requirements.

Stateful and stateless workflows:

Stateful workflows maintain their state after every action and suitable for time-consuming processes While stateless workflows do not maintain state and are suitable for short-term tasks that require minimal delay.

Real-time use cases of Azure Logic App

Data integration: Automatically integrate data from multiple sources into a central data warehouse.

Business Process Automation: Automate multiple processes, such as order processing or payment approval.

Email Notifications: Send alerts for important events, such as low inventory or system errors.

Social media tracking: Track brand mentions and auto-replies on platforms like Twitter and Facebook.

Document Processing: Extract and process data from documents such as invoices or purchase orders.

Scheduled tasks: Run repeating tasks, such as nightly backups. or cleaning files

Employee On boarding: Automate setup tasks for new employees. This includes account creation and device provisioning.

Step-by-Step Implementation in Azure Logic Apps

We are taking one real-time use case for Storing Azure Service Bus Queue Messages in an Azure Blob Storage Container.

This workflow will trigger whenever a message arrives in an Azure Service Bus queue and store the message content as a blob file in an Azure Blob Storage container.

Prerequisites

• Access to an Azure subscription.
• An Azure Service Bus queue with messages being sent to it.
• An Azure Storage account with a blob container for storing messages.

Step 1

Go to the Azure portal and sign in

Step 2

Search for “Logic App” and click on Create.

Step 3

Configure Logic App settings: Provide a name, select a resource group, location, and then click Review + create to complete the setup.

Step 4

Create a new workflow inside logic app.

Step 5

Open the Logic App Designer: In the Logic App, go to the Logic App Designer to start building the workflow.

Select the Service Bus connector: Search for Azure Service Bus and select When a message is received in a queue (peek-lock).

Step 6

Configure Service Bus connection

Step 7

Add an Action to Store Message in Blob Storage

Select the Azure Blob Storage connector: Search for Azure Blob Storage and select Create blob.

Configure Blob Storage connection

Set blob name and content

Click on save.

Step 8

Send a test message: Send a test message to the Service Bus queue.

Step 9

Verify blob creation: Go to the Azure Blob Storage container and check for a new blob with the message content.

Step 10

Go to the Logic App Runs history to see the execution details for each trigger.

Conclusion

In this article, we learned about the basics of Azure logic apps and their real-time use cases and benefits. Also, took one use case and after that step-by-step implementation about the same.

Introduction

In this article, we will create a sample products application backend using the.NET Core Web API and React JS web forms. Also, we will containerize the same with the help of Docker and Kubernetes.

Agenda

• Sample Products Application Backend (.NET Core Web API)
• Sample Products Application Frontend (React JS)
• Docker Files for Application
• Containerize the Application

Prerequisites

• Visual Studio 2022
• Docker Desktop with Kubernetes
• NPM
• .NET Core SDK
• React JS

Sample Products Application: Backend (.NET Core Web API)

Step 1. Create a new Product Management.NET Core Web API.

Step 2. First, install the following NuGet packages which we used for swagger UI and in-memory database.

Step 3. Add the product class inside the entities folder.

namespace ProductManagementAPI.Entities
{
    public class Product
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public decimal Price { get; set; }
    }
}

Step 4. Create an AppDbContext class inside the data folder with a in-memory database connection and a DB set property.

using Microsoft.EntityFrameworkCore;
using ProductManagementAPI.Entities;

namespace ProductManagementAPI.Data
{
    public class AppDbContext : DbContext
    {
        public DbSet<Product> Products { get; set; }
        public AppDbContext(DbContextOptions<AppDbContext> options)
            : base(options)
        {
        }
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            // This check prevents configuring the DbContext if options are already provided
            if (!optionsBuilder.IsConfigured)
            {
                // Configure the in-memory database here, if needed
                optionsBuilder.UseInMemoryDatabase("InMemoryDb");
            }
        }
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            // Optionally configure entity mappings here
        }
    }
}

Step 5. Add a product repository inside the repositories folder.

IProductRepository

using ProductManagementAPI.Entities;

namespace ProductManagementAPI.Repositories
{
    public interface IProductRepository
    {
        Task<List<Product>> GetAllProductsAsync();
        Task<Product> GetProductByIdAsync(int id);
        Task AddProductAsync(Product product);
        Task UpdateProductAsync(Product product);
        Task DeleteProductAsync(int id);
    }
}

ProductRepository

using Microsoft.EntityFrameworkCore;
using ProductManagementAPI.Data;
using ProductManagementAPI.Entities;

namespace ProductManagementAPI.Repositories
{
    public class ProductRepository : IProductRepository
    {
        private readonly AppDbContext _context;
        public ProductRepository(AppDbContext context)
        {
            _context = context;
        }
        public async Task<List<Product>> GetAllProductsAsync()
        {
            return await _context.Products.ToListAsync();
        }
        public async Task<Product> GetProductByIdAsync(int id)
        {
            return await _context.Products
                .AsNoTracking()
                .FirstOrDefaultAsync(p => p.Id == id);
        }
        public async Task AddProductAsync(Product product)
        {
            if (product == null)
            {
                throw new ArgumentNullException(nameof(product));
            }
            _context.Products.Add(product);
            await _context.SaveChangesAsync();
        }
        public async Task UpdateProductAsync(Product product)
        {
            if (product == null)
            {
                throw new ArgumentNullException(nameof(product));
            }
            _context.Entry(product).State = EntityState.Modified;
            await _context.SaveChangesAsync();
        }
        public async Task DeleteProductAsync(int id)
        {
            var product = await _context.Products.FindAsync(id);
            if (product == null)
            {
                throw new KeyNotFoundException("Product not found.");
            }
            _context.Products.Remove(product);
            await _context.SaveChangesAsync();
        }
    }
}

Step 6. Create a new product controller with different action methods that we used to perform different operations using our front-end application after invoking the same.

using Microsoft.AspNetCore.Mvc;
using ProductManagementAPI.Entities;
using ProductManagementAPI.Repositories;

namespace ProductManagementAPI.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ProductsController : ControllerBase
    {
        private readonly IProductRepository _repository;
        public ProductsController(IProductRepository repository)
        {
            _repository = repository;
        }
        [HttpGet]
        public async Task<IActionResult> GetAllProducts()
        {
            var products = await _repository.GetAllProductsAsync();
            return Ok(products); // Returns only the list of products
        }
        [HttpGet("{id}")]
        public async Task<IActionResult> GetProductById(int id)
        {
            var product = await _repository.GetProductByIdAsync(id);
            if (product == null)
            {
                return NotFound();
            }
            return Ok(product); // Returns only the product data
        }
        [HttpPost]
        public async Task<IActionResult> AddProduct([FromBody] Product product)
        {
            if (product == null)
            {
                return BadRequest();
            }
            await _repository.AddProductAsync(product);
            return CreatedAtAction(nameof(GetProductById), new { id = product.Id }, product);
        }
        [HttpPut("{id}")]
        public async Task<IActionResult> UpdateProduct(int id, [FromBody] Product product)
        {
            if (product == null || id != product.Id)
            {
                return BadRequest();
            }
            await _repository.UpdateProductAsync(product);
            return NoContent();
        }
        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteProduct(int id)
        {
            await _repository.DeleteProductAsync(id);
            return NoContent();
        }
    }
}

Step 7. Register our services inside the service container and configure the middleware.

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;
using ProductManagementAPI.Data;
using ProductManagementAPI.Repositories;

var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddScoped<IProductRepository, ProductRepository>();
builder.Services.AddDbContext<AppDbContext>();
builder.Services.AddCors(options => {
    options.AddPolicy("CORSPolicy", builder => builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
});
// Configure in-memory database
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseInMemoryDatabase("InMemoryDb"));
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var app = builder.Build();
// Configure the HTTP request pipeline.
app.UseCors("CORSPolicy");

app.UseSwagger();
app.UseSwaggerUI();

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();

Step 8. Finally, run the application and use Swagger UI to execute different API endpoints.

Sample Products Application: Frontend (React JS)

Let’s create a client application using React JS and consume the above API endpoints within it.

Step 1. Create a new React JS application with the help of the following command.

npx create-react-app react-netcore-crud-app

Step 2. Navigate to your project directory.

cd react-netcore-crud-app

Step 3. Install Axios to consume and hit backend API and bootstrap for designing purposes.

npm install axios
npm install bootstrap

Step 4. Add the following components and services.

Product list component

// src/components/ProductList/ProductList.js
import React, { useState, useEffect } from 'react';
import ProductListItem from './ProductListItem';
import productService from '../../services/productService';

const ProductList = () => {
    const [products, setProducts] = useState([]);
    useEffect(() => {
        fetchProducts();
    }, []);
    const fetchProducts = async () => {
        try {
            const productsData = await productService.getAllProducts();
            setProducts(productsData);
        } catch (error) {
            console.error('Error fetching products:', error);
        }
    };
    const handleDelete = async (id) => {
        try {
            await productService.deleteProduct(id);
            fetchProducts(); // Refresh product list
        } catch (error) {
            console.error('Error deleting product:', error);
        }
    };
    const handleEdit = () => {
        fetchProducts(); // Refresh product list after editing
    };
    return (
        <div className="container">
            <h2 className="my-4">Product List</h2>
            <ul className="list-group">
    {Array.isArray(products) && products.length > 0 ? (
        products.map(product => (
            <ProductListItem key={product.id} product={product} onDelete={() => handleDelete(product.id)} onEdit={handleEdit} />
        ))
    ) : (
        <p>No products available</p>
    )}
</ul>
        </div>
    );
};
export default ProductList;

Product list item component

// src/components/ProductList/ProductListItem.js
import React, { useState } from 'react';
import productService from '../../services/productService';

const ProductListItem = ({ product, onDelete, onEdit }) => {
    const [isEditing, setIsEditing] = useState(false);
    const [editedName, setEditedName] = useState(product.name);
    const [editedPrice, setEditedPrice] = useState(product.price);
    const handleEdit = async () => {
        setIsEditing(true);
    };
    const handleSave = async () => {
        const editedProduct = { ...product, name: editedName, price: parseFloat(editedPrice) };
        try {
            await productService.updateProduct(product.id, editedProduct);
            setIsEditing(false);
            onEdit(); // Refresh product list
        } catch (error) {
            console.error('Error updating product:', error);
        }
    };
    const handleCancel = () => {
        setIsEditing(false);
        // Reset edited values
        setEditedName(product.name);
        setEditedPrice(product.price);
    };
    return (
        <li className="list-group-item">
            {isEditing ? (
                <div className="row">
                    <div className="col">
                        <input type="text" className="form-control" value={editedName} onChange={e => setEditedName(e.target.value)} required />
                    </div>
                    <div className="col">
                        <input type="number" className="form-control" value={editedPrice} onChange={e => setEditedPrice(e.target.value)} required />
                    </div>
                    <div className="col-auto">
                        <button className="btn btn-success me-2" onClick={handleSave}>Save</button>
                        <button className="btn btn-secondary" onClick={handleCancel}>Cancel</button>
                    </div>
                </div>
            ) : (
                <div className="d-flex justify-content-between align-items-center">
                    <span>{product.name} - ${product.price}</span>
                    <div>
                        <button className="btn btn-danger me-2" onClick={onDelete}>Delete</button>
                        <button className="btn btn-primary" onClick={handleEdit}>Edit</button>
                    </div>
                </div>
            )}
        </li>
    );
};
export default ProductListItem;

Product service

// src/services/productService.js
import axios from 'axios';

const baseURL = 'https://localhost:7202/api/products';
const productService = {
    getAllProducts: async () => {
        try {
            const response = await axios.get(
              baseURL,
              {
                timeout: 3000,
                headers: {
                  Accept: 'application/json',
                },
              },
            );
            return response.data;
          } catch (err) {
            if (err.code === 'ECONNABORTED') {
              console.log('The request timed out.');
            } else {
              console.log(err);
            }
          }
    },
    addProduct: async (product) => {
        const response = await axios.post(baseURL, product);
        return response.data;
    },
    deleteProduct: async (id) => {
        const response = await axios.delete(`${baseURL}/${id}`);
        return response.data;
    },
    updateProduct: async (id, product) => {
        const response = await axios.put(`${baseURL}/${id}`, product);
        return response.data;
    }
};
export default productService;

App component

// src/App.js
import React, { useState } from 'react';
import ProductList from './components/ProductList/ProductList';
import ProductForm from './components/ProductForm/ProductForm';
function App() {
    const [refresh, setRefresh] = useState(false);
    const handleProductAdded = () => {
        setRefresh(!refresh); // Toggle refresh state to trigger re-render
    };
    return (
        <div>
            <ProductList key={refresh} />
            <ProductForm onProductAdded={handleProductAdded} />
        </div>
    );
}
export default App;

Step 5. Run the application using the following command and perform the different CRUD operations with the help of the same.

Docker Files for Application

Docker file for backend application (.NET Core)

# Use the official .NET Core SDK as a parent image
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build

WORKDIR /app

# Copy the project file and restore any dependencies (use .csproj for the project name)
COPY *.csproj ./

RUN dotnet restore

# Copy the rest of the application code
COPY . .

# Publish the application
RUN dotnet publish -c Release -o out

# Build the runtime image
FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS runtime

WORKDIR /app
COPY --from=build /app/out ./

# Expose the port your application will run on
EXPOSE 80

# Start the application
ENTRYPOINT ["dotnet", "ProductManagementAPI.dll"]

• Line 1–2: Uses the official .NET Core SDK image (mcr.microsoft.com/dotnet/sdk:6.0) as a base.
• Line 4: Sets the working directory to /app.
• Line 6–7-: Copies the project file(s) (*.csproj) into the container.
• Line 8: Runs dotnet restore to restore dependencies specified in the project file(s).
• Line 10–11: Copies the rest of the application code into the container.
• Line 13–14: Publishes the application in Release configuration (dotnet publish -c Release -o out), outputting to the out directory.
• Line 16–17: Uses the official .NET Core ASP.NET runtime image (mcr.microsoft.com/dotnet/aspnet:6.0) as a base.
• Line 19–20: Sets the working directory to /app and Copies the published output from the build stage (from /app/out) into the /app directory of the runtime stage.
• Line 22–23: Exposes port 80 to allow external access to the application.
• Line 25–26: Specifies dotnet ProductManagementAPI.dll as the entry point command to start the application.

Docker file for frontend application (React JS)

FROM node:16-alpine
WORKDIR /app
COPY . .
RUN npm install
RUN npm run build
EXPOSE 3000
CMD ["npm", "start"]

• Line 1: specifies the base image, using Node.js version 18.
• Line 2: sets /app as the working directory for subsequent commands.
• Line 3: Copies the contents of your local directory into the container’s working directory.
• Line 4: Installs the project dependencies inside the container.
• Line 5: Builds the production version of your React app.
• Line 6: This exposes port 3000, which is where the application will run.
• Line 7: The command starts the React application using serve to serve the build folder.

Next, modify your backend hard-coded URL in the product service.

// src/services/productService.js
import axios from 'axios';

//const baseURL = 'https://localhost:31912/api/products';
const baseURL = process.env.REACT_APP_API_URL;
const productService = {
    getAllProducts: async () => {
        try {
            const response = await axios.get(
              baseURL,
              {
                timeout: 3000,
                headers: {
                  Accept: 'application/json',
                },
              },
            );
            return response.data;
          } catch (err) {
            if (err.code === 'ECONNABORTED') {
              console.log('The request timed out.');
            } else {
              console.log(err);
            }
          }
    },
    addProduct: async (product) => {
        const response = await axios.post(baseURL, product);
        return response.data;
    },
    deleteProduct: async (id) => {
        const response = await axios.delete(`${baseURL}/${id}`);
        return response.data;
    },
    updateProduct: async (id, product) => {
        const response = await axios.put(`${baseURL}/${id}`, product);
        return response.data;
    }
};
export default productService;

Containerize the front-end and back-end application

Step 1. Build the docker images.

docker build -t productbackendapp:latest .

docker build -t productfrontendapp:latest .

Step 2. Create a deployment and service YAML files for the backend application.

deployment.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: product-management-api
  labels:
    app: product-management-api
spec:
  replicas: 1
  selector:
    matchLabels:
      app: product-management-api
  template:
    metadata:
      labels:
        app: product-management-api
    spec:
      containers:
      - name: product-management-api
        image: productbackendapp:latest
        imagePullPolicy: Never
        ports:
        - containerPort: 80

service.yml

apiVersion: v1
kind: Service
metadata:
  name: product-management-api-service
  labels:
    app: product-management-api
spec:
  type: NodePort
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  selector:
    app: product-management-api

Step 3. Create deployment, service, and backend-configmap YAML files for the frontend application.

deployment.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: react-client-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: react-client
  template:
    metadata:
      labels:
        app: react-client
    spec:
      containers:
      - name: react-client
        image: productfrontendapp:latest
        imagePullPolicy: Never
        ports:
        - containerPort: 3000
        env:
        - name: REACT_APP_API_URL
          valueFrom:
            configMapKeyRef:
              name: backend-config
              key: REACT_APP_API_URL

service.yml

apiVersion: v1
kind: Service
metadata:
  name: react-client-service
spec:
  selector:
    app: react-client
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000
  type: NodePort

backend-configmap.yml

apiVersion: v1
kind: ConfigMap
metadata:
  name: backend-config
data:
  REACT_APP_API_URL: "http://localhost:30191/api/products"Step 4. Apply all the above files one by one using kubectl commands. (Note: make sure kubernetes is running on your system with docker daemon.)

Step 4. Apply all the above files one by one using kubectl commands. (Note: make sure kubernetes is running on your system with docker daemon.)

kubectl apply -f deployment.yml
kubectl apply -f service.yml
kubectl apply -f backend-configmap.yml

Step 5. Verify the deployment, services, pods, and config map are up and running or not with the help of kubectl commands.

Step 6. Hit the backend and frontend product application using services.

GitHub:

https://github.com/Jaydeep-007/React_NETCore_CRUD-Docker-Kubernetes

Conclusion

In this article, we created a products management backend application using .NET Core with different API endpoints that are required to perform CRUD operations. Later on, we created the front-end application using React JS and consumed the back-end application inside the same with the help of Axios. Also, we containerized both applications with the help of Docker and Kubernetes.

Introduction

In this article, we are looking into the basics of hooks and their types. Also, few real-time use cases and examples.

Agenda

· What are Hooks?

· Why Hooks?

· Types of Hooks

· Examples of Hooks

Prerequisites

· NPM

· React JS

· VS Code

What are Hooks?

Hooks are special functions in React that let you use state and other React features without writing a class.

Why Hooks?

Hooks allow functional components to manage state and lifecycle events, which were previously only possible in class components.

Hooks simplify the way React developers manage state and side effects, making functional components more powerful and flexible.

Types of Hooks

1. useState

Allows you to add state to functional components.

Example:

import React, { useState } from 'react';

function UseStateDemo() {
  // Declare a state variable called `count` with an initial value of 0
  const [count, setCount] = useState(0);

  // Function to increment the count
  const increment = () => {
    setCount(count + 1);
  };

  // Function to decrement the count
  const decrement = () => {
    setCount(count - 1);
  };

  return (
    <div className="UseStateDemo">
      <h1>Counter App</h1>
      <p>Current Count: {count}</p>
      <button onClick={increment}>Increment</button>
      <button onClick={decrement}>Decrement</button>
    </div>
  );
}

export default UseStateDemo;

Explanation:

1. Importing useState:

useState is imported from React to allow the functional component to manage the state.

2. Declaring State:

const [count, setCount] = useState(0);

count is the current state variable, initialized to 0.

setCount is the function used to update the count state.

3. Increment Function:

const increment = () => { setCount(count + 1); };

This function increases the count value by 1 whenever its called.

4. Decrement Function:

const decrement = () => { setCount(count — 1); };

This function decreases the count value by 1 whenever its called.

5. Returning JSX:

The component returns JSX that displays the current count value and two buttons that trigger the increment and decrement functions when clicked.

Example Usage:

When you click the “Increment” button, the count will increase by 1.

When you click the “Decrement” button, the count will decrease by 1.

This example clearly shows how useState can be used to manage local state within a functional component, allowing you to create interactive and dynamic components in React.

2. useEffect

Allows you to perform side effects in your function components, such as data fetching or manually updating the DOM.

Example:

import React, { useState, useEffect } from 'react';

function UseEffectDemo() {
  // State to store the list of product
  const [product, setProducts] = useState([]);
  // State to handle loading status
  const [loading, setLoading] = useState(true);
  // State to handle errors
  const [error, setError] = useState(null);

  // Fetch products when the component mounts
  useEffect(() => {
    // Define an async function to fetch data
    const fetchProducts = async () => {
      try {
        // Fetch data from API
        const response = await fetch('https://fakestoreapi.com/products');
        // Check if response is ok
        if (!response.ok) {
          throw new Error('Network response was not ok');
        }
        // Parse the JSON data
        const data = await response.json();
        // Update state with the fetched data
        setProducts(data);
      } catch (error) {
        // Update state with the error
        setError(error);
      } finally {
        // Update loading state
        setLoading(false);
      }
    };

    // Call the async function
    fetchProducts();
  }, []); // Empty dependency array means this effect runs once when the component mounts

  // Render loading, error, or product data
  if (loading) {
    return <p>Loading...</p>;
  }

  if (error) {
    return <p>Error: {error.message}</p>;
  }

  return (
    <div className="ProductList">
    <h1>Product List</h1>
    <table>
      <thead>
        <tr>
          <th>ID</th>
          <th>Name</th>
          <th>Price</th>
        </tr>
      </thead>
      <tbody>
        {product.map(product => (
          <tr key={product.id}>
            <td>{product.id}</td>
            <td>{product.title}</td>
            <td>${product.price.toFixed(2)}</td>
          </tr>
        ))}
      </tbody>
    </table>
  </div>
  );
}

export default UseEffectDemo;

Explanation:

1. State Management:

product: Holds the list of products fetched from the API.

loading: Tracks whether the data is still being fetched.

error: Stores any error that occurs during the fetch process.

2. Fetching Data with useEffect:

The useEffect Hook is used to perform side effects — in this case, fetching data from the API.

The effect runs only once when the component mounts because the dependency array is empty ([]).

Inside the useEffect, an asynchronous function fetchProducts is defined and immediately invoked to fetch product data from https://fakestoreapi.com/products.

The function handles:

- Successful Fetching: The fetched data is stored in the product state.

- Error Handling: Any errors encountered during the fetch are stored in the error state.

- Loading State: The loading state is set to false once the data fetch is complete (regardless of success or failure).

3. Rendering Logic:

- Loading State: While the data is being fetched, the component renders a loading message: <p>Loading…</p>.

- Error State: If an error occurs, an error message is displayed: <p>Error: {error.message}</p>.

- Data Display: Once the data is fetched successfully, the component renders a table listing the products with their IDs, names, and prices.

Example Usage:

- When the UseEffectDemo component mounts, it automatically fetches the list of products from the provided API.

- Depending on the fetch result, it will either show the products, an error message, or a loading indicator.

This component showcases how to effectively use useEffect to perform side effects like data fetching in a React functional component, alongside managing the various states related to the fetch process (loading, error, and data).

3. useReducer

This hook is an alternative to useState for managing complex state logic.

Example:

import React, { useReducer } from 'react';

// Define the initial state
const initialState = {
  count: 0,
  name: '',
  isEditing: false,
};

// Define the reducer function
const reducer = (state, action) => {
  switch (action.type) {
    case 'INCREMENT':
      return { ...state, count: state.count + 1 };
    case 'DECREMENT':
      return { ...state, count: state.count - 1 };
    case 'TOGGLE_EDIT':
      return { ...state, isEditing: !state.isEditing };
    case 'SET_NAME':
      return { ...state, name: action.payload };
    default:
      return state;
  }
};

// Component
const UseReducerDemo = () => {
  const [state, dispatch] = useReducer(reducer, initialState);

  const handleIncrement = () => dispatch({ type: 'INCREMENT' });
  const handleDecrement = () => dispatch({ type: 'DECREMENT' });
  const handleToggleEdit = () => dispatch({ type: 'TOGGLE_EDIT' });
  const handleNameChange = (e) => dispatch({ type: 'SET_NAME', payload: e.target.value });

  return (
    <div>
      <h1>UseReducer Demo</h1>
      <div>
        <h2>Count: {state.count}</h2>
        <button onClick={handleIncrement}>Increment</button>
        <button onClick={handleDecrement}>Decrement</button>
      </div>
      <div>
        <h2>Name: {state.name}</h2>
        <button onClick={handleToggleEdit}>
          {state.isEditing ? 'Stop Editing' : 'Edit Name'}
        </button>
        {state.isEditing && (
          <input
            type="text"
            value={state.name}
            onChange={handleNameChange}
            placeholder="Enter your name"
          />
        )}
      </div>
    </div>
  );
};

export default UseReducerDemo;

Explanation:

1. Initial State:

- The initialState object defines the initial values for:

- count: A numeric counter, starting at 0.

- name: A string, initially empty, to store the user’s name.

- isEditing: A boolean that tracks whether the name is being edited, initially set to false.

2. Reducer Function:

- The reducer function determines how the state should change based on the dispatched action:

- INCREMENT: Increases the count by 1.

- DECREMENT: Decreases the count by 1.

- TOGGLE_EDIT: Toggles the isEditing state between true and false.

- SET_NAME: Updates the name state with the value provided in action.payload.

- Default Case: Returns the current state if the action type doesn’t match any case.

3. Using useReducer:

- The useReducer Hook is used to manage the component’s state. It takes the reducer function and initialState as arguments and returns the current state and a dispatch function.

- dispatch is used to send actions to the reducer, triggering state changes based on the action type.

4. Event Handlers:

- handleIncrement: Dispatches the INCREMENT action to increase the count.

- handleDecrement: Dispatches the DECREMENT action to decrease the count.

- handleToggleEdit: Dispatches the TOGGLE_EDIT action to toggle the editing mode.

- handleNameChange: Dispatches the SET_NAME action with the new name value whenever the input field changes.

5. Rendering the Component:

- The component renders:

- The current count with buttons to increment and decrement it.

- The current name with a button to toggle the editing mode.

- An input field to edit the name if isEditing is true.

Example Usage:

- Increment/Decrement Count: Users can click the buttons to adjust the count.

- Toggle Edit Mode: Users can toggle the editing mode for the name input.

- Update Name: If editing mode is active, users can type in the input field to update the name state.

Benefits of useReducer in this Component:

- Centralized State Management: The reducer function manages all state changes in one place, making the logic easy to follow and maintain.

- Scalability: As the state management logic grows more complex, useReducer can handle it more gracefully than useState would with multiple state variables.

- Readability: By using actions, the intent of each state change is clearly communicated, improving the readability of the code.

This component effectively demonstrates how useReducer can be used to manage state in more complex scenarios, providing a clear structure and making it easier to scale and maintain your application.

4. useContext

Allows you to access context values in a functional component.

Example:

import React, { createContext, useState, useContext } from 'react';

// Create a Context with default values
const ThemeContext = createContext();

const ThemeProvider = ({ children }) => {
  // State to manage the theme
  const [theme, setTheme] = useState('light');

  // Function to toggle the theme
  const toggleTheme = () => {
    setTheme((prevTheme) => (prevTheme === 'light' ? 'dark' : 'light'));
  };

  return (
    <ThemeContext.Provider value={{ theme, toggleTheme }}>
      {children}
    </ThemeContext.Provider>
  );
};

const ThemeSwitcher = () => {
  // Use the context in a component
  const { theme, toggleTheme } = useContext(ThemeContext);

  return (
    <div style={{ padding: '20px', backgroundColor: theme === 'light' ? '#f0f0f0' : '#333', color: theme === 'light' ? '#000' : '#fff' }}>
      <h1>Current Theme: {theme}</h1>
      <button onClick={toggleTheme}>Toggle Theme</button>
    </div>
  );
};

// Main component using the ThemeProvider
const UseContextDemo = () => {
  return (
    <ThemeProvider>
      <ThemeSwitcher />
    </ThemeProvider>
  );
};

export default UseContextDemo;

Explanation:

1. Creating the Context:

- ThemeContext: Created using createContext(). It acts as a container to hold the state and functions related to the theme.

- The context is initialized without a default value since it’s set within the ThemeProvider.

2. ThemeProvider Component:

- State Management: The theme state is managed using useState, with “light” as the initial value.

- toggleTheme Function: This function switches the theme between “light” and “dark” using the previous state.

- ThemeContext.Provider: The provider wraps around children (any components passed to ThemeProvider), allowing them to access the theme state and toggleTheme function via context.

3. ThemeSwitcher Component:

- Using the Context: The useContext(ThemeContext) hook is used to consume the context, giving access to theme and toggleTheme.

- Rendering:

- The background color and text color of the div change based on the current theme.

- A button is provided to toggle the theme, invoking the toggleTheme function when clicked.

4. UseContextDemo Component:

- ThemeProvider: Wraps the ThemeSwitcher component, ensuring it and any nested components have access to the ThemeContext.

- This structure allows the ThemeSwitcher to receive and use the theme and toggleTheme without needing props passed down through multiple components.

Benefits of Using Context:

- Avoiding Prop Drilling: The ThemeContext allows the theme state and functions to be shared directly with components that need them, without passing them down as props through multiple layers of components.

- Centralized State Management: The ThemeProvider centralizes the logic for managing and updating the theme, making the application easier to maintain and extend.

- Reusability: Any component within the ThemeProvider can access the theme context, making it easy to build a consistent UI across different parts of the application.

Example Use Case:

- Theming Across an Application: This pattern is commonly used in applications to provide global themes, language settings, user authentication, or any other shared state that needs to be accessed by multiple components.

Your implementation is clean, and the use of useContext in combination with a context provider demonstrates an effective way to manage the global state in a React application.

5. useMemo

Memorizes a value, re-computing it only when its dependencies change.

Example:

import React, { useState, useMemo } from 'react';

// Expensive calculation function
const calculateFactorial = (num) => {
  console.log('Calculating factorial...');
  let result = 1;
  for (let i = 1; i <= num; i++) {
    result *= i;
  }
  return result;
};

const UseMemoDemo = () => {
  const [count, setCount] = useState(0);
  const [number, setNumber] = useState(1);

  // Memoized factorial calculation
  const factorial = useMemo(() => calculateFactorial(number), [number]);

  return (
    <div>
      <h1>UseMemo Demo</h1>
      <div>
        <h2>Counter: {count}</h2>
        <button onClick={() => setCount(count + 1)}>Increment Counter</button>
      </div>
      <div>
        <h2>Factorial of {number}: {factorial}</h2>
        <input
          type="number"
          value={number}
          onChange={(e) => setNumber(Number(e.target.value))}
        />
      </div>
    </div>
  );
};

export default UseMemoDemo;

Explanation:

1. State Variables:

- count: Tracks the count of button clicks, initialized to 0.

- number: Stores the number for which the factorial will be calculated, initialized to 1.

2. Expensive Calculation Function:

- calculateFactorial(num): This function calculates the factorial of a given number num. The calculation is performed in a loop, which could become expensive for larger numbers.

- The function logs “Calculating factorial…” to the console each time it runs, which helps to see when the calculation is actually being performed.

3. Memoizing the Factorial Calculation:

- useMemo(() => calculateFactorial(number), [number]):

- useMemo is used to memoize the result of calculateFactorial(number).

- The calculation is only re-executed when the number value changes. If number stays the same, the cached result is returned, avoiding unnecessary recalculations.

- This optimization is particularly useful when the calculation is computationally expensive, as it prevents the factorial calculation from being re-executed on every render if number hasn’t changed.

4. Rendering the Component:

- Counter Section:

- Displays the current count and includes a button to increment the count.

- The counter is independent of the factorial calculation, so clicking the button will not re-trigger the factorial calculation due to useMemo.

- Factorial Section:

- Displays the factorial of the current number.

- Includes an input field to change the number, which will trigger the recalculation of the factorial if the number is modified.

Benefits of useMemo in This Component:

- Performance Optimization: By memoizing the factorial calculation, the component avoids unnecessary recomputation, improving performance, especially when dealing with large numbers or complex calculations.

- Efficient Rendering: The component only recalculates the factorial when necessary (i.e., when number changes), ensuring that unrelated state changes (like count) do not trigger expensive operations.

Example Use Case:

- Heavy Computations: useMemo is ideal in scenarios where you have computationally intensive operations that depend on specific inputs. It ensures that these operations are only performed when absolutely necessary, preventing performance bottlenecks in your application.

This component demonstrates the practical use of useMemo to optimize React applications by controlling when expensive computations are performed, ensuring smooth and efficient rendering.

6. Custom hooks

A custom hook in React is a JavaScript function that allows you to reuse stateful logic across multiple components. Custom hooks enable you to extract and share logic that would otherwise be duplicated across components, making your code more modular and easier to maintain.

Example:

import React from 'react';
import useLocalStorage from './useLocalStorage';

const CustomHookDemo = () => {
  // Use the custom hook to manage a count value in localStorage
  const [count, setCount] = useLocalStorage('count', 0);

  return (
    <div style={{ padding: '20px' }}>
      <h1>Custom Hook Demo</h1>
      <h2>Count: {count}</h2>
      <button onClick={() => setCount(count + 1)}>Increment</button>
      <button onClick={() => setCount(count - 1)}>Decrement</button>
      <button onClick={() => setCount(0)}>Reset</button>
    </div>
  );
};

export default CustomHookDemo;

import { useState, useEffect } from 'react';

// Custom hook to manage localStorage
const useLocalStorage = (key, initialValue) => {
  // Get initial value from localStorage or use initialValue
  const [storedValue, setStoredValue] = useState(() => {
    try {
      const item = window.localStorage.getItem(key);
      return item ? JSON.parse(item) : initialValue;
    } catch (error) {
      console.error(error);
      return initialValue;
    }
  });

  // Save value to localStorage whenever it changes
  useEffect(() => {
    try {
      window.localStorage.setItem(key, JSON.stringify(storedValue));
    } catch (error) {
      console.error(error);
    }
  }, [key, storedValue]);

  return [storedValue, setStoredValue];
};

export default useLocalStorage;

Explanation:

This component demonstrates the use of the useLocalStorage custom hook.

1. Hook Usage:

- The useLocalStorage hook is used to manage the count state, which is persisted in localStorage under the key ‘count’.

- setCount is a function that updates both the state and localStorage.

2. Component Structure:

- The component displays the current count and provides three buttons:

- Increment: Increases the count by 1.

- Decrement: Decreases the count by 1.

- Reset: Resets the count to 0.

useLocalStorage Custom Hook

This custom hook encapsulates the logic to synchronize state with localStorage.

1. State Initialization:

- The hook first checks if a value exists in localStorage under the provided key.

- If a value exists, it is parsed from JSON and used as the initial state.

- If no value exists, the initialValue is used as the initial state.

2. Effect for Updating localStorage:

- The useEffect hook monitors changes to storedValue or key.

- Whenever storedValue changes, the new value is stored in localStorage.

3. Error Handling:

- Both the initialization and the effect include error handling via try-catch blocks to prevent the application from crashing if there’s an issue with localStorage.

How It Works:

- State Persistence: The count state is stored in localStorage, meaning it will persist even if the user refreshes the page or closes and reopens the browser.

- Automatic Sync: Any time the count changes, the new value is automatically saved in localStorage.

- Reusability: The useLocalStorage hook can be reused in any component that needs to sync state with localStorage.

This pattern is especially useful in scenarios where you want user data to persist between sessions, such as saving form inputs, user preferences, or any other application state that needs to survive page reloads.

GitHub:

https://github.com/Jaydeep-007/React-Hooks

Conclusion:

In this article, we looked into the basics of hooks, types of hooks, and examples with step-by-step implementation.

Introduction

In this article, we will create a sample product application backend using the .NET Core Web API and web forms using React JS. Also, we will containerize the same with the help of docker.

Agenda

• Sample Product Application: Backend (.NET Core Web API)
• Sample Product Application: Frontend (React JS)
• Docker Files for Application
• Containerize the Application

Prerequisites

• Visual Studio 2022
• Docker Desktop
• NPM
• .NET Core SDK
• React JS

Sample Product Application: Backend (.NET Core Web API)

Step 1. Create a new Product Management .NET Core Web API.

Step 2. Install the following NuGet packages we used for database migrations and connectivity with SQL Server.

Step 3. Add the product class inside the entities folder.

namespace ProductManagementAPI.Entities
{
    public class Product
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public decimal Price { get; set; }
    }
}

Step 4. Create an AppDbContext class inside the data folder with a SQL Server connection and a DB set property.

using Microsoft.EntityFrameworkCore;
using ProductManagementAPI.Entities;

namespace ProductManagementAPI.Data
{
    public class AppDbContext : DbContext
    {
        public DbSet<Product> Products { get; set; }

        protected readonly IConfiguration Configuration;

        public AppDbContext(IConfiguration configuration)
        {
            Configuration = configuration;
        }
        protected override void OnConfiguring(DbContextOptionsBuilder options)
        {
            options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
            options.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
        }
    }
}

Step 5. Add a product repository inside the repositories folder.

IProductRepository

using ProductManagementAPI.Entities;

namespace ProductManagementAPI.Repositories
{
    public interface IProductRepository
    {
        void AddProduct(Product product);
        void DeleteProduct(int id);
        List<Product> GetAllProducts();
        Product GetProductById(int id);
        void UpdateProduct(Product product);
    }
}

ProductRepository

using Microsoft.EntityFrameworkCore;
using ProductManagementAPI.Data;
using ProductManagementAPI.Entities;

namespace ProductManagementAPI.Repositories
{
    public class ProductRepository : IProductRepository
    {
        private readonly AppDbContext _context;

        public ProductRepository(AppDbContext context)
        {
            _context = context;
        }

        public List<Product> GetAllProducts()
        {
            return _context.Products.ToList();
        }

        public Product GetProductById(int id)
        {
            return _context.Products.FirstOrDefault(p => p.Id == id);
        }

        public void AddProduct(Product product)
        {
            if (product == null)
            {
                throw new ArgumentNullException(nameof(product));
            }

            _context.Products.Add(product);
            _context.SaveChanges();
        }

        public void UpdateProduct(Product product)
        {
            if (product == null)
            {
                throw new ArgumentNullException(nameof(product));
            }

            _context.Entry(product).State = EntityState.Modified;
            _context.SaveChanges();
        }

        public void DeleteProduct(int id)
        {
            var product = _context.Products.Find(id);
            if (product == null)
            {
                throw new ArgumentNullException(nameof(product));
            }

            _context.Products.Remove(product);
            _context.SaveChanges();
        }
    }
}

Step 6. Create a new product controller with different action methods that we used to perform different operations using our front-end application after invoking the same.

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using ProductManagementAPI.Entities;
using ProductManagementAPI.Repositories;

namespace ProductManagementAPI.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ProductController : ControllerBase
    {
        private readonly IProductRepository _productRepository;

        public ProductController(IProductRepository productRepository)
        {
            _productRepository = productRepository;
        }

        [HttpGet]
        public IActionResult GetAllProducts()
        {
            var products = _productRepository.GetAllProducts();
            return Ok(products);
        }

        [HttpGet("{id}")]
        public IActionResult GetProductById(int id)
        {
            var product = _productRepository.GetProductById(id);
            if (product == null)
            {
                return NotFound();
            }
            return Ok(product);
        }

        [HttpPost]
        public IActionResult AddProduct([FromBody] Product product)
        {
            if (product == null)
            {
                return BadRequest();
            }

            _productRepository.AddProduct(product);
            return CreatedAtAction(nameof(GetProductById), new { id = product.Id }, product);
        }

        [HttpPut("{id}")]
        public IActionResult UpdateProduct(int id, [FromBody] Product product)
        {
            if (product == null || id != product.Id)
            {
                return BadRequest();
            }

            var existingProduct = _productRepository.GetProductById(id);
            if (existingProduct == null)
            {
                return NotFound();
            }

            _productRepository.UpdateProduct(product);
            return NoContent();
        }

        [HttpDelete("{id}")]
        public IActionResult DeleteProduct(int id)
        {
            var existingProduct = _productRepository.GetProductById(id);
            if (existingProduct == null)
            {
                return NotFound();
            }

            _productRepository.DeleteProduct(id);
            return NoContent();
        }
    }
}

Step 7. Open the app settings file and add the database connection string.

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "DefaultConnection": "Data Source=DESKTOP-8RL8JOG;Initial Catalog=ReactNetCoreCrudDb;User Id=sa;Password=database@1;"
  }
}

Step 8. Register our services inside the service container and configure the middleware.

using ProductManagementAPI.Data;
using ProductManagementAPI.Repositories;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddScoped<IProductRepository, ProductRepository>();
builder.Services.AddDbContext<AppDbContext>();
builder.Services.AddCors(options => {
    options.AddPolicy("CORSPolicy", builder => builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
});


builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
app.UseCors("CORSPolicy");

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

Step 9. Execute the following entity framework database migration command to create a database and tables.

add-migration “v1”

update-database

Step 10. Finally, run the application and use Swagger UI to execute different API endpoints.

Sample Product Application: Frontend (React JS)

Let’s create a client application using React JS and consume the above API endpoints within it.

Step 1. Create a new React JS application with the help of the following command:.

npx create-react-app react-netcore-crud-app

Step 2. Navigate to your project directory.

cd react-netcore-crud-app

Step 3. Install Axios to consume and hit backend API and bootstrap for designing purposes.

npm install axios

npm install bootstrap

Step 4. Add the following components and services:

Product list component.

// src/components/ProductList/ProductList.js
import React, { useState, useEffect } from 'react';
import ProductListItem from './ProductListItem';
import productService from '../../services/productService';

const ProductList = () => {
    const [products, setProducts] = useState([]);

    useEffect(() => {
        fetchProducts();
    }, []);

    const fetchProducts = async () => {
        try {
            const productsData = await productService.getAllProducts();
            setProducts(productsData);
        } catch (error) {
            console.error('Error fetching products:', error);
        }
    };

    const handleDelete = async (id) => {
        try {
            await productService.deleteProduct(id);
            fetchProducts(); // Refresh product list
        } catch (error) {
            console.error('Error deleting product:', error);
        }
    };

    const handleEdit = () => {
        fetchProducts(); // Refresh product list after editing
    };

    return (
        <div className="container">
            <h2 className="my-4">Product List</h2>
            <ul className="list-group">
                {products.map(product => (
                    <ProductListItem key={product.id} product={product} onDelete={() => handleDelete(product.id)} onEdit={handleEdit} />
                ))}
            </ul>
        </div>
    );
};

export default ProductList;

Product list item component.

// src/components/ProductList/ProductListItem.js
import React, { useState } from 'react';
import productService from '../../services/productService';

const ProductListItem = ({ product, onDelete, onEdit }) => {
    const [isEditing, setIsEditing] = useState(false);
    const [editedName, setEditedName] = useState(product.name);
    const [editedPrice, setEditedPrice] = useState(product.price);

    const handleEdit = async () => {
        setIsEditing(true);
    };

    const handleSave = async () => {
        const editedProduct = { ...product, name: editedName, price: parseFloat(editedPrice) };
        try {
            await productService.updateProduct(product.id, editedProduct);
            setIsEditing(false);
            onEdit(); // Refresh product list
        } catch (error) {
            console.error('Error updating product:', error);
        }
    };

    const handleCancel = () => {
        setIsEditing(false);
        // Reset edited values
        setEditedName(product.name);
        setEditedPrice(product.price);
    };

    return (
        <li className="list-group-item">
            {isEditing ? (
                <div className="row">
                    <div className="col">
                        <input type="text" className="form-control" value={editedName} onChange={e => setEditedName(e.target.value)} required />
                    </div>
                    <div className="col">
                        <input type="number" className="form-control" value={editedPrice} onChange={e => setEditedPrice(e.target.value)} required />
                    </div>
                    <div className="col-auto">
                        <button className="btn btn-success me-2" onClick={handleSave}>Save</button>
                        <button className="btn btn-secondary" onClick={handleCancel}>Cancel</button>
                    </div>
                </div>
            ) : (
                <div className="d-flex justify-content-between align-items-center">
                    <span>{product.name} - ${product.price}</span>
                    <div>
                        <button className="btn btn-danger me-2" onClick={onDelete}>Delete</button>
                        <button className="btn btn-primary" onClick={handleEdit}>Edit</button>
                    </div>
                </div>
            )}
        </li>
    );
};

export default ProductListItem;

Product service.

// src/services/productService.js
import axios from 'axios';

const baseURL = 'https://localhost:7202/api/Product';

const productService = {
    getAllProducts: async () => {
        const response = await axios.get(baseURL);
        return response.data;
    },
    addProduct: async (product) => {
        const response = await axios.post(baseURL, product);
        return response.data;
    },
    deleteProduct: async (id) => {
        const response = await axios.delete(`${baseURL}/${id}`);
        return response.data;
    },
    updateProduct: async (id, product) => {
        const response = await axios.put(`${baseURL}/${id}`, product);
        return response.data;
    }
};

export default productService;

App component.

// src/App.js
import React, { useState } from 'react';
import ProductList from './components/ProductList/ProductList';
import ProductForm from './components/ProductForm/ProductForm';

function App() {
    const [refresh, setRefresh] = useState(false);

    const handleProductAdded = () => {
        setRefresh(!refresh); // Toggle refresh state to trigger re-render
    };

    return (
        <div>
            <ProductList key={refresh} />
            <ProductForm onProductAdded={handleProductAdded} />
        </div>
    );
}

export default App;

Step 5. Run the application using the following command and perform the different CRUD operations with the help of the same.

Docker Files for Application

1. Docker file for backend application (.NET Core)

# Use the official .NET Core SDK as a parent image
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build

WORKDIR /app

# Copy the project file and restore any dependencies (use .csproj for the project name)
COPY *.csproj ./

RUN dotnet restore

# Copy the rest of the application code
COPY . .

# Publish the application
RUN dotnet publish -c Release -o out

# Build the runtime image
FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS runtime

WORKDIR /app
COPY --from=build /app/out ./

# Expose the port your application will run on
EXPOSE 80

# Start the application
ENTRYPOINT ["dotnet", "ProductManagementAPI.dll"]

• Line 1–2: Uses the official .NET Core SDK image (mcr.microsoft.com/dotnet/sdk:6.0) as a base.
• Line 4: Sets the working directory to /app.
• Line 6–7: Copies the project file(s) (*.csproj) into the container.
• Line 9: Runs dotnet restore to restore dependencies specified in the project file(s).
• Line 11–12: Copies the rest of the application code into the container.
• Line 14–15: Publishes the application in Release configuration (dotnet publish -c Release -o out), outputting to the out directory.
• Line 17–18: Uses the official .NET Core ASP.NET runtime image (mcr.microsoft.com/dotnet/aspnet:6.0) as a base.
• Line 20–21: Sets the working directory to /app and Copies the published output from the build stage (from /app/out) into the /app directory of the runtime stage.
• Line 23–24: Exposes port 80 to allow external access to the application.
• Line 26–27: Specifies dotnet ProductManagementAPI.dll as the entry point command to start the application.

2. Docker file for frontend application (React JS)

# Use the official Node.js base image
FROM node:18

# Set the working directory
WORKDIR /app

# Copy package.json and package-lock.json files
COPY package*.json ./

# Install dependencies
RUN npm install

# Copy the rest of the application code
COPY . .

# Build the React app
ARG REACT_APP_API_URL
ENV REACT_APP_API_URL=$REACT_APP_API_URL
RUN npm run build

# Install serve globally to serve the build folder
RUN npm install -g serve

# Expose the port the app runs on
EXPOSE 3000

# Start the React app
CMD ["serve", "-s", "build"]

• Line 1–2: specifies the base image, using Node.js version 18.
• Line 4–5: sets /app as the working directory for subsequent commands.
• Line 7–8: This copies package.json and package-lock.json from your local machine to the Docker image.
• Line 10–11: runs npm install to install all dependencies listed in package.json.
• Line 13–14: copies the rest of your application code to the Docker image.
• Line 16–19: The ARG instruction defines a build-time variable REACT_APP_API_URL, The ENV instruction sets an environment variable REACT_APP_API_URL with the value of the build-time variable. Also, RUN npm run build builds the React application.
• Line 21–22: installs the serve package globally to serve the built React application.
• Line 24–25: This exposes port 3000, which is where the application will run.
• Line 27–28: The command starts the React application using serve to serve the build folder.

For front-end application, Create a .env file in the root of your React project. This file will hold your environment variables, which you can use while running your Docker image and to pass the back-end API URL.

REACT_APP_API_URL=http://your-backend-url.com

Next, modify your backend hard-coded URL in the product service.

// src/services/productService.js
import axios from 'axios';

const baseURL = process.env.REACT_APP_API_URL;

const productService = {
    getAllProducts: async () => {
        const response = await axios.get(baseURL);
        return response.data;
    },
    addProduct: async (product) => {
        const response = await axios.post(baseURL, product);
        return response.data;
    },
    deleteProduct: async (id) => {
        const response = await axios.delete(`${baseURL}/${id}`);
        return response.data;
    },
    updateProduct: async (id, product) => {
        const response = await axios.put(`${baseURL}/${id}`, product);
        return response.data;
    }
};

export default productService;

Containerize the front-end and back-end application

Step 1.

Build the docker images

docker build -t productbackendapp:latest .

docker build --build-arg REACT_APP_API_URL=http://localhost:8085/api/Product -t productfrontendapp .

Step 2.

Run the images after passing the required parameters, like env and arguments.

docker run -p 8085:80 -e "ConnectionStrings__DefaultConnection=Data Source=192.168.100.194,1433;Initial Catalog=ReactNetCoreCrudDb;User Id=sa;Password=database@1;" productbackendapp:latest

docker run -p 3000:3000 productfrontendapp

Sample Application Screenshots

GitHub

https://github.com/Jaydeep-007/React_NETCore_CRUD-Docker

Conclusion

In this article, we created a product management backend application using .NET Core and SQL Server with different API endpoints that are required to perform CRUD operations. Later on, created the front-end application using React JS and consumed the back-end application inside the same with the help of Axios. Also, we containerized both applications with the help of Docker.