<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Gordon H on Medium]]></title>
        <description><![CDATA[Stories by Gordon H on Medium]]></description>
        <link>https://medium.com/@gordonwho?source=rss-a0aeb209d170------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*r3SfQshJbKE863-A.</url>
            <title>Stories by Gordon H on Medium</title>
            <link>https://medium.com/@gordonwho?source=rss-a0aeb209d170------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 21:48:17 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@gordonwho/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Integrating Keycloak with SAML for Single Sign-On (SSO)]]></title>
            <link>https://medium.com/@gordonwho/integrating-keycloak-with-saml-for-single-sign-on-sso-33da2ddbe8e6?source=rss-a0aeb209d170------2</link>
            <guid isPermaLink="false">https://medium.com/p/33da2ddbe8e6</guid>
            <category><![CDATA[aml]]></category>
            <category><![CDATA[keycloak]]></category>
            <category><![CDATA[sso]]></category>
            <dc:creator><![CDATA[Gordon H]]></dc:creator>
            <pubDate>Wed, 26 Nov 2025 18:38:26 GMT</pubDate>
            <atom:updated>2025-11-26T18:38:26.965Z</atom:updated>
            <content:encoded><![CDATA[<h3>Keycloak and SAML: The Enterprise Handshake for SSO 🤝</h3><p>When it comes to enterprise identity management and enabling <strong>Single Sign-On (SSO)</strong>, the partnership between <strong>Keycloak</strong> and the <strong>SAML</strong> protocol is fundamental. This duo provides a secure, standardized way for users to log into one central system (Keycloak) and gain immediate access to multiple external, third-party applications.</p><h3>What is SAML?</h3><p><strong>SAML (Security Assertion Markup Language)</strong> is an XML-based standard that allows an identity provider (IdP) to communicate authentication and authorization data to a service provider (SP).</p><ul><li><strong>Keycloak</strong> acts as the <strong>Identity Provider (IdP)</strong>: It confirms the user’s identity.</li><li><strong>The External Application</strong> (e.g., Salesforce, Jira, or a custom app) acts as the <strong>Service Provider (SP)</strong>: It trusts Keycloak’s confirmation.</li></ul><h3>The Metaphor: The Verified Passport and the Border Guard 🛂</h3><p>Imagine your protected external applications as different <strong>Countries</strong> you want to visit.</p><ul><li><strong>Keycloak</strong> is the <strong>Passport Office</strong>. It verifies your identity (username/password), and once confirmed, it issues you a universally recognized, tamper-proof <strong>Verified Passport</strong> (the SAML Assertion).</li><li><strong>The External Application (SP)</strong> is the <strong>Border Guard</strong>. The Border Guard doesn’t know you personally, but they trust and understand the standardized format of the Verified Passport (SAML).</li><li>The <strong>SAML Assertion</strong> is the Passport: It’s a digitally signed XML document that contains your verified identity and attributes.</li></ul><p>The goal of SSO is to let you log in once at the Passport Office (Keycloak) and use that same Verified Passport (SAML Assertion) to pass through the Border Guards (SP apps) without logging in again.</p><h3>The SAML SSO Workflow: The Border Crossing</h3><p>The interaction between the user’s browser, the IdP (Keycloak), and the SP (Application) follows a structured protocol, usually involving an HTTP POST or Redirect binding.</p><h3>Step 1: Requesting Access (Knocking on the Border Gate)</h3><ol><li>A user attempts to access a protected external application (SP), like a custom analytics portal.</li><li>The application (SP) realizes the user is not logged in. It redirects the user’s browser to the <strong>Keycloak Login URL</strong> (the Passport Office). This redirection often includes a signed <strong>SAML Request</strong> detailing which application is asking for authentication.</li></ol><h3>Step 2: Authentication (Getting the Passport)</h3><ol><li>The user lands on the <strong>Keycloak Login Page</strong>. If the user has a valid existing session, Keycloak skips the login form (this is the <strong>Single Sign-On</strong> benefit).</li><li>If credentials are required, the user logs in.</li><li>Upon successful login, Keycloak (IdP) generates a <strong>SAML Assertion</strong> — the XML document containing the user’s confirmed identity (like username, email, and roles). This document is <strong>digitally signed</strong> using Keycloak’s private key.</li></ol><h3>Step 3: Assertion Transfer (Presenting the Passport)</h3><ol><li>Keycloak sends the SAML Assertion back to the user’s browser, typically embedded in a hidden HTML form that is immediately auto-submitted.</li><li>The browser’s auto-submission sends the SAML Assertion (the Passport) directly to the <strong>Service Provider’s (SP’s) Assertion Consumer Service (ACS) endpoint</strong>.</li></ol><h3>Step 4: Verification and Access (The Border Check)</h3><ol><li>The external application (SP) receives the SAML Assertion.</li><li>The application uses Keycloak’s <strong>public key</strong> (which it was pre-configured with) to <strong>verify the digital signature</strong> on the Assertion. This ensures the Passport is authentic and hasn’t been tampered with.</li><li>Once the signature is verified, the SP trusts the data inside the Assertion and establishes a local session for the user, granting access to the application.</li></ol><p>This four-step process means the user only verifies their identity once with the trusted source (<strong>Keycloak</strong>), and all subsequent applications that speak the <strong>SAML</strong> language can instantly and securely recognize them.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=33da2ddbe8e6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ArgoCD: Your DevOps “Butler” for Kubernetes]]></title>
            <link>https://medium.com/@gordonwho/argocd-your-devops-butler-for-kubernetes-a8c1188b01f6?source=rss-a0aeb209d170------2</link>
            <guid isPermaLink="false">https://medium.com/p/a8c1188b01f6</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[argo-cd]]></category>
            <category><![CDATA[k8s]]></category>
            <dc:creator><![CDATA[Gordon H]]></dc:creator>
            <pubDate>Wed, 26 Nov 2025 17:18:40 GMT</pubDate>
            <atom:updated>2025-11-26T17:18:40.770Z</atom:updated>
            <content:encoded><![CDATA[<p>If you’re working with <strong>Kubernetes</strong>, you know that managing application deployments can get complicated. You have your application code, its configuration files, and your running cluster — keeping them all perfectly in sync, especially as things change, is a significant challenge.</p><p>That’s where <strong>ArgoCD</strong> steps in. It’s the critical piece of the puzzle that enables true modern Continuous Delivery (CD).</p><h3>What is ArgoCD?</h3><p>ArgoCD is a <strong>declarative, GitOps continuous delivery tool</strong> for Kubernetes.</p><p>In the simplest terms, it’s a dedicated piece of software that runs inside your Kubernetes cluster, and its sole job is to constantly ensure that the <strong>actual state</strong> of your running applications matches the <strong>desired state</strong>defined in your code repository (<strong>Git</strong>).</p><h3>The Metaphor: The Digital Butler 🤵</h3><p>To truly grasp the power of ArgoCD, let’s use a simple metaphor. Think of your <strong>Git repository</strong> (where your application manifests like YAML files live) as the <strong>Master Blueprint</strong> or the <strong>“Wishes List”</strong> for your entire infrastructure.</p><p><strong>ArgoCD is your Digital Butler.</strong></p><ol><li><strong>Checking the List (Git):</strong> The butler constantly checks the Master Blueprint (Git repository) to see what your infrastructure <strong>should</strong> look like (e.g., “I want 3 replicas of my web app running at all times”).</li><li><strong>Checking the Room (Kubernetes Cluster):</strong> The butler then looks at the actual running environment (the Kubernetes cluster).</li><li><strong>Making Corrections:</strong> If the actual environment (the room) doesn’t match the Master Blueprint (the list) — say, a rogue script or human error scaled the app down to 1 replica — the butler <strong>automatically steps in and fixes it</strong> by scaling the app back up to 3.</li></ol><p>This principle of using Git as the <em>single source of truth</em> and automatically reconciling the cluster state is known as <strong>GitOps</strong>.</p><h3>The ArgoCD GitOps Flow</h3><p>Using ArgoCD fundamentally changes how you deploy applications. The key shift is this: <strong>You no longer deploy <em>to</em> Kubernetes; you deploy <em>to</em> Git, and ArgoCD handles the rest.</strong></p><h3>1. The Deployment Pipeline Components</h3><p>Understanding the flow is easy once you identify the three main actors:</p><p><strong>ComponentRole in the SystemMetaphorGit Repository</strong>Contains the <strong>desired state</strong> (YAML, Helm charts, etc.). <strong>The Source of Truth.</strong>The <strong>Master BlueprintArgoCD Server</strong>Runs inside Kubernetes, constantly monitors Git, and pushes changes.The <strong>Digital ButlerKubernetes Cluster</strong>The <strong>actual state</strong> where your applications are running.The <strong>Room</strong></p><h3>2. The Simple GitOps Steps</h3><ol><li><strong>Define and Commit:</strong> You write your Kubernetes manifest files (e.g., deployment.yaml, service.yaml) and commit them to your Git repository.</li><li><strong>Configure the Application:</strong> You use the ArgoCD UI or CLI to create an <strong>Application resource</strong>. This configuration tells the Butler:</li></ol><ul><li><strong>Source:</strong> Where is the Git repository (the Master Blueprint)?</li><li><strong>Destination:</strong> Which cluster and namespace to deploy to (the Room)?</li></ul><ol><li><strong>Sync and Reconcile:</strong> ArgoCD immediately detects the manifests and starts the synchronization. It pulls the files and applies them.</li></ol><p>The moment you make a change in Git (like updating an image version), ArgoCD registers the state as <strong>“Out of Sync”</strong> and then pushes the new configuration to achieve the <strong>“Synced”</strong> state. This is truly <strong>Continuous Delivery</strong>.</p><h3>Getting Started: How to Deploy with ArgoCD</h3><p>Your setup process involves two distinct phases: installing the tool and then using the tool to deploy your code.</p><h3>Phase 1: Installing ArgoCD (Hiring the Butler)</h3><p>First, you need the ArgoCD server components running inside your target Kubernetes cluster.</p><ol><li><strong>Create a dedicated namespace:</strong></li><li>Bash</li></ol><pre>kubectl create namespace argocd</pre><p><strong>Apply the core installation manifest:</strong> This deploys the necessary API server, controller, and supporting components.</p><ol><li>Bash</li></ol><pre>kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml</pre><ol><li><strong>Access the UI:</strong> After installation, you can forward a port to access the intuitive ArgoCD web interface for visual management.</li></ol><h3>Phase 2: Deploying Your Application (Giving the Butler the Blueprint)</h3><p>With ArgoCD running, you define your application deployment by creating an <strong>Application resource</strong>.</p><h4>Example Application Definition</h4><p>This is the configuration that tells the system what you want to achieve:</p><p><strong>ArgoCD FieldExample ValueMeaning</strong><strong>spec.source.repoURL</strong>https://github.com/my-org/my-app-config<strong>Where</strong> to find the desired manifests.<strong>spec.source.path</strong>staging<strong>What directory</strong> in the repo to use.<strong>spec.destination.server</strong>https://kubernetes.default.svc<strong>Which cluster</strong> to deploy to.<strong>spec.destination.namespace</strong>my-web-app-staging<strong>Which namespace</strong> in the cluster.<strong>spec.syncPolicy.automated.selfHeal</strong>trueIf the running app deviates, <strong>automatically fix it</strong>.</p><p>By submitting this <strong>Application YAML</strong>, you establish the unbreakable link between your Git repository and your running cluster.</p><p>To update your application now, you simply <strong>push a change to Git</strong>. ArgoCD detects it, marks it for deployment, and applies the necessary changes — giving you a reliable, auditable, and transparent continuous delivery pipeline.</p><h3>Conclusion</h3><p>ArgoCD is more than just a deployment tool; it’s a paradigm shift towards GitOps, providing the foundation for highly resilient, self-healing, and easy-to-manage Kubernetes infrastructure.</p><p>It lets developers focus on pushing quality code to Git, trusting their <strong>Digital Butler</strong> to keep the production <strong>Room</strong> in perfect order.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a8c1188b01f6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Git Demystified: Your Collaborative Code Companion]]></title>
            <link>https://medium.com/@gordonwho/git-demystified-your-collaborative-code-companion-5655f098800e?source=rss-a0aeb209d170------2</link>
            <guid isPermaLink="false">https://medium.com/p/5655f098800e</guid>
            <category><![CDATA[git]]></category>
            <dc:creator><![CDATA[Gordon H]]></dc:creator>
            <pubDate>Fri, 23 May 2025 14:03:22 GMT</pubDate>
            <atom:updated>2025-05-23T14:03:22.278Z</atom:updated>
            <content:encoded><![CDATA[<p>Have you ever worked on a document with others, emailing different versions back and forth, only to end up with a tangled mess of “final_final_v2_ 진짜_final.docx”? If so, you’ll appreciate the magic of Git.</p><p>In the world of software development, where teams of engineers often work on the same codebase simultaneously, such chaos would be catastrophic. This is where Git comes in — a powerful, distributed version control system that acts as your project’s meticulous librarian, time machine, and collaborative workspace, all rolled into one.</p><h3>What is Git? The Grand Metaphor</h3><p>Imagine your project as a magnificent castle under construction. Many builders (developers) are working on different parts: one on the ramparts, another on the great hall, and a third on the dungeon.</p><ul><li>Git is the Master Blueprint and Archive Room: Instead of each builder having their own separate, ever-changing sketch, Git maintains one central, incredibly detailed master blueprint. But it’s more than just a blueprint; it’s also a comprehensive archive room where every single change ever made to the castle, by any builder, is meticulously recorded, dated, and attributed. Want to see what the castle looked like last Tuesday? Just check the archive!</li><li>Your Local Copy is Your Personal Workbench: When a builder starts working, they don’t modify the master blueprint directly. Instead, they make a personal copy of the relevant sections and bring them to their own workbench. This is your “local repository” — a complete, independent copy of the project’s history and files on your computer. You can experiment, make a mess, or build something entirely new without affecting anyone else’s work or the master blueprint.</li><li>Commits are Milestones and Notations: As you build something on your workbench, you periodically reach a good stopping point — perhaps you’ve finished a wall or added a new door. At these moments, you “commit” your changes. This is like adding a dated and descriptive note to your personal blueprint copy, saying, “On May 23rd, 2025, I finished the west wall, adding 12 stones.” Each commit is a snapshot of your project at a specific point in time, along with a message explaining <em>what</em> you did.</li><li>Branches are Parallel Construction Efforts: Sometimes, you want to experiment with a completely new design for a tower, but you don’t want to disrupt the main castle construction. So, you create a “branch.” This is like a separate, parallel construction effort where you can build your experimental tower without affecting the main castle. If your experimental tower is a success, you can “merge” it back into the main castle. If not, you can simply abandon that branch without consequence.</li><li>Pushing is Sharing Your Work with the Master Blueprint: Once you’ve finished a significant piece of work on your workbench (made several commits) and you’re confident it’s ready, you “push” your changes. This is like going to the master blueprint archive and submitting your completed sections and notes to be incorporated into the official record for everyone to see and use.</li><li>Pulling is Getting Updates from the Master Blueprint: Before you start working, or periodically during your work, you’ll want to see if other builders have added anything new to the master blueprint. You “pull” these changes. This is like checking the master blueprint archive for updates and bringing any new sections or notes back to your personal workbench to ensure your copy is up-to-date.</li></ul><h3>Essential Git Operations: Your Toolbelt for Collaboration</h3><p>Now, let’s look at some of the most common Git commands you’ll encounter, explained simply:</p><p>git init (Starting a New Project/Castle):</p><ul><li>Metaphor: You’re clearing a patch of land and setting up the very first stone for your castle. This command initializes a new Git repository in your current directory, making it ready to be managed by Git.</li><li>What it does: Creates a hidden .git folder that will store all the project&#39;s history and configurations.</li></ul><p>git clone [repository_url] (Copying an Existing Project/Castle):</p><ul><li>Metaphor: Instead of starting from scratch, you’re making an exact duplicate of an existing castle, including its entire history and blueprints, to your own land.</li><li>What it does: Downloads a complete copy of an existing Git repository from a remote location (like GitHub or GitLab) to your local machine.</li></ul><p>git add [file_name] or git add . (Staging Your Changes/Preparing Materials):</p><ul><li>Metaphor: You’ve gathered all the bricks, mortar, and tools you need for a specific part of your construction. You’re not laying them yet, but you’ve assembled them for your next building phase.</li><li>What it does: Tells Git that you want to include specific changes (or all changes, with .) in your next commit. These changes are moved to the &quot;staging area.&quot;</li></ul><p>git commit -m &quot;Your descriptive message&quot; (Saving a Milestone/Writing Your Notes):</p><ul><li>Metaphor: You’ve finished a section of your building, and you’re taking a snapshot and writing a clear, concise note about what you’ve accomplished.</li><li>What it does: Records the staged changes as a new commit in your local repository’s history. The -m flag allows you to add a message explaining what was done in that commit.</li></ul><p>git status (Checking Your Workbench&#39;s Progress):</p><ul><li>Metaphor: You’re looking around your workbench, assessing what you’ve done, what’s left to do, and if you’ve missed anything.</li><li>What it does: Shows you the current state of your working directory, telling you which files have been modified, which are staged, and which are untracked.</li></ul><p>git branch [branch_name] (Creating a Parallel Construction Effort):</p><ul><li>Metaphor: You’re starting a new, separate construction project for a specific experimental feature, without affecting the main castle.</li><li>What it does: Creates a new branch pointing to the current commit, allowing you to work on features or fixes in isolation.</li></ul><p>git checkout [branch_name] (Switching Your Focus/Moving to Another Workbench):</p><ul><li>Metaphor: You’re putting down your tools on one part of the castle and moving to another workbench to work on a different section or experimental feature.</li><li>What it does: Switches your working directory to the specified branch, allowing you to work on its files and history. (Note: In newer Git versions, git switch is often preferred for clarity).</li></ul><p>git merge [branch_name] (Integrating Parallel Efforts/Combining Sections):</p><ul><li>Metaphor: Your experimental tower is a success! You’re now carefully integrating its design and structure into the main castle blueprint.</li><li>What it does: Integrates changes from one branch into another, combining their histories.</li></ul><p>git pull (Getting Updates from the Master Blueprint/Checking for New Deliveries):</p><ul><li>Metaphor: You’re checking the master blueprint archive to see if anyone else has submitted new work or updates, and you’re bringing those new sections back to your workbench.</li><li>What it does: Fetches changes from a remote repository and integrates them into your current local branch. It’s essentially git fetch followed by git merge.</li></ul><p>git push (Sharing Your Completed Work/Submitting to the Master Blueprint):</p><ul><li>Metaphor: You’ve finished a significant piece of your work and are now submitting your completed sections and notes to the master blueprint archive so everyone else can benefit from your contributions.</li><li>What it does: Uploads your local commits to a remote repository, making them available to other collaborators.</li></ul><p>git log (Reviewing the History/Looking Through the Archive Notes):</p><ul><li>Metaphor: You’re going through the castle’s archive room, reading all the notes and seeing who built what, and when.</li><li>What it does: Displays a detailed history of commits in the current branch, showing who made what changes and when.</li></ul><h3>Conclusion: Embrace the Power of Git</h3><p>Git might seem intimidating at first, but by understanding its core concepts and the common operations, you unlock a world of collaborative efficiency. It safeguards your project’s history, empowers parallel development, and makes teamwork a breeze. So, the next time you embark on a project, remember Git — your indispensable companion for building digital castles, one commit at a time.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5655f098800e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kubernetes Explained]]></title>
            <link>https://medium.com/@gordonwho/kubernetes-explained-3d64af4209ad?source=rss-a0aeb209d170------2</link>
            <guid isPermaLink="false">https://medium.com/p/3d64af4209ad</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[k8s]]></category>
            <dc:creator><![CDATA[Gordon H]]></dc:creator>
            <pubDate>Thu, 22 May 2025 12:53:40 GMT</pubDate>
            <atom:updated>2025-05-22T12:53:40.170Z</atom:updated>
            <content:encoded><![CDATA[<p>Kubernetes Explained</p><p>Let’s imagine you’re a bustling city planner, responsible for ensuring all the city’s essential services — from the libraries to the power grid, the hospitals to the entertainment venues — are running smoothly and efficiently. This city, in our metaphor, is the world of digital applications and services.</p><p>Now, let’s introduce Kubernetes.</p><h3>Kubernetes: The Automated City Management System</h3><p>Think of Kubernetes as the ultimate, hyper-intelligent Automated City Management System. Before Kubernetes, every service (application) in our digital city was like a standalone building, individually built, maintained, and scaled by hand. If a library needed more space, someone had to manually build an extension. If the power grid experienced a surge, a human had to scramble to reroute power. It was inefficient, prone to error, and a constant drain on resources.</p><p>Kubernetes, our Automated City Management System, changes all that. It’s not just a collection of tools; it’s an intelligent orchestrator that knows how to deploy, scale, and manage all your city’s services with minimal human intervention.</p><h3>Nodes: The Plots of Land</h3><p>Every city needs land to build upon. In our digital city, these plots of land are your Nodes.</p><ul><li>A Node is like a designated plot of land in your city where you can build and run a part of your service. It’s a server (physical or virtual) that provides the computational resources — CPU, memory, storage — necessary to host your applications. You can have many such plots of land in your city.</li></ul><h3>Pods: The Mobile Homes of Your Services</h3><p>You don’t just plop a library directly onto the bare earth. You build a structure. In Kubernetes, the fundamental building block for your applications are Pods.</p><ul><li>A Pod is like a mobile home or a small, self-contained unit that houses one or more closely related parts of your service. Imagine a mobile home containing all the necessary furniture, appliances, and utilities for a small family.</li><li>If your library service needs a database and a web server, they might live together in one pod if they’re tightly coupled, or in separate pods if they’re more independent.</li><li>Pods are designed to be temporary. If a mobile home gets damaged, you don’t repair it; you replace it with a new, healthy one. This makes them highly resilient.</li></ul><h3>Deployments: The Blueprints for Your Neighborhoods</h3><p>You wouldn’t build just one mobile home for your library service; you’d want a whole cluster of them, perhaps spread across different plots of land for resilience. This is where Deployments come in.</p><ul><li>A Deployment is like a blueprint for a neighborhood of identical mobile homes (Pods). You tell Kubernetes: “I need three copies of my library service’s mobile home, and I want you to make sure there are always three running.”</li><li>The Deployment object tells the Automated City Management System <em>how many</em> copies of your Pods should be running and <em>what version</em> of your application they should contain.</li><li>If one of your “mobile homes” (Pods) crashes or a “plot of land” (Node) goes down, the Deployment automatically ensures a new one is created to maintain the desired number. It’s self-healing!</li></ul><h3>Services: The Postal Addresses and Road Systems</h3><p>Even if you have many identical mobile homes for your library service, how do people find them? How do other parts of your city communicate with them? This is the job of Services.</p><ul><li>A Service is like a stable postal address and a dedicated road system for your group of mobile homes (Pods). Even if the mobile homes (Pods) themselves move to different plots of land (Nodes), or new ones are created, the postal address (Service’s IP address and port) remains constant.</li><li>So, whether your website needs to talk to your database, or users need to access your library’s web interface, they always use the stable address provided by the Service, and Kubernetes automatically routes their requests to a healthy Pod. It’s like having a receptionist who knows exactly where to send your mail, regardless of which specific mobile home is currently available.</li></ul><h3>Ingress: The City’s Grand Entrance Gates</h3><p>While Services manage internal communication, how do external users — the citizens from outside your digital city — access your public-facing applications? This is handled by Ingress.</p><ul><li>Ingress is like the grand entrance gates and traffic controllers for your entire digital city. It’s where external requests first arrive, and it directs them to the correct internal Service based on the URL or specific rules you define.</li><li>If you have “https://www.google.com/search?q=library.yourcity.com&quot; and “https://www.google.com/search?q=hospital.yourcity.com&quot;, Ingress knows to send requests for the library to the library Service, and requests for the hospital to the hospital Service. It’s your city’s smart traffic director for external visitors.</li></ul><h3>Namespaces: The Administrative Zones</h3><p>As your digital city grows, it’s wise to divide it into administrative zones to keep things organized and prevent conflicts. These are your Namespaces.</p><ul><li>A Namespace is like a self-contained administrative zone or borough within your digital city. Each zone has its own set of rules, resources, and often, its own dedicated team of city planners.</li><li>You might have a “Development Zone” where new features are tested, a “Production Zone” for live services, and an “HR Zone” for human resources applications. Resources within one Namespace are isolated from those in another, preventing accidental interference and simplifying management.</li></ul><h3>Volumes: The Dedicated Storage Units</h3><p>Your mobile homes (Pods) are temporary. What about persistent data, like the city’s archive of books or patient records? You wouldn’t store that directly inside a mobile home that could disappear at any time. You need dedicated storage.</p><ul><li>A Volume is like a dedicated, attachable storage unit for your mobile homes (Pods). This storage unit can be connected and disconnected from different mobile homes as needed, ensuring that valuable data persists even if the mobile home itself is replaced.</li><li>Whether it’s a file system or a database, Volumes provide a reliable place for your application’s data to live independently of the Pods.</li></ul><h3>ConfigMaps &amp; Secrets: The Configuration Manuals and Vaults</h3><p>Every service needs configuration. For example, a library service needs to know the name of the city, or the address of its database. Some configurations are public, others are highly sensitive.</p><ul><li>ConfigMaps are like publicly available configuration manuals or information boards for your services. They store non-sensitive configuration data, like server names, API keys that are not confidential, or default settings.</li><li>Secrets are like secure vaults for sensitive information. This is where you store passwords, API keys that <em>are</em> confidential, and other sensitive credentials, encrypted and protected. Kubernetes ensures these secrets are only accessible to the authorized services that need them.</li></ul><h3>StatefulSets: The Reserved Parking Spots for Unique Services</h3><p>Sometimes, you have services that are not interchangeable, like a unique database instance that needs a specific identity and persistent storage that follows it, even if its “mobile home” is replaced.</p><ul><li>A StatefulSet is like reserving a specific, numbered parking spot for a unique mobile home (Pod) that needs a persistent identity and dedicated storage. Even if the mobile home itself is rebuilt, it always comes back to the same parking spot and reclaims its associated storage. This is crucial for applications like databases that rely on stable network identities and persistent data.</li></ul><h3>Conclusion: A Self-Healing, Scalable City</h3><p>With Kubernetes, our Automated City Management System, you define the desired state of your digital city: “I want three copies of my library service running, accessible at this address, using this configuration.” Kubernetes then constantly works to achieve and maintain that state, automatically deploying, scaling, and recovering your services as needed.</p><p>It’s like having a tireless, intelligent city planning team that not only builds your infrastructure but also continuously monitors it, fixing problems, and expanding services to meet demand, all while you focus on creating the amazing digital services for your citizens.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3d64af4209ad" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Keycloak concepts explained]]></title>
            <link>https://medium.com/@gordonwho/keycloak-concepts-explained-67aaad7f86ed?source=rss-a0aeb209d170------2</link>
            <guid isPermaLink="false">https://medium.com/p/67aaad7f86ed</guid>
            <category><![CDATA[keycloak]]></category>
            <category><![CDATA[sso-single-sign-on-portal]]></category>
            <dc:creator><![CDATA[Gordon H]]></dc:creator>
            <pubDate>Thu, 22 May 2025 12:50:55 GMT</pubDate>
            <atom:updated>2025-05-22T12:50:55.429Z</atom:updated>
            <content:encoded><![CDATA[<p>Keycloak concepts explained</p><p>Imagine a bustling metropolis in the digital world, a sprawling city filled with countless buildings, each representing a different application or service. This entire city, in our metaphor, is the realm of <em>online interactions</em>.</p><p>Now, let’s introduce Keycloak.</p><h3>Keycloak: The Grand Central Station of Digital Identity</h3><p>Think of Keycloak as the ultimate, state-of-the-art Grand Central Station for this digital city. Before Keycloak, every building (application) had its own separate entrance, its own unique set of security guards, and its own passport control. If you wanted to visit multiple buildings, you’d have to go through the same tedious process at each one: show your ID, get verified, and repeat, repeat, repeat. It was a nightmare of forgotten passwords and endless sign-ups.</p><p>Keycloak, our Grand Central Station, centralizes all that. Instead of going to each building’s entrance, you go to Keycloak first. It’s the only place you need to present your credentials. Once Keycloak verifies you, it gives you a special, highly secure digital travel pass that’s recognized and trusted by <em>all</em> the buildings in its network.</p><h3>Realms: The Districts of the Digital City</h3><p>Now, this Grand Central Station (Keycloak) is massive, but it’s also incredibly organized. It doesn’t just lump everyone together. Instead, it divides its operations into distinct, self-contained areas. These are our Realms.</p><p>Imagine Realms as different Districts within the Keycloak Grand Central Station. Each district has its own unique rules, its own set of affiliated buildings, and its own population of citizens (users).</p><ul><li>Example 1: The “Corporate Towers” District. This realm might manage all the internal applications for a large company. Only employees with company credentials can access buildings within this district. It has its own strict security policies and a dedicated set of administrators.</li><li>Example 2: The “Public Square” District. This realm might handle user accounts for a public-facing e-commerce website. Anyone can sign up, and the security rules might be different, perhaps allowing social logins.</li><li>Example 3: The “Developer Sandbox” District. This realm is for developers testing new applications. It might have very relaxed security settings and temporary user accounts.</li></ul><p>The key idea is that users, applications, and security configurations within one realm are completely separate and independent from those in another realm. It’s like having separate train lines and waiting areas for different types of travelers, each with their own rules of engagement. You can’t use a travel pass from the “Public Square” district to access a building in the “Corporate Towers” district, even if both are managed by the same Keycloak Grand Central Station.</p><h3>SSO (Single Sign-On): The Universal Travel Pass</h3><p>This brings us to the magic trick Keycloak performs: Single Sign-On (SSO).</p><p>With Keycloak, once you’ve been verified at the Grand Central Station (i.e., you’ve logged into Keycloak successfully), you receive that special digital travel pass. This pass isn’t just for one building; it’s universally recognized within the specific District (Realm) you’re operating in.</p><p>So, SSO is like having one master key that unlocks all the doors in a specific district, after you’ve shown your ID at the central security checkpoint.</p><p>Before SSO, imagine arriving at the “Corporate Towers” district and having to present your ID to the receptionist of Building A, then walk to Building B and present your ID again to their receptionist, and so on.</p><p>With Keycloak’s SSO, you present your ID <em>once</em> at the entrance of the “Corporate Towers” District (log into Keycloak for that realm). Once verified, you get your universal travel pass. Now, you can effortlessly glide between Building A, Building B, and all the other buildings in that district without ever being asked for your credentials again, as long as your travel pass is still valid. You’ve “signed on once” and now have “single access” to everything.</p><h3>In Summary:</h3><ul><li>Keycloak: The Grand Central Station that centralizes digital identity management for many applications.</li><li>Realms: The distinct, isolated Districts within the Keycloak Grand Central Station, each with its own users, applications, and security rules.</li><li>SSO (Single Sign-On): The Universal Travel Pass you receive from Keycloak (within a specific Realm) that allows you to seamlessly access multiple connected applications without re-authenticating each time.</li></ul><p>This powerful setup simplifies user experience, reduces security risks by centralizing authentication, and makes managing digital identities much more efficient in our sprawling digital city.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67aaad7f86ed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Explain Virtual Dom using a metaphore]]></title>
            <link>https://medium.com/@gordonwho/explain-virtual-dom-using-a-metaphore-d93e2fe3319c?source=rss-a0aeb209d170------2</link>
            <guid isPermaLink="false">https://medium.com/p/d93e2fe3319c</guid>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Gordon H]]></dc:creator>
            <pubDate>Tue, 20 May 2025 20:22:19 GMT</pubDate>
            <atom:updated>2025-05-20T20:22:19.112Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Explain Virtual Dom using a metaphore</strong></p><p><strong>The Virtual DOM: Your Web Page’s Secret Weapon for Speed (Explained with a Blueprint!)</strong></p><p>Ever wondered how modern web applications feel so snappy and responsive, even with complex UIs? A big part of the magic often lies behind a concept called the Virtual DOM. It’s a fundamental optimization technique used by popular JavaScript frameworks like React and Vue.js, and understanding it can truly demystify how these libraries achieve their performance prowess.</p><p>Let’s break it down with a simple, relatable metaphor.</p><p><strong>Your House, Its Blueprint, and the Smart Renovation</strong></p><p>Imagine you have a detailed blueprint of your house. Every wall, every window, every piece of furniture is meticulously drawn. Now, let’s say you decide to make a small change — perhaps you want to paint just one wall in your living room a vibrant blue.</p><p><strong>What’s the most efficient way to do this?</strong></p><p>You wouldn’t tear down the entire house and rebuild it from scratch, right? That’s absurdly inefficient and expensive.</p><p>Instead, you’d follow these steps:</p><p>Update the blueprint: You’d first grab your house blueprint and, using a pencil, carefully update it to reflect the new blue wall. This is a quick and easy modification on paper.</p><p>Compare the blueprints: Next, you’d compare the <em>old</em> blueprint with the <em>new, updated</em> blueprint. What’s the exact difference? Ah, just that one wall’s color.</p><p>Send the worker for targeted action: Finally, you’d send a worker to physically paint only that specific wall in your actual house. They wouldn’t touch anything else.</p><p>This entire process, from updating the blueprint to the targeted physical change, is exactly what the Virtual DOM does for your web pages!</p><p>Your Actual House = The Real DOM: This is the live, rendered HTML structure of your web page that you see and interact with. Manipulating it directly can be slow because every change might trigger the browser to repaint and recalculate the layout of large parts of the page. Think of it like a full-scale renovation every time you change something.</p><p>The Blueprint = The Virtual DOM: This is a lightweight, in-memory representation of your web page’s structure. It’s a JavaScript object that perfectly mirrors the Real DOM. It’s fast to create and manipulate because it’s just data in memory.</p><p><em>Updating the Blueprint = Updating the Virtual DOM</em>: When the data in your application changes (e.g., a user types into an input field, new data arrives from a server), your framework doesn’t immediately touch the Real DOM. Instead, it creates a brand new Virtual DOM tree that reflects these changes. This is a very fast JavaScript operation.</p><p><em>Comparing the Blueprints = Reconciliation (The “Diffing” Process)</em>: This is the clever part. The framework then compares the newly created Virtual DOM tree with the <em>previous</em> Virtual DOM tree. It’s like overlaying two blueprints to find the exact discrepancies. This process is called “reconciliation” or “diffing,” and its goal is to identify the absolute minimum set of changes required.</p><p><em>Sending the Worker for Targeted Action = Updating the Real DOM</em>: Once the differences are pinpointed, the framework efficiently applies <em>only those specific changes</em> to the actual, visible Real DOM. This minimizes direct manipulation of the browser’s expensive DOM operations, leading to a much smoother and faster user experience.</p><p><em>The Brains Behind the Blueprint:</em> How It’s Implemented</p><p>The efficiency of the Virtual DOM largely depends on how frameworks perform the reconciliation and apply those minimal changes. Here are some key strategies:</p><p><strong>Smart Tree Traversal and Comparison:</strong></p><p>Frameworks essentially walk through both the old and new Virtual DOM “blueprints” simultaneously, node by node. They compare corresponding elements based on:</p><p>Type: If an element’s type changes (e.g., a &lt;div&gt; becomes a &lt;p&gt;), the framework assumes it&#39;s a completely new element and will replace the old one entirely.</p><p>Keys (for lists): Imagine you have a list of items. If you add, remove, or reorder items, how does the framework know which is which? This is where unique key props come in handy. By assigning a stable key to each item, the framework can intelligently identify if an item was truly added, removed, or just moved to a new position, rather than tearing down and recreating the entire list.</p><p>Props/Attributes: If the element type is the same, the framework checks for changes in its attributes (like className, src, href). Only the changed attributes are updated in the Real DOM.</p><p>Children: The comparison process then recursively continues for the children of each element.</p><p><strong>The “Diffing” Algorithm:</strong></p><p>The process of identifying the smallest set of changes between the two Virtual DOM trees is powered by a “diffing” algorithm. While different frameworks might have slight variations, the core principle is to find the most efficient way to transform the old structure into the new one. This algorithm is designed to be highly optimized for speed.</p><p><strong>Batch Updates:</strong></p><p>To further boost performance, frameworks often collect multiple changes to the Virtual DOM over a short period. Instead of applying each tiny change to the Real DOM individually, they “batch” them together and apply them all in a single, efficient update. This reduces the number of times the browser has to recalculate layout and repaint, leading to fewer visual “jumps” and a smoother feel. Think of it like our painter making several small adjustments before stepping back to admire their work.</p><p>In essence, the Virtual DOM acts as a sophisticated middleman, translating your application’s state changes into the most efficient updates for the browser. By minimizing direct interaction with the performance-heavy Real DOM and employing clever reconciliation strategies, it ensures that your web applications remain fast, fluid, and a joy for users to interact with. It’s a testament to how elegant abstractions can lead to powerful real-world performance benefits.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d93e2fe3319c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hi from Gordon]]></title>
            <link>https://medium.com/@gordonwho/hi-from-gordon-062699802fc7?source=rss-a0aeb209d170------2</link>
            <guid isPermaLink="false">https://medium.com/p/062699802fc7</guid>
            <category><![CDATA[intro]]></category>
            <dc:creator><![CDATA[Gordon H]]></dc:creator>
            <pubDate>Thu, 12 Sep 2024 23:02:17 GMT</pubDate>
            <atom:updated>2024-09-12T23:02:17.752Z</atom:updated>
            <content:encoded><![CDATA[<p>This is where I will be publishing articles regarding technology.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=062699802fc7" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>