Upload 31 files

my drunkcoding blogs

az-00-pulumi-private-aks-environments.md

@@ -0,0 +1,163 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-10-12T12:00:00Z
+title: "[Az] A Comprehensive Series of Articles on Setting Up a Private AKS Environment on Azure with Pulumi."
+featured: true
+draft: false
+tags:
+  - AKS
+  - Helm
+  - CI/CD
+  - AzureDevOps
+  - Cloudflare
+  - Tunnel
+description: "In these series, Embark on a comprehensive journey to set up a fully private Azure Kubernetes Service (AKS) environment using Pulumi. This series guides you through the creation of Virtual Networks, configuration of Azure Firewalls, deployment of private AKS clusters, and integration with private Azure DevOps agents and a private CloudPC environment. Additionally, learn how to securely expose select applications to the public internet via Cloudflare Tunnels. Ideal for those aiming to build secure, scalable, and consistent environments across development, sandbox, and production stages."
+---
+
+## Introduction
+
+Setting up a completely private environment in the cloud is a complex, especially when striving to maintain consistency across DEV, SANDBOX, and PRODUCTION environments. 
+In this comprehensive series, I will share insights and strategies on how to establish an entirely private AKS environment on Azure using Pulumi.
+
+We'll delve into:
+
+- **Virtual Network Creation**: Building a secure network foundation for the environment.
+- **Azure Firewall Configuration**: Implementing robust security measures to control network traffic.
+- **Private AKS Cluster Deployment**: Setting up Kubernetes clusters that are isolated from the public internet.
+- **Private Azure DevOps Agents**: Integrating continuous integration and deployment pipelines within a secure environment.
+- **Private CloudPC Environment**: Establishing secure virtual desktop infrastructure for remote development using Windows 365 Enterprise.
+- **Secure Application Exposure**: Using Cloudflare Tunnels to expose select internal applications to the public internet without compromising security.
+
+This series aims to provide a step-by-step guide to help to build secure, scalable, and consistent private cloud environments on Azure. 
+Whether you're a cloud architect, DevOps engineer, or developer, these articles will equip you with the knowledge to tackle the challenges of private cloud infrastructure.
+
+## Table of Contents
+
+## Pulumi Account Setup
+
+**[Day 01: Setup pulumi account and project](/posts/az-01-pulumi-setup-developer-account)**
+
+Start the cloud journey with Pulumi by setting up a developer account and deploying the first Azure resources.
+This guide walks you through creating a Pulumi account, installing the necessary CLI tools, and using TypeScript to manage Azure infrastructure as code.
+
+## Private AKS Environments
+
+**[Day 02: Designing the Private AKS Environment Architecture](/posts/az-02-pulumi-private-ask-env-architecture)**
+
+In this tutorial, We will explore the design of a private AKS environment on Azure. We'll use multiple subnets, Azure Firewall, and other critical cloud services to construct a secure architecture.
+This setup is designed to keep sensitive workloads isolated and shielded from exposure to the public internet.
+
+**[Day 03: Secret Management and Centralized Log Monitoring on Azure](/posts/az-03-pulumi-private-ask-credential-log-management)**
+
+In this tutorial, walk us through the process of establishing a secure and automated system for secret management using Azure Key Vault. 
+Additionally, we will cover how to implement centralized log monitoring using Azure Log Analytics and Application Insights, enhancing observability and operational efficiency.
+
+**[Day 04: Develops a Virtual Network Hub for Private AKS on Azure](/posts/az-04-pulumi-private-aks-hub-vnet-development)**
+
+In this tutorial, We'll walk through the process of developing the first Hub VNet for a private AKS environment using Pulumi.
+We will demonstrate how to seamlessly integrate a VNet with an Azure Firewall, along with configuring outbound public IP addresses.
+
+**[Day 05: Implementing Private AKS Clusters with Advanced Networking](/posts/az-05-pulumi-private-aks-cluster-env)**
+
+In this tutorial, We'll build a private AKS cluster with advanced networking features.
+We'll explore how to integrate the AKS cluster with the Hub VNet and apply the firewall policies we've created.
+
+**[Day 06: Implements a private CloudPC and DevOps Agent Hub with Pulumi](/posts/az-06-pulumi-private-aks-cloudpc-hub)**
+
+In this tutorial, guide us through setting up a secure CloudPC and DevOps agent hub, aimed at improving the management and operational capabilities of the private AKS environment using Pulumi.
+
+## Progress Review After 06 Days
+
+Let's take a moment to review our achievements. After completing six tutorials, we have successfully deployed our private AKS environment.
+The illustration below provides a visual representation of our current environment after 6 days:
+![aks-env](/assets/az-02-pulumi-private-ask-env-architecture/private-aks-day-06.png)
+<p class="ml-44"><em>The illustration private AKS env</em></p>
+
+## CloudPC environment (Windows 365 enterprise)
+
+**[Day 07: Setup Windows 365 Enterprise as a private VDI](/posts/az-07-setup-cloudpc-windows365-enterprise)**
+
+In this tutorial, We will explore how to configure a CloudPC with Windows 365 Enterprise to establish a secure and efficient Virtual Desktop Infrastructure (VDI) for accessing a private AKS environment.
+
+## Azure DevOps Pipelines
+
+**[Day 08: Setting Up a Deployment Pipeline for Pulumi Projects.](/posts/az-08-pulumi-setup-deploy-cicd-pipeline)**
+
+In this tutorial, We will walk through creating a Continuous Integration and Continuous Deployment (CI/CD) pipeline on Azure DevOps for our Pulumi projects.
+
+**[Day 09: Synchronizing Container Images to ACR for a Private AKS Cluster Using CI/CD Pipelines.](/posts/az-09-private-aks-acr-image-sync)**
+
+In this tutorial, We explore the process of synchronizing container images with ACR for deployments in a private AKS cluster. 
+We'll cover how to configure and automate this synchronization using CI/CD pipelines, ensuring seamless updates and secure image management for private AKS environments.
+
+**[Day 10: Implementing a Helm Deployment CI/CD AzureDevOps Pipeline for a Private AKS Cluster.](/posts/az-10-private-aks-helm-deployment)**
+
+In this tutorial, We will create Helm charts for nginx-ingress and cert-manager, and set up a robust CI/CD pipeline using Azure DevOps for Helm deployments to a private AKS cluster.
+
+## Progress Review After 10 Days
+
+Let's take a moment to review our achievements. After completing 10 tutorials, we have successfully deployed our internal ingress, cert-manager and private DNS Zone.
+The illustration below provides a visual representation of our current environment:
+![aks-env](/assets/az-02-pulumi-private-ask-env-architecture/private-aks-day-10.png)
+<p class="ml-14"><em>The illustration of AKS env with private ingress and DNS Zone</em></p>
+
+## Public Apps with Cloudflare Tunnels
+
+**[Day 11: Exposing a Private AKS Application via Cloudflare Tunnel.](/posts/az-11-private-aks-expose-public-app-with-cloudflare-tunnel)**
+
+In this tutorial, We demonstrate how to securely expose an application running on a private AKS cluster to the internet using Cloudflare Tunnel, without the need for public IP addresses or open ports. We'll also show how to apply authentication to all exposed applications and centralize access control using Azure Entra ID Groups, ensuring only authorized users have access.
+
+## Microsoft Intune (MDM) Devices and Cloudflare Tunnel
+
+**[Day 12: Exposing a Private AKS Application via Cloudflare Tunnel.](/posts/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp)**
+
+In this final tutorial, We'll discover how to safely expose the private AKS cluster and applications to the internet with Cloudflare.
+It'll delve into the benefits of using Cloudflare Tunnel and WARP, exploring alternative ways to provide secure access while maintaining the integrity of the corporate network.
+
+## Conclusions
+
+Throughout this comprehensive series, we've journeyed through the intricate process of setting up a private AKS environment on Azure using Pulumi. 
+
+Starting with the Pulumi account setup, we've built a secure and scalable infrastructure that includes Virtual Networks, Azure Firewall, private AKS clusters, and private Azure DevOps agents. 
+
+Additionally, we delved into the integration of a private CloudPC environment and demonstrated secure application exposure through Cloudflare Tunnels.
+
+- Upon completing all 12 tutorials, we have effectively established a unified private infrastructure. This setup includes private AKS clusters, Azure DevOps agents, and a CloudPC environment, all seamlessly integrated with Cloudflare Tunnels and Entra ID SSO. This ensures secure access for MDM Intune devices.
+  ![private-aks-day-12](/assets/az-02-pulumi-private-ask-env-architecture/private-aks-day-12.png)
+
+- Throughout this series, we developed a total of six Azure DevOps pipelines, as shown below:
+   ![azure-devops-pipelines-overview](/assets/az-00-pulumi-private-aks-environments/azure-devops-pipelines-overview.png)
+
+- In terms of expenses, we incurred approximately $200 in Azure resource costs, with estimated around 500 USD monthly for the entire environment. Detailed in the analytics below:
+    ![az-cost-analytics](/assets/az-00-pulumi-private-aks-environments/az-cost-analytics.png)
+
+## Future Enhancements
+
+As we reflect on our journey to establish a private AKS environment on Azure, there are several crucial areas that offer opportunities for enhancing performance, security, and scalability.
+
+### Architectural Enhancements
+
+- **Implement a Secure DMZ Network**: Establish a Demilitarized Zone (DMZ) to bolster security by isolating public-facing services like the Cloudflare Tunnel. Relocating the Cloudflare Tunnel outside the private AKS cluster and into the DMZ allows for better traffic management and monitoring, while protecting internal networks from direct exposure. Utilizing Azure Virtual Machine Scale Sets for services in the DMZ will enable automatic scaling of workloads, ensuring efficient resource utilization and enhanced security.
+
+- **Refine Firewall Rules**: Enhance the firewall configurations with more granular rules, specifically tailored for the services operating within the DMZ. Restrict access by employing precise IP ranges and protocols, ensuring that only legitimate and necessary traffic is permitted, thereby improving security.
+
+- **Leverage Auto-Scaling for Private Agents**: Optimize resource usage by employing Azure Virtual Machine Scale Sets to automatically adjust the number of private Azure DevOps agents based on demand. This approach not only ensures high availability during peak workloads but also conserves resources during periods of inactivity.
+
+### Project Enhancements
+
+- **Modularize Shared Components**: Increase maintainability and reusability by extracting shared components into separate, modular projects. This strategy fosters consistency and streamlines updates across various environments, reducing the complexity and risk of manual changes.
+
+- **Optimize Build Processes with Pre-Built Binaries**: Accelerate deployment by pre-building shared components' binaries locally and committing them to the repository. This practice minimizes deployment times by avoiding repeated builds in CI/CD pipelines, leading to faster and more reliable integration and delivery processes.
+
+By pursuing these enhancements, we aim to strengthen the security, efficiency, and scalability of our private AKS environment. Implementing these improvements will better prepare our infrastructure to meet emerging challenges and support continued business growth.
+
+## References
+
+The complete source code for this series is available on my [GitHub repository](https://github.com/baoduy/drunk-azure-pulumi-articles). 
+Feel free to clone the repository and contribute by submitting pull requests or raising issues.
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | _[GitHub](https://github.com/baoduy)_

az-01-pulumi-setup-developer-account.md

@@ -0,0 +1,363 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-10-12T12:00:00Z
+title: "[Az] Day 01: Setup pulumi developer account"
+featured: false
+draft: false
+tags:
+  - aks
+  - private
+  - pulumi
+description: "Start the cloud journey with Pulumi by setting up a developer account and deploying the first Azure resources.
+This guide walks you through creating a Pulumi account, installing the necessary CLI tools, and using TypeScript to manage Azure infrastructure as code."
+---
+
+## Introduction
+
+Pulumi is a powerful open-source Infrastructure as Code (IaC) tool that allows us to define cloud resources using popular programming languages such as _TypeScript, Python, Go, and C#_. 
+By harnessing these tools, we can effectively manage our infrastructure across multiple cloud providers like **Azure, AWS, and Google Cloud**.
+
+In this guide, we will explore:
+
+- Registering for a Pulumi account
+- Generating a Personal Access Token (PAT)
+- Setting up the Pulumi and Azure CLI tools
+- Creating our first Pulumi project using the TypeScript template for Azure
+- Deploying our first Azure Resource Group and Storage Account
+
+## Table of Contents
+
+## Prerequisites
+
+- **Node.js** installed on the machine
+- An **Azure account** (you can [create a free account here](https://azure.microsoft.com/free/))
+
+## Pulumi Setup
+
+### Create a Pulumi Account
+
+1. **Visit the Pulumi Website**
+
+   Let's navigate to the [Pulumi website](https://www.pulumi.com/) and click on the **"Sign Up"** button.
+
+2. **Choose a Sign-Up Method**
+
+   Sign up using one of the following methods:
+
+   - **GitHub**
+   - **GitLab**
+   - **Bitbucket**
+   - **Email**
+
+   Follow the on-screen instructions to complete the registration.
+
+3. **Confirm Your Email**
+
+   If you signed up using an email address, check your inbox for a confirmation email and verify your account.
+
+### Generate a Personal Access Token (PAT)
+
+A Personal Access Token (PAT) is required to authenticate the Pulumi CLI with your Pulumi account.
+
+1. **Pulumi Dashboard**
+
+   Visit the [Pulumi Dashboard](https://app.pulumi.com/) and log in with your credentials.
+
+2. **Access the Tokens Page**
+
+   - Click on your avatar or username in the top-right corner.
+   - Select **"Access Tokens"** from the dropdown menu.
+
+3. **Create a New Token**
+
+   - Click on **"Create Token"**.
+   - Provide a description (e.g., "Pulumi CLI Token").
+   - Click **"Create"** and copy the generated token for later use.
+
+### (Optional) Create a New Organization
+
+If you'd like to manage your projects under a separate organization:
+
+1. **Navigate to Organizations**
+
+   - In the Pulumi Console, click on your avatar or username.
+   - Select **"Organizations"**.
+
+2. **Create a New Organization**
+
+   - Click on **"Create Organization"**.
+   - Follow the prompts to set up your organization.
+
+![Pulumi Account](/assets/az-01-pulumi-setup-developer-account/pulumi-account.png)
+
+## Install CLI Tools
+
+### Install the Pulumi CLI
+
+Follow the instructions [here](https://www.pulumi.com/docs/get-started/install/) to install the Pulumi CLI for your operating system.
+
+### Install the Azure CLI
+
+Next, Install the Azure CLI by following the instructions [here](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli).
+
+**Here are the current versions after installed them successfully.**
+
+```bash
+> pulumi version
+v3.133.0
+
+> az -v
+azure-cli  2.64.0
+```
+
+## Configure Pulumi for Azure
+
+Before diving into coding, let's configure Pulumi to work with your Azure account. Run the following commands to set up your Pulumi stack with the correct Azure subscription details:
+
+```bash
+# Set the default Pulumi organization (replace with your organization name)
+pulumi org set-default YOUR_PULUMI_ORGANIZATION
+
+# Configure Azure settings
+pulumi config set azure-native:tenantId YOUR_AZURE_TENANT_ID
+pulumi config set azure-native:subscriptionId YOUR_AZURE_SUBSCRIPTION_ID
+pulumi config set azure-native:location YOUR_AZURE_LOCATION  # e.g., SoutheastAsia
+
+# Optional: If you're using a service principal for authentication
+pulumi config set azure-native:clientId YOUR_AZURE_CLIENT_ID
+pulumi config set azure-native:clientSecret YOUR_AZURE_CLIENT_SECRET --secret
+```
+
+> **Note:** 
+> 
+> - Replace placeholders with your actual Azure details. 
+> - The `--secret` flag ensures sensitive information is encrypted using Pulumi stack encryption.
+
+## Create Your First Pulumi Project
+
+### Set Up a Git Repository
+
+Create a new directory for our Pulumi project and initialize a Git repository:
+
+```bash
+mkdir pulumi-azure-start
+cd pulumi-azure-start
+git init
+```
+
+### Initialize a New Pulumi Project
+
+Run the following command to create a new Pulumi project using the Azure TypeScript template:
+
+```bash
+pulumi new azure-typescript
+```
+
+We'll be prompted to provide:
+
+- **Login**: Authenticate using the PAT token generated earlier.
+- **Project name**: Accept the default or enter a custom name.
+- **Project description**: The description of the project. (Optional)
+- **Stack name**: The stack name, example: `dev`, `sandbox`, or `prd`
+- **Package manager**: Choose the package manager (e.g., `npm`, `yarn`, `pnpm`).
+- **Azure location**: The azure region location for the resources to be created on. e.g., `SoutheastAsia`
+
+After the project is created, if you are using your own account for development, then ensure you're logged into Azure using Az CLI:
+
+```bash
+az login
+
+# Sample Code
+Retrieving tenants and subscriptions for the selection...
+
+[Tenant and subscription selection]
+
+No     Subscription name    Subscription ID                       Tenant
+-----  -------------------  ------------------------------------  -----------
+[1] *  DrunkCoding          54dbd16b-81cd-yyyy-xxxx-xxxyyyzzz000  DrunkCoding
+
+```
+
+> **Note**:
+>
+> - Pulumi supports various package managers, including `npm`, `yarn`, and `pnpm`. For consistency, this guide will use `pnpm` for all Pulumi projects.
+> - By default, all pulumi stacks are encrypted with a randomly generated key. If you prefer to use a custom encryption key, refer to the [Pulumi documentation](https://www.pulumi.com/docs/iac/concepts/secrets/#configuring-secrets-encryption) for instructions.
+
+## Understand the Project Structure
+
+### Project files
+
+The template generates several files:
+
+- **Pulumi.yaml**: Contains project metadata.
+- **Pulumi.dev.yaml**: Contains stack-specific configuration and secrets.
+- **index.ts**: The main program file where you'll define your infrastructure.
+
+### Review the Sample Code
+
+Open `index.ts` in your preferred code editor and review the sample code. It typically includes the creation of a Resource Group and a Storage Account.
+
+<details><summary><em>View Code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/day-0/day00_pulumi-azure-start/index.ts#1-1000)
+
+</details>
+
+> Note: Exporting the key here is just for demo purposes. 
+> In the real environment, all the connection string and credentials should be stored in the Key Vault instead.
+
+## Preview and Deploy Pulumi Stack
+
+### Preview the Changes
+
+Before deploying, preview the changes to ensure everything is set up correctly:
+
+```bash
+pulumi up
+```
+
+<details><summary><em>Sample Output:</em></summary>
+
+```bash
+Previewing update (dev)
+
+View in Browser (Ctrl+O): https://app.pulumi.com/drunkcoding/day00_pulumi-azure-start/dev/previews/xxxxxxxx-1f60-4ed9-bb35-xxxxxxxxxxxx
+
+     Type                                     Name                          Plan
+ +   pulumi:pulumi:Stack                      day00_pulumi-azure-start-dev  create
+ +   ├─ azure-native:resources:ResourceGroup  resourceGroup                 create
+ +   └─ azure-native:storage:StorageAccount   sa                            create
+
+Outputs:
+    primaryStorageKey: output<string>
+
+Resources:
+    + 3 to create
+
+Do you want to perform this update?  [Use arrows to move, type to filter]
+  yes
+> no
+  details
+```
+
+</details>
+
+### Deploy the Stack
+
+Deploy your resources to Azure:
+
+```bash
+pulumi up -y
+```
+
+<details><summary><em>Sample Output:</em></summary>
+
+```bash
+Updating (dev)
+
+View Live: https://app.pulumi.com/YOUR_ORGANIZATION/day00_pulumi-azure-start/dev/updates/1
+
+     Type                                     Name                          Status
+ +   pulumi:pulumi:Stack                      day00_pulumi-azure-start-dev  created
+ +   ├─ azure-native:resources:ResourceGroup  resourceGroup                 created
+ +   └─ azure-native:storage:StorageAccount   storageaccount                created
+
+Outputs:
+    primaryStorageKey: "<secure>"
+
+Resources:
+    + 3 created
+
+Duration: 35s
+```
+
+</details>
+
+### Verify the Deployment
+
+After deployment, We can verify the resources in the Azure Portal:
+
+- Log in to the [Azure Portal](https://portal.azure.com/).
+- Navigate to **Resource Groups** and locate your newly created resource group.
+- Verify that the Storage Account is present within the resource group.
+
+![Azure Resources](/assets/az-01-pulumi-setup-developer-account/az-resources.png)
+
+## Clean Up Resources
+
+To avoid incurring unnecessary costs, destroy the resources when they're no longer needed:
+
+```bash
+pulumi destroy -y
+```
+
+<details><summary><em>Sample Output:</em></summary>
+
+```bash
+Destroying (dev)
+
+View Live: https://app.pulumi.com/YOUR_ORGANIZATION/day00_pulumi-azure-start/dev/updates/2
+
+     Type                                     Name                          Status
+ -   pulumi:pulumi:Stack                      day00_pulumi-azure-start-dev  deleted
+ -   ├─ azure-native:storage:StorageAccount   storageaccount                deleted
+ -   └─ azure-native:resources:ResourceGroup  resourceGroup                 deleted
+
+Outputs:
+  - primaryStorageKey: "<secure>"
+
+Resources:
+    - 3 deleted
+
+Duration: 25s
+
+The resources in the stack have been deleted, but the history and configuration are still maintained.
+If you want to remove the stack completely, run `pulumi stack rm dev`.
+```
+
+</details>
+
+## Pulumi CLI commands
+
+The most common commands in the CLI that you’ll be using are as follows:
+
+- `pulumi new`: creates a new project using a template
+- `pulumi stack select`: switching between the stacks (at least one is required to perform an update)
+- `pulumi config`: configure variables such as keys, regions, and so on
+- `pulumi up`: preview and deploy changes to your program and/or infrastructure
+- `pulumi preview`: preview your changes explicitly before deploying
+- `pulumi destroy`: destroy your program and its infrastructure when you’re done
+
+> Refer [here for the details](https://www.pulumi.com/docs/iac/cli/commands/) of Pulumi commands
+
+## Conclusion
+
+Congratulations! You've successfully:
+
+- Registered for a Pulumi account
+- Generate a Personal Access Token
+- Set up the Pulumi and Azure CLI tools
+- Create your first Pulumi project using TypeScript for Azure
+- Deployed an Azure Resource Group and Storage Account
+
+Pulumi simplifies cloud resource management by allowing you to use familiar programming languages and tools. We can now explore adding more complex resources and configurations on the projects.
+
+## References
+
+- [Sample source code](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/day-0/day00_pulumi-azure-start#day-0)
+- [Pulumi get started](https://www.pulumi.com/docs/iac/get-started/)
+- [Pulumi Commands](https://www.pulumi.com/docs/iac/cli/commands/)
+- [Pulumi Secret Config](https://www.pulumi.com/docs/iac/concepts/secrets/#configuring-secrets-encryption)
+
+## Next
+
+**[Day 02: Private Aks Environment Architecture.](/posts/az-02-pulumi-private-ask-env-architecture)**
+
+In the next tutorial, We will discuss the architecture of private AKS that we are going to provision on Azure, leveraging multiple subnets, Azure Firewall, and other essential cloud services.
+This architecture ensures that sensitive workloads remain isolated and protected from public internet exposure.
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | _[GitHub](https://github.com/baoduy)_

az-02-pulumi-private-ask-env-architecture.md

@@ -0,0 +1,102 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-10-12T12:00:00Z
+title: "[Az] Day 02: Private Azure Kubernetes (AKS) Environment Architecture."
+featured: false
+draft: false
+tags:
+  - AKS
+  - Private
+  - Pulumi
+description: "
+In this tutorial, We will explore the design of a private AKS environment on Azure. We'll use multiple subnets, Azure Firewall, and other critical cloud services to construct a secure architecture.
+This setup is designed to keep sensitive workloads isolated and shielded from exposure to the public internet.
+"
+---
+
+## Introduction
+
+In today's cloud-centric world, security is paramount. By default, many cloud services are publicly accessible over the internet, which can pose significant risks for sensitive workloads. 
+
+When deploying a private AKS (AKS) environment, it's essential to protect all components while maintaining efficient network communication.
+
+This post explains an architecture of private AKS that we are going to set up on Azure, leveraging multiple subnets, Azure Firewall, and other essential cloud services. 
+
+![Private AKS Environment Architecture Diagram](/assets/az-02-pulumi-private-ask-env-architecture/private-aks-day-02.png)
+<p class="ml-44"><em>(Download the original draw.io file <a href="/assets/az-02-pulumi-private-ask-env-architecture/private-aks.drawio" download>here)</a></em></p>
+
+## Table of Contents
+
+## Architecture Overview
+
+This architecture ensures that sensitive workloads remain isolated and protected from public internet exposure.
+
+### Hub VNet
+
+The Hub VNet acts as the central point for network security and communication management, utilizing a **hub-and-spoke** architecture. It includes:
+
+- **Azure Firewall**: Positioned in dedicated subnets, it serves as the main security gateway, regulating all the network traffic. 
+  It consolidates outbound traffic through a single public IP address for **easier control and third-party whitelisting**. 
+  Security measures include:
+  - **Outbound Traffic Control**: Inspects and authorizes outgoing traffic to approved IP ranges or services.
+  - **No Inbound NAT Rules**: Blocks unsolicited inbound internet traffic, enhancing security.
+  - **Network Traffic Control**: Restricts direct access to the AKS cluster and other resources, allowing only legitimate internal interactions.
+
+- **General Subnet**: Allocated for Azure resources with private links, such as Key Vault, SQL Server, and Storage Account. It is entirely internal with no public access, ensuring secure operations.
+
+### AKS VNet
+
+The AKS VNet is designed to host the private AKS cluster, ensuring secure and efficient communication with other network components:
+
+- **AKS Subnet**: Hosts the AKS cluster within a dedicated subnet. The Kubernetes API server is accessible only via a private endpoint, and pod networking manages secure communication with services in the General Subnet. 
+- **Azure Firewall Rules:** only allows external access to necessary resources for AKS cluster.
+
+### CloudPC VNet
+
+The CloudPC VNet provides secure environments for virtual desktops and DevOps operations, maintaining isolation from critical infrastructure:
+
+- **CloudPC Subnet**: Provides secure VDI environment (using Windows 365 enterprise) for internal resource access, eliminating public exposure.
+- **DevOps Subnet**: Hosts resources for DevOps private agents, including CI/CD pipelines for private ASK deployment.
+
+## Subnet IP Allocation
+
+Here is the summary of the private IP address allocation for each subnet:
+
+| VNet Name           | Subnet Name                    | Address Prefix      | Total | Usable |
+|---------------------|--------------------------------|---------------------|-------|--------|
+| **1. Hub VNet**     | 1.1 Firewall Subnet            | `192.168.30.0/26`   | 64    | 59     |
+|                     | 1.2 Firewall Management Subnet | `192.168.30.64/26`  | 54    | 59     |
+|                     | 1.3 General Subnet             | `192.168.30.128/27` | 32    | 27     |
+| **2. AKS VNet**     | 2.1 AKS Subnet                 | `192.168.31.0/24`   | 256   | 251    |
+| **3. CloudPC VNet** | 3.1 CloudPC Subnet             | `192.168.32.0/25`   | 128   | 123    |
+|                     | 3.2 DevOps Subnet              | `192.168.32.128/27` | 32    | 27     |
+
+> **Note**: Adjust the address space according to your environment, as this is intended for demonstration purposes.
+
+## Conclusion
+
+Designing the network architecture with a strong focus on security allows us to fully utilize Azure services while safeguarding our workloads from external threats. This private AKS environment offers a robust, scalable, and adaptable platform for deploying containerized applications.
+
+- **Complete Isolation**: Essential resources remain shielded from the public internet. Service access is secured through private endpoints and managed by Azure Firewall.
+- **Centralized Security Management**: Azure Firewall acts as a unified control point for overseeing and securing all network traffic and leaving the environment.
+- **Scalability and Flexibility**: Each subnet can be scaled independently according to workload demands, offering flexibility in expanding the AKS cluster or integrating additional services.
+- **Reduced Attack Surface**: By segmenting services into distinct subnets and employing Azure Firewall as a protective barrier, the attack surface is significantly minimized, reducing the risk of unauthorized access.
+- **Efficient Communication**: Private endpoints and internal routing facilitate seamless communication between services without exposing them to external networks.
+
+## References
+
+- [Use Azure Firewall to help protect an AKS cluster](https://learn.microsoft.com/en-us/azure/architecture/guide/aks/aks-firewall)
+- [Limit network traffic with Azure Firewall in AKS](https://learn.microsoft.com/en-us/azure/aks/limit-egress-traffic?tabs=aks-with-system-assigned-identities)
+
+## Next
+
+**[Day 03: Secret Management and Centralized Log Monitoring on Azure](/posts/az-03-pulumi-private-ask-credential-log-management)**
+
+In the next article, we will guide you through the process of establishing a secure and automated system for secret management using Azure Key Vault.
+Additionally, we will cover how to implement centralized log monitoring using Azure Log Analytics and Application Insights, enhancing observability and operational efficiency.
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | _[GitHub](https://github.com/baoduy)_

az-03-pulumi-private-ask-credential-log-management.md

@@ -0,0 +1,239 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-10-12T12:00:00Z
+title: "[Az] Day 03: Secret Management and Centralized Log Monitoring on Azure."
+featured: false
+draft: false
+tags:
+  - AKS
+  - Private
+  - Pulumi
+description: "
+In this tutorial, walk us through the process of establishing a secure and automated system for secret management using Azure Key Vault. Additionally, we will cover how to implement centralized log monitoring using Azure Log Analytics and Application Insights, enhancing observability and operational efficiency.
+"
+---
+
+## Introduction
+
+In this article, we will discuss the process of establishing a secure and automated system for secret management for the environment.
+
+Additionally, we will cover how to implement centralized log monitoring enhancing observability and operational efficiency.
+
+1. **Secret Management:**  
+    Utilizes _Azure Key Vault_ to securely manage and store sensitive information such as credentials, certificates, and secrets. This guarantees consistent and secure access across all applications and services.
+
+2. **Centralized Application Log Management:**  
+    Implements a centralized logging system using _Azure Log Analytics_ and _Application Insights_ to collect and analyze logs from all applications. This setup allows for effective performance monitoring, issue troubleshooting, and operational insight maintenance across the environment.
+
+3. **CI/CD flow:**
+   ![secrets-management](/assets/az-03-pulumi-private-ask-credential-log-management/secrets-management.png)
+    <p class="ml-44"><em>Illustration of the software CI/CD flow</em></p>
+
+   - The purpose of this CI/CD flow is to ensure that environment secrets, especially for production, are automatically generated by Pulumi and stored securely in Azure Key Vault.
+   - When developers need to deploy an application, they only need to specify the secret name in the deployment spec.
+   - During the deployment process, the CI/CD pipeline will automatically replace the secret name with the actual secret from Key Vault.
+   - This approach guarantees that sensitive production secrets remain secure and are not exposed to the team members.
+
+## Table of Contents
+
+## Configuration
+
+Before we start coding, it's important to define our configuration settings. This involves specifying resource names and subnet address spaces that we'll use throughout the project.
+
+### Resource Groups
+
+We categorize our resources into different Azure resource groups for better organization and management:
+
+| Resource Group                  | Description                                             |
+|---------------------------------|---------------------------------------------------------|
+| **Shared Resource Group**       | Where our Key Vault and logging components reside.      |
+| **Hub VNet Resource Group**     | Contains our main VNet hub.                             |
+| **AKS VNet Resource Group**     | Contains resources specific to the AKS cluster.         |
+| **CloudPC VNet Resource Group** | For resources related to virtual desktops or cloud PCs. |
+
+### Allocated Subnets
+
+Again, this is the subnet Ip address spaces that we have defined in the [previous post](/posts/az-02-pulumi-private-ask-env-architecture#summary-of-allocated-subnets).
+
+| VNet Name           | Subnet Name                    | Address Prefix      | Total | Usable |
+|---------------------|--------------------------------|---------------------|-------|--------|
+| **1. Hub VNet**     | 1.1 Firewall Subnet            | `192.168.30.0/26`   | 64    | 59     |
+|                     | 1.2 Firewall Management Subnet | `192.168.30.64/26`  | 54    | 59     |
+|                     | 1.3 General Subnet             | `192.168.30.128/27` | 32    | 27     |
+| **2. AKS VNet**     | 2.1 AKS Subnet                 | `192.168.31.0/24`   | 256   | 251    |
+| **3. CloudPC VNet** | 3.1 CloudPC Subnet             | `192.168.32.0/25`   | 128   | 123    |
+|                     | 3.2 DevOps Subnet              | `192.168.32.128/27` | 32    | 27     |
+
+### The configuration file
+Here is the `config.ts` file will be used for all pulumi our projects:
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/config.ts#1-21)
+
+</details>
+
+> **Note:** Adding a number as a prefix to the Azure resource group names helps keep them sorted in sequence, making them easier to find and navigate.
+
+## The `Common` Project
+
+To promote code reusability and maintainability, we create a common project named `az-commons`.
+This library contains utilities and helper functions that we'll use across all our Pulumi projects.
+
+### The `azEnv` Module
+
+This module provides functions to retrieve Azure environment configurations:
+
+- **Tenant ID**: Identifies the Azure Active Directory (EntraID) tenant.
+- **Subscription ID**: Identifies the Azure subscription where resources will be deployed.
+- **Current Principal**: The object ID of the user or service principal executing the scripts.
+- **Region Code**: The Azure region.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-commons/azEnv.ts#1-1000)
+
+</details>
+
+### The `naming` Module
+
+This module helps generate resource names with a consistent prefix based on the Pulumi stack name:
+
+- **`getGroupName`**: Prepends the stack name to a resource group name.
+- **`getName`**: uses to format the name with convention _{stack}-nameWithoutNumber-{suffix}_ and remove the numbers from the name.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-commons/naming.ts#1-1000)
+
+</details>
+
+### The `stackEnv` Module
+
+This module provides functions to retrieve Pulumi stack environment configurations:
+
+- **`isDryRun`**: Indicates whether the current execution is a dry run (preview) or an actual deployment.
+- **Organization**: The Pulumi organization name.
+- **Project Name**: The name of the Pulumi project.
+- **Stack**: The name of the Pulumi stack.
+- **StackReference**: This helper function ensures that a project correctly references stacks within the same organization and environment.
+  For example, the `dev` stack of project `az-02-hub-vnet` will reference the `dev` stack of project `az-01-shared`.
+  This mechanism prevents cross-environment resource referencing, ensuring that resources from different environments (e.g., dev and prod) are kept isolated and properly aligned within the intended environment.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-commons/stackEnv.ts#1-1000)
+
+</details>
+
+## The `Shared` Project
+
+Following the instructions from [Day 01](/posts/az-01-pulumi-setup-developer-account), we create a new project named `az-01-shared`.
+This project will include the following components:
+
+### The `Vault` Module
+
+Creating a `Azure Key Vault` is a secure storage solution for managing secrets, keys, and certificates. It helps safeguard cryptographic keys and secrets used by cloud applications and services.
+
+- **Vault Options**:
+  - **enablePurgeProtection**: This option enables purge protection for the Key Vault. When enabled, it prevents the permanent deletion of the vault and its contents for a specified retention period, even if a delete operation is performed. This is crucial for compliance and recovery scenarios.
+  - **enabledForDiskEncryption**: This setting allows the Key Vault to be used for Azure Disk Encryption. It is necessary for encrypting virtual machine disks, ensuring that data at rest is protected.
+  - **softDeleteRetentionInDays**: This specifies the number of days that deleted vault items (like keys, secrets, and certificates) are retained in a "soft deleted" state. During this period, they can be recovered. The minimum value is 7 days, and the maximum is 90 days.
+  - **enableRbacAuthorization:** This enables Role-Based Access Control (RBAC) for managing access to the Key Vault. It requires authentication through EntraID, allowing for more granular and secure access management.
+
+- **Vault Roles Management**: To implement the principle of least privilege, we create two EntraID groups:
+  - **AZ ROL DEV-SHARED-VLT READONLY**: For read-only access to the Key Vault.
+  - **AZ ROL DEV-SHARED-VLT WRITE**: For write access to the Key Vault.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-01-shared/Vault.ts#1-1000)
+
+</details>
+
+### The `Log` Module
+
+This module provisions a Log Analytics Workspace, which is used for collecting and analyzing telemetry data from various sources, providing insights into resource utilization and performance.
+
+- **Workspace Options**:
+  - **immediatePurgeDataOn30Days**: which allows data to be purged immediately after 30 days.
+  - **workspaceCapping**: Sets a daily data ingestion quota to control costs and manage data volume.
+  - **sku**: Defines the pricing tier for the workspace, which affects cost and features.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-01-shared/Log/Workspace.ts#1-1000)
+
+</details>
+
+### The `AppInsight` module
+
+This module provisions an Application Insights component for monitoring web applications, linking it to a Log Analytics Workspace for data ingestion.
+
+- **AppInsights Options**:
+  - **kind** and **applicationType**: Define the type of application being monitored, in this case, a web application.
+  - **retentionInDays**: Sets the data retention period to 30 days.
+  - **immediatePurgeDataOn30Days**: Allows data to be purged immediately after 30 days.
+  - **ingestionMode**: Specifies that data ingestion is done through Log Analytics.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-01-shared/Log/AppInsight.ts#1-1000)
+
+</details>
+
+### The main `index.ts` module: 
+
+This is a main module for the `shared` project, and a similar structure is maintained across all related projects. This file is tasked with:
+
+- Establishing Resource Groups.
+- Deploying all the Azure Resources above.
+- Exporting essential resource details for future use by other projects.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-01-shared/index.ts#1-1000)
+
+</details>
+
+## Deployment and Cleanup
+
+### Deploying the Stack
+
+To deploy the stack, execute the `pnpm run up` command. This provisions the necessary Azure resources. We can verify the deployment as follows:
+
+- EntraID groups configured for Key Vault access control:
+  ![Entra-Group](/assets/az-03-pulumi-private-ask-credential-log-management/az-01-entra-groups.png)
+
+- Successfully deployed Azure resources:
+  ![Azure-Resources](/assets/az-03-pulumi-private-ask-credential-log-management/az-01-resources.png)
+
+### Cleaning Up the Stack
+
+To remove the stack and clean up all associated Azure resources, run the `pnpm run destroy` command. This ensures that any resources no longer needed are properly deleted.
+
+## Conclusion
+
+By following this guide, we have successfully automated the deployment of secure `secret management` and centralized `log management` using Azure Key Vault, Log Analytics, and Application Insights with Pulumi.
+
+This setup ensures that sensitive data is securely stored and that we have real-time monitoring of application performance across our environment.
+
+Implementing RBAC and the principle of least privilege enhances the security posture of our infrastructure. Centralized logging enables us to efficiently troubleshoot issues and gain operational insights.
+
+## References
+
+- [az-01-shared](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-01-shared).
+- [az-commons](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-commons).
+
+## Next
+
+**[Day 04: Develops a Virtual Network Hub for Private AKS on Azure](/posts/az-04-pulumi-private-aks-hub-vnet-development)**
+
+In the next article, We'll walk through the process of developing the first Hub VNet for a private AKS environment using Pulumi.
+We will demonstrate how to seamlessly integrate a VNet with an Azure Firewall, along with configuring outbound public IP addresses.
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | _[GitHub](https://github.com/baoduy)_

az-04-pulumi-private-aks-hub-vnet-development.md

@@ -0,0 +1,118 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-10-12T12:00:00Z
+title: "[Az] Day 04: Develop a VNet Hub for Private AKS on Azure."
+featured: false
+draft: false
+tags:
+  - AKS
+  - Private
+  - Pulumi
+description: "
+In this tutorial, We’ll walk through the process of developing the first Hub VNet for a private AKS environment using Pulumi. We will demonstrate how to seamlessly integrate a VNet with an Azure Firewall, along with configuring outbound public IP addresses.
+"
+---
+
+## Introduction
+
+In this tutorial, we will guide you through the development of the initial Hub VNet for a private AKS environment using Pulumi.
+
+We will demonstrate how to seamlessly integrate a VNet with an Azure Firewall, along with configuring outbound public IP addresses.
+
+Security is paramount. Our focus will be on enhancing security by implementing network policies, firewalls, and encryption to safeguard our environment, all while maintaining cost-effectiveness on Azure.
+
+## Table of Contents
+
+## The Hub VNet modules
+
+### The `VNet` Module
+
+This module facilitates the creation of a Virtual Network, allowing for the specification of subnets as parameters. It also enables VNet encryption by default to enhance security.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-02-hub-vnet/VNet.ts#1-1000)
+
+</details>
+
+### The `FirewallPolicy.ts` Module
+
+This module is responsible for creating a FirewallPolicy resource, which serves as the root policy for the Azure Firewall. This root policy will be the foundation for linking additional policy groups in subsequent Pulumi projects.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-02-hub-vnet/FirewallPolicy.ts#1-1000)
+
+</details>
+
+### The `Firewall.ts` Module
+
+This module is designed to set up an Azure Firewall, including essential parts such as IP addresses and diagnostic settings.
+It ensures the firewall is connected to the designated subnet within the VNet and is associated with the root policy resources.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-02-hub-vnet/Firewall.ts#1-1000)
+
+</details>
+
+### Developing a Hub VNET
+
+Our goal is to set up the main parts required for the Hub VNet, which include:
+
+1. **Resource Group**: A container for managing related Azure resources.
+2. **Virtual Network (VNet)**: The main network that hosts our subnets.
+3. **Subnets**: Segments within the VNet to isolate and organize resources.
+4. **Public IP Addresses**: For outbound internet connectivity and firewall management.
+5. **Firewall Policy**: Defines rules to control network traffic.
+6. **Azure Firewall**: A managed firewall service to protect our network.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-02-hub-vnet/index.ts#1-1000)
+
+</details>
+
+> **Note:**
+>
+> - Properly setting the `dependsOn` property ensures that resources are created and destroyed in the correct sequence.
+> - The code above demonstrates how to reuse the log workspace from the `az-01-shared` project for Firewall diagnostics, enabling effective tracing and monitoring of firewall rules.
+
+## Deployment and Cleanup
+
+### Deploying the Stack
+
+To deploy the stack, execute the `pnpm run up` command. This provisions the necessary Azure resources. We can verify the deployment as follows:
+
+- Successfully deployed Azure resources:
+  ![Azure-Resources](/assets/az-04-pulumi-private-aks-hub-vnet-development/az-02-hub-vnet.png)
+  _Overview of successfully deployed Azure resources._
+
+### Cleaning Up the Stack
+
+To remove the stack and clean up all associated Azure resources, run the `pnpm run destroy` command. This ensures that any resources no longer needed are properly deleted.
+
+## Conclusion
+
+In this guide, we have successfully constructed a Hub Virtual Network (VNet) for our private AKS environment using Pulumi.
+This Hub VNet serves as a crucial element in managing and securing access to all resources within our infrastructure, ensuring robust control and enhanced security measures.
+
+## References
+
+- [az-commons Source Code](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-commons/README.md)
+- [az-02-hub-vnet Source Code](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-02-hub-vnet/README.md)
+- [Azure DevOps IPs and FQDNs](https://learn.microsoft.com/en-us/azure/devops/organizations/security/allow-list-ip-url)
+- [Pulumi for Azure](https://www.pulumi.com/docs/intro/cloud-providers/azure/)
+
+## Next
+
+**[Day 05: Implementing a Private AKS Cluster with Pulumi](/posts/az-05-pulumi-private-aks-cluster-env)**
+
+In the next tutorial, We'll build a private AKS cluster with advanced networking features.
+We'll explore how to integrate the AKS cluster with the Hub VNet and apply the firewall policies we've created.
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | _[GitHub](https://github.com/baoduy)_

az-05-pulumi-private-aks-cluster-env.md

@@ -0,0 +1,174 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-10-12T12:00:00Z
+title: "[Az] Day 05: Implementing a Private AKS Cluster with Pulumi."
+featured: false
+draft: false
+tags:
+  - AKS
+  - Private
+  - Pulumi
+description: "
+In this tutorial, We’ll build a private AKS cluster with advanced networking features. We’ll explore how to integrate the AKS cluster with the Hub VNet and apply the firewall policies we’ve created.
+"
+---
+
+## Introduction
+
+Building a private AKS cluster offers enhanced network security and complete control over ingress and egress traffic.
+
+This tutorial will guide you through the setup of a private AKS cluster with advanced networking capabilities, integrating it into a sophisticated network architecture using Pulumi.
+
+By the end of this guide, you'll know how to integrate the AKS cluster with a Hub VNet and apply firewall policies established in the [previous `az-02-hub-vnet` project](az-04-pulumi-private-aks-hub-vnet-development).
+
+## Table of Contents
+
+## The project modules
+
+### The `ContainerRegistry.ts` Module
+
+To enhance security and ensure that all Docker images deployed to our AKS cluster are verified, this module establishes a private Container Registry. By restricting AKS to pull images exclusively from this private registry, we eliminate the need to open firewalls on the public internet.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-03-aks-cluster/ContainerRegistry.ts#1-1000)
+
+</details>
+
+### The `AksFirewallRules.ts` Module
+
+This module sets up a **FirewallPolicyRuleCollectionGroup** with policies that enable controlled outbound communication for AKS nodes. The rules ensure that only necessary traffic is permitted, thus enhancing the security posture of our AKS cluster.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-03-aks-cluster/AksFirewallRules.ts#1-1000)
+
+</details>
+
+### The `VNet.ts` Module
+
+The Virtual Network (VNet) serves as the backbone for our AKS cluster. It provides the primary network environment that includes subnets dedicated to AKS nodes.
+The VNet is peered with the Hub VNet to enable seamless integration with other services and to route all traffic through the Hub's firewall, ensuring all egress traffic is controlled.
+
+1. **Security Group**: By default, the VNet allows resources in all subnets to access the internet. To enhance security, a security group is created with the following default rules:
+
+   - Block all internet access from all subnets.
+   - Allow VNet-to-VNet communication to enable hub-spoke connectivity.
+   - Additional security rules can be added through parameters.
+
+   <details><summary><em>View code:</em></summary>
+
+   [inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-03-aks-cluster/VNet.ts#1-1000)
+
+   </details>
+
+2. **Route Table**: This VNet will peer with the hub, necessitating a route table to direct all traffic to the private IP address of the firewall.
+
+    <details><summary><em>View code:</em></summary>
+    
+    [inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-03-aks-cluster/VNet.ts#1-1000)
+    
+    </details>
+
+3. **VNet**: Finally, the VNet is configured to create the route table and security group, injecting them into all provided subnets. Additionally, it establishes VNet peering with the hub VNet.
+
+    <details><summary><em>View code:</em></summary>
+    
+    [inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-03-aks-cluster/VNet.ts#10-1000)
+    
+    </details>
+
+### The `AKS.ts` Module
+
+1. **SSH Key Generation Custom Resource**: An SSH key is required for configuring an AKS cluster. 
+
+    Due to Pulumi's lack of native SSH support, I use **[Dynamic Resource Providers](https://www.pulumi.com/docs/iac/concepts/resources/dynamic-providers/)** to create a custom component that dynamically generates an SSH key at runtime.
+    
+   <details><summary><em>View SSH generator code:</em></summary>
+    
+    [inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-03-aks-cluster/SshGenerator.ts#1-1000)
+    
+    </details>
+   
+    > This component also demonstrates how to securely store secrets within the Pulumi state.
+
+    Furthermore, a helper method uses the SSH generator alongside a random password to create an SSH public and private key pair and stored them in Key Vault for AKS.
+    
+    <details><summary><em>View code:</em></summary>
+    
+    [inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-03-aks-cluster/Aks.ts#78-116)
+    
+    </details>
+
+2. **AKS Identity Creation**: AKS can be configured to use Microsoft Entra ID for user authentication.
+
+    This setup allows users to sign in to an AKS cluster using a Microsoft Entra authentication to manage access to namespaces and cluster resources.
+
+    <details><summary><em>View code:</em></summary>
+    
+    [inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-03-aks-cluster/Aks.ts#11-71)
+    
+    </details>
+
+3. **AKS Cluster Creation**: Finally, by integrating all components, we establish our AKS cluster. The source code contains several key elements worth noting.
+    <details><summary><em>View code:</em></summary>
+    
+    [inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-03-aks-cluster/Aks.ts#121-1000)
+    
+    </details>
+
+## Developing a Private AKS Cluster
+
+Our goal is to configure all necessary elements for the AKS Cluster, which include:
+
+1. **Resource Group**: A container for organizing related Azure resources, simplifying management and cost tracking.
+2. **Container Registry**: The main repository for all Docker images used by our private AKS, ensuring secure image deployment.
+3. **AKS Firewall Policy**: To enable outbound internet connectivity, we must configure firewall rules that allow AKS nodes to communicate securely with essential Azure services.
+4. **Virtual Network (VNet)**: The primary network hosting our AKS subnets, integrated with our Hub VNet to ensure secure and managed traffic flow.
+5. **AKS Cluster**: An Azure-managed Kubernetes service, configured with advanced security and connectivity options.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-03-aks-cluster/index.ts#1-1000)
+
+</details>
+
+## Deployment and Cleanup
+
+### Deploying the Stack
+
+To deploy the stack, execute the `pnpm run up` command. This provisions the necessary Azure resources. We can verify the deployment as follows:
+
+- Successfully deployed Azure resources:
+  ![Azure-Resources](/assets/az-05-pulumi-private-aks-cluster-env/az-03-aks-cluster.png)
+  _Overview of successfully deployed Azure resources._
+
+### Cleaning Up the Stack
+
+To remove the stack and clean up all associated Azure resources, run the `pnpm run destroy` command. This ensures that any resources no longer needed are properly deleted.
+
+## Conclusion
+
+In this tutorial, we've successfully implemented a private AKS cluster with advanced networking features using Pulumi.
+By setting up a private Container Registry, configuring firewall rules, and integrating the cluster with a Hub VNet, we have enhanced the security and manageability of our Kubernetes environment.
+These steps ensure that the AKS cluster is well-secured and capable of meeting the demands of a production-grade infrastructure.
+
+## References
+
+- [Outbound network and FQDN rules for AKS clusters](https://learn.microsoft.com/en-us/azure/aks/outbound-rules-control-egress)
+- [Dynamic resource providers](https://www.pulumi.com/docs/iac/concepts/resources/dynamic-providers/)
+- [Use EntraID role-based access control for AKS](https://learn.microsoft.com/en-us/azure/aks/manage-azure-rbac?tabs=azure-cli)
+- [Use a service principal with AKS](https://learn.microsoft.com/en-us/azure/aks/kubernetes-service-principal?tabs=azure-cli)
+- [Best Practices for Private AKS Clusters](https://docs.microsoft.com/azure/aks/private-clusters)
+
+## Next
+
+**[Day 06: Implements a private CloudPC and DevOps Agent Hub with Pulumi](/posts/az-06-pulumi-private-aks-cloudpc-hub)**
+
+In the next tutorial, it will guide us through setting up a secure CloudPC and DevOps agent hub, aimed at improving the management and operational capabilities of your private AKS environment using Pulumi.
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | _[GitHub](https://github.com/baoduy)_

az-06-pulumi-private-aks-cloudpc-hub.md

@@ -0,0 +1,165 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-10-12T12:00:00Z
+title: "[Az] Day 06: Implement a private CloudPC and DevOps Agent Hub with Pulumi."
+featured: false
+draft: false
+tags:
+  - AKS
+  - Private
+  - Pulumi
+description: "
+In this tutorial, guide us through setting up a secure CloudPC and DevOps agent hub, aimed at improving the management and operational capabilities of the private AKS environment using Pulumi.
+"
+---
+
+## Introduction
+
+Creating a secure private VNet for CloudPC (Windows 365 Enterprise) and Azure DevOps agent allows for an isolated network environment, enabling secure access, management, and control of cloud resources.
+
+This guide will walk you through the process of setting up a private VNet using Pulumi, integrating it with the Hub VNet was created in the previous article.
+
+## Table of Contents
+
+## The project modules
+
+### The `CloudPcFirewallRules` Module
+
+This module defines the firewall policies for:
+
+- **CloudPC**: We adhere to the recommended network rules for [Windows 365 Enterprise](https://learn.microsoft.com/en-us/windows-365/enterprise/requirements-network?tabs=enterprise%2Cent). Additionally, we ensure that all machines within the CloudPC subnet have access to AKS, DevOps subnets, and other Azure resources.
+  <details><summary><em>View code:</em></summary>
+
+  [inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-04-cloudPC/CloudPcFirewallRules/cloudpcPolicyGroup.ts#1-1000)
+
+  </details>
+
+- **DevOps**: The current setup allows all machines in the DevOps subnet unrestricted access to all resources, including those on the internet. To improve security, it is recommended to restrict access to only necessary resources and implement more granular firewall rules.
+  <details><summary><em>View code:</em></summary>
+
+  [inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-04-cloudPC/CloudPcFirewallRules/devopsPolicyGroup.ts#1-1000)
+
+  </details>
+
+- **Index File**: Combines CloudPC and DevOps rules into a unified `FirewallPolicyRuleCollectionGroup`, linking them to the root policy established in the `az-02-hub-vnet` project.
+  <details><summary><em>View code:</em></summary>
+
+  [inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-04-cloudPC/CloudPcFirewallRules/index.ts#1-1000)
+
+  </details>
+
+### The `VNet.ts` Module
+
+This module is responsible for creating a virtual network (VNet) with two subnets.
+It also establishes peering with the Hub VNet that was set up in the previous project, similar to the VNet component used for AKS in `az-03-aks-cluster` project.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-04-cloudPC/VNet.ts#78-172)
+
+</details>
+
+### The `DiskEncryptionSet.ts` Module
+
+This module demonstrates how to encrypt Azure resources using a custom encryption key stored in Azure Key Vault. It includes the following components:
+
+- **User Assigned Identity**: This identity is used to grant access to the Key Vault, allowing it to read the encryption key.
+  <details><summary><em>View code:</em></summary>
+
+  [inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-04-cloudPC/DiskEncryptionSet.ts#17-44)
+
+  </details>
+
+- **Vault Encryption Key**: A custom encryption key with a size of 4096 bits, configured for automatic rotation every year within the Key Vault.
+  <details><summary><em>View code:</em></summary>
+
+  [inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-04-cloudPC/DiskEncryptionSet.ts#49-88)
+
+  </details>
+
+- **Disk Encryption Set**: This component creates a `DiskEncryptionSet` using the User Assigned Identity and the custom encryption key mentioned above.
+
+  <details><summary><em>View code:</em></summary>
+
+  [inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-04-cloudPC/DiskEncryptionSet.ts#90-119)
+
+  </details>
+
+### The `VM.ts` Module
+
+This module facilitates the provisioning of a Linux virtual machine (VM)
+on Azure with automatically generated login credentials and disk encryption and connects the VM to a subnet within the virtual network.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-04-cloudPC/VM.ts#1-1000)
+
+</details>
+
+### The `PrivateDNS.ts` Module
+
+To optimize internal network communication, we implement a DNS resolver. This module sets up a private DNS zone that facilitates efficient name resolution within our network infrastructure.
+
+1. **Private DNS Zone**: Creates a dedicated DNS zone for internal use.
+2. **VNet Links**: Establishes connections between the private DNS zone and both the Hub and CloudPC virtual networks.
+3. **A Record**: Configures A record that points to the private IP address of our NGINX ingress controller.
+   > In the following topics, We will cover the NGINX ingress controller deployed on AKS as private ingress, and it will be assigned the internal IP address `192.168.31.250`. This IP must be within the AKS subnet range.
+
+By linking this private DNS to both the Hub and CloudPC VNets, we ensure that all DNS requests for our internal services are correctly routed to the NGINX ingress controller. This setup enhances security and improves network performance by keeping internal traffic within our private network.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-04-cloudPC/PrivateDNS.ts#1-1000)
+
+</details>
+
+## Developing the CloudPC Stack
+
+Our objective is to establish a private Virtual Network (VNet) for CloudPC and Azure DevOps agents using Pulumi,
+enabling us to provision the necessary Azure resources effectively.
+
+1. **Firewall Policy**: Implement security policies to manage egress traffic for CloudPC and DevOps agents.
+2. **VNet and Peering**: Develop the primary network infrastructure, including subnets for CloudPC and the Azure DevOps agent, with necessary VNet peering.
+3. **Disk Encryption Set**: Integrate a disk encryption set to secure virtual machine data at rest.
+4. **Deploy a Linux VM**: Provision a Linux virtual machine to host the Azure DevOps agent. The agent installation process will be covered in the following topic.
+
+<details><summary><em>View code:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/az-04-cloudPC/index.ts#1-1000)
+
+</details>
+
+## Deployment and Cleanup
+
+### Deploying the Stack
+
+To deploy the stack, run the `pnpm run up` command. This will provision all the necessary Azure resources, such as the Virtual Network (VNet), subnets, firewall, and private endpoints. Before executing the command, ensure you are logged into your Azure account using the Azure CLI and have configured Pulumi with the correct backend and credentials.
+
+![Azure-Resources](/assets/az-06-pulumi-private-aks-cloudpc-hub/az-04-cloudpc.png)
+
+<p class="ml-44"><em>The deployed Azure resources</em></p>
+
+### Cleaning Up the Stack
+
+To remove all associated Azure resources and clean up the stack, execute the `pnpm run destroy` command. This will help avoid unnecessary costs and ensure that all resources are properly deleted after testing or development.
+
+## References
+
+- [Azure Virtual Network Documentation](https://learn.microsoft.com/en-us/azure/virtual-network/virtual-networks-overview)
+- [Firewall Policies and Rule Collection Groups](https://learn.microsoft.com/en-us/azure/firewall/policy-overview)
+- [Azure Bastion Configuration](https://learn.microsoft.com/en-us/azure/bastion/bastion-overview)
+- [TeamServicesAgentLinux Extension](https://learn.microsoft.com/en-us/azure/devops/pipelines/release/deployment-groups/howto-provision-deployment-group-agents?view=azure-devops)
+- [Network requirements For Windows 365 Enterprise](https://learn.microsoft.com/en-us/windows-365/enterprise/requirements-network?tabs=enterprise%2Cent)
+- [AzureDevOps Allowed IP addresses and domain URLs](https://learn.microsoft.com/en-us/azure/devops/organizations/security/allow-list-ip-url?view=azure-devops&tabs=IP-V4)
+
+## Next
+
+**[Day 07: Setup Windows 365 Enterprise as a private VDI](/posts/az-07-setup-cloudpc-windows365-enterprise)**
+
+In the next article, we will explore how to configure a CloudPC with Windows 365 Enterprise to establish a secure and efficient Virtual Desktop Infrastructure (VDI) for accessing a private AKS environment.
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | _[GitHub](https://github.com/baoduy)_

az-07-setup-cloudPC-windows365-enterprise.md

@@ -0,0 +1,116 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-10-12T12:00:00Z
+title: "[Az] Day 07: Setting Up a CloudPC with Windows 365 Enterprise."
+featured: false
+draft: false
+tags:
+  - AKS
+  - Private
+  - Pulumi
+description: "
+In this tutorial, We will explore how to configure a CloudPC with Windows 365 Enterprise to establish a secure and efficient Virtual Desktop Infrastructure (VDI) for accessing a private AKS environment.
+"
+---
+
+## Introduction
+
+In this article, we will learn how to set up a CloudPC with Windows 365 Enterprise to create a secure and efficient Virtual Desktop Infrastructure (VDI) for accessing a private AKS environment.
+
+We will cover the essential steps, including configuring network settings, setting up provisioning profiles and policies with Microsoft Intune, and creating an Entra ID group to streamline the provisioning process.
+
+## Obtaining a License
+
+Before we begin the configuration, it is important to ensure that we have a `Windows 365 Enterprise license`. We can either purchase a new license or obtain a trial license through the [Microsoft 365 Admin Center](https://admin.microsoft.com).
+
+![windows365-license](/assets/az-07-pulumi-setup-cloudPC-windows365-enterprise/windows365-license.png)
+
+> Note: A trial license is available, typically lasting one month, with the possibility of extending it for an additional month.
+
+## Table of Contents
+
+## Intune Configuration
+
+Since Microsoft Intune is widely used for device management, we will not delve into its setup here. Instead, our focus will be on configuring Windows 365 Enterprise.
+
+### Entra Provision Group
+
+- First, we navigate to **Groups** in the [Microsoft Endpoint Manager Admin Center](https://intune.microsoft.com/#home) and create a new group named `MDM - IT Windows 365`.
+
+  <img alt="entra-windows365-group" src="/assets/az-07-pulumi-setup-cloudPC-windows365-enterprise/entra-windows365-group.png" width="550px">
+
+- Then, we return to the **Microsoft 365 Admin Center** to assign the license to this group. This step automates the license assignment for all members within the group.
+  <img alt="entra-group-license-assignment" src="/assets/az-07-pulumi-setup-cloudPC-windows365-enterprise/entra-group-license-assignment.png" width="550px">
+
+### Creating Provisioning Profiles
+
+Once we have the license ready and assigned to our Entra ID group, we can proceed to create a provisioning profile for Windows 365 Enterprise. 
+
+- Navigate to **Devices** within Microsoft Intune, and then select **Provisioning** > **Windows 365**.
+
+- Set up a new provisioning profile called `Windows 365 - IT Managed`.
+  - Join type: Select **Microsoft Entra Join**.
+  - Network: Choose **Azure network connection** and associate it with the previously established CloudPC subnet.
+  - Activate EntraID SSO: This will configure single sign-on (SSO) for the CloudPC.
+    ![windows365-provision-profile](/assets/az-07-pulumi-setup-cloudPC-windows365-enterprise/intune-windows365-policy-01.png)
+
+### Provisioning CloudPC Devices
+
+With our profile ready, we can start provisioning CloudPC devices for users. To do this, we need to make sure the target users are part of the `MDM - IT Windows 365` group. 
+
+- After adding users, the provisioning process will automatically start, and the devices will be ready for use within 1 hour.
+
+- Once the provisioning is complete, the assigned users will be able to access their CloudPC through the Windows 365 portal.
+  ![intune-wm-provisioned](/assets/az-07-pulumi-setup-cloudPC-windows365-enterprise/intune-wm-provisioned.png)
+
+## Accessing Windows 365
+
+We can access our CloudPC in several ways:
+
+1. **Online Portal Access**: We can access Windows 365 through the [online portal](https://windows365.microsoft.com). 
+    
+    This allows us to log in and launch the remote desktop directly within our web browser.
+
+   ![windows365-browser](/assets/az-07-pulumi-setup-cloudPC-windows365-enterprise/windows365-browser.png)
+
+2. **Windows App Access**: Microsoft provides a _Windows App_ that enables us to launch Windows 365 natively. 
+
+    This app is available for download from the Windows 365 online portal.
+
+   ![windows-app](/assets/az-07-pulumi-setup-cloudPC-windows365-enterprise/windows365-apps.png)
+
+   Once the app is installed, we can add the appropriate URL as a workspace and log in using our Entra ID. This setup allows us to launch and access Windows 365 natively on our platform.
+
+   ![windows-app-dashboard](/assets/az-07-pulumi-setup-cloudPC-windows365-enterprise/windows-app-dashboard.png)
+
+3. **Private AKS Access**: with Windows 365 configured above, We can access to our private AKS cluster:
+   - **Through Azure Portal**: This allows us to access and manage AKS resources, including namespaces, pods, and deployments, directly in the browser.
+    ![private-aks-access](/assets/az-07-pulumi-setup-cloudPC-windows365-enterprise/azure-portal-private-aks.png)
+
+   - **Using Kubectl CLI**: To use the `kubectl` command locally, follow the Azure Portal instructions to set up our local environment. This setup requires the installation of `Azure CLI`, `kubectl`, and `kubelogin`.
+    ![private-aks-connection](/assets/az-07-pulumi-setup-cloudPC-windows365-enterprise/private-aks-connect.png)
+    
+   - **Using Lens**: Lens is my favourite tool for managing Kubernetes clusters alternately for boring `kubectl` commands. You should be able to download it [here](https://k8slens.dev/).
+     ![k8s-lens](/assets/az-07-pulumi-setup-cloudPC-windows365-enterprise/k8s-lens.png)
+   
+## Conclusion
+
+In this guide, we have successfully set up a CloudPC using Windows 365 Enterprise, configured the necessary provisioning profiles, and ensured secure access to our private AKS environment through a Virtual Desktop Infrastructure (VDI). This setup provides our teams with efficient, secure remote access that integrates seamlessly with our existing infrastructure.
+
+## Reference
+
+- [Overview of Windows 365 deployment](https://learn.microsoft.com/en-us/windows-365/enterprise/deployment-overview)
+- [Start using Windows Autopatch](https://learn.microsoft.com/en-us/windows/deployment/windows-autopatch/prepare/windows-autopatch-feature-activation)
+- [K8s Lens](https://k8slens.dev/)
+
+## Next Topic
+
+**[Day 08: Setting Up a Deployment Pipeline for Pulumi Projects.](/posts/az-08-pulumi-setup-deploy-cicd-pipeline)**
+
+In the next article, we will walk through creating a Continuous Integration and Continuous Deployment (CI/CD) pipeline on Azure DevOps for our Pulumi projects.
+
+## Thank You
+
+Thank you for taking the time to read this guide! We hope it has been helpful. Feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | _[GitHub](https://github.com/baoduy)_

az-08-pulumi-setup-deploy-cicd-pipeline.md

@@ -0,0 +1,182 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-10-12T12:00:00Z
+title: "[Az] Day 08: Setting Up a Deployment Pipeline for Pulumi Projects."
+featured: false
+draft: false
+tags:
+  - AKS
+  - Private
+  - Pulumi
+description: "
+In this tutorial, We will walk through creating a Continuous Integration and Continuous Deployment (CI/CD) pipeline on Azure DevOps for our Pulumi projects.
+"
+---
+
+## Introduction
+In this tutorial, We will walk through creating a Continuous Integration and Continuous Deployment (CI/CD) pipeline on Azure DevOps for our Pulumi projects.
+
+## Table of Contents
+
+## Prerequisites
+
+Ensure you have:
+
+- An Azure DevOps account with a project.
+- [Pulumi extensions](https://marketplace.visualstudio.com/items?itemName=pulumi.build-and-release-task) for Azure DevOps.
+- Permissions to deploy resources in your Azure subscription.
+
+## Preparation
+
+### Pulumi Variable Group
+
+Create a variable group in Azure DevOps **Libraries** named **pulumi**, and add the `PULUMI_ACCESS_TOKEN` variable:
+<img alt="pulumi-variable-group" src="/assets/az-08-pulumi-setup-deploy-cicd-pipeline/pulumi-variable-group.png" width="450px">
+
+### Setting Up Azure Resource Management Connection
+
+1. Navigate to **Service connections** in Azure DevOps and create a new **Azure Workload Identity** connection named `az-pulumi` for **Azure Resource Management**:
+   <img alt="az-federation" src="/assets/az-08-pulumi-setup-deploy-cicd-pipeline/az-federation.png" width="450px">
+
+   > Note: Specifying a resource group is optional. This can be used to restrict the connection's access to a specific resource group if needed.
+
+2. Once the service connection is established, verify the app registration presence in the Azure Portal here:
+   ![Azure-Connection-Details](/assets/az-08-pulumi-setup-deploy-cicd-pipeline/az-federation-details.png)
+   <p class="ml-44"><em>The app registration on Azure Portal</em></p>
+
+3. Ensure the app registration has enough permissions for deployment:
+   - As an `Owner` and `Key Vault Administrator` roles at the **subscription** level.
+   - **Microsoft Graph** permissions to provide it with the necessary privileges for comprehensive deployment operations.
+      ![api-permission](/assets/az-08-pulumi-setup-deploy-cicd-pipeline/az-app-permission.png)
+      <p class="ml-40"><em>The API permission of the app registration</em></p>
+   - As member of  `AZ ROL DEV-AKS-ADMIN` Entra Group: This is necessary for granting the permissions for Helm deployment on AzureDevOps.
+
+## Deployment Templates
+
+For reusability, several templates have been developed:
+
+### Build Template: `build-template.yml`
+
+- **Parameters**:
+
+  1. **stack**: Specifies the target Pulumi stack.
+  2. **workDir**: Defines the working directory of the Pulumi project.
+
+- **Steps**:
+
+  1. **Install Node.js**: Install current Node LTS version.
+  2. **Setup pnpm**: Configures `pnpm` package management.
+  3. **Build Commons Project**: Installs dependencies and runs the build script for `az-commons`.
+  4. **Install Project Dependencies**: Installs dependencies for the specified `workDir`.
+
+<details><summary><em>View yaml:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/pipeline/pulumi/build-template.yml#1-1000)
+
+</details>
+
+### Deployment Template: `deploy-template.yml`
+
+- **Parameters**:
+
+  1. **stack**: Specifies the target Pulumi stack.
+  2. **workDir**: Defines the working directory of the Pulumi project.
+  3. **azureSubscription**: Represents the Azure subscription connection.
+
+- **Steps**:
+
+  1. **Install Pulumi CLI**: Install the latest version of the Pulumi CLI for Linux.
+  2. **Pulumi Refresh**: Refreshes the stack if the `pulumi.refresh` parameter is set to true.
+  3. **Pulumi Up After Refresh**: Executes `pulumi up` if `pulumi.refresh` is true, ensuring the stack is updated after a refresh.
+  4. **Pulumi Up**: Executes `pulumi up` to deploy the stack.
+
+<details><summary><em>View yaml:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/pipeline/pulumi/deploy-template.yml#1-1000)
+
+</details>
+
+> Using Pulumi refresh is essential for maintaining an accurate state. For more details, refer to [this article](https://www.pulumi.com/blog/repairing-state-with-pulumi-refresh/).
+
+## Pulumi Deployment Pipeline
+
+To establish a deployment pipeline in Azure DevOps, We'll create a new pipeline and use the `deploy.azure-pipelines.yml` file.
+
+### YAML Configuration
+
+1. **Trigger**: The pipeline is set to trigger automatically for branches matching the pattern _releases/\*_.
+2. **Agent Pool**: We use the _ubuntu-latest_ agent pool for running our pipeline tasks.
+3. **Variables**: The configuration includes several key variables:
+   - `pulumi`: A variable group containing essential Pulumi configuration settings.
+   - `azureSubscription`: The name of the Azure Resource Manager connection.
+   - `pnpm_config_cache`: The specified location for the pnpm cache.
+   - `env_name`: Dynamically derived from the branch name, determining the deployment environment.
+
+### Pipeline Structure and Flow
+
+Our pipeline consists of four distinct deployment stages. Each stage utilizes the `build-and-deploy.yml` template file, with appropriate parameters passed to it.
+
+To initiate the pipeline:
+
+1. Create a new branch named `releases/dev`
+2. Push the changes to this branch
+3. The pipeline will automatically trigger and run
+
+Here's a visual representation of the deployment sequence:
+![deploy-pipeline-flow](/assets/az-08-pulumi-setup-deploy-cicd-pipeline/deploy-pipeline-flow.png)
+
+<p class="ml-44"><em>Visualization of the Deployment Pipeline Stages</em></p>
+
+The pipeline progresses through these stages in order, ensuring a systematic and controlled deployment process.
+Each stage builds upon the previous one, allowing for a comprehensive and structured approach to deploying our Pulumi projects.
+
+<details><summary><em>View yaml:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/pipeline/pulumi/deploy.azure-pipelines.yml#1-1000)
+
+</details>
+
+## Pulumi Destroy Pipeline
+
+This pipeline demonstrates how to safely destroy a Pulumi deployment stack. Exercise caution, as once a stack is destroyed, it cannot be restored.
+
+To set up a destruction pipeline in Azure DevOps, use the `danger-destroy.azure-pipelines.yml` file.
+The destruction states are reverted from the deployment state.
+
+Here's a visual representation of the deployment sequence:
+![deploy-pipeline-flow](/assets/az-08-pulumi-setup-deploy-cicd-pipeline/pulumi-destroy-pipeline.png)
+> Each stage in this process uses the `danger-build-and-destroy.yml` file with the necessary parameters.
+
+<p class="ml-44"><em>Visualization of the Destroy Pipeline</em></p>
+
+<details><summary><em>View yaml:</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/pipeline/pulumi/danger-destroy.azure-pipelines.yml#1-1000)
+
+</details>
+
+## Conclusion
+
+In this tutorial, we've successfully set up a CI/CD pipeline using Pulumi and Azure DevOps.
+This pipeline automates the deployment of infrastructure, ensuring that our environments are consistent, scalable, and easy to manage.
+
+By leveraging Pulumi's abilities, we can integrate infrastructure as code into our development workflows, enhancing both efficiency and reliability.
+
+## References
+
+- [Pipeline Samples](https://github.com/baoduy/drunk-azure-pulumi-articles/tree/main/pipeline)
+- [Pulumi extensions](https://marketplace.visualstudio.com/items?itemName=pulumi.build-and-release-task)
+- [Pnpm Pipeline Config](https://pnpm.io/continuous-integration#azure-pipelines)
+- [Repairing State With Pulumi Refresh](https://www.pulumi.com/blog/repairing-state-with-pulumi-refresh/).
+
+## Next
+
+**[Day 09: Synchronizing Container Images to ACR for a Private AKS Cluster Using CI/CD Pipelines.](/posts/az-09-private-aks-acr-image-sync)**
+
+In the next article, We explore the process of synchronizing container images with ACR for deployments in a private AKS cluster. We'll cover how to configure and automate this synchronization using CI/CD pipelines, ensuring seamless updates and secure image management for private AKS environments.
+
+## Thank You
+
+Thank you for taking the time to read this guide! We hope it has been helpful. Feel free to explore further and happy coding! 🌟✨
+
+**Steven** | _[GitHub](https://github.com/baoduy)_

az-09-private-aks-acr-image-sync.md

@@ -0,0 +1,106 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-10-12T12:00:00Z
+title: "[Az] Day 09: Synchronizing Container Images to ACR for a Private AKS Cluster Using CI/CD Pipelines."
+featured: false
+draft: false
+tags:
+  - AKS
+  - Pulumi
+  - CI/CD
+  - AzureDevOps
+description: "
+In this tutorial, We explore the process of synchronizing container images with ACR for deployments in a private AKS cluster. We’ll cover how to configure and automate this synchronization using CI/CD pipelines, ensuring seamless updates and secure image management for private AKS environments.
+"
+---
+
+## Introduction
+
+Deploying applications in a private AKS cluster presents unique challenges, especially when the cluster lacks direct internet access.
+In such environments, the cluster cannot pull container images from public registries like Docker Hub or Quay.io.
+Instead, all container images must be sourced from a private ACR accessible within the cluster's network.
+
+To address this, we need a robust solution that not only synchronizes required images into the ACR but also integrates with Continuous Integration/Continuous Deployment (CI/CD) pipelines and adheres to Software Development Life Cycle (SDLC) best practices.
+This ensures that all images are reviewed and approved before being imported, enhancing security and compliance.
+
+## Table of Contents
+
+## Implementation
+
+By leveraging Azure DevOps CI/CD pipelines, we can automate the public image importing process as below.
+
+### 1. Image Configuration File
+
+The `images.txt` file lists all the container images that need to be imported into the private ACR.
+
+Each line specifies the source image and the destination repository within the ACR, separated by `=>`. This format allows for easy maintenance and review of the images being imported.
+
+<details><summary><em>Example <code>images.txt</code></em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/pipeline/image-sync/images.txt#1-1000)
+
+</details>
+
+- **Source Image:** The full path to the image in the public registry, including the tag.
+- **Destination Repository:** The repository path within the ACR where the image will be imported.
+- **Comments:** Lines starting with `#` are treated as comments and ignored by the script.
+
+### 2. Synchronization Script
+
+The `sync-script.sh` script automates the process of importing images listed in `images.txt` into the ACR. It reads each line of the configuration file, processes the source and destination information, and uses the Azure CLI to import the images.
+
+<details><summary><em>View code</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/pipeline/image-sync/sync-script.sh#1-1000)
+
+</details>
+
+### 3. Azure Pipeline
+
+To streamline the synchronization process, we utilize a CI/CD pipeline. This pipeline is designed to automatically execute the synchronization script whenever there are updates to the `images.txt` file, ensuring that all container images in the ACR remain current.
+
+<details><summary><em>View code</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/image-sync-pipeline/image-sync.azure-pipelines.yml#1-1000)
+
+</details>
+
+**Important Variables:**
+
+- The `image-sync` variable group contains the `DOCKER_NAME` and `DOCKER_TOKEN`, which are essential for accessing Docker Hub and avoiding rate limits.
+- The `azureSubscription` with a specific Azure service connection name in Azure DevOps.
+- Replace `acrName` with the actual name of the Azure Container Registry.
+
+![az-devops-sync-pipeline](/assets/az-09-private-aks-acr-image-sync/az-devops-sync-pipeline.png)
+
+Once the pipeline completes successfully, you can verify that all images have been correctly imported into the ACR.
+![acr-imported-images](/assets/az-09-private-aks-acr-image-sync/acr-imported-images.png)
+
+<p class="ml-44"><em>The imported images on ACR repositories</em></p>
+
+## Conclusion
+
+Synchronizing container images for a private AKS cluster without direct internet access requires careful planning and automation. By leveraging a combination of an image configuration file, a synchronization script, and an Azure DevOps CI/CD pipeline, we can:
+
+- Automate the import of necessary images into a private ACR.
+- Ensure that all images are reviewed and approved according to SDLC practices.
+- Maintain a secure and compliant deployment environment within the private AKS cluster.
+
+This approach not only streamlines the deployment process but also integrates seamlessly with existing development workflows, promoting efficiency and reliability in managing containerized applications.
+
+## References
+
+- [Image importing pipeline](https://github.com/baoduy/drunk-azure-pulumi-articles/tree/main/image-sync-pipeline)
+- [Azure Container Registry Documentation](https://docs.microsoft.com/azure/container-registry/)
+
+## Next
+
+**[Day 10: Implementing a Helm Deployment CI/CD AzureDevOps Pipeline for a Private AKS Cluster.](/posts/az-10-private-aks-helm-deployment)**
+
+In the next article, We will create Helm charts for nginx-ingress and cert-manager, and set up a robust CI/CD pipeline using Azure DevOps for Helm deployments to a private AKS cluster.
+
+## Thank You
+
+Thank you for taking the time to read this guide! We hope it has been helpful. Feel free to explore further and happy coding! 🌟✨
+
+**Steven** | _[GitHub](https://github.com/baoduy)_

az-10-private-aks-helm-deployment.md

@@ -0,0 +1,165 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-10-12T12:00:00Z
+title: "[Az] Day 10: Implementing a Helm Deployment CI/CD AzureDevOps Pipeline for a Private AKS Cluster."
+featured: false
+draft: false
+tags:
+  - AKS
+  - Helm
+  - CI/CD
+  - AzureDevOps
+description: "
+In this tutorial, We will create Helm charts for nginx-ingress and cert-manager, and set up a robust CI/CD pipeline using Azure DevOps for Helm deployments to a private AKS cluster.
+"
+---
+
+## Introduction
+
+In our previous article, we covered the process of importing Docker images into a private Azure Container Registry (ACR). 
+Building on that foundation, this guide will walk you through creating Helm charts for nginx-ingress and cert-manager, and setting up a comprehensive Helm deployment pipeline for your private Azure Kubernetes Service (AKS) cluster using Azure DevOps.
+
+## Table of Contents
+
+## Configuring an Azure DevOps Agent
+
+To streamline the deployment process of your Helm charts, it's crucial to set up and configure an Azure DevOps agent on the virtual machine (VM) provisioned by the _az-04-cloudPC_ project. 
+This setup ensures that your CI/CD pipeline functions smoothly within a private network environment.
+
+### Installing the Azure DevOps Agent
+
+1. Log into your virtual machine using Windows 365 Virtual Desktop Infrastructure (VDI).
+2. Follow the detailed instructions in the [Microsoft documentation](https://learn.microsoft.com/en-gb/azure/devops/pipelines/agents/linux-agent?view=azure-devops) to install the Azure DevOps agent on a Linux-based VM.
+3. Once installed, assign the agent to the `aks-agents` pool to optimize resource allocation.
+
+After installed, the agent should be listed under Azure DevOps project's agents as below:
+![private-aks-agent-pool](/assets/az-10-private-aks-helm-deployment/private-aks-agent-pool.png)
+
+### Installing Essential Tools
+
+For effective Helm chart deployment, ensure the following tools are installed on the agent:
+
+- **Azure CLI**: Required for managing Azure resources. Follow the installation guide [here](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli-linux?pivots=apt).
+- **KubeLogin**: This is a client-go credential plugin implementing azure authentication and required for pipeline deployment to authenticate with AKS using Service Principal. Refer [here](https://azure.github.io/kubelogin/install.html).
+- **Helm CLI**: Essential for managing Kubernetes applications. Refer to the installation instructions [here](https://helm.sh/docs/intro/install/).
+- **Kubectl**: Necessary for Kubernetes cluster management. Installation guidance is available [here](https://kubernetes.io/docs/tasks/tools/install-kubectl-linux/).
+
+> Note: After installing these tools, restart the VM to ensure that the installations are correctly applied and effective.
+
+### Azure DevOps Extensions
+
+To facilitate our deployment process, we'll be using the [Replace Tokens](https://marketplace.visualstudio.com/items?itemName=qetza.replacetokens) extension for Azure Pipelines.
+This task replaces tokens in text-based files with actual variable values, allowing for dynamic configuration of our Helm charts.
+Ensure this extension is installed in your Azure DevOps environment before proceeding with the pipeline setup.
+
+## Nginx and Cert Manager Helm Chart
+
+Our Helm chart is designed to deploy three essential parts:
+
+1. **Nginx Ingress Controller**: This internal ingress controller will service traffic at the IP address `192.168.31.250`, using the internal domain `drunkcoding.net`.
+2. **Cert-Manager**: This component is responsible for generating SSL certificates for all internal subdomains. It also monitors certificate expiration and handles timely renewals.
+3. **Let's Encrypt ClusterIssuer**: The chart includes templates to deploy a Let's Encrypt ClusterIssuer, enabling Cert-Manager to issue free SSL certificates from Let's Encrypt.
+
+<details><summary><em>View the <code>Chart.yaml</code> file</em></summary>
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/pipeline/ingress-helm/Chart.yaml#1-1000)
+
+</details>
+
+### Env-Variables Values
+
+We've created a `values-dev.yaml` file to configure our development environment.
+- **Chart Variables**: Tokens in the format `${{Name}}` are placeholders for variables that will be populated from the pipeline during deployment. These variables can be sourced from library groups, Azure Key Vault, or inline variables.
+- **Chart Images**: All chart images are configured to be pulled from our internal Azure Container Registry (ACR), which was set up in the previous topic.
+
+<details><summary><em>View the <code>values-dev.yaml</code> file</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/pipeline/ingress-helm/values-dev.yaml#1-1000)
+
+</details>
+
+### Setting Up an Azure DevOps Pipeline
+
+With our Helm charts prepared, it's time to create an Azure DevOps pipeline to deploy these to our secure AKS cluster.
+
+**Pipeline Preparation:**
+- First, go to your Git repository and start a new pipeline. Choose "Existing pipeline" and choose the `ingress-helm.azure-pipelines.yml` file.
+- Next, We'll need to set up some variables for this pipeline:
+  1. `cf-dns`: This group includes two key details:
+     - `cf-domain`: This is the Cloudflare domain, used here for SSL verification since we are managing DNS internally.
+     - `cf-dns-token`: A token from Cloudflare that lets us edit DNS; it has certain permissions. You can refer [here](/posts/ks-08-cert-manager-with-private-aks) for guidance on setting this up.
+     <img alt="cf-variable-group" src="/assets/az-10-private-aks-helm-deployment/cf-variable-group.png" width="450px">
+  2. `env_name`: This should be the name of the branch from which the pipeline building.
+  3. `azureSubscription`: The name of your Azure subscription, set as _az-pulumi_ from previous steps. Make sure this account can manage Helm deployment and is part of the `AZ ROL DEV-AKS-ADMIN` group within AKS Admin Active Directory.
+  4. `rsGroup`: The name of the Azure resource group that contains your AKS cluster.
+  5. `aksName`: The name given to your AKS cluster.
+  6. `acrName`: The name of the Azure Container Registry.
+  7. `private-ip`: A dedicated private IP for the ingress controller.
+  8. `valueFile`: The specific Helm values file name only.
+  9. `chart`: The location of Helm chart.
+  10. `releaseName`: The name of the Helm release.
+
+**Pipeline Deployment:**
+- Once the deployment is successful:
+    ![nginx-ingress-pipeline](/assets/az-10-private-aks-helm-deployment/nginx-ingress-pipeline.png)
+
+- We'll find that the pods are now active within the `nginx-ingress` namespace.
+    ![nginx-ingress-namespace-pods](/assets/az-10-private-aks-helm-deployment/nginx-ingress-namespace-pods.png)
+
+<details><summary><em>View the <code>values-dev.yaml</code> here</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/pipeline/ingress-helm/ingress-helm.azure-pipelines.yml#1-1000)
+
+</details>
+
+## Application Helm Chart
+
+Now, let's create another Helm chart to deploy our applications. For this example, we'll use a Helm chart to deploy the `azuredocs/aks-helloworld:v1` image, provided by the Microsoft AKS team for demonstration purposes. Once deployed, the cert-manager will automatically issue an SSL certificate for the subdomain `hello.drunkcoding.net`, enabling us to access the application via Windows 365 VDI.
+**Pipeline Deployment:**
+- Upon successful deployment:
+  ![drunk-apps-helm-deployment](/assets/az-10-private-aks-helm-deployment/drunk-apps-helm-deployment.png)
+
+- The application pods should now be active within the `drunk-apps` namespace.
+  ![drunk-apps-namespace-pods](/assets/az-10-private-aks-helm-deployment/drunk-apps-namespace-pods.png)
+
+- The SSL certificate `tls-hello-world-lets` should be successfully issued and stored in the `drunk-apps` namespace's secrets.
+  ![drunk-apps-namespace-cert](/assets/az-10-private-aks-helm-deployment/issued-cert-hello.png)
+
+**Application Access:**
+- Access the app via Windows 365 VDI:
+    ![windows365-drunk-apps](/assets/az-10-private-aks-helm-deployment/windows365-drunk-apps.png)
+
+<details><summary><em>View the app helm chart here</em></summary>
+
+[inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/pipeline/drunk-apps-helm/drunk-apps-helm.azure-pipelines.yml#1-1000)
+
+</details>
+
+## Conclusion
+
+In this guide, we've walked through the process of creating Helm charts for nginx-ingress and cert-manager, and setting up an Azure DevOps pipeline to deploy these charts to a private AKS cluster. This approach allows for easy management and deployment of these critical components in your Kubernetes infrastructure.
+
+By leveraging Helm and Azure DevOps, We can ensure consistent and repeatable deployments across your environments, making it easier to manage and scale your applications in a private AKS cluster.
+
+Remember to always follow security best practices, such as using Azure Key Vault for storing sensitive information and regularly updating your deployments with the latest security patches.
+
+## References
+
+- [Nginx Helm Chart](https://github.com/baoduy/drunk-azure-pulumi-articles/tree/main/pipeline/ingress-helm)
+- [Drunk Apps Helm Chart](https://github.com/baoduy/drunk-azure-pulumi-articles/tree/main/pipeline/drunk-apps-helm)
+- [Self-hosted Linux agents](https://learn.microsoft.com/en-gb/azure/devops/pipelines/agents/linux-agent?view=azure-devops)
+- [Helm Documentation](https://helm.sh/docs/)
+- [Nginx Ingress Controller Documentation](https://kubernetes.github.io/ingress-nginx/)
+- [Cert-Manager Documentation](https://cert-manager.io/docs/)
+- [AzureDevOps Replace Token Extension](https://marketplace.visualstudio.com/items?itemName=qetza.replacetokens&targetId=aed13a53-890d-4411-a029-49b8b9bf9004&utm_source=vstsproduct&utm_medium=ExtHubManageList)
+
+## Next
+
+**[Day 11: Exposing a Private AKS Application via Cloudflare Tunnel.](/posts/az-11-private-aks-expose-public-app-with-cloudflare-tunnel)**
+
+In the next article, We demonstrate how to securely expose an application running on a private AKS cluster to the internet using Cloudflare Tunnel, without the need for public IP addresses or open ports. We'll also show how to apply authentication to all exposed applications and centralize access control using Azure Entra ID Groups, ensuring only authorized users have access.
+
+## Thank You
+
+Thank you for taking the time to read this guide! We hope it has been helpful in setting up your Helm deployment pipeline for a private AKS cluster. Feel free to explore further and happy deploying! 🚀🌟
+
+**Steven** | _[GitHub](https://github.com/baoduy)_

az-11-private-aks-expose-public-app-with-cloudflare-tunnel.md

@@ -0,0 +1,190 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-10-12T12:00:00Z
+title: "[Az] Day 11: Exposing a Private AKS Application via Cloudflare Tunnel."
+featured: false
+draft: false
+tags:
+  - AKS
+  - Helm
+  - CI/CD
+  - AzureDevOps
+  - Cloudflare
+  - Tunnel
+description: "
+In this tutorial, We demonstrate how to securely expose an application running on a private AKS cluster to the internet using Cloudflare Tunnel, without the need for public IP addresses or open ports. We’ll also show how to apply authentication to all exposed applications and centralize access control using Azure Entra ID Groups, ensuring only authorized users have access.
+"
+---
+
+## Introduction
+In environments with stringent security policies, exposing applications hosted on private AKS clusters to the internet without compromising security can be challenging. These environments often have **no inbound internet access** and **no open ports**, limiting conventional methods of application exposure.
+
+In this guide, we’ll walk through how to securely expose an application hosted on a private AKS cluster to the internet using **Cloudflare Tunnel**, a solution that eliminates the need for public IP addresses or open ports. Additionally, we’ll demonstrate how to secure the application with **Cloudflare Access** integrated with **Azure EntraID Single Sign-On (SSO)**.
+
+## Table of Contents
+
+## Prerequisites
+
+Before diving into Cloudflare Tunnel, make sure you have the following set-up:
+
+- **Cloudflare Zero Trust:** You need an active Cloudflare account with the [Zero Trust feature](https://developers.cloudflare.com/cloudflare-one/setup/) enabled to set up a Cloudflare Tunnel.
+
+## Setting Up Cloudflare Tunnel
+
+**Cloudflare Tunnel** (formerly Argo Tunnel) provides a secure connection between your services and Cloudflare without the need for public IP addresses or inbound firewall rules.
+
+### Generate Tunnel Token
+
+To get started, follow these steps to create a Cloudflare Tunnel token:
+
+1. **Sign in to Cloudflare**  
+   Log in to your Cloudflare account and navigate to the [Zero Trust dashboard](https://one.dash.cloudflare.com).
+
+2. **Create a Tunnel**  
+   Go to **Network** and select **Tunnels**. Click **Create a tunnel** and choose the `cloudflared` option.
+   ![cloudflare-tunnel-creation](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/cloudflare-tunnel-creation.png)
+
+3. **Name and Save the Tunnel**  
+   Name your tunnel `private-aks-tunnel` and click **Save**.
+
+4. **Copy Tunnel Token**  
+   Once the tunnel is created, a token will be generated. Copy the tunnel token and securely store it in **Azure Key Vault** as a secret named `cf-tunnel-token`.
+   ![key-vault-secret-cf-tunnel](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/key-vault-secret-cf-tunnel.png)
+   > Ensure that the token is accurately stored in the Key Vault. This token will be used when deploying the `cloudflared` Helm chart.
+
+### Deploying **Cloudflared** with Helm
+
+With the secure storage of the tunnel token in Key Vault, follow these refined steps to deploy **cloudflared** on the AKS cluster using Helm:
+
+1. **Cloudflared Chart:**
+
+   I created the [cloudflared Helm chart](https://github.com/baoduy/drunk-azure-pulumi-articles/tree/main/pipeline/cf-tunnel-helm), expanding upon the previous chart template. 
+   This implementation establishes an AKS network policy that blocks inbound traffic to the namespace while allowing only the necessary outbound traffic to the internal Nginx Ingress using the private IP `192.168.31.250`.
+
+    <details><summary><em>View the <code>values-dev.yaml</code> file</em></summary>
+    
+    [inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/pipeline/cf-tunnel-helm/values-dev.yaml#1-1000)
+    
+    </details>
+
+2. **Cloudflared Deployment Pipeline:**
+   
+   This pipeline mirrors the previous pipeline, with an additional enhancement to directly retrieve secrets from the Key Vault, bypassing the need for a Variable Group.
+
+    <details><summary><em>View the <code>network-rule.yaml</code> file</em></summary>
+    
+    [inline](https://github.com/baoduy/drunk-azure-pulumi-articles/blob/main/pipeline/cf-tunnel-helm/templates/network-rule.yaml#1-1000)
+    
+    </details>
+
+> **Important:**
+> - To optimize the Cloudflare Tunnel's outbound operations, adjust the AKS firewall settings in accordance with [Cloudflare's recommendations](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/deploy-tunnels/tunnel-with-firewall).
+> - These settings are required for the tunnel's ability to establish and maintain effective communication with Cloudflare servers, handling inbound requests seamlessly.
+
+### Deploying the Cloudflare Tunnel
+
+1. Create a new pipeline named `cf-tunnel-helm` with the `cf-tunnel-helm.azure-pipelines.yml` file, enabling the deployment
+of this Helm chart to AKS.
+
+   ![Cloudflare Tunnel Deployment Pipeline](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/cf-system-helm-pipeline.png)
+
+2. Once deployment is successful, the Cloudflare Tunnel pods should be running within the `cf-system` namespace.
+   ![cf-system Namespace Pods](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/cf-system-pods.png)
+
+3. Return to the [Cloudflare Zero Trust](https://one.dash.cloudflare.com) dashboard to verify the tunnel status, which should display as healthy.
+   ![Cloudflare Tunnel Dashboard Status](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/cf-dashboard-tunnel-status.png)
+
+## Exposing the Application
+
+With all preparations complete, we can now expose the application to the internet follow these steps:
+
+1. Go to the Cloudflare Tunnel created previously and click "Edit."
+2. Navigate to the "Public Hostname" section and configure it as follows:
+   - **Subdomain**: The subdomain of the app. in this example, `hello` is used.
+   - **Domain**: Choose any available domain; in this example, `st24.dev` is used.
+   - **Service Type**: HTTP
+   - **URL**: Enter the internal Nginx ingress IP address and application port, e.g., `192.168.31.250:80`.
+   - **HTTP Host Header**: This should match the internal ingress domain associated with the application, e.g., `hello.drunkcoding.net`.
+
+   ![cf-tunnel-public-hello-app](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/cf-tunnel-public-hello-app.png)
+
+3. Save the configuration. After saving, The application should be able to access publicly via `hello.st24.dev`.
+
+   ![hello-app-with-st24](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/hello-app-with-st24.png)
+
+## Securing the Application with Authentication
+
+Once the application is exposed to the internet, it becomes accessible to everyone, posing security concerns. 
+To enhance security, we need to restrict access to authorized personnel only, such as company staff or specific group members. 
+Cloudflare provides a robust solution for securing applications accessible via tunnels.
+
+### Configuring Cloudflare SSO with EntraID
+
+First, logging into the [Cloudflare Zero Trust](https://one.dash.cloudflare.com) dashboard, Navigate to **Settings** > **Authentication**, and select "Add New" under the **Login methods** section.
+
+1. **Login providers:** Cloudflare offers multiple login providers; choose **Azure AD** for this configuration.
+  ![cloudflare-login-providers](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/cloudflare-login-providers.png)
+
+2. **EntraID SSO:** Follow the provided instructions to integrate Azure AD (EntraID) authentication.
+  ![cloudflare-azure-ad-login](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/cloudflare-azure-ad-login.png)
+
+3. **Verification:** Test the configuration to verify that authentication can successfully retrieve the `name` and `id` of EntraID groups.
+  ![cloudflare-azure-ad-login-test](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/cloudflare-azure-ad-login-test.png)
+
+### Creating a New EntraID Group
+
+Next, log into the Azure Portal and create a new EntraID group named `DRUNK CF APPS` with the ID `f8863b0f-3376-4d14-85ba-b376a7d5aeca`. This group will be used to control access to the exposed application.
+![entra-drunk-app-group](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/entra-drunk-app-group.png)
+
+### The `hello` App Access Policy
+
+Finally, return to the [Cloudflare Zero Trust](https://one.dash.cloudflare.com) dashboard and go to **Access** > **Applications**. Click "Add an Application" and select the `Self-hosted` type.
+
+1. **App Configuration**: Ensure the domain matches the application you wish to protect. In this example, we'll protect the `hello.st24.dev` application previously exposed.
+    ![cf-app-config](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/cf-app-config.png)
+
+2. **App Identity**: Choose the login provider configured earlier.
+    ![cf-app-identity-providers](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/cf-app-identity-providers.png)
+
+3. **App Policy**: Configure a policy that requires authentication via required provider and restricts access to users in the specified EntraID group ids.
+    ![cf-app-policy](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/cf-app-policy.png)
+    > The list of permitted Azure Groups should include the EntraID Group IDs that are allowed access to this app. Without this configuration, the app would be accessible to anyone with an EntraID account in the organization.
+
+4. **Testing the App Policy**: After creating the application, click "Test Your Policy" to ensure it functions as intended using a specific account.
+    ![cf-app-policy-test](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/cf-app-policy-test.png)
+
+## Accessing the Protected App
+
+1. Visit `hello.st24.dev`, and We should encounter a login dialog requesting Azure AD authentication before accessing the application.
+  ![cf-apps-login-dialog](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/cf-apps-login-dialog.png)
+
+2. After logged in, users will gain normal access to the application.
+  ![hello-app-with-st24](/assets/az-11-private-aks-expose-public-app-with-cloudflare-tunnel/hello-app-with-st24.png)
+
+## Conclusion
+
+In this guide, we've explored how to securely expose an application running on a private AKS cluster to the internet without relying on public IP addresses or open ports. By leveraging **Cloudflare Tunnel**, we established a secure outbound-only connection that adheres to stringent security policies. This method eliminates the risks associated with inbound internet access while providing a seamless way to make internal services accessible externally.
+
+We also implemented **Cloudflare Access** integrated with **Azure Entra ID Single Sign-On (SSO)** to add an authentication layer to all exposed applications. This integration ensures that only authorized users within your organization can access the applications, enhancing security by centralizing access control through Entra ID Groups. By doing so, we simplified user management and strengthened compliance with organizational policies.
+
+This approach not only maintains the security integrity of your infrastructure but also offers a scalable solution for exposing multiple applications securely. It demonstrates how modern cloud services can be combined to meet complex security requirements without compromising accessibility or user experience.
+
+## Reference
+
+- [Cloudflared Helm Chart](https://github.com/baoduy/drunk-azure-pulumi-articles/tree/main/pipeline/cf-tunnel-helm)
+- [Tunnel with firewall](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/deploy-tunnels/tunnel-with-firewall)
+- [Configure Cloudflare with Microsoft Entra ID](https://learn.microsoft.com/en-us/entra/identity/enterprise-apps/cloudflare-integration)
+
+
+## Next
+
+**[Day 12: Exposing a Private AKS Application via Cloudflare Tunnel.](/posts/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp)**
+
+In the next and final tutorial, We'll discover how to safely expose the private AKS cluster and applications to the internet with Cloudflare. 
+It'll delve into the benefits of using Cloudflare Tunnel and WARP, exploring alternative ways to provide secure access while maintaining the integrity of the corporate network.
+
+## Thank You
+
+Thank you for taking the time to read this guide! We hope it has been helpful. Feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | _[GitHub](https://github.com/baoduy)_

az-12-private-aks-enable-mdm-devices-cf-tunnel-warp.md

@@ -0,0 +1,200 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-10-12T12:00:00Z
+title: "[Az] Day 12: Enabling MDM Devices by leverage Cloudflare Tunnel and WARP."
+featured: false
+draft: false
+tags:
+  - AKS
+  - private cluster
+  - Cloudflare
+  - Tunnel
+  - warp
+description: "
+In this final tutorial, We'll discover how to safely expose the private AKS cluster and applications to the internet with Cloudflare. It'll delve into the benefits of using Cloudflare Tunnel and WARP, exploring alternative ways to provide secure access while maintaining the integrity of the corporate network.
+"
+---
+## Introduction
+
+In the final tutorial of our series on establishing a private AKS environment on Azure with Pulumi, we confront a critical balancing act: ensuring secure access for developers and users without compromising the environment's integrity. 
+
+While stringent security is paramount for compliance, excessive restrictions can hinder developer productivity by obstructing access to essential tools. This challenge is compounded by the rise of remote work, which necessitates robust solutions for managing devices and enforcing security policies beyond traditional network boundaries.
+
+This is where Cloudflare WARP and its Zero Trust model come into play. WARP empowers us to grant secure, private access to corporate applications while meticulously verifying device health before connection. By routing traffic through Cloudflare's global network, the WARP client allows for granular web filtering and robust security measures enforced by Cloudflare Gateway.
+
+This approach offers a compelling solution for organizations with remote workforces, enhancing security while minimizing friction for users. By integrating Cloudflare Tunnel and WARP into our private AKS environment, we can strike a balance: enabling seamless developer access while upholding the integrity and security of our corporate network. 
+
+## Table of Contents
+
+## Prerequisites
+
+Before diving into Cloudflare Tunnel and WARP, make sure you have the following set-up:
+
+- **Cloudflare Zero Trust:** You need an active Cloudflare account with the [Zero Trust feature](https://developers.cloudflare.com/cloudflare-one/setup/) enabled to set up a Cloudflare Tunnel.
+- **Microsoft Intune:** Ensure Microsoft Intune is configured for Mobile Device Management (MDM) to manage your devices effectively.
+- **Test Device:** We'll demonstrate using a macOS virtual machine enrolled in the organization's MDM. You can test with your enrolled device by following similar steps.
+  ![intune-mdm-devices](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/intune-mdm-devices.png)
+
+## WARP Configuration
+
+To begin, log into the [Cloudflare Zero Trust](https://one.dash.cloudflare.com) dashboard and navigate to **Settings** > **WARP Client** and configure the following settings:
+
+1. **Device Enrollment Permissions:**
+    - **Device Enrollment Rules**: Click the "Manage" button under the Device enrollment permissions section to add the necessary _Device enrollment rules_ as depicted below.
+      ![cf-device-onboarding-rules](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-device-onboarding-rules.png)
+    
+    - **Authentication**: Ensure that the authentication tab exclusively enables the _Azure AD_ provider, with both _WARP authentication identity_ and _Apply to all Access applications_ activated.
+      ![cf-device-onboarding-auth](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-device-onboarding-auth.png)
+
+2. **Global Settings**: Activate the Admin override feature, setting the timeout appropriately—6 hours is a recommended.
+      ![cf-warp-global-settings](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-warp-global-settings.png)
+
+3. **Device Posture:** This section is crucial for defining device validation rules.
+    - **WARP Client Check**: Activate both the _Gateway_ and _WARP_ checking rules.
+    - **Third-Party Service Providers**: Click the "Add new" button and select _Microsoft Endpoint Manager_. Follow the provided instructions to implement the Microsoft Intune MDM validation check.
+    - **Service Provider Check**: Create a new rule named `Device-Compliant`, assigning it a value of `Compliant`. Avoid selecting an operation unless the rule is intended for a specific OS.
+     ![cf-warp-device-posture](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-warp-device-posture.png)
+
+4. **Virtual Network Configuration**: Navigate to the "Virtual Network" section to establish two distinct virtual networks:
+    - **default:** This network is automatically generated by Cloudflare and serves as the primary network for _organizational_ access, allowing connection to internal applications across the entire organization.
+    - **it-internal-net:** This is a dedicated network tailored for the _IT department_, providing access to specific internal services such as SSH connections to DevOps agent virtual machines.
+     ![cf-warp-network](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-warp-network.png)
+
+## WARP Profile Configuration
+
+Upon navigating to Device Settings, you'll find a default profile. This profile can be enhanced with the following customizations:
+
+1. **Configuration Options:**
+   Adjust the settings as outlined below:
+    - **Captive Portal Detection:** Enable with a 3-minute timeout. This feature allows the WARP client to temporarily deactivate when encountering a captive portal, facilitating connection to networks like those in hotels, airplanes, or other public environments.
+    - **Lock WARP Switch:** Ensure that users cannot disable the WARP switch, preventing them from disconnecting the client.
+    - **Allow Updates:** Permit local administrators to receive update notifications for the client and initiate the updates.
+    - **Automatic Reconnection:** Set to enable with a 3-minute timeout. This ensures the WARP client automatically reconnects after the specified duration.
+    - **Service Mode:** Default to **Gateway with WARP**. This should not be altered.
+      ![cf-warp-profile-config-settings](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-warp-profile-config-settings.png)
+
+2. **Split Tunneling:**
+   It should be in **Exclude IPs and Domains** mode, configure traffic routing preferences within Cloudflare Zero Trust.
+    
+    By default, all private IP address spaces are excluded. To allow remote devices to access AKS and DevOps subnets, adjust the exclusion rules. Click the "Manage" button to ensure these subnets are included for access.
+    ![cf-warp-profile-split-tunnel](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-warp-profile-split-tunnel.png)
+    
+3. **Microsoft 365 Traffic Routing:** 
+   If your organization uses Microsoft 365, it's advisable to enable direct routing for its traffic to ensure optimal performance.
+
+
+## WARP Team Domain Management
+
+Upon registering for Cloudflare Zero Trust, you will need to specify a **Team Domain**. If you do not recall your current team domain or wish to modify it, head over to **Settings** > **Custom Pages**. Here, you can view and update your team domain, as well as customize the appearance of login and error pages to better fit your organization’s branding needs.
+![cf-warp-custom-pages](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-warp-custom-pages.png)
+
+## Deploying the WARP Client with Intune
+
+1. **Deploy via Intune:** To streamline the deployment of the WARP Client across all devices, follow the [guide here](https://developers.cloudflare.com/cloudflare-one/connections/connect-devices/warp/deployment/mdm-deployment/partners/intune/). 
+   This resource details how to onboard the WARP client app with Intune for efficient distribution to widely selected devices.
+
+2. **Activating WARP:**
+   - After installing the WARP client, the Cloudflare icon will appear in the Taskbar/MenuBar, and a browser window will automatically open, prompting users to log in with Azure AD credentials.
+      ![cf-warp-client-login](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-warp-client-login.png)
+   - Upon successful login, the WARP client will register the device with Cloudflare Zero Trust and display a "Protected" status, indicating that the device is secured.
+      ![cf-warp-client-status](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-warp-client-status.png)
+   - The device will also appear on the Zero Trust portal under **My Team** > **Devices**, with its posture status visible as shown below:
+      ![cf-warp-device-posture-status](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-warp-device-posture-status.png)
+
+> Important: Cloudflare Zero Trust is complimentary for up to the first 50 users. Fees apply for additional users. For more information, visit the [pricing page](https://www.cloudflare.com/en-gb/plans/zero-trust-services/).
+
+## Network Policy
+
+To ensure secure access to the AKS Subnet `192.168.31.0/24` and DevOps Subnet `192.168.32.128/27`. Here’s how to set up the necessary network policies to permit only compliant devices:
+1. **Blocking Non-compliant Devices:**
+
+    Configure a network firewall policy to restrict access for non-compliant devices. Follow these instructions to establish this rule:
+    Go to **Gateway** > **Firewall Policies** and create a new entry named `Block Non-Compliant Devices` with the parameters below:
+   - **Name**: Block Non-Compliant Devices
+     - **Traffic**: 
+       - **Selector**: `Destination IP`
+       - **Operator**: `in`
+       - **Value**: `192.168.31.0/24`, `192.168.32.128/27`
+     - **Device Posture**: 
+       - **Selector**: `Passed Device Posture`
+       - **Operator**: `is not`
+       - **Value**: `device-compliant (Intune)`
+     - **Action**: `Block`
+     - **Enable Block Notification for WARP Client**: Activate this to alert users when their device fails compliance checks.
+
+2. **Securing IT Department Access**:
+   
+   We previously established an `it-internal-net` specifically for the IT department. To prevent unauthorized access to this network by non-IT personnel, configure an additional firewall policy:
+    - Create an Entra Group named `DRUNK IT DEVELOPERS` with the ID `8a176875-cc7c-4524-86b9-e47573380fe0`.
+    - Set up a new policy with the following specifications:
+      - **Name**: Block IT Network
+      - **Traffic**:
+        - **Selector**: `Destination IP`
+        - **Operator**: `in`
+        - **Value**: `192.168.31.0/24`, `192.168.32.128/27`
+        - **AND**
+        - **Selector**: `Virtual Network`
+        - **Operator**: `is`
+        - **Value**: `it-internal-net`
+      - **Identity**:
+        - **Selector**: `User Group Names`
+        - **Operator**: `not in`
+        - **Value**: `DRUNK IT DEVELOPERS`
+      - **Action**: `Block`
+      - **Enable Block Notification for WARP Client**: Activate this to notify users who attempt unauthorized access.
+
+3. **Policy Order:** Ensure the policies are applied in the correct sequence as shown in the interface image.
+![cf-network-policies](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-network-policies.png)
+
+## Enhancing Application Access Security Policy
+
+With all previous configurations in place, the tunnel is ready for use. The next crucial step is to enhance the security of the Access application, created earlier, to ensure robust protection. 
+
+While the existing `hello` application is secured with Azure AD authentication, it remains accessible from any device as long as users can log into Azure AD. This situation presents a security risk, as compromised user accounts could be exploited.
+
+- To increase security, we can restrict application access exclusively to corporate-compliant devices. This is achieved by updating the policy, as shown below:
+   ![cf-access-app-with-device-policy](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-access-app-with-device-policy.png)
+
+- Users attempting to access the application from non-compliant devices will receive a blocking message, as illustrated here:
+   ![cf-access-app-blocking-message](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-access-app-blocking-message.png)
+
+## Accessing Private Resources
+
+Accessing private network resources through WARP is a critical feature that I find extremely valuable. By configuring Cloudflare Tunnel, we can enable WARP devices to securely access private network ranges.
+
+1. **Configure Private Network Tunnel:**
+   To start, navigate to the Cloudflare Tunnel settings. Click "Edit" next to your tunnel, select the "Private Network" tab, and add the specific private IP ranges wish to be exposed. Refer to the screenshot below for guidance:
+    ![cf-tunnel-private-network-config](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-tunnel-private-network-config.png)
+
+2. **Switch WARP Network:**
+   On the WARP-enabled device, switch the network to `it-internal-net` to gain access to the designated internal resources.
+    ![cf-warp-network-switch](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-warp-network-switch.png)
+
+3. **SSH into DevOps Agent:**
+   With the WARP device configured, We can now establish an SSH connection to the DevOps virtual machine, as though direct local network.
+    ![cf-warp-ssh-devops](/assets/az-12-private-aks-enable-mdm-devices-cf-tunnel-warp/cf-warp-ssh-devops.png)
+
+> If you encounter any issues, ensure that your Azure firewall settings, CloudPC Security Group, and Cloudflare Tunnel network policies are properly configured to permit access to the DevOps subnet from the AKS subnet.
+
+## Conclusion
+
+In this final tutorial of our series on establishing a private AKS environment on Azure with Pulumi, we've successfully integrated Cloudflare Tunnel and WARP into our secure network infrastructure. By leveraging Cloudflare Tunnel and WARP, we've been able to strike a balance between enabling seamless developer access and upholding the integrity and security of our corporate network.
+
+The implementation of Cloudflare Tunnel and WARP has provided us with numerous benefits, including:
+
+* Granular web filtering and robust security measures enforced by Cloudflare Gateway
+* Zero Trust model for secure, private access to corporate applications
+* Enhanced security while minimizing friction for users
+* Simplified deployment and management of the WARP client application
+
+## Reference
+ 
+ - [Cloudflare Tunnel](https://developers.cloudflare.com/cloudflare-one/setup/)
+ - [The Cloudflare WARP client](https://developers.cloudflare.com/cloudflare-one/connections/connect-devices/warp/)
+ - [Download WARP](https://developers.cloudflare.com/cloudflare-one/connections/connect-devices/warp/download-warp/)
+
+## Thank You
+
+Thank you for taking the time to read this guide! We hope it has been helpful. Feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | _[GitHub](https://github.com/baoduy)_

dotnet-01-mvc-anti-forgery-token-and-machine-key.md

@@ -0,0 +1,144 @@
+---
+author: Steven Hoang
+pubDatetime: 2017-02-14T00:00:00Z
+title: "[.NET] Anti Forgery Token and Machine Key for MVC on IIS"
+postSlug: anti-forgery-token-and-machine-key-aspnet-mvc-iis
+featured: false
+draft: false
+tags:
+  - dotnet
+  - MVC
+  - web-farm
+  - iis
+ogImage: ""
+description:
+  The Medium post explains the importance of anti-forgery tokens and machine keys in web application security against CSRF attacks.
+  It provides implementation details for ASP.NET, including the use of AntiForgeryToken and configuring the machine key.
+  The post emphasizes the necessity of implementing both measures to enhance overall security.
+---
+
+If you're developing using ASP.NET MVC, it's highly likely that you've come across the concept of anti-forgery tokens.
+These tokens play a critical role in bolstering the security of our web applications and safeguarding them against Cross-Site Request Forgery (CSRF) attacks.
+
+In this attack vector, unauthorized commands are transmitted from a user that the website trusts.
+CSRF attacks exploit the trust that a site has for a user, and
+the anti-forgery token mitigates this by ensuring that the unauthorized commands do not execute.
+
+To leverage this security feature in your ASP.NET MVC application, two key steps are involved:
+
+1. Implement the `AntiForgeryToken` method directly within the form you wish to protect.
+   This method generates the token that will be validated upon form submission.
+
+```csharp
+@using (Html.BeginForm())
+{
+    @Html.AntiForgeryToken()
+    ....
+}
+```
+
+2. Adorn the corresponding action method in your controller with the ValidateAntiForgeryToken attribute.
+   This ensures that the ASP.NET MVC framework validates the token included in the request against the token stored in the form body.
+
+```csharp
+[HttpPost]
+[ValidateAntiForgeryToken]
+public ActionResult Create(FormCollection collection)
+{
+    ...
+}
+```
+
+## How does it work?
+
+When utilizing the `AntiForgeryToken` method within a form, ASP.NET generates an encrypted `AntiForgeryToken`.
+This token is placed into a hidden field and then transmitted to the client browser.
+Upon submitting the form back to the server, this token is decrypted and validated to confirm the authenticity of the request.
+Only upon successful validation will the targeted action method be executed.
+However, this validation occurs only if the action method is adorned with the `ValidateAntiForgeryTokenAttribute`.
+
+The generated token structure resembles:
+
+```html
+<form action="Create" method="post">
+  <input
+    name="__RequestVerificationToken"
+    type="hidden"
+    value="Kw1D9Co5OuHbp2TajfwB2xdR-lABEkjtwwMs0tLr9K8Y-dycbbRQU904HljeF4rBu0DnMpZpCtf1TrAoGmgnMxpeapzJtdR-P0BC3wuAc1-ZaHGSnYeEKoTa9fbMUOFx0"
+  />
+</form>
+```
+
+## What is the issue?
+
+While deploying your website in an environment comprising multiple load-balanced servers (aka a web farm),
+you may encounter the following issue when clicking the `submit` button:
+
+> The anti-forgery token could not be decrypted.
+> If this application is hosted by a Web Farm or cluster,
+> ensure that all machines are running the same version of ASP.NET Web Pages
+> and that the configuration specifies explicit encryption and validation keys.
+> AutoGenerate cannot be used in a cluster.
+
+## Why did this issue happen?
+
+Consider a setup where the environment consists of two servers performing load balancing as illustrated in the given diagram:
+![Request-Diagram.png](/assets/donet-mvc-anti-forgery-token-and-machine-key/Request-Diagram.png)
+
+In this setup, the ASP.NET application utilizes two unique keys (decryptionKey and validationKey) for token encryption/decryption and token validation.
+By default, these keys are randomly generated each time the website starts.
+
+In our diagram, we have two instances of the same website hosted on different servers forming a single web farm.
+When the website starts on both servers, two different sets of keys are independently generated for each instance.
+
+Let's say a user, denoted here as user A, sends a request that is redirected to server 1 by the load balancer.
+The website responds by providing a view along with an encrypted AntiForgeryToken.
+Later user A submits the form back to the load balancer, expecting the form to be processed by server 1.
+
+However, if the load balancer redirects the request to server 2, there’s a problem.
+The token encrypted by Server 1 cannot be decrypted on Server 2 as the decryptionKey on Server 2 differs from the one on Server 1.
+This mismatch of keys results in an error.
+
+To prevent such issues, ensure consistency in keys for every instance of the website inside a single web farm
+needs to use the same set of keys for token encryption/decryption and validation.
+
+However, when dealing with multiple websites hosted on the same server,
+these keys need to be unique for each website. Similarly, when the same website is hosted in multiple environments,
+the keys employed in each environment should be different.
+This is to maintain the secure and independent identity of each website and environment.
+
+## The solution for IIS
+
+The goal is to establish a mechanism to share a set of keys across multiple servers within a single farm.
+This will ensure successful encryption and decryption regardless of the server performing the task.
+
+For an AspNet MVC website hosted on IIS, a set of keys can be generated following these steps:
+
+1. Select the website on IIS.
+2. Double-click on "Machine Key."
+3. De-select all checkboxes, click on the "Generate" button on the right side, and then hit "Apply."
+
+![IIS-machine-key-settings](/assets/donet-mvc-anti-forgery-token-and-machine-key/IIS-machine-key.png)
+
+Once generated, the keys are saved in the "web.config" file of the website.
+You can distribute these keys to all website instances on all the servers in the farm as follows:
+
+1. Open the "web.config" file and locate the keys,
+2. Copy these keys and distribute them across all website instances within the farm.
+
+```xml
+<system.web>
+    <machineKey decryptionKey="13C9825F6B5ABB0622CF09B6C7F949F83D113B3CC2351438"
+                validationKey="DA39AFED706512A688EDD4FA5898FABF2D8A0D6897465093B1237C1D46E34F8E7B0E9A09FFE647CAC32DEFE9AFAEDDE6EFE8FF6CDE0BF27C883277BB3566BFA6" />
+ </system.web>
+```
+
+After accomplishing this, try submitting your website again. These measures should resolve the initial issue.
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*

dotnet-02-tool-for-azure-ad-to-adss-Users-writeback.md

@@ -0,0 +1,70 @@
+---
+author: Steven Hoang
+pubDatetime: 2021-10-13T00:00:00Z
+title: "[.NET] Small tool for Azure AD to AD User Write back"
+postSlug: azure-ad-to-adss-users-write-back
+featured: false
+draft: false
+tags:
+  - dotnet
+  - tools
+  - azureAD
+  - sync
+ogImage: ""
+description: Sharing a small tool-self developed to sync the users from AzureAD to on=premise Active Directory Service.
+---
+
+Azure AD Sync is an instrumental resource for forging a hybrid cloud model and facilitating password write-back.
+However, if your organization requires user write-back functionality, Azure AD Sync alone will not suffice.
+
+## Solution
+
+To address this need, I have developed a tool that implements user write-back functionality. With this self-contained tool, you can specify which users in which Azure groups should be written back and determine the Organizational Unit (OU) and AD group where users should be assigned.
+
+## Configuration
+
+1. Create an Application Registration (e.g., named 'azure-adds-user-write-back') with Microsoft Graph API permission set to `Group.Read.All` and `User.Read.All`.
+2. Update the information in `appsettings.json` as follows:
+
+```json
+{
+  "AzAdSync": {
+    "Authority": "https://login.microsoftonline.com/[TenantId]",
+    "ClientId": "[ClientId]",
+    "ClientSecret": "[ClientSecret]",
+    "AzureAdGroups": ["The Azure AD groups would like to write back"],
+    "AdOrgUnit": "The OU of ADDS for write-back users."
+  }
+}
+```
+
+## Tool Tech-stack
+
+This application is developed using the .NET Core framework.
+You can build the project as a Window-x64 single file, self-contained.
+After that, you will be able to copy and run it on any domain-joined computer without needing the .NET runtime.
+
+To install the app as a window service, run `sc.exe create "AADS Users WriteBack" binpath=[Path To]\Azure.ADDS.UserWriteBack.exe`.
+Ensure that the Logon account is updated with a Windows account with permission to create ADDS objects,
+and switch the start type to `Automatic`.
+
+> Please note that the log files will be writing to the `C:\Windows\System32\Logs folder.`
+
+The application will check and sync users from AzureAdGroups every 1 hour.
+Upon successful write-back of the user account to ADDS,
+the account owner must reset their password since the application generates a random password of 50 length characters.
+
+> This password is just a temporary password as it will be overwritten with the latest password once users changed their password in Azure AD by the password write-back of AD-AAD Sync.
+
+## Source Code
+
+The source code is accessible at this Github repository: https://github.com/baoduy/Azure.ADDS.UserWriteBack.
+Please adjust the steps and instructions to match your actual tool's requirements and behavior.
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*

dotnet-03-multi-platform-dockerfile.md

@@ -0,0 +1,413 @@
+---
+author: Steven Hoang
+pubDatetime: 2023-09-10T00:00:00Z
+title: "[.NET] Optimising .NET Core with Multi-Platform Docker Images: A Complete Guide"
+postSlug: dotnet-dockerfile-multi-platform
+featured: false
+draft: false
+tags:
+  - dotnet
+  - dockerfile
+  - multi-platform
+  - arm
+ogImage: ""
+description:
+  In this post, sharing about Docker optimisation for the .NET Core framework
+  and build a multi-platform image using the capabilities of Docker buildx,
+  enabling us to create multi-platform images that can seamlessly run on diverse architectures.
+  Moreover, we will discuss the integration of GitAction into the image-building process, empowering us to automate creating and publishing multi-platform Docker images.
+---
+
+## Built-in template
+
+Let's start with a simple API for a .NET application with Docker support.
+Once begun, a Dockerfile will automatically be generated for the project.
+
+Here's how a basic Dockerfile might look.
+
+```ps
+FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS base
+WORKDIR /app
+EXPOSE 80
+EXPOSE 443
+
+FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
+WORKDIR /src
+COPY ["SampleApi/SampleApi.csproj", "SampleApi/"]
+RUN dotnet restore "SampleApi/SampleApi.csproj"
+COPY . .
+WORKDIR "/src/SampleApi"
+RUN dotnet build "SampleApi.csproj" -c Release -o /app/build
+
+FROM build AS publish
+RUN dotnet publish "SampleApi.csproj" -c Release -o /app/publish /p:UseAppHost=false
+
+FROM base AS final
+WORKDIR /app
+COPY --from=publish /app/publish .
+ENTRYPOINT ["dotnet", "SampleApi.dll"]
+```
+
+Utilizing the provided Dockerfile, we can seamlessly build and execute the application in a Docker environment successfully.
+![sample-api.png](/assets/dotnet-multi-platform-dockerfile/sample-api.png)
+
+### What is the issue?
+
+The resulting image generated from the Dockerfile previously illustrated exceeds **215 MB** in size.
+Although this might not prove troublesome, when executing on systems abundant in storage capacity,
+it can lead to rapid depletion of SD card storage space on platforms with lower specifications or IOT devices,
+such as a Raspberry K3s cluster.
+
+Our next step involves optimizing this Dockerfile to minimize its footprint.
+
+## Dockerfile optimisation
+
+Let's proceed by transitioning the .NET image to the alpine image by adding `-alpine` at the end of the image version.
+
+Remarkably, the updated image size has contracted substantially to approximately **110 MB**,
+signifying a reduction of almost half from its original dimensions.
+
+```ps
+# 1. Changes this image from 'aspnet:7.0' to 'aspnet:7.0-alpine'
+FROM mcr.microsoft.com/dotnet/aspnet:7.0-alpine AS base
+WORKDIR /app
+EXPOSE 80
+EXPOSE 443
+
+# 2. Changes this image from 'sdk:7.0' to 'sdk:7.0-alpine'
+FROM mcr.microsoft.com/dotnet/sdk:7.0-alpine AS build
+WORKDIR /src
+COPY ["SampleApi/SampleApi.csproj", "SampleApi/"]
+RUN dotnet restore "SampleApi/SampleApi.csproj"
+COPY . .
+WORKDIR "/src/SampleApi"
+RUN dotnet build "SampleApi.csproj" -c Release -o /app/build
+
+FROM build AS publish
+RUN dotnet publish "SampleApi.csproj" -c Release -o /app/publish /p:UseAppHost=false
+
+FROM base AS final
+WORKDIR /app
+COPY --from=publish /app/publish .
+ENTRYPOINT ["dotnet", "SampleApi.dll"]
+```
+
+![alpine-debian-sdk-image-size.png](/assets/dotnet-multi-platform-dockerfile/alpine-debian-sdk-image-size.png)
+
+### With Self contained .NET app (**experimental**)
+
+Additionally, a feature is presented that enhances the "dotnet push" operation,
+enabling it to create self-contained, singular executable files and reduced library applications.
+
+This facilitates the construction of applications that are not reliant on the .NET runtime,
+as well as the removal of all unused methods present within the library,
+consequently yielding a more compact application.
+
+Let's evaluate the Dockerfile delineated below, _The comments have been added on top of all changed lines_.
+
+Please note that,
+the `PublishTrimmed` and `PublishSingleFile` are experimental feature and may not compatible with all applications.
+So verify the applications carefully before moving to the Production environment.
+
+```ps
+# 1. Changes this image from 'aspnet:7.0-alpine' to 'runtime-deps:7.0-alpine'
+FROM mcr.microsoft.com/dotnet/runtime-deps:7.0-alpine AS base
+WORKDIR /app
+EXPOSE 80
+EXPOSE 443
+
+FROM mcr.microsoft.com/dotnet/sdk:7.0-alpine AS build
+WORKDIR /src
+COPY ["SampleApi/SampleApi.csproj", "SampleApi/"]
+RUN dotnet restore "SampleApi/SampleApi.csproj"
+COPY . .
+WORKDIR "/src/SampleApi"
+RUN dotnet build "SampleApi.csproj" -c Release -o /app/build
+
+FROM build AS publish
+
+# 2. updated 'dotnet publish' options
+RUN dotnet publish "SampleApi.csproj" -c Release -o /app/publish \
+  --runtime alpine-x64 \
+  --self-contained true \
+  /p:PublishTrimmed=true \
+  /p:PublishSingleFile=true
+
+FROM base AS final
+WORKDIR /app
+COPY --from=publish /app/publish .
+
+# 3. updated the endpoint, the application path no need to mentiond the '.dll' anymore.
+ENTRYPOINT ["./SampleApi"]
+```
+
+Good news! Our application is impressively lean and only uses about **47MB**.
+That's pretty light, right? So, we can count on it to run smoothly even in low-specs environments.
+
+Nonetheless, it is prudently advisable to subject your application to a comprehensive compatibility test with the Alpine image,
+ensuring seamless real-world performance without compromising on any usage scenarios.
+
+### Docker Image without root user.
+
+In a production environment, it is recommended to restrict the utilization of root user privileges for the majority of applications.
+In the event that your application doesn't necessitate elevated permissions, you are advised to instantiate a non-root user during the Docker build process.
+
+I'd like to share a quick best practice tip with you to boost the security level of your images. Keep in mind, this might not necessarily decrease the image size, but it's an essential step nonetheless.
+
+Implementing this practice could potentially prevent any flags by our InfoSec's security scanning system during the vetting process for Production deployment. It's always better to be safe and secure as we progress!
+
+```ps
+FROM mcr.microsoft.com/dotnet/runtime-deps:7.0-alpine AS base
+WORKDIR /app
+EXPOSE 80
+EXPOSE 443
+
+FROM mcr.microsoft.com/dotnet/sdk:7.0-alpine AS build
+WORKDIR /src
+COPY ["SampleApi/SampleApi.csproj", "SampleApi/"]
+RUN dotnet restore "SampleApi/SampleApi.csproj"
+COPY . .
+WORKDIR "/src/SampleApi"
+RUN dotnet build "SampleApi.csproj" -c Release -o /app/build
+
+FROM build AS publish
+RUN dotnet publish "SampleApi.csproj" -c Release -o /app/publish \
+  --runtime alpine-x64 \
+  --self-contained true \
+  /p:PublishTrimmed=true \
+  /p:PublishSingleFile=true
+
+FROM base AS final
+
+# 1. Create a new user and change directory ownership
+RUN adduser --disabled-password \
+  --home /app \
+  --gecos '' dotnetuser && chown -R dotnetuser /app
+
+# 2. Impersonate into the new user
+USER dotnetuser
+WORKDIR /app
+
+COPY --from=publish /app/publish .
+ENTRYPOINT ["./SampleApi"]
+```
+
+## Multi-platform docker image.
+
+Even after performing the aforementioned steps, the Docker image remains built for the x64 platform.
+To add support for the Docker on an ARM processor, it is essential to revise your Docker image and leverage the "docker buildx" feature for cross-compatibility.
+Consider the changes of the following Dockerfile for reference.
+
+```ps
+FROM mcr.microsoft.com/dotnet/runtime-deps:7.0-alpine AS base
+WORKDIR /app
+EXPOSE 80
+EXPOSE 443
+
+# 1. Add 2 (BUILDPLATFORM and TARGETARCH) arguments and add 'platform' parameter to the FROM statement.
+FROM --platform=$BUILDPLATFORM mcr.microsoft.com/dotnet/sdk:7.0-alpine AS build
+ARG TARGETARCH
+ARG BUILDPLATFORM
+
+WORKDIR /src
+COPY ["SampleApi/SampleApi.csproj", "SampleApi/"]
+RUN dotnet restore "SampleApi/SampleApi.csproj"
+COPY . .
+WORKDIR "/src/SampleApi"
+
+# 2. add '-a $TARGETARCH' to the 'dotnet build' command.
+RUN dotnet build "SampleApi.csproj" -c Release -o /app/build -a $TARGETARCH
+
+FROM build AS publish
+
+# 2. add '-a $TARGETARCH' to the 'dotnet publish' command.
+RUN dotnet publish "SampleApi.csproj" -c Release -o /app/publish \
+    #--runtime alpine-x64 \
+    --self-contained true \
+    /p:PublishTrimmed=true \
+    /p:PublishSingleFile=true \
+    -a $TARGETARCH
+
+# 3. Add 2 (BUILDPLATFORM and TARGETARCH) arguments and add 'platform' parameter to the FROM statement.
+FROM --platform=$BUILDPLATFORM base AS final
+ARG TARGETARCH
+ARG BUILDPLATFORM
+
+RUN adduser --disabled-password \
+  --home /app \
+  --gecos '' dotnetuser && chown -R dotnetuser /app
+
+USER dotnetuser
+WORKDIR /app
+
+COPY --from=publish /app/publish .
+ENTRYPOINT ["./SampleApi"]
+```
+
+This is the command to construct a multi-platform compatible image.
+
+```bash
+# Build Docker for x64 processor
+docker build --platform="linux/amd64" -f Dockerfile -t sampleapi-x64:latest .
+
+# Build image for arm64 processor
+docker build --platform="linux/arm64" -f Dockerfile -t sampleapi-arm64:latest .
+
+# All together, build image for multi-platform with docker buildx
+docker buildx build --platform="linux/amd64,linux/arm64" -f Dockerfile -t sampleapi:latest .
+```
+
+Here are some sample results of Docker images on my Intel workstation.
+![multi-platform-docker-image.png](/assets/dotnet-multi-platform-dockerfile/multi-platform-docker-image.png)
+
+Test to ensure both images work correctly without any issues on my workstation.
+![Running-instance-docker.png](/assets/dotnet-multi-platform-dockerfile/Running-instance-docker.png)
+
+## Altogether with GitAction.
+
+We have successfully established a Dockerfile that facilitates multi-platform support for .NET 7.
+In coordination with GitHub Actions, this allows us to construct and propel the respective image to a container registry
+Docker Hub being our prime focus in this situation.
+
+Prior to engaging with the GitHub Action setup, I want to highlight a valuable feature known as **[Reusing workflows](https://docs.github.com/en/actions/using-workflows/reusing-workflows)**.
+This sophisticated feature grants us the capability to outline a build workflow, which can be employed repetitively across multiple projects down the line.
+
+To provide an illustrative example, please consider the undermentioned workflow located at **[.github/workflows/docker-publish.yaml](https://github.com/baoduy/ShareWorkflows/blob/main/.github/workflows/docker-publish.yaml)** within the **[ShareWorkflows](https://github.com/baoduy/ShareWorkflows)** repository.
+This workflow effectively develops a Dockerfile for multi-platform usage and subsequently propels the images to Docker Hub.
+
+```yaml
+name: Docker-Publish
+
+on:
+  workflow_call:
+    inputs:
+      # The location of the Dockerfile parameter.
+      dockerFile:
+        required: true
+        type: string
+        description: The location of the Dockerfile.
+
+      # The context path of the project parameter.
+      context:
+        default: .
+        type: string
+        description: The context path of the project.
+
+      # The docker platforms parameter with default value is "linux/arm64 and linux/amd64"
+      platforms:
+        default: linux/arm64,linux/amd64
+        type: string
+        description: The docker platforms parameter with default value is "linux/arm64 and linux/amd64".
+
+      # The name of the docker image parameter.
+      imageName:
+        required: true
+        type: string
+        description: The name of the docker image.
+
+      # The version parameter of the image with default value is current date-time.
+      version:
+        default: $(date +%s)
+        type: string
+        description: The version of the image with default value is current date-time.
+    secrets:
+      # The DOCKER_USERNAME secret parameter.
+      DOCKER_USERNAME:
+        required: true
+        description: The docker hub user name.
+      # The DOCKER_TOKEN secret parameter.
+      DOCKER_TOKEN:
+        required: true
+        description: The docker hub PAT token.
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      # Setup Buildx
+      - name: Docker Setup Buildx
+        uses: docker/setup-buildx-action@v2.9.1
+        with:
+          platforms: ${{ inputs.platforms }}
+
+      # Login to docker hub
+      - name: Docker Login
+        uses: docker/login-action@v2.0.0
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+          ecr: auto
+          logout: true
+
+      # Pull the previous image from docker hub to use it as cache to improve the image build time.
+      - name: docker pull cache image
+        continue-on-error: true
+        run: docker pull ${{ inputs.imageName }}:latest
+
+      # Setup QEMU
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+
+      # Build and Publish to Docker
+      - name: Build the Docker image
+        run: |
+          docker buildx build ${{ inputs.context }} --file ${{ inputs.dockerFile }} \
+            --tag ${{ inputs.imageName }}:${{ inputs.version }} \
+            --tag ${{ inputs.imageName }}:latest \
+            --cache-from=${{ inputs.imageName }}:latest \
+            --push --platform=${{ inputs.platforms }}
+```
+
+### How to reuse the Git workflows
+
+I've pushed my SampleAPI to my GitHub. You can find it in the **[HBD.Samples](https://github.com/baoduy/HBD.Samples)** repository.
+Following with the SampleAPI of GitAction that calls the shared workflow, making sure to give it the right parameters.
+
+_Remember, before you get this action running, it's important to first update the workflow location according to your Git repository
+and add your **DOCKER_USERNAME** and **DOCKER_TOKEN** into your repository's secrets._
+
+```yaml
+name: Docker-Buildx
+
+on:
+  push:
+    branches:
+      - "main"
+
+jobs:
+  dotnet_release_job:
+    # TODO: Update this path according to your git repository.
+    uses: baoduy/ShareWorkflows/.github/workflows/docker-publish.yaml@main
+    with:
+      # The location of the Dockerfile parameter.
+      dockerFile: "01_Multi_platform_docker_image_for_NET/SampleApi/Dockerfile"
+      # The context path of the project parameter.
+      context: '"./01_Multi_platform_docker_image_for_NET"'
+      # The name of the docker image parameter.
+      imageName: "baoduy2412/sample-01-api"
+      # The docker platforms parameter.
+      platforms: linux/arm64,linux/amd64
+    secrets:
+      # The DOCKER_USERNAME secret parameter.
+      DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
+      # The DOCKER_TOKEN secret parameter.
+      DOCKER_TOKEN: ${{ secrets.DOCKER_TOKEN }}
+```
+
+Woohoo! Once the Git action has been executed successfully, we can hop over to Docker Hub to see the image neatly tagged across multiple platforms.
+
+![Image_on_Docker_Hub.png](/assets/dotnet-multi-platform-dockerfile/Docker-hub-results.png)
+
+_To ensure that everything's working as it should,
+both images were put to the test on my iMac (which has an Intel chip) and a K3s Raspberry Pi 4 cluster._
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*

dotnet-04-aspire-local-env-tests.md

@@ -0,0 +1,552 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-08-22T12:00:00Z
+title: "[.NET] Aspire, Simplifying Local Development Environment and Testing."
+postSlug: dotnet-04-aspire-local-env-and-testing
+featured: true
+draft: false
+tags:
+  - dotnet
+  - aspire
+  - local-env
+description: "Setting up a new project can be challenging, especially with the involvement of various technologies. This guide explores how .NET Aspire simplifies development by streamlining local environment setup, testing, and continuous integration, while also detailing the end-to-end process with an Azure DevOps CI/CD pipeline."
+---
+
+Starting a new project is both exciting and challenging, especially when it comes to configuring the development environment. Many projects require a mix of technologies, which can lead to time-consuming setup and potential errors. **.NET Aspire** simplifies this process by offering a framework that helps developers set up a consistent and efficient environment across various projects.
+
+With .NET Aspire, We can create a ready-to-run local environment that integrates seamlessly with Docker, allowing the development team to focus on coding without worrying about complex setup requirements. It supports smooth integration with containers, making it easier to handle dependencies and ensuring that our local environment closely mirrors the development/staging environment setup.
+
+In addition to simplifying environment setup, this guide walks us through writing robust integration tests. These tests ensure all components work well together and catch potential issues early in the development process. We'll also learn how to incorporate these tests into a continuous integration (CI) pipeline, ensuring the code is consistently validated and error-free before it reaches production.
+
+## Why .NET Aspire?
+
+**.NET Aspire** is designed to improve the experience of building .NET cloud-native applications. It provides a consistent, opinionated set of tools and patterns that help to build and run distributed apps. .NET Aspire assists with:
+
+- **Orchestration**: Features for running and connecting multi-project applications and their dependencies in local development environments.
+- **Integrations**: NuGet packages for commonly used services, such as Redis or PostgreSQL, with standardized interfaces ensuring they connect consistently and seamlessly with the app.
+- **Tooling**: Project templates and tooling experiences for Visual Studio, Visual Studio Code, and the `dotnet` CLI to help to create and interact with .NET Aspire projects.
+
+---
+
+## Table of Contents
+
+1. [Why .NET Aspire?](#why-net-aspire)
+2. [Setting Up the Local Environment](#setting-up-the-local-environment)
+3. [Hosting with Aspire](#hosting-with-aspire)
+4. [.NET Aspire for Testing](#net-aspire-for-testing)
+5. [Running Tests on Azure DevOps](#running-tests-on-azure-devops)
+6. [Conclusion](#conclusion)
+
+---
+
+## Setting Up the Local Environment
+
+Let's start by creating a simple API project and hosting it with .NET Aspire.
+
+### Prerequisites
+
+- **.NET 8 SDK** or later
+- **Docker Desktop** installed and running
+- **Aspire workload** installed: Install the Aspire workload using the following command:
+
+  ```bash
+  dotnet workload install aspire
+  ```
+
+### Creating an API Project
+
+Assuming we already have a simple API that utilizes the following technologies:
+
+- **MediatR**: A library used to implement the command and response pattern at the API level. It helps decouple request handling logic from controllers, making the code more modular and easier to maintain.
+- **Entity Framework Core (EF Core)**: An Object-Relational Mapper (ORM) used to manage database access.
+- **PostgreSQL**: Used as the database to store and manage the application's data.
+
+This API has the following endpoints, as displayed in the Swagger UI:
+
+![Api](/assets/dotnet-04-aspire-local-env-tests/api.png)
+
+### Aspire Templates Explanation
+
+Aspire provides several project templates to help to get started quickly with different aspects of application development and testing:
+
+- **App Host**: The primary template for creating an Aspire hosting project. It sets up the necessary infrastructure to host the application and its dependencies.
+- **Service Defaults**: Configures essential services for the application, such as `OpenTelemetry` for distributed tracing, `DefaultHealthChecks` for monitoring service health, and `RequestTimeouts` to manage request durations. While optional, it's highly recommended for applications hosted on Aspire to ensure robust monitoring and orchestration management.
+- **Test Project (MSTest)**: Sets up a project for unit testing using the MSTest framework.
+- **Test Project (NUnit)**: Sets up a project for unit testing using the NUnit framework.
+- **Test Project (xUnit)**: Sets up a project for unit testing using the xUnit framework.
+
+![AspireTemplates](/assets/dotnet-04-aspire-local-env-tests/AspireTemplates.png)
+
+---
+
+## Hosting with Aspire
+
+To host the API above with its dependencies with Aspire, follow these steps:
+
+### Create `Aspire.Host`
+
+First, create a new project named `Aspire.Host` using the App Host template provided by .NET Aspire.
+
+### Add PostgreSQL Support
+
+Next, install the Aspire PostgreSQL hosting package to add PostgreSQL support to this project.
+
+```bash
+dotnet add package Aspire.Hosting.PostgreSQL
+```
+
+> **Note**: Refer to the [.NET Aspire GitHub repository](https://github.com/dotnet/aspire) for a full list of hosting components supported by Aspire.
+
+### Aspire Host with `Config as Code`
+
+Open `Program.cs` in the `Aspire.Host` project and configure the `DistributedApplication` as shown:
+
+```csharp
+var builder = DistributedApplication.CreateBuilder(args);
+
+// Database
+var postgres = builder.AddPostgres("postgres").PublishAsConnectionString();
+var db = postgres.AddDatabase("Db");
+
+// Internal API
+builder.AddProject<Projects.Api>("api")
+    .WithReference(db);
+
+builder.Build().Run();
+```
+
+**Explanation**:
+
+- **AddPostgres("postgres")**: Adds a PostgreSQL service.
+- **PublishAsConnectionString()**: Makes the connection string available to other services.
+- **AddDatabase("Db")**: Sets up a database named "Db".
+- **AddProject**: Includes the API project in the Aspire host configuration.
+- **WithReference(db)**: Links the API project to the database.
+
+### EF Core Database Migration
+
+Automating database migrations is important when using EF Core to ensure consistency across environments. While we won't discuss the details here, you can refer to the [EF Core Migrations guide](https://learn.microsoft.com/en-us/dotnet/aspire/database/ef-core-migrations) compatible with .NET Aspire.
+
+### Aspire Host Dashboard
+
+Run the `Aspire.Host` project. The dashboard will display all running components.
+
+![Dashboard](/assets/dotnet-04-aspire-local-env-tests/AspireDashboard.png)
+
+---
+
+## .NET Aspire for Testing
+
+Integration tests ensure that different parts of the application work together correctly. However, writing and running them on CI/CD pipelines can be challenging and time-consuming. .NET Aspire simplifies this process by handling much of the setup for us.
+
+### Create `Aspire.Tests`
+
+Create a new test project named `Aspire.Tests` using the Test Project (xUnit) template provided by .NET Aspire. This template sets up the necessary scaffolding for integration tests using xUnit.
+
+### Add Reference to `Aspire.Host`
+
+Instead of installing the same NuGet package dependencies in `Aspire.Tests`, add a project reference to `Aspire.Host`. This allows the test project to leverage the configurations and services defined in the host project.
+
+Here is a reference graph:
+
+![ProjectDependency](/assets/dotnet-04-aspire-local-env-tests/ProjectDependency.png)
+
+### ApiFixture Class
+
+The `ApiFixture` class sets up the necessary environment for integration tests. It extends `WebApplicationFactory<Api.Program>` and implements `IAsyncLifetime` to manage the lifecycle of the test environment.
+
+```csharp
+public sealed class ApiFixture : WebApplicationFactory<Api.Program>, IAsyncLifetime
+{
+    private readonly IHost _app;
+    private readonly IResceBuilder<PostgresServerResce> _postgres;
+    private string? _postgresConnectionString;
+
+    /**
+     * Constructor for ApiFixture.
+     * Initializes the DistributedApplicationOptions and sets up the PostgreSQL server resce.
+     */
+    public ApiFixture()
+    {
+        var options = new DistributedApplicationOptions
+        {
+            AssemblyName = typeof(ApiFixture).Assembly.FullName,
+            DisableDashboard = true
+        };
+        var builder = DistributedApplication.CreateBuilder(options);
+
+        _postgres = builder.AddPostgres("postgres").PublishAsConnectionString();
+        _app = builder.Build();
+    }
+
+    /**
+     * Creates and configures the host for the application.
+     * Adds the PostgreSQL connection string to the host configuration.
+     * Ensures the database is created before returning the host.
+     *
+     * @param builder The IHostBuilder instance.
+     * @return The configured IHost instance.
+     */
+    protected override IHost CreateHost(IHostBuilder builder)
+    {
+        builder.ConfigureHostConfiguration(config =>
+        {
+            config.AddInMemoryCollection(new Dictionary<string, string?>
+            {
+                { "ConnectionStrings:Db", _postgresConnectionString },
+            }!);
+        });
+
+        //TODO: add logic for db migration and seeding data here.
+        var host = base.CreateHost(builder);
+        host.EnsureDbCreated().GetAwaiter().GetResult();
+        return host;
+    }
+
+    /**
+     * Disposes the resces used by the fixture asynchronously.
+     * Stops the application host and disposes of it.
+     */
+    public new async Task DisposeAsync()
+    {
+        await base.DisposeAsync();
+        await _app.StopAsync();
+        if (_app is IAsyncDisposable asyncDisposable)
+        {
+            await asyncDisposable.DisposeAsync().ConfigureAwait(false);
+        }
+        else
+        {
+            _app.Dispose();
+        }
+    }
+
+    /**
+     * Initializes the fixture asynchronously.
+     * Starts the application host and waits for the PostgreSQL resce to be in the running state.
+     * Retrieves the PostgreSQL connection string.
+     */
+    public async Task InitializeAsync()
+    {
+        var resceNotificationService = _app.Services.GetRequiredService<ResceNotificationService>();
+        await _app.StartAsync();
+
+        await resceNotificationService.WaitForResceAsync(_postgres.Resce.Name, KnownResceStates.Running);
+        _postgresConnectionString = await _postgres.Resce.GetConnectionStringAsync();
+    }
+}
+```
+
+**Explanation**:
+
+The `ApiFixture` class is responsible for:
+
+- Setting up a PostgreSQL server resource.
+- Configuring the host with the necessary connection strings.
+- Ensuring the database is created and testing data prepared before tests run.
+- Starting and stopping the application host.
+- Cleaning up resources after tests are completed.
+
+### Test Cases Class
+
+The `ProductEndpointsTests` class contains integration tests for the product endpoints of the API. It uses the `ApiFixture` to set up the test environment and `HttpClient` to make requests to the API.
+
+```csharp
+public class ProductEndpointsTests(ApiFixture fixture, ITestOutputHelper output) : IClassFixture<ApiFixture>
+{
+    private readonly HttpClient _client = fixture.CreateClient();
+
+    /**
+     * Tests the creation of a product.
+     * Ensures that the product is created successfully and returns a valid product ID.
+     */
+    [Fact]
+    public async Task CreateProduct_ReturnsCreatedProduct()
+    {
+        // Arrange
+        var command = new CreateProduct.Command { Name = "Test Product", Price = 10.99m };
+        // Act
+        var response = await _client.PostAsJsonAsync("/products", command);
+
+        // Assert
+        response.EnsureSuccessStatusCode();
+        var productId = await response.Content.ReadFromJsonAsync<int>();
+        Assert.True(productId > 0);
+    }
+
+    /**
+     * Tests the retrieval of a product.
+     * Ensures that the product is retrieved successfully and matches the expected values.
+     */
+    [Fact]
+    public async Task GetProduct_ReturnsProduct()
+    {
+        // Arrange
+        var command = new CreateProduct.Command { Name = "Test Product", Price = 10.99m };
+        var createResponse = await _client.PostAsJsonAsync("/products", command);
+        var productId = await createResponse.Content.ReadFromJsonAsync<int>();
+
+        // Act
+        var response = await _client.GetAsync($"/products/{productId}");
+
+        // Assert
+        response.EnsureSuccessStatusCode();
+        var product = await response.Content.ReadFromJsonAsync<Product>();
+        Assert.NotNull(product);
+        Assert.Equal("Test Product", product.Name);
+        Assert.Equal(10.99m, product.Price);
+    }
+
+    /**
+     * Tests the update of a product.
+     * Ensures that the product is updated successfully and returns a NoContent status.
+     */
+    [Fact]
+    public async Task UpdateProduct_ReturnsNoContent()
+    {
+        // Arrange
+        var command = new CreateProduct.Command { Name = "Test Product", Price = 10.99m };
+        var createResponse = await _client.PostAsJsonAsync("/products", command);
+        var productId = await createResponse.Content.ReadFromJsonAsync<int>();
+
+        var updateCommand = new UpdateProduct.Command { Id = productId, Name = "Updated Product", Price = 20.99m };
+
+        // Act
+        var response = await _client.PutAsJsonAsync($"/products/{productId}", updateCommand);
+
+        // Assert
+        response.EnsureSuccessStatusCode();
+        Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
+    }
+
+    /**
+     * Tests the deletion of a product.
+     * Ensures that the product is deleted successfully and returns a NoContent status.
+     */
+    [Fact]
+    public async Task DeleteProduct_ReturnsNoContent()
+    {
+        // Arrange
+        var command = new CreateProduct.Command { Name = "Test Product", Price = 10.99m };
+        var createResponse = await _client.PostAsJsonAsync("/products", command);
+        var productId = await createResponse.Content.ReadFromJsonAsync<int>();
+
+        // Act
+        var response = await _client.DeleteAsync($"/products/{productId}");
+
+        // Assert
+        response.EnsureSuccessStatusCode();
+        Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
+    }
+}
+```
+
+**Explanation**:
+
+The `ProductEndpointsTests` class is responsible for testing the CRUD of the product endpoints. It ensures that:
+
+- **Creating a product** works correctly and returns a valid product ID.
+- **Retrieving a product** returns the expected product details.
+- **Updating a product** successfully applies the changes and returns the appropriate status.
+- **Deleting a product** removes it from the database and returns the correct status code.
+
+> **Note:** Postgres connection issues may arise when running multiple sets of test cases in parallel. In such cases, instead of using `IClassFixture<>`, consider using [`IAssemblyFixture`](https://github.com/JDCain/Xunit.Extensions.AssemblyFixture). This approach ensures that only a single instance of `DistributedApplication` is created for the entire test suite.
+
+### Testing Results
+
+Here are the reports on Azure DevOps after the pipeline ran successfully.
+
+- **Test Case Results**:
+
+  The test case results show the outcome of each executed test.
+
+  ![TestCasesResults](/assets/dotnet-04-aspire-local-env-tests/TestCasesResults.png)
+
+- **Coverage Results**:
+
+  Code coverage results provide insights into how much of the codebase is being tested.
+
+  ![TestCoverageResults](/assets/dotnet-04-aspire-local-env-tests/TestCoverageResults.png)
+
+---
+
+## Running Tests on Azure DevOps
+
+### Configuring the Pipeline
+
+To automate testing and code coverage collection, let's set up a continuous integration (CI) pipeline using Azure DevOps.
+
+In the Azure DevOps project, create a new pipeline that builds the code, runs tests, and collects code coverage data.
+
+Here is an example of what our `azure-pipelines.yml` file might look like.
+
+```yaml
+trigger:
+  - main
+
+resources:
+  - repo: self
+
+variables:
+  BuildConfiguration: Release
+  RestoreBuildProjects: "**/*.csproj"
+  TestProjects: "**/*[Tt]ests/*.csproj"
+
+  # Agent VM image name
+  vmImageName: "ubuntu-latest"
+
+stages:
+  - stage: Build
+    displayName: Build and Test Stage
+    jobs:
+      - job: Build
+        displayName: Build
+        pool:
+          vmImage: $(vmImageName)
+        steps:
+          # Use the correct .NET SDK version
+          - task: UseDotNet@2
+            displayName: "Use .NET SDK 8.x"
+            inputs:
+              packageType: "sdk"
+              version: "8.x"
+
+          # Install the necessary .NET workload
+          - task: Bash@3
+            displayName: "Install Aspire Workload"
+            inputs:
+              targetType: "inline"
+              script: "dotnet workload install aspire"
+
+          # Build the project
+          - task: DotNetCoreCLI@2
+            displayName: "Build Project"
+            inputs:
+              command: "build"
+              projects: $(RestoreBuildProjects)
+              arguments: -c $(BuildConfiguration)
+
+          # Run tests and collect code coverage
+          - task: DotNetCoreCLI@2
+            displayName: "Run Tests and Collect Coverage"
+            inputs:
+              command: "test"
+              projects: "$(TestProjects)"
+              arguments: '--configuration $(BuildConfiguration) --collect "Code Coverage"'
+```
+
+**Explanation**:
+
+- **UseDotNet@2**: Ensures that the correct .NET SDK is installed on the build agent.
+- **Install Aspire Workload**: Installs the Aspire workload needed for the project.
+- **Build Projects**: Builds all the projects specified by the `RestoreBuildProjects` variable.
+- **Run Tests and Collect Code Coverage**: Executes the tests in the projects specified by the `TestProjects` variable and collects code coverage data.
+
+_Note_: Ensure that the YAML file includes the `UseDotNet@2` task to specify the required .NET SDK version.
+
+### Running the Pipeline
+
+Save the pipeline configuration and run it. Monitor the build process to ensure all steps complete successfully.
+
+After the pipeline completes, the test results and code coverage reports should be appeared in Azure DevOps.
+
+1. **Test Results**:
+
+   Displays which tests passed or failed.
+
+   ![devops-test-results](/assets/dotnet-04-aspire-local-env-tests/az-devops-no-filter-test-results.png)
+
+2. **Code Coverage**:
+
+   Provides detailed information about which parts of the code were tested.
+
+   ![devops-test-coverage](/assets/dotnet-04-aspire-local-env-tests/az-devops-no-filter-test-coverage.png)
+
+> **Note**: The initial code coverage might be lower than expected. For example, you might see an overall coverage of 23.89%, even though the API component itself has 88.14% coverage. This discrepancy occurs because the coverage report includes all libraries, those not part of the API project.
+
+### Improving Code Coverage Reports
+
+To generate a more meaningful code coverage report, We can configure it to include only the relevant components of the project.
+
+1. **Creating the Coverage Filtering File**:
+
+   Create a file named `coverage.runsettings` in the project root with the appropriate configuration.
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<RunSettings>
+  <DataCollectionRunSettings>
+    <DataCollectors>
+      <DataCollector friendlyName="XPlat Code Coverage">
+        <Configuration>
+          <Include>
+            [Api*]*
+          </Include>
+          <Exclude>
+          </Exclude>
+        </Configuration>
+      </DataCollector>
+    </DataCollectors>
+  </DataCollectionRunSettings>
+</RunSettings>
+```
+
+**Explanation**:
+
+- The `<Include>` section specifies which assemblies to include in the code coverage report. In this case, `[Api*]*` includes all assemblies starting with "Api".
+- The `<Exclude>` section can be used to exclude specific assemblies or classes.
+
+2. **Updating the Pipeline Configuration**:
+
+   Modify the `azure-pipelines.yml` file to use the `coverage.runsettings` file and publish the code coverage results.
+
+```yaml
+# ... previous configuration ...
+
+# Run tests with coverage filtering
+- task: DotNetCoreCLI@2
+  displayName: "Test with Coverage Filtering"
+  inputs:
+    command: "test"
+    projects: "$(TestProjects)"
+    arguments: '--configuration $(BuildConfiguration) --settings coverage.runsettings --collect "XPlat Code Coverage"'
+
+# Publish the code coverage results to Azure DevOps
+- task: PublishCodeCoverageResults@2
+  inputs:
+    summaryFileLocation: "$(Agent.TempDirectory)/**/coverage.cobertura.xml"
+```
+
+**Explanation**:
+
+- **Run Tests with Coverage Filtering**: Executes tests using the `coverage.runsettings` file to filter the code coverage data.
+- **Publish Code Coverage Results**: Publishes the code coverage results to Azure DevOps for easy visualization.
+
+3. **Enhanced Coverage Report**:
+
+   After running the updated pipeline, We should see an improved code coverage report that focuses on the relevant parts of the project. The coverage results will now provide detailed insights at the class level using the XPlat format.
+
+![devops-test-coverage-with-filter](/assets/dotnet-04-aspire-local-env-tests/az-devops-with-filter-test-coverage.png)
+
+---
+
+## Conclusion
+
+By utilizing .NET Aspire and Docker, we can create a consistent, isolated environment that streamlines not just Entity Framework integration testing but the entire development lifecycle. .NET Aspire offers a flexible to `config as code` and sharing `ready-to-run` environment to all the development teams.
+
+---
+
+## References
+
+- [Sample Code From DrunkCode](https://github.com/baoduy/sample-aspire-dotnet-unittests)
+- [.NET Aspire Documentation](https://learn.microsoft.com/en-us/dotnet/aspire/get-started/aspire-overview)
+- [EfCore Migration in .NET Aspire](https://learn.microsoft.com/en-us/dotnet/aspire/database/ef-core-migrations)
+
+---
+
+## Thank You
+
+Thank for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven**
+[GitHub](https://github.com/baoduy)

ks-00-series-k8s-setup-local-env-pi-cluster.md

@@ -0,0 +1,72 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-09-25T12:00:00Z
+title: "[K8s] A Complete Series of Articles on Kubernetes Environment Locally"
+featured: true
+draft: false
+tags:
+  - k3s
+  - kubernetes
+  - picluster
+description: "A concise series guiding you through setting up a local Kubernetes environment using K3s on Raspberry Pi 4 clusters. Learn how to install K3s, configure Nginx Ingress, implement SSL certificates with Cert-Manager and Cloudflare, and host applications like Outline VPN and Longhorn."
+---
+
+## Introduction
+
+Welcome to our complete series of articles on building a local Kubernetes environment using K3s on Raspberry Pi 4 clusters. This series is designed to provide us with step-by-step guidance through practical examples.
+
+We'll start by installing K3s, a lightweight version of Kubernetes that's perfect for devices like the Raspberry Pi. Then, we'll set up Nginx Ingress to manage network traffic and explore two ways to implement SSL certificates: using Cert-Manager and leveraging Cloudflare for a simpler approach.
+
+Additionally, we'll learn how to expose our services to the internet without a static IP by using Cloudflare Tunnel. We'll also host applications like Outline VPN for secure connections and Longhorn for reliable, cloud-native storage solutions.
+
+By the end of this series, we'll have a fully functional Kubernetes environment capable of running and managing complex applications, all from our local setup. Let's dive in and start this exciting journey together!
+
+---
+
+## Series of Articles
+
+### [Day 01: Step-By-Step Guide: Installing K3s on a Raspberry Pi 4 Cluster](/posts/ks-01-install-k3s-on-pi-cluster/)
+
+In this guide, sharing some useful tips to help you seamlessly install K3s on a Raspberry Pi 4 cluster.
+Let's dive in and start the installation process.
+
+### [Day 02: Step-By-Step Guide: Installing Nginx Ingress on K3s Pi 4 Cluster](/posts/ks-02-install-nginx-on-pi-cluster/)
+
+This guide provides helpful tips for installing the Nginx Ingress on a K3s Raspberry Pi 4 cluster.
+Detailed and step-by-step instructions will ensure a seamless installation process. Let's get started!
+
+### [Day 03: Step-By-Step Guide: Installation of Cert-Manager, Implementing Free SSL Certificates for Kubernetes Clusters](/posts/ks-03-install-cert-manager-free-ssl-kubernetes-cluster)
+
+This comprehensive guide will help you to smoothly install Cert-Manager and implement free SSL certificates for Kubernetes clusters.
+It is designed with step-by-step instructions to facilitate a seamless installation process. Dive in and let's begin this journey for enhanced security!
+
+### [Day 04: Step-By-Step Guide: Cert-Manager Alternative with Cloudflare, Implementing Free SSL Certificates for Kubernetes Clusters](/posts/ks-04-cert-manager-alternative-with-cloudflare)
+
+We explore the concept of using a Cert-Manager Alternative with Cloudflare to implement free SSL Certificates for Kubernetes clusters.
+This strategy leverages Cloudflare SSL certificates conjunction with the Kubernetes setup to provide a secure environment, replacing the need of Cert-Manager.
+Discover how this approach simplifies the process, and enhances the security of our Kubernetes clusters.
+
+### [Day 05: Step-By-Step Guide: Nginx Alternative with Cloudflare Tunnel, Enables services to internet a public static IP address](/posts/ks-05-public-services-with-cloudflare-tunnel)
+
+This robust solution provides a feasible alternative to Nginx when there's no public static IP address or port forwarding required.
+This guide walks us through the process step by step, enabling the services online more efficiently.
+
+### [Day 06: Step-By-Step Guide: Hosting Outline VPN on Kubernetes](/posts/ks-06-hosting-outline-vpn-kubernetes)
+
+Outline VPN, a comprehensive server and client software tool, is a free and open-source system developed by Google.
+In this article, we will delve into the process of hosting Outline VPN on Kubernetes and outlining the steps to expose connection ports via NGINX.
+
+### [Day 07: Step-By-Step Guide: Hosting Longhorn on K3s (ARM)](/posts/ks-07-hosting-longhorn-on-kubernetes)
+
+In this article, we will explore how to deploy Longhorn, a cloud-native distributed block storage system designed for Kubernetes on our K3s (ARM).
+Longhorn is known for its lightweight, reliable, and open-source nature, which simplifies the process of adding persistent storage to Kubernetes clusters, making it easier to run stateful applications.
+
+### [Day 08: To be continue...](/posts/ks-00-series-k8s-setup-local-env-pi-cluster)
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*

ks-01-Install-k3s-on-pi-cluster.md

@@ -0,0 +1,172 @@
+---
+author: Steven Hoang
+pubDatetime: 2023-09-15T00:00:00Z
+title: "[k8s] Step-By-Step Guide: Installing K3s on a Raspberry Pi 4 Cluster"
+featured: false
+draft: false
+tags:
+  - k3s
+  - kubernetes
+  - picluster
+ogImage: ""
+description:
+  In this guide, sharing some useful tips to help you seamlessly install K3s on a Raspberry Pi 4 cluster.
+  Let's dive in and start the installation process.
+---
+
+In this guide, share some useful tips to help you seamlessly install K3s on a Raspberry Pi 4 cluster.
+Let's dive in and start the installation process.
+
+## Raspberry Pi4 CLuster Illustration.
+
+Before beginning the installation process, let's take a moment to review the cluster setup and the corresponding IP addresses assigned to each node in our Raspberry Pi 4 cluster.
+
+<img src="/assets/ks-Install-k3s-on-pi-cluster/pi-cluster-diagram.png" width="600px">
+
+In our configuration, we have three Raspberry Pi 4 units connected to a switch. This switch, in turn, is connected to the router supplied by my internet service provider.
+Additionally, I have been provided with a static public IP address for internet access.
+
+The table below outlines the specific IP configuration for each of the nodes in our Raspberry Pi cluster:
+
+![IP Table Diagram](/assets/ks-Install-k3s-on-pi-cluster/ip-table.png)
+
+I will pick the Pi running at 192.168.1.85 as my master mode and start the installation as below instructions.
+
+---
+
+## K3s Installation
+
+### Pi Os installation
+
+Given our project's need for a k3s cluster, I selected the Raspberry Pi OS Lite 64Bit which can be downloaded from the [Raspberry PI Imager](https://www.raspberrypi.com/software/).
+This particular OS variant doesn't include a desktop environment. Thus, SSH will be our primary method for node installation.
+
+![Raspberry Pi OS Selection](/assets/ks-Install-k3s-on-pi-cluster/pi-os-version.png)
+
+Before you flash the OS onto the SD Card, it's crucial to configure the node name and login details for each node.
+
+![Pi Configuration](/assets/ks-Install-k3s-on-pi-cluster/pi-configuration.png)
+
+Once the OS preparation for each node is complete, I set up the following cluster:
+
+- **pi-master**: 192.168.1.85 (Running Pi OS Lite 64Bit)
+- **pi-node-1**: 192.168.1.86 (Running Pi OS Lite 64Bit)
+- **pi-node-2**: 192.168.1.87 (Running Pi OS Lite 64Bit)
+
+I use `Termius` as my tool of choice for establishing a connection to the cluster for installation purposes. You can download it for free from [here](https://termius.com).
+
+### I. Config static IP for Pi
+
+By default, Pi OS will use DHCP to receive random Ip from the router, so to ensure the stable connectivity between the node
+We will config the status IP for each node by using the following steps.
+
+```shell
+# 1. Open the file dhcpcd.conf
+sudo nano /etc/dhcpcd.conf
+
+# 2. update the below parameters according to your router ip-address.
+interface eth0
+static ip_address=192.168.1.85/24
+static routers=192.168.1.254
+
+# 3. select control + X and save the changes.
+```
+
+### II. Disable swap
+
+When installing Kubernetes on Linux, it's recommended to disable swap because of how Kubernetes manages resources.
+
+- **Memory Management**: Kubernetes efficiently manages and allocates resources, including memory. Allowing an operating system to swap can interrupt Kubernetes' memory management process.
+
+- **Performance Issues**: Swapping can lead to performance degradation. When Kubernetes needs to access something that has been swapped to disk, it must wait for it to be loaded back into memory, causing delays.
+
+- **Predictability**: Disabling swap helps ensure predictable performance, as it removes the chance of the system swapping out Kubernetes' processes.
+
+- **Kubernetes Design**: Kubernetes is designed to work with no swapping activity. It assumes that applications are memory-resident, which means it expects them to stay in memory all the time.
+
+To disable swap on Linux, you can use the following command:
+
+```shell
+# 1. Turn off swap temporary.
+sudo swapoff -a
+
+# 2. To turn of swap permanently we need to update the `CONF_SWAPSIZE` in `dphys-swapfile` file to `0`
+sudo nano /etc/dphys-swapfile
+
+# 3. set
+  CONF_SWAPSIZE=0
+
+# 4. select control + X and save the changes.
+```
+
+### III. Cgroup configuration
+
+If a `FATA[0000] failed to find memory cgroup (v2)` error surfaces during the installation of k3s, it is likely because the Pi OS lacks the required `cgroup` configuration. Below are the steps needed to resolve this issue:
+
+```shell
+# 1. Open the cmdline.txt file
+sudo nano /boot/cmdline.txt
+
+#2. Add below into THE END of the current line
+cgroup_enable=cpuset cgroup_memory=1 cgroup_enable=memory
+
+# 3. Save the file and reboot
+sudo reboot
+```
+
+### IV. Master node installation
+
+Execute the following command to install the K3s master node. Make sure to replace the IP address according to your cluster configuration:
+
+```shell
+curl -sfL https://get.k3s.io | INSTALL_K3S_EXEC="server --disable=traefik --flannel-backend=host-gw --tls-san=192.168.1.85 --bind-address=192.168.1.85 --advertise-address=192.168.1.85 --node-ip=192.168.1.85 --cluster-init" sh -s -
+```
+
+**K3s parameters examination:**
+
+- **server**: This is telling k3s to run in server mode (as opposed to agent mode). In server mode, k3s will start up and manage Kubernetes master components.
+- **--disable=traefik**: This is instructing k3s to disable the Traefik ingress controller. By default, k3s includes and enables Traefik; this flag will prevent that from happening.
+- **--flannel-backend=host-gw**: This flag is setting the backend for Flannel (k3s's default network provider) to use. The host-gw option provides high-performance networking by creating a route for each node in the cluster.
+- **--tls-san=192.168.1.85**: The --tls-san flag allows you to specify additional IP or DNS names that should be included in the TLS certificate that is automatically generated for the Kubernetes API server. You can repeat this flag to add more than one SAN. The value 192.168.1.85 is an additional Subjective Alternative Name (SAN) for the Kubernetes API server's certificate.
+- **--bind-address=192.168.1.85**: This is the IP address that the k3s API server will listen to.
+- **--advertise-address=192.168.1.85**: This is the IP address that the k3s API server will advertise to other nodes in the cluster. They will use this IP to connect to the API server.
+- **--node-ip=192.168.1.85**: This defines the IP that should be used for Kubernetes services on the node.
+- **--cluster-init**: This flag instructs k3s to initialize a new Kubernetes cluster. If this flag is not provided, k3s will join an existing cluster if one is available.
+
+Once installed, the k3s configuration should be located in `/etc/rancher/k3s/k3s.yaml`. Using this configuration with **[K8s Lend](https://k8slens.dev)** allows access to the K3s cluster.
+
+Here's a snapshot of how it should look:
+
+![k8s-lend-master-node.png](/assets/ks-Install-k3s-on-pi-cluster/k8s-lend-master-node.png)
+
+### V. Worker nodes installation
+
+To install the worker nodes, we first need to obtain the `K3S_TOKEN` from the master node. Execute the command shown below to retrieve it:
+
+```shell
+# get node-token from master node
+sudo cat /var/lib/rancher/k3s/server/node-token
+
+# The result is something likes this
+  `THIS19937008cbde678aeaf200517f07c0ccd67dc80bdf4df6f746IS4780e15ebcd::server:40fc2cc2fnode81cdacc0b9bb1231token`
+```
+
+Upon retrieval of the node token, it is necessary to inject it into the script shown below. This script should be executed on all the Pi nodes specified previously. Please ensure to update the IP address associated with K3S_URL, as required.
+
+```shell
+# Execute this to install the nodes
+curl -sfL https://get.k3s.io | K3S_URL=https://192.168.1.85:6443 \
+  K3S_TOKEN="THIS19937008cbde678aeaf200517f07c0ccd67dc80bdf4df6f746IS4780e15ebcd::server:40fc2cc2fnode81cdacc0b9bb1231token" sh -
+```
+
+Congratulations, your K3s cluster is now ready to be utilized.
+
+![k82-lend-pi-cluster.png](/assets/ks-Install-k3s-on-pi-cluster/k82-lend-pi-cluster.png)
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*

ks-02-Install-nginx-on-pi-cluster.md

@@ -0,0 +1,187 @@
+---
+author: Steven Hoang
+pubDatetime: 2023-09-16T00:00:00Z
+title: "[k8s] Step-By-Step Guide: Installing Nginx Ingress on K3s Pi 4 Cluster"
+featured: false
+draft: false
+tags:
+  - k3s
+  - kubernetes
+  - picluster
+  - nginx
+ogImage: ""
+description:
+  This guide provides helpful tips for installing the Nginx Ingress on a K3s Raspberry Pi 4 cluster.
+  Detailed and step-by-step instructions will ensure a seamless installation process. Let's get started!
+---
+
+In our [previous article](/posts/ks-install-k3s-on-raspberry-pi-cluster), we successfully set up a k3s Pi cluster. We will now build upon that foundation. Let's dive in!
+
+<img src="/assets/ks-Install-k3s-on-pi-cluster/pi-cluster-diagram.png" width="600px">
+
+- **pi-master**: 192.168.1.85 (Running Pi OS Lite 64Bit)
+- **pi-node-1**: 192.168.1.86 (Running Pi OS Lite 64Bit)
+- **pi-node-2**: 192.168.1.87 (Running Pi OS Lite 64Bit)
+
+### Router Port Forwarding Setup.
+
+In order to make the internal applications accessible via the internet, we need to set up port forwarding on our router.
+This routing process will redirect internet requests coming to ports 80 and 443 to our master private IP node (192.168.1.85).
+
+Please note, the configuration interface may vary among different routers. Nonetheless, most broadband routers should offer the same functionality pertaining to port forwarding.
+
+<img src="/assets/ks-Install-nginx-on-pi-cluster/pi-cluster-port-forwarding-diagram.png" width="600px">
+
+Here are my current router settings.
+
+<img src="/assets/ks-Install-nginx-on-pi-cluster/router-port-forwarding-config.png" width="550px"/>
+
+---
+
+### Nginx installation
+
+We're going to start by installing Nginx on our cluster. In the following guide, we will illustrate how to set up and run Nginx on K3s.
+At its core, Nginx will listen to inbound requests on the master node's IP address and subsequently forward these requests to the services operating within our cluster.
+
+<img alt="pi-cluster-nginx-diagram" src="/assets/ks-Install-nginx-on-pi-cluster/pi-cluster-nginx-diagram.png" width="600px">
+
+**1. Config Ip address**
+
+Helm charts come with a file called `values.yaml` which contains the default configuration values.
+We can override these values by creating your own values.yaml file. Here is an example:
+
+```yaml
+# Refer to line 434 here for details
+# https://github.com/kubernetes/ingress-nginx/blob/main/charts/ingress-nginx/values.yaml
+
+controller:
+  service:
+    # Our primary node ip address here.
+    # Do remember replacing this ip address with your once accordingly.
+    loadBalancerIP: "192.168.1.85"
+```
+
+**2. Download the Helm chart:**
+
+Download the Nginix helm chart. You can do this by adding the Nginx repo to the Helm. Run the following commands:
+
+```shell
+helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
+helm repo update
+```
+
+**3. Create namespace**
+
+```shell
+kubectl create namespace nginx-ingress
+```
+
+**4. Install the Helm chart:**
+
+Now you can install the Helm chart using your custom values.yaml file to override the default configuration values. Run the following command:
+
+```shell
+helm install nginx ingress-nginx/ingress-nginx --values values.yaml -n nginx-ingress
+```
+
+**5. Verify nginx pod:**
+
+After installed successfully, we should be able to find a pod running there:
+![nginx-installed-successfully.png](/assets/ks-Install-nginx-on-pi-cluster/nginx-installed-successfully.png)
+
+### Nginx Verification
+
+**1. Deploy the echo application:**
+
+You can deploy an echo server application using a simple Kubernetes deployment and service.
+The echo server will respond with the same request it receives.
+
+Here is a sample YAML file you can use:
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: echo-deployment
+  namespace: default
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: echo
+  template:
+    metadata:
+      labels:
+        app: echo
+    spec:
+      containers:
+        - name: echo
+          image: ealen/echo-server
+          ports:
+            - containerPort: 80
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: echo-service
+  namespace: default
+spec:
+  ports:
+    - port: 80
+  selector:
+    app: echo
+```
+
+Save this YAML into a file, let's say `echo-app.yaml`, and apply it to `default` namespace (_using `default` namespace in Production is not recommended_):
+
+```shell
+kubectl apply -f echo-app.yaml -n default
+```
+
+2. Create an ingress rule:
+
+Now that your echo server is running, you can create an ingress rule to route traffic to it.
+
+Here is a sample ingress YAML:
+
+```yaml
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: echo-ingress
+  namespace: default
+spec:
+  ingressClassName: nginx
+  rules:
+    # Replace the domain below with your domain accordingly.
+    - host: echo.drunkcoding.net
+      http:
+        paths:
+          - pathType: Prefix
+            path: "/"
+            backend:
+              service:
+                name: echo-service
+                port:
+                  number: 80
+```
+
+**3. Update your domain DNS**
+
+To ensure you can access from the internet, you need to point a domain to your public address.
+
+Here is my `drunkcoding.net` DNS configuration on Cloudflare for reference purposes.
+![drunkcoding-cloudflare-dns.png](/assets/ks-Install-nginx-on-pi-cluster/drunkcoding-cloudflare-dns.png)
+
+After all these configurations now we should be able to access your application hosting on our k3s cluster from the internet.
+When accessing to `http://echo.drunkcoding.net` you able to see the JSON response from the echo pod as below.
+
+![echo-app-response.png](/assets/ks-Install-nginx-on-pi-cluster/echo-app-response.png)
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*

ks-03-install-cert-manager-free-ssl-kubernetes-cluster.md

@@ -0,0 +1,158 @@
+---
+author: Steven Hoang
+pubDatetime: 2023-09-17T00:00:00Z
+title: "[k8s] Step-By-Step Guide: Installation of Cert-Manager, Implementing Free SSL Certificates for Kubernetes Clusters"
+featured: false
+draft: false
+tags:
+  - k3s
+  - kubernetes
+  - cert-manager
+  - ssl
+  - tls
+ogImage: ""
+description:
+  This comprehensive guide will help you to smoothly install Cert-Manager and implement free SSL certificates for Kubernetes clusters.
+  It is designed with step-by-step instructions to facilitate a seamless installation process. Dive in and let's begin this journey for enhanced security!
+---
+
+Welcome back to our ongoing dialogue about Kubernetes. In the [previous article](/posts/ks-install-nginx-on-k3s-raspberry-pi-cluster/), we successfully executed the Nginx installation and made our applications internet-accessible.
+However, you might've observed that the applications are operating under the HTTP protocol, which is not secure at present.
+
+> As of July 2018, with the release of Chrome 68, Google started marking all non-HTTPS websites as 'Not secure' in the Chrome browser.
+> This means that if a website doesn't use HTTPS, Chrome displays a warning to users in the address bar, indicating that the connection is not secure.
+> The goal of this move was to push more webmasters to secure their websites with SSL/TLS certificates, providing a safer browsing experience for users.
+
+Securing our applications through SSL encryption is crucial, particularly in production environments. For enhanced security, it's recommended to procure and implement valid SSL certificates for all production applications.
+
+However, for the development or testing environments, which may not require paid SSL certificates, you can make use of Cert-Manager.
+This tool utilizes Let's Encrypt to generate SSL certificates free of cost, providing a secure and cost-effective solution for **non-production** environments.
+
+## Cert-Manager installation
+
+1. **Prerequisite** - Kubernetes cluster with admin access is required. Make sure you have kubectl installed and configured to interact with your cluster.
+
+2. **Add the Jetstack Helm repository** - Jetstack is the organization that maintains cert-manager, and they provide a Helm repository that we can use to install it:
+
+```shell
+helm repo add jetstack https://charts.jetstack.io
+helm repo update
+```
+
+3. **Install cert-manager CustomResourceDefinitions** (CRDs) - These are the resources that cert-manager uses to store its configuration. Run the following command to install the CRDs:
+
+Please make certain that you are utilizing the most up-to-date version. You can achieve this by substituting `v1.13.0` with the newest release from the cert-manager official GitHub repository.
+Visit the following link to obtain the latest version: [Cert-Manager Releases](https://github.com/cert-manager/cert-manager/releases).
+
+```shell
+kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.13.0/cert-manager.crds.yaml
+```
+
+4. **Create cert-manager Namespace** - It's a good practice to install cert-manager in its own namespace. Use this command:
+
+```shell
+kubectl create namespace cert-manager
+```
+
+5. Create `value.yaml` file with the content below
+
+```yaml
+ingressShim:
+  defaultIssuerName: "letsencrypt-prod"
+  defaultIssuerKind: "ClusterIssuer"
+```
+
+6. **Install cert-manager** Helm chart - This will install cert-manager along with its components:
+
+```shell
+helm install cert-manager jetstack/cert-manager --values values.yaml -n cert-manager
+```
+
+7. **Verify the Installation** - Check if the cert-manager pods are running:
+
+![cert-manager-pod.png](/assets/ks-install-cert-manager-free-ssl-kubernetes-cluster/cert-manager-pod.png)
+
+8. **Cluster Issuer configuration**
+
+```yaml
+# File name is `cluster-issuer.yaml`
+apiVersion: cert-manager.io/v1
+kind: ClusterIssuer
+metadata:
+  # The name should be the same with `defaultIssuerName` above
+  name: letsencrypt-prod
+  namespace: cert-manager
+spec:
+  acme:
+    server: https://acme-v02.api.letsencrypt.org/directory
+    # Replace with your domain email.
+    email: support@drunkcoding.net
+    privateKeySecretRef:
+      name: letsencrypt-prod
+    solvers:
+      - http01:
+          ingress:
+            # The ingress class name of nginx.
+            class: nginx
+```
+
+Apply it on the cluster:
+
+```shell
+kubectl apply -f cluster-issuer.yaml
+```
+
+## Update echo-app ingress.
+
+Leverage the existing `echo-app` to enhance your project. We'll revise the ingress configuration to enable HTTPS for secure communication in our application.
+Additionally, we'll integrate with cert-manager for automated SSL certificate generation.
+
+```yaml
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: echo-ingress
+  namespace: default
+  annotations:
+    # 1. enable cert-manager for this ingress
+    kubernetes.io/tls-acme: "true"
+spec:
+  ingressClassName: nginx
+  # 3. Config the tls secret name. Replace the domain and secretName below with your config accordingly.
+  tls:
+    - hosts:
+        - echo.drunkcoding.net
+      secretName: tls-drunkcoding-net
+  rules:
+    - host: echo.drunkcoding.net
+      http:
+        paths:
+          - pathType: Prefix
+            path: "/"
+            backend:
+              service:
+                name: echo-service
+                port:
+                  number: 80
+```
+
+> The certificate generated from `Let's Encrypt` has validity of 90 days. However, the `cert-manager` will automatically renew the certificate as it nears its expiration date.
+
+## Verify application
+
+Once the configuration is properly set up and the certificate has been successfully issued, you should be able to locate a certificate named `tls-drunkcoding-net` housed under the `default` namespace secrets.
+![tls-drunkcoding-net certificate](/assets/ks-install-cert-manager-free-ssl-kubernetes-cluster/echo-app-with-cert.png)
+
+The application is also fully functional with SSL for secure communication.
+![Secure application communication](/assets/ks-install-cert-manager-free-ssl-kubernetes-cluster/cert-drunkcoding-net.png)
+
+Below is the detailed certificate information as seen from the browser.
+![Browser certificate details](/assets/ks-install-cert-manager-free-ssl-kubernetes-cluster/cert-details.png)
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*

ks-04-cert-manager-alternative-with-cloudflare.md

@@ -0,0 +1,146 @@
+---
+author: Steven Hoang
+pubDatetime: 2023-09-17T02:00:00Z
+title: "[k8s] Step-By-Step Guide: Cert-Manager Alternative with Cloudflare, Implementing Free SSL Certificates for Kubernetes Clusters"
+featured: false
+draft: false
+tags:
+  - k3s
+  - kubernetes
+  - cert-manager
+  - cloudflare
+  - ssl
+  - tls
+ogImage: ""
+description:
+  We explore the concept of using a Cert-Manager Alternative with Cloudflare to implement free SSL Certificates for Kubernetes clusters.
+  This strategy leverages Cloudflare SSL certificates conjunction with the Kubernetes setup to provide a secure environment, replacing the need of Cert-Manager.
+  Discover how this approach simplifies the process, and enhances the security of our Kubernetes clusters.
+---
+
+In our [previous post](/posts/ks-install-cert-manager-free-ssl-kubernetes-cluster), we walked through the process of successfully installing Cert-Manager to handle SSL certificate assignments for all ingresses.
+While advantageous, this approach comes with a few noteworthy challenges:
+
+- **Limited validity period**: Certificates provided by Cert-Manager are valid for a short period (90 days), meaning any third-party systems utilizing the services may need to update their certificate whitelist every 90 days.
+- **Inappropriate for production environments**: Certificates provided by Let's Encrypt, while useful, may not be suitable for production environments.
+- **Opening Port 80**: To validate and issue the certificate, Cert-Manager requires the use of insecure HTTP on port 80 during the process. However, if for any reason, the infrastructure team is reluctant to expose port 80 to the internet, then the operation of Cert-Manager may be compromised.
+- **Potential Cert-Manager failures**: There can be instances where Cert-Manager encounters issues and fails to renew the certificate. In such cases, third-party systems may be unable to access our service due to failed certificate verification.
+
+By understanding these issues, We'll explore a better solution to replace the Cert-Manager with Cloudflare. More detailed information will follow in subsequent posts.
+
+## Cert-Manager Alternative
+
+Cloudflare provides several valuable services:
+
+1. **Domain Management**: Makes it simple to purchase, move, and control domain names. It centralised DNS record setup, subdomain management in once place.
+
+2. **Universal SSL (Free)**: Provides automatic secure HTTPS access to our website. This saves time from the need to buy and manage SSL certificates.
+
+3. **Advanced Certificate Manager**: Perfect for businesses wanting more control over their SSL certificates. We can customize the certificates, including those for multiple subdomain levels.
+
+4. **Proxy**: Sits between the website's server and its visitors, with [WAF enabled](https://www.cloudflare.com/application-services/products/waf/) through proxy giving protection from threats like DDoS attacks and bots, while also enhancing performance.
+   All requests appear to be coming from Cloudflare IP addresses, enabling us to enhance site security by just whitelisting [Cloudflare IP Addresses](https://www.cloudflare.com/en-in/ips/).
+
+## Kickstart with Cloudflare
+
+1. Before we get started, ensure that we have a Cloudflare account that can register for one, free of charge, [here](https://www.cloudflare.com).
+2. The next essential step is to onboard a Domain into Cloudflare's management system. Rest assured, this process is straightforward and involves zero downtime.
+3. For demonstration, I have onboarded my `drunkcoding.net` to Cloudflare. Once a Domain is onboarded, it should resemble the following demonstration.
+   ![Cloudflare Drunkcoding Domain Setup](/assets/ks-cert-manager-alternative-with-cloudflare/cloudflare-drunkcoding-domain.png)
+
+4. Moving forward to the **DNS** Records management, I have added an A record with the proxy option enabled, as shown below.
+   ![Cloudflare DrunkCoding Records](/assets/ks-cert-manager-alternative-with-cloudflare/cloudflare-druncoding-records.png)
+   Once set up, all requests to subdomains such as `echo.drunkcoding.net`, `wiki.drunkcoding.net`, etc., will be redirected to my public IP address.
+
+5. Next, under **SSL/TLS**, I created an Origin Server for the domains `drunkcoding.net and *.drunkcoding.net` and chose the certificate validity from 7 days to 15 years.
+   ![Cloudflare Drunkcoding Server SSL](/assets/ks-cert-manager-alternative-with-cloudflare/cloudflare-drunkcoding-server-ssl.png)
+   After setting this up, please ensure to download the certificate and private key immediately and save it to local files as we won't be able to access the private key in the future.
+
+6. Following this, download the Cloudflare Root CA certificate from [here](https://developers.cloudflare.com/ssl/static/origin_ca_rsa_root.pem).
+7. Once all the above steps are complete, we should have the following three files:
+
+   - `cert.crt`: This public key certification is in PEM format.
+   - `private.key`: This private key of the certificate is also in PEM format.
+   - `Root CA`: This root CA certificate is also in PEM format.
+
+8. Switch the SSL/TLS encryption mode of the domain to `Full (strict)`
+   ![cloudflare-domain-tls-mode.png](/assets/ks-cert-manager-alternative-with-cloudflare/cloudflare-domain-tls-mode.png)
+
+## Cloudflare Certificate Installation
+
+1. **Certificate preparation:**
+
+Before to proceeding, it is necessary to append the contents of the `Root CA` file to the `cert.crt` file, as illustrated in the following example:
+
+```textmate
+-----BEGIN CERTIFICATE-----
+    Content of cert.crt file here
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+    Content of ca file here
+-----END CERTIFICATE-----
+```
+
+2. **Create a secret certificate on kubernetes:**
+
+Update the name based on your naming convention. In this context, we're using `tls` as the prefix and `import` as the suffix.
+This denotes that it's a TLS certificate secret imported from a third party, as opposed to being auto-generated by Cert-Manager.
+
+```shell
+kubectl create secret tls tls-drunkcoding-net-import --cert=cert.crt --key=private.key --namespace=our-namespace
+```
+
+Remember to do this for each namespace in the cluster if there are services utilizing this domain.
+
+After the successful creation, a secret, similar to the one illustrated below, should be identifiable.
+![ks-drunkcoding-tls-secret.png](/assets/ks-cert-manager-alternative-with-cloudflare/ks-drunkcoding-tls-secret.png)
+
+3. **Update Application Ingress:**
+
+Leverage the existing `echo-app` ingress. We'll revise the ingress configuration use the imported certificate by change the secretName of the ingress as below.
+
+```yaml
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: echo-ingress
+  namespace: default
+  annotations:
+    kubernetes.io/tls-acme: "true"
+spec:
+  ingressClassName: nginx
+  tls:
+    - hosts:
+        - echo.drunkcoding.net
+      # only need to change this secret name.
+      secretName: tls-drunkcoding-net-imported
+  rules:
+    - host: echo.drunkcoding.net
+      http:
+        paths:
+          - pathType: Prefix
+            path: "/"
+            backend:
+              service:
+                name: echo-service
+                port:
+                  number: 80
+```
+
+The application will be protected with cloudflare cert, and below is the detailed certificate information as seen from the browser.
+
+![Browser certificate details](/assets/ks-cert-manager-alternative-with-cloudflare/cert-details.png)
+
+You may observe that the certificates provided by Cloudflare and Cert-Manager bear a resemblance, owing to their shared use of Let's Encrypt for free SSL certificate generation.
+However, it's important to note that for production applications, an upgrade to [**Cloudflare Advanced Certificate Manager**](https://www.cloudflare.com/lp/pg-advanced-certificate-manager/)
+is recommended for Production environment which provides a certificate from a standard, trusted third-party authority and boasts an extended validity period.
+
+> After completing these steps, we can proceed with uninstalling the Cert-Manager, as it is no longer needed.
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*

ks-05-public-services-with-cloudflare-tunnel.md

@@ -0,0 +1,178 @@
+---
+author: Steven Hoang
+pubDatetime: 2023-09-18T00:00:00Z
+title: "[k8s] Step-By-Step Guide: Nginx Alternative with Cloudflare Tunnel, Enables services to internet a public static IP address"
+featured: false
+draft: false
+tags:
+  - k3s
+  - kubernetes
+  - cloudflare
+  - tunnel
+ogImage: ""
+description:
+  This robust solution provides a feasible alternative to Nginx when there's no public static IP address or port forwarding required.
+  This guide walks us through the process step by step, enabling the services online more efficiently.
+---
+
+In the previous articles we successfully:
+
+1. [Install kubernetes cluster](/posts/ks-install-k3s-on-raspberry-pi-cluster).
+2. [Install Ngix on cluster](/posts/ks-install-nginx-on-k3s-raspberry-pi-cluster).
+3. [Install SSL for Ingress with Cert-Manager](/posts/ks-install-cert-manager-free-ssl-kubernetes-cluster) or with [Cloudflare SSL](/posts/ks-cert-manager-alternative-with-cloudflare).
+
+However, to expose our services to the internet, it's essential to obtain a **Static Public IP Address** and configure the **router/firewall to open ports 80 and 443**.
+If for any reason we're unable to meet these requirements, we won't be able to expose our services online.
+
+In addition, if our organization relies on private Kubernetes on cloud platforms such as AKS, EKS, or GKS, and we wish to expose a select set of services to the internet
+without jeopardizing security, we might consider using [Cloudflare Tunnel](https://www.cloudflare.com/products/tunnel/).
+
+Let's delve into this topic further.
+
+<img src="/assets/ks-public-services-with-cloudflare-tunnel/argo-tunnel-network-diagram-1024x491.png" width="600px">
+
+## Cloudflare Tunnel Configuration
+
+1. This guide assumes that we have followed the instructions from our [previous post](/posts/ks-install-cert-manager-free-ssl-kubernetes-cluster), and configured Cloudflare account with at least one onboarded domain.
+
+2. The next step is to create a [Cloudflare Zero Trust Account](https://one.dash.cloudflare.com). While creating this account might require adding a payment method, please note that there are no charges for the first 50 users. You can proceed to register without any hesitation.
+
+<img src="/assets/ks-public-services-with-cloudflare-tunnel/cloudflare-zero-trust-dashboard.png" width="600px">
+
+2. Once logged in, navigate to **Access => Tunnel** and create a new tunnel. For the purposes of this guide, we'll name it `pi-k3s`. After creating the tunnel, make sure to copy the tunnel token that appears (similar to the one below):
+
+```textmate
+eyJhIjoiYWVlMGFjYzZiYejTkz....yzCfgm7oqfnhz2DrJDKyL8PBDr9hR5FvYgDR45TxPiAxbmVW=
+```
+
+3. Finally, ensure we click the Save button to confirm the creation of the tunnel.
+
+## Kubernetes Tunnel Installation
+
+1. Create cloudflare Namespace. It's a good practice to install the tunnel in its own namespace. Use this command:
+
+```shell
+kubectl create namespace cloudflare
+```
+
+2. Create the `cloudflare-tunnel.yaml` deployment file as below:
+
+```shell
+apiVersion: v1
+kind: Secret
+metadata:
+  name: cloudflare-tunnel
+  namespace: cloudflare
+  labels:
+    app: cloudflare-tunnel
+type: Opaque
+stringData:
+  # the cloudflare tunnel token here
+  token: 'eyJhIjoiYWVlMGFjYzZiYejTkz....yzCfgm7oqfnhz2DrJDKyL8PBDr9hR5FvYgDR45TxPiAxbmVW='
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: cloudflare-tunnel
+  namespace: cloudflare
+  labels:
+    app: tunnel
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: cloudflare-tunnel
+  template:
+    metadata:
+      labels:
+        app: cloudflare-tunnel
+    spec:
+      containers:
+        - name: cloudflare-tunnel
+          image: cloudflare/cloudflared:latest
+          args:
+            - tunnel
+            - '--no-autoupdate'
+            - run
+            - '--token'
+            - $(token)
+          envFrom:
+            - secretRef:
+                name: cloudflare-tunnel
+          resources:
+            limits:
+              cpu: 500m
+              memory: 512Mi
+            requests:
+              cpu: 1m
+              memory: 10Mi
+          imagePullPolicy: Always
+          securityContext:
+            readOnlyRootFilesystem: true
+      restartPolicy: Always
+      terminationGracePeriodSeconds: 30
+      dnsPolicy: ClusterFirst
+      automountServiceAccountToken: false
+  strategy:
+    type: RollingUpdate
+    rollingUpdate:
+      maxUnavailable: 25%
+      maxSurge: 25%
+  revisionHistoryLimit: 1
+  progressDeadlineSeconds: 600
+```
+
+3. Install Cloudflare tunnel:
+
+```shell
+kubectl apply -f cloudflare-tunnel.yaml
+```
+
+4. Verify running pods after deployed.
+
+![cloudflare-tunnel-pods.png](/assets/ks-public-services-with-cloudflare-tunnel/cloudflare-tunnel-pods.png)
+
+5. Back to the Cloudflare Zero Trust the tunnel status should be in `Health` also.
+
+![cloudflare-tunnel-status.png](/assets/ks-public-services-with-cloudflare-tunnel/cloudflare-tunnel-status.png)
+
+## Exposing the Application to the Internet
+
+1. Navigate to the tunnel configuration page. Under the 'Public Host' section, add a public host name to expose our `echo service` to the internet. See the example below.
+
+Note: Kubernetes internal service URLs follow the convention: `http://{service-name}.{namespace}.svc.cluster.local`.
+
+![Cloudflare Public Host Configuration](/assets/ks-public-services-with-cloudflare-tunnel/cloudflare-echo-service-config.png)
+
+2. Verify the performance of the application by visiting `https://echo.drunkcoding.net`. The service should be accessible without any constraints.
+
+3. I have established two endpoints as follows and conducted a load test using Postman.
+   The results were astonishing as the Cloudflare tunnel delivered speeds even greater than direct access via Nginx.
+
+- **echo-nginx.drunkcoding.net**: This endpoint provides access to the echo application through Nginx ingress and with a public IP address.
+- **echo.drunkcoding.net**: This endpoint offers access to the echo application through the Cloudflare tunnel.
+
+Please see the results in the attached image.
+![load-test.png](/assets/ks-public-services-with-cloudflare-tunnel/load-test.png)
+
+> Note: The cluster hosting this application is based in Singapore, while the test was conducted from a terminal in Vietnam.
+
+## Concluding Remarks
+
+Leveraging Cloudflare tunnels simplifies application exposure to the internet without the necessity of below:
+
+- A public IP Address.
+- Port forwarding.
+- Firewall whitelisting.
+- Nginx proxy/ingress.
+- A Cert-manager or Cloudflare origin server certificate.
+
+This results in a significantly simplified infrastructure setup.
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*

ks-06-hosting-outline-vpn-kubernetes.md

@@ -0,0 +1,392 @@
+---
+author: Steven Hoang
+pubDatetime: 2023-10-05T00:00:00Z
+title: "[k8s] Step-By-Step Guide: Hosting Outline VPN on Kubernetes"
+featured: false
+draft: false
+tags:
+  - k3s
+  - kubernetes
+  - nginx
+  - outline
+ogImage: ""
+description: "Outline VPN, a comprehensive server and client software tool, is a free and open-source system developed by Google.
+In this article, we will delve into the process of hosting Outline VPN on Kubernetes and outlining the steps to expose connection ports via NGINX."
+---
+
+In our [previous article]("posts/ks-install-nginx-on-k3s-raspberry-pi-cluster"),
+we were successfully installed NGINX on Kubernetes.Now, we're going to take NGINX for a spin and use it to host the Outline VPN on Kubernetes and open up our connection ports.
+
+You're probably aware that by default, Outline VPN changes the client port each time a new connection is made.
+It can be a bit of a challenge when we need to expose the ports through NGINX and get the outbound port on the whitelist at the firewall level.
+
+However, there is a feature that allows us to modify the Outline VPN's default configuration during deployment.
+With this little tweak, we can get all connections to pass through a single port and manage to expose both the management and client ports through NGINX.
+Stick with us as we walk you through this process.
+
+## Install Outline VPN
+
+Before proceeding with the installation of the Outline, it's essential to define some variables as follows:
+
+- **Management Port (60000)**: This port facilitates the connection between the Outline Manager and the VPN server.
+- **Client Port (40000)**: This port is assigned for client devices to establish a connection with the VPN server.
+- **Hostname (vpn.drunkcoding.net)**: This DNS (Domain Name Server) allows client devices to communicate with the VPN server from the public internet.
+
+1. Let's start with a new _Outline-system_ namespace creation.
+
+```shell
+kubectl create namespace outline-system
+```
+
+2. Create a Self-sign certificate
+
+To install Outline VPN, a required certificate plays multiple crucial roles:
+
+- **Server Authentication**: This certificate is key in verifying the VPN server you're connecting to is the genuine one.
+
+- **Data Encryption**: This certificate establishes the encryption for all data transmissions between your device and the VPN server.
+  If someone happens to intercept the data, they won't be able to decipher it due to this encryption.
+
+- **Secured Connection Assurance**: This essential certificate ensures the connection between the client devices and the VPN server is both private and secure.
+  This is particularly crucial when connecting from insecure networks like public Wi-Fi.
+
+Let's generate a self-signed certificate.
+It can be accomplished through various methods, each tailored to specific environments.
+
+Here, we'll be using OpenSSL as an example. The commands illustrating this process are detailed below:
+
+```shell
+# 1. Create private key
+openssl genrsa -out private.key 2048
+
+# 2. Create a Certificate Signing Request (CSR) using the private key with some parameters as below:
+#-----
+# - Country Name (2 letter code) [AU]:VN
+# - State or Province Name (full name) [Some-State]:VN
+# - Locality Name (eg, city) []:HCM
+# - Organization Name (eg, company) [Internet Widgits Pty Ltd]:drunkcoding
+# - Organizational Unit Name (eg, section) []:DCN
+# - Common Name (e.g. server FQDN or YOUR name) []:vpn.drunkcoding.net
+# - Email Address []:system@drunkcoding.net
+
+# - Please enter the following 'extra' attributes
+# - to be sent with your certificate request
+# - A challenge password []:123456
+# - An optional company name []:DCN
+openssl req -new -key private.key -out csr_request.csr
+
+# 3. Create a self-signed certificate
+openssl x509 -req -days 365 -in csr_request.csr -signkey private.key -out cert.crt
+```
+
+Once the certificate is generated, following command to import into kubernetes cluster.
+
+```shell
+kubectl create secret tls tls-outline-vpn-imported --cert=cert.crt --key=private.key --namespace=outline-system
+```
+
+3. Deploy Outline Service with following `outline-deployment.yaml` file.
+
+- **PersistentVolumeClaim**:
+  A PersistentVolumeClaim named _outline-vpn-claim_ is created
+  which requests storage is being created in the namespace _outline-system_ to store the configuration of Outline VPN.
+- **Deployment**: A Deployment named _outline-vpn_ is being created in the namespace _outline-system_.
+  With this Deployment, a Pod is created with a container that uses the image quay.io/outline/shadowbox:stable. The container defines two TCP ports (40000, 60000) to expose.
+- **Service**: A Service named _outline-vpn_ is configured to expose the Pods and expose the ports (40000 and 60000) for both TCP and UDP protocols.
+
+```yaml
+# 1. PersistentVolume
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: outline-vpn-claim
+  namespace: outline-system
+status:
+  phase: Bound
+  accessModes:
+    - ReadWriteOnce
+  capacity:
+    storage: 5Gi
+spec:
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 5Gi
+  #TODO: Remember to change `storageClassName` according to your environment.
+  storageClassName: local-path
+  volumeMode: Filesystem
+---
+#2. Pod Deployment
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: outline-vpn
+  namespace: outline-system
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: outline-vpn
+      name: outline-vpn
+  template:
+    metadata:
+      labels:
+        app: outline-vpn
+        name: outline-vpn
+    spec:
+      volumes:
+        - name: server-config-volume
+          emptyDir: {}
+        - name: shadowbox-config
+          persistentVolumeClaim:
+            claimName: outline-vpn-claim
+        - name: tls
+          secret:
+            secretName: tls-outline-vpn-imported
+            items:
+              - key: tls.crt
+                path: shadowbox.crt
+              - key: tls.key
+                path: shadowbox.key
+            defaultMode: 420
+      containers:
+        - name: outline-vpn
+          image: quay.io/outline/shadowbox:stable
+          ports:
+            - containerPort: 40000
+              protocol: TCP
+            - containerPort: 60000
+              protocol: TCP
+          env:
+            - name: SB_API_PORT
+              value: "60000"
+            - name: SB_API_PREFIX
+              value: b782eecb-bb9e-58be-614a-d5de1431d6b3
+            - name: SB_CERTIFICATE_FILE
+              value: /tmp/shadowbox.crt
+            - name: SB_PRIVATE_KEY_FILE
+              value: /tmp/shadowbox.key
+          volumeMounts:
+            - name: server-config-volume
+              mountPath: /cache
+            - name: shadowbox-config
+              mountPath: /opt/outline
+            - name: shadowbox-config
+              mountPath: /root/shadowbox
+            - name: tls
+              readOnly: true
+              mountPath: /tmp/shadowbox.crt
+              subPath: shadowbox.crt
+            - name: tls
+              readOnly: true
+              mountPath: /tmp/shadowbox.key
+              subPath: shadowbox.key
+          lifecycle:
+            postStart:
+              exec:
+                command:
+                  - /bin/sh
+                  - "-c"
+                  - >-
+                    echo
+                    '{"rollouts":[{"id":"single-port","enabled":true}],"portForNewAccessKeys":40000,"hostname":"vpn.drunkcoding.net"}'
+                    >
+                    /root/shadowbox/persisted-state/shadowbox_server_config.json;
+          imagePullPolicy: Always
+      restartPolicy: Always
+      terminationGracePeriodSeconds: 30
+  strategy:
+    type: RollingUpdate
+    rollingUpdate:
+      maxUnavailable: 25%
+      maxSurge: 25%
+  revisionHistoryLimit: 10
+  progressDeadlineSeconds: 600
+---
+# 3. Service
+apiVersion: v1
+kind: Service
+metadata:
+  name: outline-vpn
+  namespace: outline-system
+  labels:
+    app: outline-vpn
+spec:
+  ports:
+    - name: apiport-tcp
+      protocol: TCP
+      port: 60000
+      targetPort: 60000
+    - name: apiport-udp
+      protocol: UDP
+      port: 60000
+      targetPort: 60000
+    - name: accessport-tcp
+      protocol: TCP
+      port: 40000
+      targetPort: 40000
+    - name: accessport-udp
+      protocol: UDP
+      port: 40000
+      targetPort: 40000
+  selector:
+    app: outline-vpn
+  type: ClusterIP
+  internalTrafficPolicy: Cluster
+```
+
+Apply it on the cluster:
+
+```shell
+kubectl apply -f outline-deployment.yaml
+```
+
+Upon successful deployment, you should be able to see a pod along with its corresponding logs as in the screenshot below.
+![outline-vpn-deployed-successfully.png](/assets/ks-hosting-outline-vpn-kubernetes/outline-vpn-deployed-successfully.png)
+
+## PostStart command & Environment variables explanation
+
+In the deployment lifecycle configuration above, there is a postStart command
+that creates a JSON file located at **/root/shadowbox/persisted-state/shadowbox_server_config.json**.
+
+The structure of the JSON object should look like this:
+
+```json
+{
+  "rollouts": [
+    {
+      "id": "single-port",
+      "enabled": true
+    }
+  ],
+  "portForNewAccessKeys": 40000,
+  "hostname": "vpn.drunkcoding.net"
+}
+```
+
+Let's break down the components of the JSON configuration for the Outline VPN:
+
+- **rollouts**: This has an ID 'single-port', indicating to the Outline VPN that client connections are to be allowed on this single port.
+- **portForNewAccessKeys**: This represents the port number (40000), where new access keys will be created.
+- **hostname**: This refers to the domain name or IP address of the VPN server the clients will connect to, in this case being "vpn.drunkcoding.net".
+
+There are also a few environment variables to acknowledge:
+
+- **SB_API_PORT**: It denotes the port exposed by the Outline Management API.
+- **SB_API_PREFIX**: It's a random GUID to be used as a prefix on the Outline Management API.
+- **SB_CERTIFICATE_FILE**: It points to a file, /tmp/shadowbox.crt, which corresponds to the certificate we created earlier.
+- **SB_PRIVATE_KEY_FILE**: This points to the path of the private key file. In this case, it's /tmp/shadowbox.key. This file matches the aforementioned certificate.
+
+## Exposing connection ports through nginx
+
+Once we've completed the installation as mentioned above, our Outline Container will be active and providing services on ports 60000 and 40000.
+Currently, this service is confined to the Kubernetes network, meaning they can't be accessed directly from external sources, such as the internet.
+
+In order to make these services receptive to outside connections, we'll need to expose the ports through NGINX.
+The following illustration provides a visual representation on how to do this.
+![outline-nginx-kubernetes.png](/assets/ks-hosting-outline-vpn-kubernetes/outline-nginx-kubernetes.png)
+
+To begin with, we need to update the `values.yaml` file from our previous NGINX deployment. This configuration will open up the needed ports.
+
+Here's the template:
+
+```yaml
+# Refer to line 155 and 160 here for details
+# https://github.com/kubernetes/ingress-nginx/blob/main/charts/ingress-nginx/values.yaml
+
+# 1. Expose the TCP with convention tcp: 'port':'namespace/service:port'
+tcp:
+  60000: "outline-system/outline-vpn:60000"
+  40000: "outline-system/outline-vpn:40000"
+
+# 2. Expose the UDP with convention udp: 'port':'namespace/service:port'
+udp:
+  40000: "outline-system/outline-vpn:40000"
+
+controller:
+  service:
+    loadBalancerIP: "192.168.1.85"
+```
+
+After updating the values.yaml with the correct information, re-upgrade the helm chart using the command:
+
+```shell
+# 1. To install brand new nginx
+helm install nginx ingress-nginx/ingress-nginx --values values.yaml -n nginx-ingress
+
+# 2. To update the existing nginx
+helm upgrade nginx ingress-nginx/ingress-nginx --values values.yaml -n nginx-ingress
+
+# 3. TO delete existing nginx and re-install with step 1 above.
+helm delete nginx -n nginx-ingress
+```
+
+## Managing the Outline VPN
+
+Follow these steps to manage your Outline VPN:
+
+**Step 1: Download the Outline Manager**
+
+Download the Outline Manager from [Outline's official website](https://getoutline.org/get-started/#step-1).
+
+**Step 2: Prepare the Connection Configuration**
+
+Prepare the connection configuration with the following parameters:
+
+- **apiUrl**: Use the following format `https://{hostname}:{management-port}/{SB_API_PREFIX}`.
+- **certSha256**: This is the thumbprint of the certificate created. Use the following command to access the thumbprint:
+
+```shell
+echo SHA=$(openssl x509 -noout -fingerprint -sha256 -inform pem -in cert.crt | sed "s/://g" | sed 's/.*=//')
+```
+
+**Step 3: Generate the Configuration**
+
+Our configuration should look like this:
+
+```json
+{
+  "apiUrl": "https://vpn.drunkcoding.net:60000/b782eecb-bb9e-58be-614a-d5de1431d6b3",
+  "certSha256": "34B3C8EB1C6EC9B5335556D7E8DC73A30152D27C66B054BAB8ACF5D11AE0C810"
+}
+```
+
+**Step 4: Setup Outline Anywhere**
+
+Open the Outline Manager App and click **Setup Outline Anywhere**. Paste the configuration into the second input box and click Done. .
+![outline-manager-config.png](/assets/ks-hosting-outline-vpn-kubernetes/outline-manager-config.png)
+
+**Step 5: Connect to the Outline VPN Server**
+
+On successful configuration, you should be able to connect to the Outline VPN server as shown below:
+![outline-manager-server.png](/assets/ks-hosting-outline-vpn-kubernetes/outline-manager-server.png)
+
+**Step 6: Create a Connection**
+
+To allow the clients to connect to the server, click Add new key to create a connection and note down the access key:
+
+```textmate
+ss://Y2hhY2hhMjAtaWV0Zi1wb2x5MTMwNTpQc1YxY0V0ZkhzSVFueEJFVEVsMFRF@vpn.drunkcoding.net:40000/?outline=1
+```
+
+## Getting Started with the Outline Client
+
+To get started with the VPN, follow the steps below:
+
+1. Begin by navigating to the [Outline official website](https://getoutline.org/get-started/#step-3) to download the client application. Be sure to select the version compatible with your platform architecture.
+
+2. Launch the client application. Select **Add Access Key**, then input the access key mentioned above. Afterward, click on **Add Server**.
+   <img src="/assets/ks-hosting-outline-vpn-kubernetes/outline-client-config.png" width="400px">
+
+3. Proceed by clicking on the 'Connect' button to establish a connection.
+
+4. To verify the VPN server's capability, access [myip.info](https://www.myip.info). Upon successful connection, your public IP address should reflect the Kubernetes outbound public IP. This means the VPN server is functioning as expected.
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*

ks-07-hosting-longhorn-on-kubernetes.md

@@ -0,0 +1,279 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-02-29T00:00:00Z
+title: "[k8s] Step-By-Step Guide: Hosting Longhorn on K3s (ARM)"
+featured: false
+draft: false
+tags:
+  - k3s
+  - kubernetes
+  - longhorn
+  - storage
+ogImage: ""
+description: "In this article, we will explore how to deploy Longhorn, a cloud-native distributed block storage system designed for Kubernetes on our K3s (ARM). 
+Longhorn is known for its lightweight, reliable, and open-source nature, which simplifies the process of adding persistent storage to Kubernetes clusters, making it easier to run stateful applications."
+---
+
+As you know by default the kubernetes provide a **"local-path"** storage. However, this local storage has many limitation:
+
+1. **Node Affinity**: When using local-path storage, the volume created is tied to the specific node where the pod runs.
+   If that node goes down for maintenance or any other reason, the pods won’t be able to start on other nodes because they won’t find their volumes.
+
+2. **Not Network Storage**: Local-path storage is not network-based. The volume remains local to the K3s node where the pod executes.
+   It doesn't allow data sharing across nodes.
+
+3. **Not Suitability for Production**: While local-path storage is suitable for small, single-node development clusters,
+   it’s not recommended for production-grade multi-node clusters.
+
+## What is Longhorn?
+
+Longhorn, an innovative open-source project by **Rancher Labs**, offers a reliable, lightweight, and user-friendly distributed block storage system for Kubernetes.
+
+1. **High Availability**: Longhorn replicates storage volumes across multiple nodes in the Kubernetes cluster,
+   ensuring that data remains available even if a node fails.
+2. **Cost-Effective**: Traditional external storage arrays can be expensive and non-portable. Longhorn offers a cost-effective,
+   cloud-native solution that can run anywhere.
+3. **Disaster Recovery**: Longhorn allows you to easily create a disaster recovery volume in another Kubernetes cluster and fail over to it in the event of an emergency.
+   This ensures that your applications can quickly recover with a defined Recovery Point Objective (RPO) and Recovery Time Objective (RTO).
+
+## Longhorn installation
+
+Longhorn provides a straightforward method for installing the iSCSI driver and NFSv4 directly on all nodes. Follow the steps below to set up the necessary components.
+
+1. **Installing open-iscsi**
+
+   The open-iscsi package is a prerequisite for Longhorn to create distributed volumes that can be shared across nodes.
+   Ensure that this driver is installed on all worker nodes within your cluster.
+
+Execute the following command on your cluster to install the driver
+
+```shell
+# please check the latest release of the longhorn here https://github.com/longhorn/longhorn and update the version accordingly. Current version is v1.6.0
+kubectl apply -f https://raw.githubusercontent.com/longhorn/longhorn/v1.6.0/deploy/prerequisite/longhorn-iscsi-installation.yaml
+```
+
+After deploying the iSCSI driver, confirm the status of the installer pods using the following command:
+
+```shell
+kubectl get pod | grep longhorn-iscsi-installation
+
+# The result
+longhorn-iscsi-installation-pdbgq   1/1     Running   0          21m
+longhorn-iscsi-installation-qplbb   1/1     Running   0          39m
+```
+
+Additionally, review the installation logs to ensure successful deployment:
+
+```shell
+kubectl logs longhorn-iscsi-installation-pdbgq -c iscsi-installation
+
+# The result
+...
+IProcessing triggers for libc-bin (2.35-0ubuntu3.6) ...
+Processing triggers for man-db (2.10.2-1) ...
+Processing triggers for initramfs-tools (0.140ubuntu13.1) ...
+update-initramfs: Generating /boot/initrd.img-6.5.0-18-generic
+iscsi install successfully
+```
+
+Once the iscsi installed successfully, Then you can safely uninstall the above with following command.
+
+```shell
+kubectl delete -f https://raw.githubusercontent.com/longhorn/longhorn/v1.6.0/deploy/prerequisite/longhorn-iscsi-installation.yaml
+```
+
+2. **Installing NFSv4 client**
+
+   To enable Longhorn’s backup functionality and ensure proper operation, the NFSv4 client must be installed on the worker nodes within your cluster.
+
+Follow these steps to set up the necessary components:
+
+```shell
+# please check the latest release of the longhorn here https://github.com/longhorn/longhorn and update the version accordingly. Current version is v1.6.0
+kubectl apply -f https://raw.githubusercontent.com/longhorn/longhorn/v1.6.0/deploy/prerequisite/longhorn-nfs-installation.yaml
+```
+
+After deploying the NFSv4 client, confirm the status of the installer pods using the following command:
+
+```shell
+kubectl get pod | grep longhorn-nfs-installation
+
+# The results
+NAME                                  READY   STATUS    RESTARTS   AGE
+longhorn-nfs-installation-mt5p7   1/1     Running   0          143m
+longhorn-nfs-installation-n6nnq   1/1     Running   0          143m
+```
+
+And also can check the log with the following command to see the installation result:
+
+```shell
+kubectl logs longhorn-nfs-installation-mt5p7 -c nfs-installation
+
+# The results
+...
+rpc-svcgssd.service is a disabled or a static unit, not starting it.
+rpc_pipefs.target is a disabled or a static unit, not starting it.
+var-lib-nfs-rpc_pipefs.mount is a disabled or a static unit, not starting it.
+Processing triggers for man-db (2.10.2-1) ...
+Processing triggers for libc-bin (2.35-0ubuntu3.6) ...
+nfs install successfully
+```
+
+Once the NFSv4 installed successfully, Then you can safely uninstall the above with following command.
+
+```shell
+kubectl delete -f https://raw.githubusercontent.com/longhorn/longhorn/v1.6.0/deploy/prerequisite/longhorn-nfs-installation.yaml
+```
+
+3. **Installing Longhorn**
+
+- Preparing the configuration `value.yaml` file
+
+```yaml
+csi:
+  kubeletRootDir: "/var/lib/kubelet"
+defaultSettings:
+  diskType: "flesystem"
+```
+
+- Install Longhorn in the `longhorn-system` namespace with configuration above.
+
+```shell
+# 1. added longhorn chart
+helm repo add longhorn https://charts.longhorn.io
+helm repo update
+
+# 2. Installing
+helm install longhorn longhorn/longhorn -f value.yaml --namespace longhorn-system --create-namespace
+```
+
+Once installed successfully and all the pods are up and running.
+You should be able to access Longhorn UI through the `longhorn-frontend` service (needs port-forward or expose through nginx or cloudflare tunnel).
+<img src="/assets/ks-hosting-longhorn-on-kubernetes/longhorn-ui.png" width="600px">
+
+4. **Uninstalling Longhorn**
+
+   If any reason we would like to uninstall Longhorn helm then the below commands will help.
+
+```shell
+# Update `deleting-confirmation-flag` to allows uninstall longhorn
+kubectl -n longhorn-system patch -p '{"value": "true"}' --type=merge lhs deleting-confirmation-flag
+# Uninstall longhorn
+helm uninstall longhorn -n longhorn-system
+# Delete namespace
+kubectl delete namespace longhorn-system
+```
+
+### Using the Longhorn storage with Mariadb
+
+To explore Longhorn storage capabilities, we’ll set up a MariaDB Galera multi-primary database cluster for synchronous replication and high availability. Follow these steps:
+
+```shell
+# Setup chart repo
+helm repo add bitnami https://charts.bitnami.com/bitnami
+helm repo update
+
+# Install mariadb-ha
+helm install mariadb-ha bitnami/mariadb-galera \
+   --set global.storageClass=longhorn \
+   --set rootUser.password=Pass@word1 \
+   --set galera.mariabackup.password=Password1 \
+   --set db.name=drunk_db \
+   --namespace db --create-namespace
+
+# Uninstall mariadb-ha
+helm uninstall mariadb-ha -n db
+```
+
+After deployed successful, you should find three MariaDB pods running in the `db` namespace:
+
+```shell
+kubectl get pod -n db
+
+# The results
+NAME                          READY   STATUS    RESTARTS   AGE
+mariadb-ha-mariadb-galera-0   1/1     Running   0          5m6s
+mariadb-ha-mariadb-galera-1   1/1     Running   0          3m44s
+mariadb-ha-mariadb-galera-2   1/1     Running   0          2m41s
+```
+
+You’ll also find three persistent volumes in the Longhorn UI portal. !Longhorn Volumes
+<img src="/assets/ks-hosting-longhorn-on-kubernetes/longhorn-volumes.png" width="600px">
+
+### Longhorn System Backup
+
+Longhorn supports a variety of backup targets, including Azure Storage, AWS S3, Google Storage, NFS, and SMB/CIFS.
+This post will initially cover the configuration for Azure Storage, with subsequent posts addressing the other backup targets.
+
+1. **System Backup with Azure Storage**
+
+This section assumes that you already have Azure Storage and a Kubernetes cluster that can connect to Azure.
+
+- Create a `longhorn-azure-blob-backup.yaml` secret with your Azure Storage Account credentials:
+
+```yaml
+# Update the secret below with your Azure Storage Account credentials
+apiVersion: v1
+kind: Secret
+metadata:
+  name: longhorn-azure-blob-backup
+  namespace: longhorn-system
+stringData:
+  AZBLOB_ACCOUNT_KEY: "YOUR_STORAGE_KEY"
+  AZBLOB_ACCOUNT_NAME: "YOUR_STORAGE_NAME"
+```
+
+- Apply the secret to the cluster using the following command.
+
+```shell
+kubectl apply -f longhorn-azure-blob-backup.yaml
+```
+
+- Next, update the backup information in the defaultSettings section of the `value.yaml` file:
+
+```yaml
+csi:
+  kubeletRootDir: "/var/lib/kubelet"
+defaultSettings:
+  diskType: "flesystem"
+  backupTargetCredentialSecret: "longhorn-azure-blob-backup" #The name of the secret created above.
+  backupTarget: "azblob://YOUR_CONTAINER_NAME@core.windows.net/" # Trailer slash is important
+```
+
+- Upgrade the Longhorn Helm chart with the updated values using the following command:
+
+```shell
+helm upgrade longhorn longhorn/longhorn -f value.yaml --namespace longhorn-system
+
+# You should see a message indicating that the upgrade was successful
+Release "longhorn" has been upgraded. Happy Helming!
+NAME: longhorn
+LAST DEPLOYED: Wed Feb 28 08:57:56 2024
+NAMESPACE: longhorn-system
+STATUS: deployed
+REVISION: 2
+TEST SUITE: None
+NOTES:
+Longhorn is now installed on the cluster!
+
+Please wait a few minutes for other Longhorn components such as CSI deployments, Engine Images, and Instance Managers to be initialized.
+
+Visit our documentation at https://longhorn.io/docs/
+```
+
+- Once the upgrade is complete, the backup information under `Setting` → `General` should reflect the changes made.
+  <img src="/assets/ks-hosting-longhorn-on-kubernetes/long-horn-azure-backup.png" width="600px">
+
+- After creating a sys-backup under `Setting` → `System Backup`, you should see the following
+  <img src="/assets/ks-hosting-longhorn-on-kubernetes/azure-sys-bakup.png" width="600px">
+
+- You should be able to see the data being backed up into the Azure Storage Container.
+  <img src="/assets/ks-hosting-longhorn-on-kubernetes/azure-storage-account.png" width="600px">
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*

ks-08-cert-manager-with-private-aks.md

@@ -0,0 +1,256 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-08-15T00:00:00Z
+title: "[AKS] Implementing Cert Manager with Private Azure Kubernetes Service (AKS)."
+featured: false
+draft: false
+tags:
+  - aks
+  - cert-manager
+ogImage: ""
+description: "Exploring the deployment and management of SSL certificates using cert-manager in a private Azure Kubernetes Service (AKS) environment. 
+This article covers the architecture involving CloudPC and AKS VNETs, the use of NGINX ingress for private connections, and the implementation of Cloudflare DNS management to secure internal communications."
+---
+
+In a previous [post](https://drunkcoding.net/posts/ks-03-install-cert-manager-free-ssl-kubernetes-cluster/), It detailed how to set up Cert Manager on a Raspberry Pi K3s Cluster. That was a great starting point, and in this article, I decided to explore a more complex scenario by deploying Cert Manager within a private Kubernetes cluster on Azure. I’m excited to share the insights and techniques I discovered along the way, hoping they can make your journey a bit smoother."
+
+### **Azure Architecture Overview**
+
+The following diagram illustrates the architecture we'll be working with:
+<img src="/assets/aks-cert-manager-with-private-aks/private-AKS-with-cert-manager.png">
+
+The setup involves two Virtual Networks (VNETs) that are peered:
+
+1. **CloudPC VNET:** This is where we host all our Windows 365 Enterprise environments, allowing remote users to securely access the company’s resources.
+
+2. **AKS VNET:** This VNET hosts our private AKS cluster. To keep things secure, I’ve set up a firewall that controls all outbound traffic, with no direct inbound access from the internet. The public IP is purely for outbound traffic—no inbound ports are left open.
+
+3. **NGINX Ingress:** This piece allows CloudPC to access applications running on AKS through VNET peering, making sure everything stays within a private network.
+
+### **The Challenge I Encountered: Securing Internal Traffic**
+
+One of the challenges I came across was figuring out how to secure the communication between the applications hosted on AKS and the CloudPC environment, even though it’s all internal within the virtual networks. I wanted to make sure that all data in transit was encrypted using SSL certificates.
+
+### **How I Solved It: Leveraging Cloudflare DNS and Cert Manager**
+
+To address the challenge, I implemented the following approach:
+
+1. **Domain Setup with Cloudflare:** Let’s assume I have a domain, `drunk.dev`, registered with Cloudflare. While this domain isn’t directly used for external-facing services. But, I utilize this domain with Let’s Encrypt to verify and issue SSL certificates for the ingress controllers of my applications within the AKS cluster.
+
+2. **Internal DNS Configuration on Azure:** Internally, I created a private DNS Zone in Azure with the same name (`drunk.dev`) and linked this zone to both the CloudPC and AKS VNETs. This setup is critical as it ensures that internal DNS queries for the `drunk.dev` domain are resolved correctly within the private network, facilitating secure communication between services.
+
+---
+
+### **Installation**
+
+1. **Create a Cloudflare DNS API Token:**  
+    First, navigate to the Cloudflare profile and create an API token by following [this link](https://dash.cloudflare.com/profile/api-tokens). The API token should have permissions to manage DNS records for the domains.
+
+   Additionally, for enhanced security, specify the AKS public IP address under `Client IP Address Filtering` in Cloudflare. This ensures that the API token is only accessible from the AKS platform, preventing unauthorized access from other locations.
+   <img src="/assets/aks-cert-manager-with-private-aks/cf-dns-token.png">
+
+2. **Create a Kubernetes Secret for the Cloudflare API Token:**
+
+Next, create a Kubernetes secret to securely store the Cloudflare API token within the AKS cluster. This secret will be referenced by Cert Manager during DNS validation.
+
+```yaml
+apiVersion: "v1"
+kind: Secret
+metadata:
+  name: cf-dns-secret
+stringData:
+  token: "YOUR-CF-DNS-TOKEN"
+# Replace 'YOUR-CF-DNS-TOKEN' with the actual API token generated in the previous step.
+```
+
+3. **Cert Manager Installation:**
+
+- **Create a values.yaml file for Helm Installation:**
+  Before installing Cert Manager, create a values.yaml file with the following content. The extraArgs section is important as it directs Cert Manager to use Cloudflare’s DNS resolver for DNS-01 challenge validation.
+
+```yaml
+# auto create CRD resources
+installCRDs: true
+
+# Default ingress value
+ingressShim:
+  defaultIssuerName: "letsencrypt-prod"
+  defaultIssuerKind: "ClusterIssuer"
+  defaultIssuerGroup: "cert-manager.io"
+
+#extra args is important for Cloudflare DNS validation
+extraArgs:
+  - --dns01-recursive-nameservers-only
+  - --dns01-recursive-nameservers=1.1.1.1:53
+```
+
+This configuration ensures that Cert Manager will only use Cloudflare’s DNS servers (specifically 1.1.1.1:53) to perform DNS-01 challenge validation, which is necessary for issuing SSL certificates.
+
+- **Install Cert Manager with Helm:**
+  Now, proceed with installing Cert Manager using Helm. The following commands will add the Jetstack Helm repository, update it, and then install Cert Manager with the custom values.yaml configuration file above.
+
+```shell
+helm repo add jetstack https://charts.jetstack.io
+helm repo update
+
+helm install cert-manager jetstack/cert-manager \
+  --values values.yaml \
+  -n cert-manager \
+  --create-namespace --cleanup-on-fail
+```
+
+- **Set Up a ClusterIssuer for Cert Manager:**
+  The next step is create a ClusterIssuer resource to define how Cert Manager should obtain SSL certificates. The following template uses the Cloudflare DNS API token stored in the Kubernetes secret created earlier.
+
+```yaml
+apiVersion: cert-manager.io/v1
+kind: ClusterIssuer
+metadata:
+  name: letsencrypt-prod
+spec:
+  acme:
+    server: https://acme-v02.api.letsencrypt.org/directory
+    # Replace with the administrator email associated with your domain.
+    email: "admin@drunk.dev"
+    privateKeySecretRef:
+      name: letsencrypt-prod
+    solvers:
+      - dns01:
+          cloudflare:
+            #Update this accoring to your domain
+            email: "admin@drunk.dev"
+            # Ensure that the name matches the secret you created (cf-dns-secret),
+            # and the key references the correct data key within the secret (token).
+            apiTokenSecretRef:
+              name: cf-dns-secret
+              key: token
+```
+
+- **Firewall Whitelisting**
+
+Since the AKS cluster’s outbound traffic is managed by a firewall, it’s neededs to whitelist specific external services to ensure that Cert Manager can successfully issue certificates. Without these exceptions, the certificate issuance process will fail.
+
+Here’s what needs to allow in the Firewall rules:
+
+- Allow outbound access to `api.cloudflare.com` on port `443`.
+- Allow outbound access to `*.api.letsencrypt.org` on port `443`.
+
+---
+
+## Nginx Ingress Installation
+
+Setting up NGINX Ingress in a private AKS environment involves configuring it to use a private IP address and an internal ingress class.
+
+1. **Install NGINX Ingress Controller**: To deploy NGINX as an internal Ingress controller with a private IP address, create a values.yaml file with the following configuration.
+
+```yaml
+controller:
+  hostNetwork: "false"
+  useIngressClassOnly: "true"
+  watchIngressWithoutClass: "true"
+  # the ingress class name is internal
+  ingressClass: "internal"
+  # The custom ingress class
+  ingressClassResource:
+    name: "internal"
+    enabled: true
+    default: true
+    controllerValue: k8s.io/ingress-nginx
+  service:
+    annotations:
+      # This annotation to tell Azure to create an internal load balancer.
+      service.beta.kubernetes.io/azure-load-balancer-internal: "true"
+    externalTrafficPolicy: "Local"
+    # update this private IP address accroding to your address spaces.
+    loadBalancerIP: "192.168.250.250"
+```
+
+**Explanation:**
+
+- `hostNetwork`: false ensures that the NGINX pods do not bind directly to the node’s network interfaces, maintaining isolation.
+- `useIngressClassOnly`: Ensures that only Ingress resources with the specified ingressClass will be processed by this controller.
+- `ingressClass`: Named internal to distinguish it from other Ingress classes, ensuring it’s used specifically for internal traffic.
+- `service.annotations`: The key annotation service.beta.kubernetes.io/azure-load-balancer-internal: 'true' tells Azure to create an internal load balancer instead of a public one.
+- `loadBalancerIP`: Assigns a static private IP address (192.168.250.250) to the NGINX load balancer, ensuring it’s accessible only within the internal network.
+  Once NGINX is deployed with this configuration, it will only be accessible from within the internal network via the private IP address `192.168.250.250`.
+
+**Install Nginx with Helm**
+
+```shell
+helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
+helm repo update
+
+helm nginx ingress-nginx/ingress-nginx \
+  --values values.yaml \
+  -n  nginx-ingress \
+  --create-namespace --cleanup-on-fail
+```
+
+2. **Configure DNS for Internal Access**
+
+After deploying the NGINX Ingress controller, the next step is to ensure that internal DNS queries resolve to the NGINX private IP. To do this, add an A record in the Azure private DNS zone that created earlier:
+
+- **DNS Record**: Add an A record pointing to 192.168.250.250 for the internal domain. This ensures that any internal traffic destined for blogs.drunk.dev is routed to the NGINX Ingress controller.
+  <img src="/assets/aks-cert-manager-with-private-aks/az-private-dns.png">
+
+3. **Create a Secure Ingress with Dynamic TLS Certificate Generation**
+
+Now, it’s time to create a secure Ingress resource that uses dynamic TLS certificate generation.
+
+Here’s an example configuration:
+
+```yaml
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: drunk-blog-apps
+  namespace: drunk-apps
+  annotations:
+    kubernetes.io/tls-acme: "true"
+    nginx.ingress.kubernetes.io/backend-protocol: HTTP
+    ingress.kubernetes.io/force-ssl-redirect: "true"
+spec:
+  # the name of ingress class percificly here.
+  ingressClassName: internal
+  # The tls config
+  tls:
+    - hosts:
+        - blogs.drunk.dev
+      secretName: tls-blogs-lets
+  rules:
+    # the host config
+    - host: blogs.drunk.dev
+      http:
+        paths:
+          - path: /
+            pathType: Prefix
+            backend:
+              service:
+                name: blog-apps
+                port:
+                  number: 8080
+```
+
+**Key Points:**
+
+- `ingressClassName`: Specifies that this Ingress resource should be handled by the internal Ingress class, ensuring it’s routed through the private NGINX controller.
+- `tls`: Configures automatic TLS certificate generation for `blogs.drunk.dev` using Cert Manager. The certificate will be stored in a Kubernetes secret named `tls-blogs-lets`.
+- `annotations`: The force-ssl-redirect: 'true' annotation ensures that all HTTP traffic is redirected to HTTPS, securing the communication.
+
+Once the Ingress resource is created, Cert Manager will automatically issue a TLS certificate for `blogs.drunk.dev` and bind it to the Ingress. The certificate will be monitored and automatically renewed by Cert Manager before expiration, ensuring continuous security without manual intervention.
+
+---
+
+### Conclusion
+
+So, that’s how I secured internal communications within my private AKS environment using Cert Manager and Cloudflare DNS management. This approach simplified the management of SSL certificates and provided an extra layer of security for internal data transmissions.
+
+I hope you found this walkthrough helpful or at least interesting. If you have any thoughts, questions, or would like to share your own experiences, feel free to reach out. I’m always keen to hear how others are tackling similar challenges!
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*

tools-automate-letsencrypt-certification-with-azure-keyvault.md

@@ -0,0 +1,255 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-08-26T12:00:00Z
+title: "[Tools] Automating Let's Encrypt Certificate Management with Azure Key Vault and Cloudflare"
+postSlug: tools-automate-letsencrypt-certification-with-azure-keyvault
+featured: false
+draft: false
+tags:
+  - azure-key-vault
+  - lets-encrypt
+  - cloudflare
+  - tools
+description: "This post introduces a tool that automates the generation and renewal of Let's Encrypt certificates, importing them into Azure Key Vault. 
+It detects certificates nearing expiration and only regenerates those, supporting multiple domains managed via Cloudflare. 
+The tool runs as a monthly cron job on AKS, ensuring SSL certificates are always up to date without manual intervention."
+---
+
+## Introduction
+
+Custom domain names enhance the professionalism and credibility of applications hosted on Azure services.
+However, associating a custom domain requires a trusted SSL/TLS certificate. For **development and sandbox environments**
+used internally by development teams, leveraging **Let's Encrypt** certificates offers a convenient and automated solution.
+Let's Encrypt provides free SSL certificates, but they have a short lifespan of only 90 days, necessitating frequent renewals.
+
+To streamline this process, I've developed a tool that automates the generation and renewal of Let's Encrypt certificates specifically for development
+and sandbox environments. The tool detects expiring certificates and renews only those that are nearing expiration, ensuring efficient management.
+The new certificates are securely imported into **Azure Key Vault**, allowing seamless integration with Azure resources such as **Azure API Management**
+and **Azure Front Door**. To eliminate manual intervention entirely, the tool runs as a monthly cron job on **Azure Kubernetes Service (AKS)**.
+
+## Why Automate Certificate Management?
+
+Manually managing short-lived Let's Encrypt SSL certificates can be time-consuming and error-prone, especially when dealing with multiple domains
+and environments. Automating the certificate management process offers several significant advantages:
+
+- **Cost Savings for Development and Sandbox Environments**: Let's Encrypt provides a free alternative to paid certificates,
+  making it ideal for non-production environments where cost optimization is important.
+
+- **Elimination of Certificate Expiration Concerns**: The tool proactively identifies and renews certificates nearing expiration,
+  ensuring your services remain secure without requiring manual intervention.
+
+- **Simplified Management of Multiple Domains**: With built-in support for handling multiple domains via **Cloudflare**,
+  the tool streamlines the process of managing DNS challenges required for certificate validation.
+
+- **Secure Integration with Azure Key Vault**: Automatically importing generated certificates into Azure Key Vault provides a secure
+  and centralized storage solution, enhancing overall security and simplifying certificate management across your Azure resources.
+
+## How It Works
+
+The tool automates SSL certificate management by running as a **monthly cron job** on AKS. It handles the entire lifecycle of SSL certificates, from detection of impending expiration to deployment of new certificates. The workflow is as follows:
+
+1. **Check Certificate Expiration**: The tool scans all certificates stored in Azure Key Vault to determine their expiration dates.
+
+2. **Generate New Certificates**: For certificates nearing expiration, the tool requests new SSL certificates from **Let's Encrypt**.
+
+3. **DNS Challenge via Cloudflare**: The tool integrates with **Cloudflare** to perform DNS challenges required by Let's Encrypt to validate domain ownership.
+
+4. **Import Certificates to Azure Key Vault**: The newly obtained certificates are securely imported into **Azure Key Vault**, replacing the old certificates.
+
+5. **Automated Monthly Execution**: The tool is scheduled to run monthly on AKS, ensuring that certificates are kept up-to-date with minimal manual effort.
+
+## Setting Up Cloudflare DNS API Token
+
+To enable the tool to perform DNS challenges for domain validation, you need to create a Cloudflare API token with permissions to manage DNS records.
+
+1. **Create an API Token**:
+
+   - Log in to your Cloudflare account and navigate to your profile.
+   - Go to the **API Tokens** section or directly via [this link](https://dash.cloudflare.com/profile/api-tokens).
+   - Click on **"Create Token"**.
+
+2. **Configure Token Permissions**:
+
+   - **Permissions**: Grant **Zone** > **DNS** > **Edit** permissions.
+   - **Zone Resources**: Select **Specific Zone** and choose the domain(s) you want to manage.
+
+3. **Client IP Address Filtering (Optional but Recommended)**:
+
+   - For enhanced security, specify the AKS cluster's public IP address under **"Client IP Address Filtering"** in the token settings.
+   - This restricts API token usage to requests originating from your AKS cluster, preventing unauthorized access.
+
+4. **Save the Token**:
+
+   - Generate the token and copy it. You'll need it for the tool's configuration.
+
+![Cloudflare API Token Creation](/assets/tools-aks-cert-manager-with-private-aks/cf-dns-token.png)
+
+## Configuration
+
+The tool is configured using environment variables or a JSON configuration file. Here's an example `appsettings.json` file:
+
+```json
+{
+  "CertManager": {
+    "ProductionEnabled": true,
+    "CfEmail": "your-cloudflare-email@example.com",
+    "CfToken": "YOUR_CLOUDFLARE_API_TOKEN",
+    "ZoneId": "YOUR_CLOUDFLARE_ZONE_ID",
+    "LetsEncryptEmail": "your-email@example.com",
+    "Domains": ["api.example.com", "*.example.com"],
+    "CertInfo": {
+      "CountryName": "SG",
+      "State": "Singapore",
+      "Locality": "Singapore",
+      "Organization": "YourOrganization",
+      "OrganizationUnit": "YourUnit"
+    },
+    "KeyVaultUrl": "https://your-keyvault-name.vault.azure.net/",
+    "KeyVaultUID": "OPTIONAL_USER_ASSIGNED_IDENTITY_CLIENT_ID"
+  }
+}
+```
+
+**Configuration Parameters Explained**:
+
+- **ProductionEnabled**: Set to `true` to use Let's Encrypt production environment. Set to `false` for testing purposes.
+
+- **CfEmail**: Your Cloudflare account email address.
+
+- **CfToken**: The Cloudflare API token created earlier.
+
+- **ZoneId**: The ID of your Cloudflare DNS zone. You can find this in your Cloudflare dashboard under the domain's **Overview** section.
+
+- **LetsEncryptEmail**: An email address for Let's Encrypt notifications.
+
+- **Domains**: An array of domains and subdomains for which you want to generate certificates.
+
+- **CertInfo**: Certificate subject information.
+
+- **KeyVaultUrl**: The URL of your Azure Key Vault where certificates will be stored.
+
+- **KeyVaultUID**: The Client ID of the User Assigned Managed Identity (UAMI) used by your AKS cluster (optional if using the default identity).
+
+## Deploying to AKS
+
+### Prerequisites
+
+- An AKS cluster where the tool will run.
+
+- The AKS cluster's agent pool has a User Assigned Managed Identity (UAMI) for Azure resource authentication.
+
+- Access to the Azure Key Vault where certificates will be stored.
+
+### Granting Key Vault Access to AKS UAMI
+
+Before deploying the tool, you need to grant your AKS cluster's UAMI the necessary permissions to access Azure Key Vault:
+
+1. **Identify the AKS Agent Pool UAMI**:
+
+   - In the Azure portal, navigate to your AKS cluster.
+   - Under **Settings**, select **Identity**.
+   - Note the **Client ID** of the **User Assigned** identity associated with your node pools.
+
+![AKS User Assigned Managed Identity](/assets/tools-automate-letsencrypt-certification-with-azure-keyvault/aks-uaid.png)
+
+2. **Grant Key Vault Permissions**:
+
+   - Navigate to your Azure Key Vault.
+   - Select **Access control (IAM)**.
+   - Click on **"Add role assignment"**.
+   - In the **Role** dropdown, select **"Key Vault Certificates Officer"**.
+   - Click **Next** and select the AKS UAMI as the **Member**.
+   - Review and assign the role.
+
+By granting the **Key Vault Certificates Officer** role to your AKS UAMI, you allow the tool running on AKS to manage certificates within the Key Vault.
+
+### Deploying the Tool Using Helm
+
+Assuming you are using Helm for deployment, you can update your Helm chart values file with the necessary configurations.
+
+Here's an example `values.yaml` file:
+
+```yaml
+services:
+  cert-renewal:
+    image: baoduy2412/keyvault-letsencrypt:latest
+    environment:
+      CertManager__ProductionEnabled: "true"
+      CertManager__CfEmail: "your-cloudflare-email@example.com"
+      CertManager__CfToken: "YOUR_CLOUDFLARE_API_TOKEN"
+      CertManager__ZoneId: "YOUR_CLOUDFLARE_ZONE_ID"
+      CertManager__LetsEncryptEmail: "your-email@example.com"
+      CertManager__Domains__0: "api.example.com"
+      CertManager__Domains__1: "*.example.com"
+      CertManager__CertInfo__CountryName: "SG"
+      CertManager__CertInfo__State: "Singapore"
+      CertManager__CertInfo__Locality: "Singapore"
+      CertManager__CertInfo__Organization: "YourOrganization"
+      CertManager__CertInfo__OrganizationUnit: "YourUnit"
+      CertManager__KeyVaultUrl: "https://your-keyvault-name.vault.azure.net/"
+      CertManager__KeyVaultUID: "OPTIONAL_USER_ASSIGNED_IDENTITY_CLIENT_ID"
+    schedule: "0 0 1 * *" # Runs on the 1st of every month at midnight
+```
+
+**Notes**:
+
+- **Image**: Ensure you're using the correct Docker image.
+
+- **Environment Variables**: Update all placeholders with your actual configuration values.
+
+- **Schedule**: The cron expression `"0 0 1 * *"` schedules the job to run at midnight on the first day of every month.
+
+### Deploying the Helm Chart
+
+1. **Update Helm Repositories**:
+
+   ```bash
+   helm repo update
+   ```
+
+2. **Deploy or Upgrade the Chart**:
+
+   ```bash
+   helm upgrade --install cert-renewal ./path-to-your-chart -f values.yaml
+   ```
+
+Replace `./path-to-your-chart` with the path to your Helm chart.
+
+## Conclusion
+
+Managing SSL certificates for Azure resources with custom domains can be challenging due to the frequent renewal requirements of Let's Encrypt certificates. This tool automates the entire process of certificate generation, validation, and deployment, significantly simplifying SSL certificate management for development and sandbox environments.
+
+By running as a monthly cron job on AKS, it ensures that your certificates are always up-to-date without manual intervention. The integration with Azure Key Vault enhances security by providing centralized and secure storage of your certificates, which can be accessed by other Azure services as needed.
+
+**Leveraging Infrastructure as Code for Deployment**
+
+Once the certificates are stored in Azure Key Vault, you can further automate the deployment process by using infrastructure as code (IaC) tools like Pulumi or Terraform.
+These tools can retrieve the certificates from Key Vault and deploy them to your Azure resources automatically.
+By incorporating this into your IaC pipelines, you ensure that any updates to the certificates are seamlessly propagated to services like Azure API Management, Azure Front Door, or Azure Application Gateway, maintaining consistent and secure configurations across your infrastructure.
+
+**Key Benefits**:
+
+- **Automated Renewal**: Eliminates the manual effort required to renew Let's Encrypt certificates every 90 days.
+
+- **Cost Efficiency**: Uses free Let's Encrypt certificates, reducing costs for non-production environments.
+
+- **Scalability**: Easily manages multiple domains and environments.
+
+- **Security**: Securely stores certificates in Azure Key Vault and restricts Cloudflare API access to your AKS cluster.
+
+Give it a try and simplify your SSL certificate management process!
+
+---
+
+**Resources**:
+
+- **GitHub Repository**: [az-keyvault-letsencrypt](https://github.com/baoduy/az-keyvault-letsencrypt)
+- **Docker Image**: [baoduy2412/keyvault-letsencrypt](https://hub.docker.com/r/baoduy2412/keyvault-letsencrypt)
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*

tools-az-scan-and-disable-entra-accounts.md

@@ -0,0 +1,497 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-07-29T12:00:00Z
+title: "[AZ] How to Scan and Disable Inactive Accounts on Azure EntraID"
+postSlug: tools-az-scan-and-disable-entra-accounts
+featured: false
+draft: false
+tags:
+  - Azure
+  - EntraID
+  - Disable Account
+ogImage: ""
+description:
+  Inactive accounts in Azure EntraID can pose significant security risks.
+  This post discusses the importance of implementing a housekeeping strategy and introduces a streamlined approach using Azure DevOps.
+---
+
+## Introduction
+
+As organizations grow, so does the number of user accounts within their systems. Managing these accounts efficiently is crucial for maintaining security and compliance. In particular, inactive accounts in **Azure Entra ID** (formerly known as Azure Active Directory) can pose significant security risks. These dormant accounts are potential entry points for malicious actors seeking unauthorized access to sensitive data.
+
+In this comprehensive guide, we'll walk through how to automate the management of inactive Azure Entra ID accounts using a TypeScript application. We'll cover everything from setting up an Azure Entra ID application, implementing the TypeScript program, to scheduling the script using Azure DevOps for regular execution.
+
+## Table of Contents
+
+1. [Understanding the Risks of Inactive Accounts](#1-understanding-the-risks-of-inactive-accounts)
+2. [Creating an Azure Entra ID Application](#2-creating-an-azure-entra-id-application)
+3. [Implementing the TypeScript Program](#3-implementing-the-typescript-program)
+4. [Scheduling the Script with Azure DevOps](#4-scheduling-the-script-with-azure-devops)
+5. [Conclusion](#5-conclusion)
+
+---
+
+## 1. Understanding the Risks of Inactive Accounts
+
+Inactive accounts are user accounts that haven't been used for a significant period. They can accumulate due to employee turnover, role changes, or users simply forgetting about them. These accounts are risky because:
+
+- **Security Vulnerabilities**: They might have weak or outdated passwords, making them easy targets.
+- **Unauthorized Access**: If compromised, they can provide unauthorized access to internal systems and data.
+- **Compliance Issues**: Regulations often require the timely removal or deactivation of unused accounts.
+
+Regularly auditing and managing these accounts helps mitigate these risks and ensures compliance with security best practices.
+
+---
+
+## 2. Creating an Azure Entra ID Application
+
+To interact with Azure Entra ID programmatically, we'll create an **App Registration**.
+This application will authenticate and manage user accounts via the Microsoft Graph API.
+
+### Steps to Create an App Registration
+
+#### 1. Navigate to Azure Entra ID
+
+- Log in to the [Azure portal](https://portal.azure.com).
+- In the left-hand navigation pane, select **Azure Entra ID**.
+
+#### 2. Create a New App Registration
+
+- Click on **"App registrations"** in the sidebar.
+- Click on **"New registration"** at the top.
+
+![App Registration Navigation](/assets/tools-az-scan-and-disable-entra-accounts/app-registration.png)
+
+#### 3. Configure the App Registration
+
+- **Name**: Enter a meaningful name, e.g., `Azure-EntraID-Management` app.
+- **Supported account types**: Choose **"Accounts in this organizational directory only (Single tenant)"**.
+- **Redirect URI**: This is not required for our application, so you can leave it blank.
+- Click **"Register"** to create the app.
+
+### Adding API Permissions
+
+After creating the app registration, we need to grant it permissions to access the Microsoft Graph API.
+
+#### 1. Navigate to API Permissions
+
+- In the app registration's overview page, click on **"API permissions"** in the sidebar.
+
+#### 2. Add Permissions
+
+- Click on **"Add a permission"**.
+- Select **"Microsoft Graph"**.
+- Choose **"Application permissions"** since this app will run as a background service or daemon.
+
+#### 3. Select Required Permissions
+
+Search for and select the following permissions:
+
+- **`AuditLog.Read.All`**: Allows the app to read all audit log data.
+- **`User.Read.All`**: Allows the app to read user profiles.
+- **`User.ReadWrite.All`**: Allows the app to read and write user profiles.
+
+![API Permissions](/assets/tools-az-scan-and-disable-entra-accounts/app-api-permission.png)
+
+> **Note**: The **`User.ReadWrite.All`** permission is required to enable or disable user accounts.
+
+#### 4. Grant Admin Consent
+
+- After adding the permissions, click on **"Grant admin consent for [Your Tenant Name]"**.
+- Confirm by clicking **"Yes"** in the prompt.
+
+#### 5. Create a Client Secret
+
+- Navigate to **"Certificates & secrets"**.
+- Click on **"New client secret"**.
+- Provide a description and set an expiration period.
+- Click **"Add"**.
+- Copy the **Value** of the client secret and store it securely. You won't be able to view it again.
+
+### Collect Necessary Information
+
+You'll need the following information for your application:
+
+- **Tenant ID**: Found in **Azure Entra ID** > **Properties**.
+- **Client ID**: Found in your app registration's **Overview** page.
+- **Client Secret**: The value you just created.
+
+---
+
+## 3. Implementing the TypeScript Program
+
+We'll create a TypeScript program that:
+
+- Authenticates with Azure Entra ID using the app registration.
+- Retrieves inactive user accounts based on their last sign-in date.
+- Disables these inactive accounts.
+- Generates a report of all disabled accounts.
+
+### Setting Up the Project
+
+#### 1. Initialize the Project
+
+Create a new directory for your project and initialize npm:
+
+```bash
+mkdir azure-entra-id-management
+cd azure-entra-id-management
+npm init -y
+```
+
+#### 2. Install Dependencies
+
+Install the required packages:
+
+```bash
+npm install @azure/identity @microsoft/microsoft-graph-client dayjs
+npm install --save-dev typescript ts-node
+```
+
+- **`@azure/identity`**: Provides Azure authentication methods.
+- **`@microsoft/microsoft-graph-client`**: Allows interaction with Microsoft Graph API.
+- **`dayjs`**: A lightweight library for date manipulation.
+- **`typescript`** and **`ts-node`**: Required for compiling and running TypeScript code.
+
+#### 3. Configure TypeScript
+
+Create a `tsconfig.json` file:
+
+```json
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "target": "es6",
+    "moduleResolution": "node",
+    "sourceMap": true,
+    "outDir": "dist"
+  },
+  "lib": ["es2015"],
+  "files": ["index.ts"]
+}
+```
+
+### Writing Code
+
+#### 1. Create the Source File and Import Required Modules
+
+At the top of `index.ts`, import the necessary modules:
+
+```typescript
+import { DefaultAzureCredential } from "@azure/identity";
+import { Client } from "@microsoft/microsoft-graph-client";
+import { TokenCredentialAuthenticationProvider } from "@microsoft/microsoft-graph-client/authProviders/azureTokenCredentials";
+import dayjs from "dayjs";
+```
+
+> **Note**: The `isomorphic-fetch` import is necessary for environments where `fetch` is not available globally.
+
+#### 2. Set Configuration Variables
+
+Define the configuration variables and excluded accounts:
+
+```typescript
+// Configuration
+const INACTIVITY_THRESHOLD_MONTHS = 2; // Adjust as needed
+const EXCLUDED_ACCOUNTS = ["admin@example.com", "serviceaccount@example.com"];
+
+// Azure AD App Credentials - Replace with your actual credentials or use environment variables
+const TENANT_ID = process.env.AZURE_TENANT_ID;
+const CLIENT_ID = process.env.AZURE_CLIENT_ID;
+const CLIENT_SECRET = process.env.AZURE_CLIENT_SECRET;
+```
+
+> **Security Tip**: Never hard-code credentials. Use environment variables or secure credential management.
+
+#### 3. Set Up Authentication and Client
+
+Create a `ClientSecretCredential` and initialize the Microsoft Graph client:
+
+```typescript
+if (!TENANT_ID || !CLIENT_ID || !CLIENT_SECRET) {
+  throw new Error(
+    "Please ensure AZURE_TENANT_ID, AZURE_CLIENT_ID, and AZURE_CLIENT_SECRET are set."
+  );
+}
+
+/** 1. Setup Credentials and Microsoft Graph client */
+const client = Client.initWithMiddleware({
+  debugLogging: false,
+  authProvider: new TokenCredentialAuthenticationProvider(
+    // This DefaultAzureCredential will detect the credentials from environment variables above automatically.
+    new DefaultAzureCredential(),
+    {
+      scopes: ["https://graph.microsoft.com/.default"],
+    }
+  ),
+});
+```
+
+#### 4. Define Types
+
+Define types for the Azure AD user and result:
+
+```typescript
+type AzResult<T> = { value: Array<T> };
+type AdUser = {
+  userPrincipalName: string;
+  id: string;
+  accountEnabled: boolean;
+};
+```
+
+#### 5. Implement Functions
+
+##### a. Retrieve Inactive Accounts
+
+```typescript
+async function getInactiveAccounts(cutoffDate: Dayjs): Promise<AdUser[]> {
+  /** Query all the accounts that has signInActivity date before the expected parameter date */
+  const accounts = (await client
+    .api("/users/")
+    .filter(`signInActivity/lastSignInDateTime lt ${cutoffDate.toISOString()}`)
+    .select("id,userPrincipalName,accountEnabled")
+    .get()) as AzResult<AdUser>;
+
+  /** Filter the enabled account only here
+   * as the API filter has limitation that not allows to query based on both signInActivity and accountEnabled */
+  return accounts.value.filter(m => m.accountEnabled);
+}
+```
+
+> **Note**: The Microsoft Graph API may paginate results. The loop ensures all pages are retrieved.
+
+##### b. Disable Accounts
+
+```typescript
+async function disableAccounts(users: AdUser[]): Promise<void> {
+  return await Promise.all(
+    accounts.map(async u => {
+      /* Check and keep the account if found in the excludedAccounts */
+      if (
+        EXCLUDED_ACCOUNTS.find(a =>
+          u.userPrincipalName.toLowerCase().includes(a.toLowerCase())
+        )
+      ) {
+        console.log(
+          `User account ${u.userPrincipalName} has been excluded from disabling.`
+        );
+        return;
+      }
+
+      // Perform the account disabling
+      await client.api(`/users/${u.id}`).update({
+        accountEnabled: false,
+      });
+
+      console.log(
+        `User account with ID ${u.userPrincipalName} has been disabled.`
+      );
+    })
+  );
+}
+```
+
+##### c. Retrieve Disabled Accounts
+
+```typescript
+async function getDisabledAccounts(): Promise<AdUser[]> {
+  /** Query all the accounts that has accountEnabled is false */
+  const rs = (await client
+    .api("/users/")
+    .filter(`accountEnabled eq false`)
+    .select("id,userPrincipalName,accountEnabled")
+    .get()) as AzResult<AdUser>;
+
+  return rs.value;
+}
+```
+
+##### d. Print Accounts
+
+```typescript
+function printAccounts(message: string, accounts: AdUser[]): void {
+  console.log(message);
+  accounts.forEach((user, index) => {
+    console.log(
+      `${index + 1}. ${user.userPrincipalName} (Enabled: ${user.accountEnabled})`
+    );
+  });
+}
+```
+
+#### 6. Main Execution Function
+
+Finally, create the main function to orchestrate the process:
+
+```typescript
+(async () => {
+  try {
+    //1. Scanning account that inactive for more than 2 months
+    const cutoffDate = dayjs().subtract(INACTIVITY_THRESHOLD_MONTHS, "month");
+    console.log(
+      `Scanning for accounts inactive since before ${cutoffDate.format("YYYY-MM-DD")}...\n`
+    );
+
+    // Retrieve inactive accounts
+    const inactiveAccounts = await getInactiveAccounts(cutoffDate);
+    printAccounts(
+      `Found ${inactiveAccounts.length} inactive account(s):`,
+      inactiveAccounts
+    );
+
+    // Disable inactive accounts
+    if (inactiveAccounts.length > 0) {
+      await disableAccounts(inactiveAccounts);
+    } else {
+      console.log("No inactive accounts to disable.");
+    }
+
+    // Retrieve and print disabled accounts
+    const disabledAccounts = await getDisabledAccounts();
+    printAccounts(`\nCurrently disabled accounts:`, disabledAccounts);
+  } catch (error) {
+    console.error("An error occurred:", error);
+  }
+})();
+```
+
+#### 7. Running the Program
+
+Ensure the environment variables are set:
+
+```bash
+export AZURE_TENANT_ID=your_tenant_id
+export AZURE_CLIENT_ID=your_client_id
+export AZURE_CLIENT_SECRET=your_client_secret
+```
+
+Compile and run the program:
+
+```bash
+npx ts-node src/index.ts
+```
+
+---
+
+## 4. Scheduling the Script with Azure DevOps
+
+To automate the execution of the script, we'll use Azure DevOps to schedule it as part of a pipeline.
+
+### Steps to Schedule the Script
+
+#### 1. Commit the Code to a Repository
+
+- Create a Git repository in Azure DevOps.
+- Commit all your code, including the `package.json`, `tsconfig.json`, and `src` directory.
+
+#### 2. Create a Variable Group
+
+Navigate to **Pipelines** > **Library** in Azure DevOps.
+
+- Click **"Variable groups"** and then **"Add variable group"**.
+- Name the variable group, e.g., `AzureEntraIDCredentials`.
+- Add the following variables:
+  - `AZURE_TENANT_ID`
+  - `AZURE_CLIENT_ID`
+  - `AZURE_CLIENT_SECRET`
+- For each variable, enter the corresponding value and mark it as **secret**.
+- Save the variable group.
+
+![Variable Group](/assets/tools-az-scan-and-disable-entra-accounts/variable-group.png)
+
+#### 3. Create the Pipeline
+
+In **Pipelines**, click **"Create Pipeline"** and follow the prompts to set up a YAML pipeline.
+
+##### a. Define the YAML Pipeline
+
+Create a `azure-pipelines.yml` file in your repository with the following content:
+
+```yaml
+trigger: none
+
+schedules:
+  - cron: "0 0 * * 0" # Runs at midnight every Sunday
+    displayName: "Weekly Sunday Run"
+    branches:
+      include:
+        - main
+    always: true
+    batch: false
+
+pool:
+  vmImage: "ubuntu-latest"
+
+variables:
+  - group: AzureEntraIDCredentials
+
+steps:
+  - task: NodeTool@0
+    inputs:
+      versionSpec: "14.x" # Adjust Node.js version as needed
+    displayName: "Install Node.js"
+
+  - script: |
+      npm ci
+      npx ts-node src/index.ts
+    displayName: "Install dependencies and run script"
+    env:
+      AZURE_TENANT_ID: $(AZURE_TENANT_ID)
+      AZURE_CLIENT_ID: $(AZURE_CLIENT_ID)
+      AZURE_CLIENT_SECRET: $(AZURE_CLIENT_SECRET)
+```
+
+##### b. Pipeline Explanation
+
+- **Trigger**: Set to `none` to prevent automatic builds on code changes.
+- **Schedules**: Configured to run every Sunday at midnight.
+- **Pool**: Uses the latest Ubuntu VM image.
+- **Variables**: Includes the variable group with your credentials.
+- **Steps**:
+  - **NodeTool**: Ensures Node.js is available on the agent.
+  - **Script**: Installs dependencies and runs the script.
+
+#### 4. Run and Monitor the Pipeline
+
+- Save and run the pipeline manually to test it.
+- Monitor the pipeline's execution in the **Pipelines** section.
+- Ensure that the script runs successfully and performs the expected actions.
+
+#### 5. Secure the Pipeline
+
+- **Permissions**: Ensure only authorized personnel can modify the pipeline and variable group.
+- **Secret Variables**: Keep your credentials secure by marking them as secrets and avoiding logging sensitive information.
+
+---
+
+## 5. Conclusion
+
+Automating the management of inactive Azure Entra ID accounts enhances your organization's security posture by reducing potential attack surfaces. By leveraging TypeScript and Azure DevOps, you can create a scalable and maintainable solution that integrates seamlessly with your existing workflows.
+
+> You can refer the **Full Working Source Code here**: [drunkcoding public code](https://dev.azure.com/drunk24/drunkcoding-public/_git/az.tools?path=/az-entraID-scan&version=GBmain)
+
+### Key Takeaways
+
+- **Security First**: Regularly auditing and managing inactive accounts is critical for security and compliance.
+- **Automation**: Automating tasks reduces manual effort and the likelihood of human error.
+- **Scalability**: Using TypeScript and Azure DevOps allows for easy updates and scalability as your organization grows.
+
+### Next Topic
+
+- **Enhancements**: Extend the script to send email notifications before disabling accounts.
+- **Logging**: Integrate logging mechanisms for better auditing and monitoring.
+- **Policy Compliance**: Ensure the solution complies with your organization's policies and any applicable regulations.
+
+---
+
+> **Important**: Accessing certain Microsoft Graph API endpoints requires appropriate licensing. Ensure you have the necessary Microsoft Entra ID P2 or equivalent licenses to use the AuditLog API and other premium features.
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*

tools-az-service-bus-dead-letters-cleanup.md

@@ -0,0 +1,265 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-08-26T12:00:00Z
+title: "[Tools] Cleaning Up Azure Service Bus Dead-Letter Queues with .NET"
+postSlug: tools-az-service-bus-dead-letters-cleanup
+featured: false
+draft: false
+tags:
+  - azure-servicebus-cleanup
+  - deadletters-cleanup
+  - tools
+description: "This post highlights the importance of regularly cleaning Azure Service Bus Dead-Letter Queues (DLQs) to prevent `QuotaExceededException` storage issues and maintain performance. 
+It explains how to automate the process with a .NET background service that moves dead-letter messages to Azure Blob Storage for future analysis, 
+along with a ready-to-use Docker image for easy deployment."
+---
+
+## Introduction
+
+In cloud-based applications, message queues are critical for enabling reliable, asynchronous communication between services. **Azure Service Bus** is a robust messaging platform that facilitates this communication in distributed systems. However, messages that cannot be processed or delivered successfully may end up in the **Dead-Letter Queue (DLQ)**. If left unmanaged, these dead-letter messages can accumulate, leading to storage issues and degraded system performance.
+
+In this article, we'll explore the importance of regularly cleaning up dead-letter queues in Azure Service Bus. We'll guide you through implementing a .NET background service that automates this cleanup process by moving dead-letter messages to Azure Blob Storage. This approach ensures your messaging system remains efficient while preserving problematic messages for future analysis or reprocessing.
+
+## Table of Contents
+
+## Understanding Dead-Letter Queues
+
+A **Dead-Letter Queue (DLQ)** is a sub-queue associated with each Azure Service Bus entity (queue or topic subscription). It holds messages that cannot be delivered or processed successfully. Messages may be moved to the DLQ for several reasons:
+
+- **Exceeding Maximum Delivery Attempts**: A message is retried multiple times but still cannot be processed successfully.
+- **Message Expiration**: The message's **Time to Live (TTL)** expires before it is processed.
+- **Filter Violations**: The message does not match the filter criteria of a subscription.
+- **Processing Errors**: An application explicitly moves a message to the DLQ due to a processing failure.
+
+By design, the DLQ provides a way to isolate faulty messages, allowing your system to continue processing valid messages without interruption.
+
+## Why Regularly Clean Up Dead-Letter Messages?
+
+### 1. Prevent Storage Overruns
+
+Dead-letter messages accumulate over time, consuming storage resources. If left unchecked, this can lead to a `QuotaExceededException`, where the maximum size limit for a Service Bus entity is reached:
+
+```
+Microsoft.Azure.ServiceBus.QuotaExceededException:
+The maximum entity size has been reached or exceeded for Topic:
+'YourTopicName'. Size of entity in bytes: 2147489161, Max entity size in bytes: 2147483648.
+```
+
+This exception can disrupt normal operations, preventing new messages from being sent or received.
+
+### 2. Maintain System Performance and Reliability
+
+Large volumes of dead-letter messages can degrade the performance of your Service Bus namespace. They can slow down operations such as message retrieval and monitoring, leading to bottlenecks in your system.
+
+### 3. Enable Effective Error Handling and Analysis
+
+By archiving dead-letter messages to Azure Blob Storage, you retain the ability to analyze and diagnose issues without impacting the performance of your messaging system. This allows your team to:
+
+- **Investigate Failures**: Understand why messages failed and identify patterns.
+- **Reprocess Messages**: Correct issues and resend messages if necessary.
+- **Improve Resilience**: Implement fixes to prevent similar failures in the future.
+
+## Implementing a Dead-Letter Cleanup Service with .NET
+
+To automate the cleanup process, we'll create a .NET background service that:
+
+1. **Retrieves dead-letter messages** from all queues and topic subscriptions.
+2. **Archives messages** to Azure Blob Storage.
+3. **Deletes messages** from the DLQ after successful archiving.
+
+### Prerequisites
+
+- **Azure Service Bus Namespace**: With appropriate permissions (Manage rights) to access queues and topics.
+- **Azure Storage Account**: For storing archived dead-letter messages.
+- **.NET 6 SDK**: Installed on your development machine.
+- **Docker**: (Optional) For containerized deployment.
+
+### Getting the Source Code
+
+The source code for the cleanup tool is available on GitHub:
+
+- **Repository**: [Azure Service Bus Dead-Letter Cleanup Tool](https://github.com/baoduy/tool-serviceBus-deadLetters-cleanup)
+
+### Service Configuration
+
+The service uses an `appsettings.json` file for configuration:
+
+```json
+{
+  "ServiceBus": {
+    "ConnectionString": "YOUR_SERVICE_BUS_CONNECTION_STRING"
+  },
+  "StorageAccount": {
+    "ConnectionString": "YOUR_STORAGE_ACCOUNT_CONNECTION_STRING",
+    "ContainerName": "bus-dead-letters"
+  },
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning"
+    }
+  }
+}
+```
+
+- **ServiceBus**:
+  - `ConnectionString`: Your Azure Service Bus connection string with Manage permissions.
+- **StorageAccount**:
+  - `ConnectionString`: Your Azure Storage Account connection string.
+  - `ContainerName`: The name of the Blob Storage container where dead-letter messages will be stored.
+
+> **Security Note**: For production environments, consider using Azure Key Vault or environment variables to securely manage connection strings.
+
+### How the Cleanup Service Works
+
+1. **Connect to Azure Service Bus**: The service connects to your Service Bus namespace using the provided connection string.
+
+2. **Discover Entities**: It retrieves all queues and topic subscriptions in the namespace.
+
+3. **Process Dead-Letter Messages**:
+
+   - For each entity, it checks the DLQ for messages.
+   - If messages are found, it reads them and saves each message as a JSON file in Azure Blob Storage.
+   - The messages are organized in folders by entity name and date, making them easy to locate.
+
+4. **Delete Processed Messages**: After successfully archiving, the messages are deleted from the DLQ.
+
+### Archiving Structure in Blob Storage
+
+The messages are stored in Azure Blob Storage with the following structure:
+
+```
+bus-dead-letters/
+├── queues/
+│   ├── queue1/
+│   │   └── 2023-09-20/
+│   │       ├── message1.json
+│   │       └── message2.json
+│   └── queue2/
+│       └── 2023-09-20/
+│           └── message1.json
+└── topics/
+    ├── topic1/
+    │   ├── subscription1/
+    │   │   └── 2023-09-20/
+    │   │       └── message1.json
+    │   └── subscription2/
+    │       └── 2023-09-20/
+    │           └── message1.json
+```
+
+### Setting Up the Service
+
+#### Option 1: Running Locally
+
+1. **Clone the Repository**:
+
+   ```bash
+   git clone https://github.com/baoduy/tool-serviceBus-deadLetters-cleanup.git
+   cd tool-serviceBus-deadLetters-cleanup
+   ```
+
+2. **Configure the Service**:
+
+   - Update `appsettings.json` with your connection strings.
+   - Alternatively, set the environment variables `ServiceBus__ConnectionString`, `StorageAccount__ConnectionString`, and `StorageAccount__ContainerName`.
+
+3. **Build and Run the Service**:
+
+   ```bash
+   dotnet build
+   dotnet run
+   ```
+
+#### Option 2: Using Docker
+
+A Docker image is available for easy deployment:
+
+- **Docker Image**: [baoduy2412/servicebus-cleanup](https://hub.docker.com/r/baoduy2412/servicebus-cleanup)
+
+##### Running with Docker Compose
+
+Create a `docker-compose.yml` file:
+
+```yaml
+version: "3.8"
+
+services:
+  servicebus-cleanup:
+    image: baoduy2412/servicebus-cleanup:latest
+    environment:
+      ServiceBus__ConnectionString: YOUR_SERVICE_BUS_CONNECTION_STRING
+      StorageAccount__ConnectionString: YOUR_STORAGE_ACCOUNT_CONNECTION_STRING
+      StorageAccount__ContainerName: bus-dead-letters
+    restart: unless-stopped
+```
+
+Run the service:
+
+```bash
+docker-compose up -d
+```
+
+##### Running with Docker Command Line
+
+```bash
+docker run -d \
+  -e ServiceBus__ConnectionString=YOUR_SERVICE_BUS_CONNECTION_STRING \
+  -e StorageAccount__ConnectionString=YOUR_STORAGE_ACCOUNT_CONNECTION_STRING \
+  -e StorageAccount__ContainerName=bus-dead-letters \
+  baoduy2412/servicebus-cleanup:latest
+```
+
+### Managing Storage Costs with Lifecycle Policies
+
+Over time, archived messages in Blob Storage can accumulate and consume significant storage space. To manage this:
+
+1. **Set Up Lifecycle Management**:
+
+   - In the Azure Portal, navigate to your Storage Account.
+   - Select **Lifecycle management** under **Blob service**.
+
+2. **Create a Rule**:
+
+   - **Name**: e.g., `DeleteOldArchivedMessages`.
+   - **Scope**: Apply to the container `bus-dead-letters`.
+   - **Filter**: Optionally specify filters if needed.
+   - **Action**: Delete blobs older than a specified number of days (e.g., 30 days).
+
+3. **Save the Rule**: Azure will automatically delete archived messages older than the specified retention period.
+
+## Conclusion
+
+Dead-letter queues are an integral part of Azure Service Bus, providing a mechanism to handle messages that cannot be processed. However, without regular maintenance, they can lead to storage overruns and impact system performance.
+
+By implementing the .NET background service described in this article, you can automate the cleanup of dead-letter queues:
+
+- **Automated Cleanup**: Keeps DLQs empty, preventing storage issues.
+- **Message Archiving**: Stores messages for future analysis without impacting Service Bus performance.
+- **Scalability**: The tool operates at the namespace level, handling all queues and topics automatically.
+- **Cost Management**: Utilizes storage lifecycle policies to control storage costs.
+
+This approach ensures your messaging system remains reliable and efficient while preserving valuable data for troubleshooting and improvement.
+
+## Additional Resources
+
+- **GitHub Repository**: [Azure Service Bus Dead-Letter Cleanup Tool](https://github.com/baoduy/tool-serviceBus-deadLetters-cleanup)
+- **Docker Image**: [baoduy2412/servicebus-cleanup](https://hub.docker.com/r/baoduy2412/servicebus-cleanup)
+- **Azure Service Bus Documentation**:
+  - [Dead-letter Queues](https://docs.microsoft.com/azure/service-bus-messaging/service-bus-dead-letter-queues)
+  - [Service Bus Quotas and Limits](https://docs.microsoft.com/azure/service-bus-messaging/service-bus-quotas)
+- **Azure Blob Storage**:
+  - [Lifecycle Management Overview](https://docs.microsoft.com/azure/storage/blobs/lifecycle-management-overview)
+  - [Optimize Costs by Automating Data Lifecycle Management](https://docs.microsoft.com/azure/storage/blobs/storage-lifecycle-management-concepts)
+
+---
+
+By automating dead-letter queue management, you enhance the stability and maintainability of your messaging infrastructure, ensuring it continues to meet the demands of your applications.
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*

tools-devops-repositories-branches-cleanup.md

@@ -0,0 +1,487 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-08-21T12:00:00Z
+title: "[DevOps] Automating Branch Cleanup in Azure DevOps with Node.js"
+postSlug: tools-devops-repositories-branches-cleanup
+featured: false
+draft: false
+tags:
+  - azure-devops
+  - repo-cleanup
+  - tools
+description: "A comprehensive guide on automating the cleanup of old branches in Azure DevOps Git repositories using a Node.js script.
+The script identifies branches that haven't been updated in the last 90 days and deletes them if they meet certain criteria."
+---
+
+## Introduction
+
+As software projects evolve, Git repositories can become cluttered with outdated or redundant branches. This clutter makes repository navigation cumbersome and can introduce confusion or errors in the development process. Automating the cleanup of these branches helps maintain an organized and efficient development environment.
+
+In this guide, we'll walk through setting up a TypeScript script that automatically deletes old, unnecessary branches in Azure DevOps. We'll cover the essential steps, focusing on the implementation and automation of the cleanup process.
+
+---
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Table of Contents](#table-of-contents)
+- [Why Automate Branch Cleanup?](#why-automate-branch-cleanup)
+- [Prerequisites](#prerequisites)
+- [Project Setup](#project-setup)
+- [Configuration File](#configuration-file)
+- [Implementing the TypeScript Script](#implementing-the-typescript-script)
+  - [1. Loading Environment Variables](#1-loading-environment-variables)
+  - [2. Defining the Configuration Interface](#2-defining-the-configuration-interface)
+  - [3. Setting Constants](#3-setting-constants)
+  - [4. Getting the Git API Client](#4-getting-the-git-api-client)
+  - [5. Loading the Configuration](#5-loading-the-configuration)
+  - [6. Retrieving Repositories and Branches](#6-retrieving-repositories-and-branches)
+  - [7. Determining the Last Commit Date](#7-determining-the-last-commit-date)
+  - [8. Checking if a Branch is Merged](#8-checking-if-a-branch-is-merged)
+  - [9. Deleting a Branch](#9-deleting-a-branch)
+  - [10. Compiling the Exclusion List](#10-compiling-the-exclusion-list)
+  - [11. Cleaning Up Branches](#11-cleaning-up-branches)
+- [Automating with Azure DevOps Pipeline](#automating-with-azure-devops-pipeline)
+- [Conclusion](#conclusion)
+- [Additional Resources](#additional-resources)
+- [Thank You](#thank-you)
+
+---
+
+## Why Automate Branch Cleanup?
+
+Automating branch cleanup is essential for several reasons:
+
+- **Reduce Clutter**: Keeps the repository clean, making it easier for developers to navigate.
+- **Improve Performance**: Enhances CI/CD pipeline performance by reducing overhead.
+- **Prevent Confusion**: Minimizes the risk of developers working on or merging outdated branches.
+- **Enhance Security**: Removes obsolete branches that may contain vulnerabilities.
+
+---
+
+## Prerequisites
+
+Ensure you have the following before starting:
+
+- **Azure DevOps Account**: Access to your organization's Azure DevOps instance.
+- **Personal Access Token (PAT)**: A PAT with permissions to access and manage repositories.
+- **Node.js and npm**: Installed on your machine (Node.js version 14 or later).
+- **TypeScript**: Installed globally (`npm install -g typescript`).
+- **Azure DevOps Node API Package**: Install via `npm install azure-devops-node-api`.
+- **dotenv Package**: Install via `npm install dotenv`.
+
+---
+
+## Project Setup
+
+1. **Create a New Directory**: Initialize a new Node.js project.
+
+   ```bash
+   mkdir azure-devops-branch-cleanup
+   cd azure-devops-branch-cleanup
+   npm init -y
+   ```
+
+2. **Install Dependencies**:
+
+   ```bash
+   npm install @azure/identity @microsoft/microsoft-graph-client azure-devops-node-api dayjs dotenv
+   npm install --save-dev typescript @types/node
+   ```
+
+---
+
+## Configuration File
+
+Create a `config.json` file in your project root to specify branches that should be excluded from deletion:
+
+```json
+{
+  "globalExcludes": ["master", "develop", "main", "release"],
+  "repositoryExcludes": {
+    "your-repo-name": ["feature/important-branch"]
+  }
+}
+```
+
+- **globalExcludes**: Branches excluded from deletion across all repositories.
+- **repositoryExcludes**: Specific branches to exclude in specific repositories.
+
+---
+
+## Implementing the TypeScript Script
+
+Create a TypeScript file, e.g., `cleanup.ts`, and implement the following steps:
+
+### 1. Loading Environment Variables
+
+Use the `dotenv` package to load environment variables.
+
+```typescript
+import * as dotenv from "dotenv";
+dotenv.config();
+
+const isDryRun = process.env.DryRun === "true";
+```
+
+**Environment Variables Required**:
+
+- `AZURE_DEVOPS_URL`: Your Azure DevOps organization URL.
+- `AZURE_DEVOPS_PAT`: Your Personal Access Token.
+- `AZURE_DEVOPS_PROJECT`: Your project name.
+- `DryRun`: Set to `"true"` for dry-run mode (no actual deletions).
+
+### 2. Defining the Configuration Interface
+
+Define an interface to ensure type safety.
+
+```typescript
+interface Config {
+  globalExcludes: string[];
+  repositoryExcludes: {
+    [repoName: string]: string[];
+  };
+}
+```
+
+### 3. Setting Constants
+
+Define constants used in the script.
+
+```typescript
+const DAYS_90_MS = 90 * 24 * 60 * 60 * 1000; // 90 days in milliseconds
+```
+
+### 4. Getting the Git API Client
+
+Authenticate and obtain the Git API client.
+
+```typescript
+import * as azdev from "azure-devops-node-api";
+import * as GitApi from "azure-devops-node-api/GitApi";
+
+async function getGitApi(): Promise<GitApi.IGitApi> {
+  const orgUrl = process.env.AZURE_DEVOPS_URL;
+  const token = process.env.AZURE_DEVOPS_PAT;
+
+  if (!orgUrl || !token) {
+    throw new Error(
+      "Azure DevOps URL or PAT is not set in environment variables."
+    );
+  }
+
+  const authHandler = azdev.getPersonalAccessTokenHandler(token);
+  const connection = new azdev.WebApi(orgUrl, authHandler);
+  return await connection.getGitApi();
+}
+```
+
+### 5. Loading the Configuration
+
+Load the `config.json` file.
+
+```typescript
+import * as fs from "fs";
+import * as path from "path";
+
+function loadConfig(): Config {
+  const configPath = path.join(__dirname, "config.json");
+  const configContent = fs.readFileSync(configPath, "utf-8");
+  return JSON.parse(configContent) as Config;
+}
+```
+
+### 6. Retrieving Repositories and Branches
+
+Get the list of repositories and branches.
+
+```typescript
+import * as GitInterfaces from "azure-devops-node-api/interfaces/GitInterfaces";
+
+async function getRepositories(
+  gitApi: GitApi.IGitApi,
+  project: string
+): Promise<GitInterfaces.GitRepository[]> {
+  return await gitApi.getRepositories(project);
+}
+
+async function getBranches(
+  gitApi: GitApi.IGitApi,
+  project: string,
+  repoId: string
+): Promise<GitInterfaces.GitRef[]> {
+  const branches = await gitApi.getRefs(repoId, project);
+  return branches.filter(b => b.name.startsWith("refs/heads/"));
+}
+```
+
+### 7. Determining the Last Commit Date
+
+Get the date of the last commit on a branch.
+
+```typescript
+async function getLastCommitDate(
+  gitApi: GitApi.IGitApi,
+  project: string,
+  repoId: string,
+  branchName: string
+): Promise<Date | null> {
+  const commits = await gitApi.getCommits(
+    repoId,
+    { itemVersion: { version: branchName } },
+    project,
+    undefined,
+    1
+  );
+
+  if (commits.length > 0) {
+    const commitDate = commits[0].committer.date || commits[0].author.date;
+    return new Date(commitDate);
+  }
+
+  return null;
+}
+```
+
+### 8. Checking if a Branch is Merged
+
+Check if a branch is merged into any of the target branches.
+
+```typescript
+import { GitVersionType } from "azure-devops-node-api/interfaces/GitInterfaces";
+
+async function isBranchMerged(
+  gitApi: GitApi.IGitApi,
+  project: string,
+  repoId: string,
+  branch: string,
+  targetBranches: string[]
+): Promise<boolean> {
+  for (const targetBranch of targetBranches) {
+    const diff = await gitApi.getCommitDiffs(
+      repoId,
+      project,
+      true,
+      1,
+      undefined,
+      { baseVersionType: GitVersionType.Branch, baseVersion: branch },
+      { targetVersionType: GitVersionType.Branch, targetVersion: targetBranch }
+    );
+
+    if (diff && diff.aheadCount === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+```
+
+### 9. Deleting a Branch
+
+Delete the branch if it meets the criteria.
+
+```typescript
+async function deleteBranch(
+  gitApi: GitApi.IGitApi,
+  project: string,
+  repoId: string,
+  branch: GitInterfaces.GitRef
+): Promise<void> {
+  if (!isDryRun) {
+    if (branch.isLocked) {
+      await gitApi.updateRef(
+        { name: branch.name, isLocked: false },
+        repoId,
+        "",
+        project
+      );
+    }
+
+    await gitApi.updateRefs(
+      [
+        {
+          name: branch.name,
+          newObjectId: "0000000000000000000000000000000000000000",
+          oldObjectId: branch.objectId,
+        },
+      ],
+      repoId,
+      "",
+      project
+    );
+  }
+
+  console.log(`Deleted branch: ${branch.name} (Dry Run: ${isDryRun})`);
+}
+```
+
+### 10. Compiling the Exclusion List
+
+Combine global and repository-specific exclusions.
+
+```typescript
+function getExclusionList(config: Config, repoName: string): string[] {
+  const globalExcludes = config.globalExcludes || [];
+  const repoSpecificExcludes = config.repositoryExcludes[repoName] || [];
+  return [...new Set([...globalExcludes, ...repoSpecificExcludes])];
+}
+```
+
+### 11. Cleaning Up Branches
+
+Main function orchestrating the cleanup.
+
+```typescript
+async function cleanUpBranches(): Promise<void> {
+  const project = process.env.AZURE_DEVOPS_PROJECT;
+  if (!project) {
+    throw new Error(
+      "Azure DevOps project name is not set in environment variables."
+    );
+  }
+
+  const config = loadConfig();
+  const now = new Date();
+  const gitApi = await getGitApi();
+  const repositories = await getRepositories(gitApi, project);
+
+  for (const repo of repositories) {
+    console.log(`Processing repository: ${repo.name}`);
+    const excludeBranches = getExclusionList(config, repo.name);
+    const branches = await getBranches(gitApi, project, repo.id);
+
+    for (const branch of branches) {
+      const branchName = branch.name.replace("refs/heads/", "");
+
+      if (excludeBranches.includes(branchName)) {
+        console.log(`Skipping excluded branch: ${branchName}`);
+        continue;
+      }
+
+      const lastCommitDate = await getLastCommitDate(
+        gitApi,
+        project,
+        repo.id,
+        branchName
+      );
+
+      if (
+        !lastCommitDate ||
+        now.getTime() - lastCommitDate.getTime() < DAYS_90_MS
+      ) {
+        console.log(`Branch is recent or active: ${branchName}`);
+        continue;
+      }
+
+      const isMerged = await isBranchMerged(
+        gitApi,
+        project,
+        repo.id,
+        branchName,
+        config.globalExcludes
+      );
+
+      if (isMerged) {
+        await deleteBranch(gitApi, project, repo.id, branch);
+      } else {
+        console.log(`Branch is not merged: ${branchName}`);
+      }
+    }
+  }
+}
+
+cleanUpBranches().catch(err => {
+  console.error("An error occurred:", err);
+});
+```
+
+---
+
+## Automating with Azure DevOps Pipeline
+
+To automate the script execution, set up an Azure DevOps Pipeline.
+
+1. **Create a Variable Group**:
+
+   - Navigate to **Pipelines** > **Library** in Azure DevOps.
+   - Click **"Variable groups"** > **"Add variable group"**.
+   - Name the group, e.g., `az-devops`.
+   - Add the variables:
+     - `AZURE_DEVOPS_URL`
+     - `AZURE_DEVOPS_PAT` (set as secret)
+     - `AZURE_DEVOPS_PROJECT`
+   - Save the variable group.
+
+2. **Create the Pipeline YAML File**:
+
+   Create a `azure-pipelines.yml` file in your repository:
+
+   ```yaml
+   trigger: none
+
+   schedules:
+     - cron: "0 0 * * 0" # Runs every Sunday at 00:00
+       displayName: "Weekly Branch Cleanup"
+       branches:
+         include:
+           - main
+       always: true
+       batch: false
+
+   pool:
+     vmImage: ubuntu-latest
+
+   variables:
+     - group: az-devops
+
+   steps:
+     - task: NodeTool@0
+       inputs:
+         versionSpec: "14.x"
+       displayName: "Install Node.js"
+
+     - script: |
+         npm ci
+         npx ts-node cleanup.ts
+       displayName: "Run Branch Cleanup Script"
+       env:
+         AZURE_DEVOPS_URL: $(AZURE_DEVOPS_URL)
+         AZURE_DEVOPS_PAT: $(AZURE_DEVOPS_PAT)
+         AZURE_DEVOPS_PROJECT: $(AZURE_DEVOPS_PROJECT)
+   ```
+
+   - **Notes**:
+     - Replace `cleanup.ts` with the path to your script.
+     - Ensure the pipeline has access to the variable group.
+
+---
+
+## Conclusion
+
+Automating branch cleanup ensures your repositories remain organized, improving developer productivity and reducing potential errors. By following this guide, you can set up a script to automatically identify and delete old, unused branches in Azure DevOps, and schedule it using Azure Pipelines for regular maintenance.
+
+**Benefits**:
+
+- **Efficiency**: Saves time and resources.
+- **Consistency**: Maintains a consistent repository state.
+- **Scalability**: Easily extends to multiple projects and repositories.
+
+---
+
+## Additional Resources
+
+- **Full Working Source Code**: [drunkcoding public code](https://dev.azure.com/drunk24/drunkcoding-public/_git/az.tools?path=/az-devops-delete-branches&version=GBmain)
+- **Azure DevOps Node API Documentation**: [Git API Reference](https://github.com/microsoft/azure-devops-node-api/blob/master/api/GitApi.ts)
+- **Azure DevOps REST API Reference**: [Git Repositories](https://docs.microsoft.com/en-us/rest/api/azure/devops/git/repositories)
+
+---
+
+**Note**: Always test scripts in a controlled environment before deploying them in production. Ensure compliance with your organization's policies and procedures.
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*

tools-sql-database-cleanup.md

@@ -0,0 +1,110 @@
+---
+author: Steven Hoang
+pubDatetime: 2024-08-26T12:00:00Z
+title: "[Tools] Automating SQL Data Cleanup in Development and Sandbox Environments"
+postSlug: tools-sql-server-data-cleanup
+featured: false
+draft: true
+tags:
+  - database-cleanup
+  - tools
+description: "The post introduces the **SQL Data Cleanup** tool, which automates the removal of old records from SQL databases, 
+improving performance and saving storage costs in development environments. It includes configuration options and Docker support for easy setup."
+---
+
+### Introduction
+
+In development and sandbox environments, data can pile up quickly—old transaction records, exchange rates, logs, you name it! Without regular cleanup, databases become bloated, making it harder to work efficiently and often leading to increased storage costs. To tackle this, I’ve created the **SQL Data Cleanup** program, a handy tool that automates the removal of outdated records from SQL databases based on flexible configurations.
+
+Let’s dive into why this matters and how this tool can help streamline your database management.
+
+### Why Bother Cleaning Up?
+
+Here are a few great reasons to stay on top of your data cleanup game:
+
+- **Reduce Clutter**: As databases grow, they can get messy, making it harder to find relevant data and slowing down development work.
+- **Boost Performance**: A lean database runs smoother! Regular cleanup helps keep things fast and efficient.
+- **Save Money**: In cloud environments, storage costs can sneak up on you. Cleaning up old, unnecessary data helps keep your budget under control.
+- **Avoid Confusion**: Nobody wants to mistakenly work with outdated records. Keeping only the relevant data ensures developers don’t accidentally reference old info in their code.
+
+### The Solution: SQL Data Cleanup Program
+
+To solve this, I’ve created a simple yet powerful tool that automates the cleanup of specific databases and tables. You can find the code and more details here: [GitHub: SQL Data Cleanup Tool](https://github.com/baoduy/tool-sql-data-cleanup).
+
+The program allows you to configure which data to remove, how long to keep it, and what fields to use when determining the age of records. Here’s a basic example configuration:
+
+```json
+{
+  "DbCleanup": {
+    "OlderThanDays": 365,
+    "ConnectionString": "YOUR_CONNECTION_STRING",
+    "PrimaryField": "Id",
+    "ConditionFields": ["CreatedOn"],
+    "Databases": {
+      "database-1": {
+        "PrimaryField": "Id",
+        "ConditionFields": ["UpdateOn"],
+        "Tables": {
+          "table-1": { "PrimaryField": "Id" },
+          "random-table-2": { "PrimaryField": "Id" }
+        }
+      }
+    }
+  }
+}
+```
+
+### Configuration Breakdown
+
+The configuration has three levels: **Global**, **Database**, and **Table**, giving you full control over the cleanup process.
+
+- **Global Settings**:
+
+  - **OlderThanDays**: Specify how long to keep data (in this case, 365 days).
+  - **ConnectionString**: The SQL connection string template.
+  - **PrimaryField**: The key field used to identify records in all tables.
+  - **ConditionFields**: These fields determine the age of the records to be cleaned up.
+
+- **Database-Level Settings**:
+
+  - Similar to global settings but applied to specific databases.
+
+- **Table-Level Settings**:
+  - Customize which fields to use for each table, ensuring flexibility in how you manage each dataset.
+
+### Docker Support
+
+To make things even easier, I’ve built the program into a Docker image, available on Docker Hub. You can run it on both ARM and AMD platforms without any hassle!
+
+- **Docker Image**: [baoduy2412/tool-sql-cleanup](https://hub.docker.com/r/baoduy2412/tool-sql-cleanup)
+
+Here’s a sample `docker-compose.yml` configuration to get you started:
+
+```yaml
+services:
+  app:
+    image: baoduy2412/tool-sql-cleanup:latest
+    environment:
+      DbCleanup__OlderThanDays: "365"
+      DbCleanup__ConnectionString: "YOUR_CONNECTION_STRING"
+      DbCleanup__PrimaryField: "Id"
+      DbCleanup__ConditionFields__0: "CreatedOn"
+      DbCleanup__Databases__database-1__PrimaryField: "Id"
+      DbCleanup__Databases__database-1__ConditionFields__0: "UpdateOn"
+      DbCleanup__Databases__database-1__Tables__table-1__PrimaryField: "Id"
+      DbCleanup__Databases__database-1__Tables__random-table-2__PrimaryField: "Id"
+```
+
+### Conclusion
+
+The **SQL Data Cleanup** program is a lifesaver for keeping your development and sandbox environments lean and efficient. It helps automate the process of removing outdated data, boosts performance, reduces costs, and ensures your database doesn’t become a tangled mess. Best of all, it’s fully configurable—you choose which tables to clean up and how long to keep your data.
+
+Feel free to give it a try, and as always, I’d love to hear your feedback! Let’s keep our databases tidy! 🚀
+
+---
+
+## Thank You
+
+Thank you for taking the time to read this guide! I hope it has been helpful, feel free to explore further, and happy coding! 🌟✨
+
+**Steven** | *[GitHub](https://github.com/baoduy)*