<?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 Lukmon Adeokun on Medium]]></title>
        <description><![CDATA[Stories by Lukmon Adeokun on Medium]]></description>
        <link>https://medium.com/@adekunledally?source=rss-c685bf147b25------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dlpYxmf3yitIoajTkPmsqg.jpeg</url>
            <title>Stories by Lukmon Adeokun on Medium</title>
            <link>https://medium.com/@adekunledally?source=rss-c685bf147b25------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 22:35:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@adekunledally/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[Engineering a Multi-Region RideShare Platform on AWS]]></title>
            <link>https://medium.com/@adekunledally/engineering-a-multi-region-rideshare-platform-on-aws-110d976a752d?source=rss-c685bf147b25------2</link>
            <guid isPermaLink="false">https://medium.com/p/110d976a752d</guid>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[site-reliability-engineer]]></category>
            <category><![CDATA[amazon-web-services]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Lukmon Adeokun]]></dc:creator>
            <pubDate>Sat, 05 Sep 2026 14:42:25 GMT</pubDate>
            <atom:updated>2026-09-05T15:47:45.424Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Evolving a single-region EKS application into a production-oriented platform using managed data services, delivery automation, observability, and platform engineering principles</strong></p><p>There is a point in many Kubernetes projects where “it runs” stops being a useful definition of success. The RideShare application had reached that point.</p><p>The platform already looked cloud-native on the surface. It consisted of independently deployable services running on Amazon EKS. Helm managed the Kubernetes resources. NGINX Ingress handled north-south traffic, cert-manager automated TLS, External Secrets Operator synchronized credentials from AWS Secrets Manager, and Horizontal Pod Autoscalers and Pod Disruption Budgets supported availability.</p><p>PostgreSQL ran inside the cluster under CloudNativePG, while Redis ran under the Redis Operator. The application worked, and the architecture was technically credible.</p><p>But it was still a single-region system with a large operational surface area concentrated inside one Kubernetes cluster. The same team operating the application was also responsible for the database pods, cache pods, persistent volumes, operators, failover behaviour, upgrades, backups, and recovery procedures. A regional or cluster-level failure could take down the entire platform.</p><p>This project builds on the earlier implementation, which I documented in <a href="https://medium.com/@adekunledally/building-a-production-grade-rideshare-platform-on-kubernetes-lessons-from-running-microservices-on-5f596f4e4e75"><strong>Building a Production-Grade RideShare Platform on Kubernetes: Lessons from Running Microservices</strong></a><strong>.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XuQj4E2YLBGa-UI8gxW4BQ.png" /><figcaption><strong>Figure 1:</strong> The evolution of the RideShare platform from a stateful, single-region EKS deployment to a multi-region architecture built around managed AWS services, automated delivery and regional observability.</figcaption></figure><p>This article covers the original single-region EKS platform and examines its evolution into a multi-region architecture built around managed AWS services, delivery automation, observability, and operational controls.</p><p>The goal of the project therefore became larger than deploying more infrastructure. It became:</p><p><em>Engineering the evolution of a cloud-native RideShare application from a single-region Kubernetes deployment i.e a single-region EKS with CloudNativePG and the Redis Operator to a production-oriented, multi-region platform using Amazon RDS, Amazon ElastiCache, automation, observability, operational controls, and Platform Engineering principles.</em></p><p>This article is the story of this evolution, the trade-offs made, the problems encountered, the evidence demanded before calling a phase complete, and the moments when the safest engineering decision was to stop rather than keep typing commands.</p><p><strong>The original platform was working begging the question: why migrate to managed services?</strong></p><p>The original system ran in a single EKS cluster in `us-east-2`. Its services included rider, driver, trip, matching, email, and frontend workloads. PostgreSQL was managed by CloudNativePG with data persisted on Amazon EBS. Redis was managed by a Kubernetes operator. The application used WebSockets for real-time matching behaviour and exposed APIs through NGINX Ingress.</p><p>Nothing was fundamentally wrong with this design. In-cluster data services can be a valid choice when a team deliberately accepts the operational responsibility and has the skills, automation, and recovery discipline to support them.</p><p>That was the first important trade-off. I was not replacing CloudNativePG or the Redis Operator because Kubernetes operators are inherently bad. I was changing the allocation of responsibility.</p><p>With CloudNativePG, Kubernetes reconciled the PostgreSQL topology, but I still owned the consequences of storage failures, database upgrades, backup reliability, failover behaviour, node disruption, and recovery testing. With the Redis Operator, I gained declarative lifecycle management, but also retained responsibility for Redis clustering, persistence, upgrades, pod placement, and operator health.</p><p>Amazon RDS and Amazon ElastiCache reduced that operational burden. They provided managed capabilities around maintenance, backups, monitoring, encryption, Multi-AZ resilience, and service lifecycle management. In return, the platform accepted greater AWS coupling, additional cost, network dependencies, and less control over the underlying database and cache hosts.</p><p>The decision was not “Kubernetes versus AWS.” It was a decision about which layer should own stateful reliability.</p><p><strong>I treated the transformation as a sequence of controlled migrations</strong></p><p>I divided the work into phases instead of attempting a large replacement:</p><p>0. Architecture and strategy</p><p>1. Platform governance and standardisation</p><p>2. Platform evolution and managed-service migration</p><p>3. Delivery automation and rollback validation</p><p>4. Observability and Site Reliability Engineering</p><p>Each phase had explicit exit criteria. A phase was not complete because its YAML had been merged. It was complete only when the intended behaviour had been demonstrated and recorded.</p><p>That distinction changed the way I approached the whole project. It made rollback, evidence, and negative testing part of implementation rather than follow-up work.</p><p><strong>Rebuild rather than rename</strong></p><p>One early decision was whether to rename and modify the existing EKS environment or rebuild it from approved definitions.</p><p>Renaming appeared cheaper and faster. Rebuilding was operationally more expensive because it temporarily duplicated capacity and required another controlled migration. I chose to rebuild.</p><p>The target clusters became:</p><p>- `rideshare-prod-use1` in `us-east-1` (use1)</p><p>- `rideshare-prod-use2` in `us-east-2` (use2)</p><p>Rebuilding exposed hidden assumptions that an in-place rename would have preserved. It tested whether the cluster definitions, Helm values, IAM relationships, add-ons, node labels, taints, and operational procedures were genuinely reproducible.</p><p>Both clusters used dedicated platform and application node groups. Platform nodes were labelled and tainted with `workload-type=platform`, while application workloads ran on application nodes. Controllers such as cert-manager, External Secrets, ingress components, and later the monitoring stack received explicit selectors and tolerations.</p><p>This separation was intentionally modest. It did not pretend to provide complete tenant isolation, but it protected critical platform services from competing directly with application workloads and made scheduling intent visible in code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JzMk5yGtnCcnqJR45MZS0g.png" /><figcaption><strong>Figure 2:</strong> Detailed architecture of the evolved RideShare platform, showing Route 53 traffic distribution across two regional Amazon EKS clusters, shared Amazon RDS and ElastiCache services, GitHub Actions delivery through OIDC, centralized secrets management, regional observability stacks, and supporting platform controls.</figcaption></figure><p><strong>Moving PostgreSQL to RDS( reducing toil without hiding the failure domain)</strong></p><p>The target data architecture used a shared Amazon RDS for PostgreSQL deployment as the authoritative database for both EKS clusters.</p><p>The migration sequence mattered:</p><p>· Provision encrypted, private RDS infrastructure with Multi-AZ capability</p><p>· Configure database users and connectivity</p><p>· Migrate schema and data</p><p>· Compare record counts and run critical queries</p><p>· Store credentials in AWS Secrets Manager</p><p>· Synchronize Kubernetes Secrets through External Secrets Operator</p><p>· Update application configuration to use the RDS endpoint</p><p>· Validate both clusters</p><p>· Retain the original CloudNativePG environment until rollback confidence was established.</p><p>The most tempting mistake would have been to remove the old database as soon as the first application pod connected to RDS. I resisted that. Connectivity was only one test. I also needed confidence in schema completeness, data consistency, application behaviour, and the ability to reverse the cutover.</p><p>The transition was not frictionless. Application startup failures exposed incorrect endpoints in configuration. At another point, an AWS CLI command attempted to reach `https://rds..amazonaws.com` because the region was missing. That tiny error was instructive; in a multi-region system, region is not background context. It is part of command correctness.</p><p>External Secrets introduced another chain of dependencies to worry about. Secrets Manager, IAM policy, IAM role, OIDC provider, Kubernetes service account, SecretStore, ExternalSecret, and finally the generated Kubernetes Secret. When synchronization failed, checking only the final Secret was not enough. I learned to walk the chain in order and identify the exact trust or permission boundary that had failed.</p><p><strong>The trade-offs behind the move to RDS</strong></p><p>Moving PostgreSQL out of EKS reduced database operational ownership and improved the managed backup and Multi-AZ story. It did not automatically create a multi-region database.</p><p>Both application regions still depended on a shared authoritative service. The remote EKS region could experience additional database latency and inter-region transfer cost. RDS could become a shared dependency whose failure affected both otherwise healthy clusters. A serious production design would therefore need explicit RPO and RTO targets, tested restoration, and a decision about cross-region database replication or promotion.</p><p>The migration improved the system, but it did not abolish trade-offs. It moved them to a different boundary.</p><p><strong>Moving Redis to ElastiCache(less operator ownership, more network concerns)</strong></p><p>Redis followed a similar path. The in-cluster Redis Operator was replaced by a shared Amazon ElastiCache deployment.</p><p>The migration required more than changing `REDIS_URL`. I needed to validate authentication, TLS expectations, security-group paths, endpoint selection, application timeouts, and behaviour from both regions. Redis-dependent workflows including matching and WebSocket-driven interactions had to continue working before operator-managed Redis could be retired.</p><p>I encountered intermittent connection problems caused by endpoint and network-rule mismatches. The useful lesson was not simply “fix the security group.” It was learning to separate layers:</p><p>1. Does DNS resolve the expected endpoint?</p><p>2. Is the destination port reachable?</p><p>3. Does TLS negotiation succeed if enabled?</p><p>4. Are the credentials accepted?</p><p>5. Does the application use the same URL format tested manually?</p><p>6. Does the end-to-end workflow behave correctly under real traffic?</p><p>ElastiCache reduced the burden of running Redis pods and their operator. In exchange, the platform accepted another shared dependency, cross-region latency, data-transfer cost, and greater sensitivity to VPC routing and security configuration.</p><p>Again, the decision was about operational ownership not about pretending the managed service had no failure modes.</p><p><strong>Multi-region traffic required application-aware health, not just a healthy load balancer</strong></p><p>The two EKS regions were placed behind Route 53 latency-based routing for `rideshare.lukmonadeokun.com`.</p><p>Latency routing supported active-active regional entry points, but it introduced an important trap which is a Network Load Balancer and NGINX Ingress can both be healthy while the application behind them is unavailable.</p><p>I saw this in practice during failure testing. Removing application capacity in one region could still produce a `503` because traffic continued to reach infrastructure that was technically alive. The health signal was measuring the wrong layer.</p><p>I introduced application-level regional health checks rather than relying solely on transport-level reachability. Route 53 needed a signal that represented whether the RideShare application could serve users, not whether an NLB could accept a TCP connection.</p><p>Even then, DNS failover was not instantaneous. Resolver caching and TTL behaviour affected convergence, and existing WebSocket sessions could not magically migrate between regions. The final design therefore documented the limitations instead of presenting DNS routing as seamless session mobility.</p><p>That distinction matters to me: resilience claims should describe what the system actually guarantees.</p><p><strong>CI/CD became an identity and rollback problem, not just a deployment problem</strong></p><p>The delivery pipeline used GitHub Actions to deploy the Helm release independently to both regions. AWS access was provided through GitHub OIDC rather than long-lived AWS keys.</p><p>OIDC improved credential hygiene, but it also made the trust relationship precise. The GitHub repository, branch or environment claims had to match the IAM role’s trust policy. The `use1` deployment was additionally protected by a GitHub Environment approval gate.</p><p>One of the more frustrating failures happened after the workflow had successfully assumed its AWS role and updated kubeconfig. It reached “Verify target cluster,” step then kubectl returned:</p><p>“You must be logged in to the server”</p><p>That message could easily lead to random RBAC changes. Instead, I separated the path:</p><p>· Did GitHub issue the expected OIDC identity?</p><p>· Did AWS STS allow the role assumption?</p><p>· Did the workflow target the correct account and region?</p><p>· Did `aws eks update-kubeconfig` reference the correct cluster?</p><p>· Was the assumed IAM role authorised by EKS?</p><p>The eventual deployment succeeded, including the protected approval flow and post-deployment checks. The important part was not the final green tick; it was avoiding a broad permissions change simply because the first error mentioned login.</p><p><strong>A successful deployment was not enough.I deliberately broke one</strong></p><p>To close the delivery phase, I added Helm’s atomic failure protection:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fXl-AqHOAfU2fHO2El9FRg.png" /><figcaption>Figure 3. Added Helm’s atomic failure protection</figcaption></figure><p>Then I supplied a deliberately invalid frontend image tag in `use2`.</p><p>The upgrade timed out as expected. Helm recorded revision 10 as failed and automatically created revision 11 as a rollback to the previously healthy revision 9. I then verified the restored frontend image, running pods, healthy deployments, HPA state, regional health endpoint, and production health endpoint. Both health checks returned `OK`, and no pod referenced the invalid image.</p><p>This test changed the meaning of “rollback supported.” It was no longer a command in a runbook. It was observed behaviour with evidence.</p><p>Protected `main` also influenced my workflow. Changes were made on focused branches, validated, pushed, reviewed through pull requests, and merged only after checks passed. That sometimes felt slower than editing `main` directly, but it produced an auditable path from intent to production state.</p><p><strong>Storage taught me to prefer additive changes</strong></p><p>Observability required persistent storage for Prometheus, Grafana, and Alertmanager. The clusters already had a legacy `gp2` StorageClass using the in-tree EBS provisioner. I was concerned that replacing it with `gp3` might break existing workloads.</p><p>So I did not replace it.</p><p>I created a separate `gp3` StorageClass backed by `ebs.csi.aws.com`, enabled encryption and expansion, and used `WaitForFirstConsumer`. The existing `gp2` class remained untouched.</p><p>I smoke-tested `gp3` independently in both clusters with a temporary PVC and pod. `WaitForFirstConsumer` ensured the EBS volume was provisioned in the Availability Zone of the selected node. I wrote data to the mounted volume, read it back, inspected the resulting PV and EBS volume, then deleted the temporary namespace and confirmed that the test volume was removed.</p><p>There were small mistakes along the way such as an AWS volume query used the wrong region, a malformed JMESPath expression failed, and I mistyped a topology label. None of those mistakes required risky remediation. I corrected the observation commands and continued.</p><p>That experience reinforced a pattern I now use deliberately:</p><p><em>When replacing shared infrastructure, prefer an additive path that can be tested independently before changing existing consumers.</em></p><p><strong>Observability: From “pods are running” to measurable platform behaviour</strong></p><p>I deployed `kube-prometheus-stack` version `88.6.3` independently in both production clusters. The stack included Prometheus, Alertmanager, Grafana, Prometheus Operator, kube-state-metrics, Node Exporter, and Kubernetes recording and alerting rules.</p><p>Prometheus, Grafana, Alertmanager, the operator, and kube-state-metrics were scheduled onto the tainted platform nodes. Node Exporter ran across all four nodes in each cluster. Persistent data used the new encrypted `gp3` StorageClass:</p><p>Prometheus retention was bounded by both time and size (seven days and 16 GB). Grafana and Prometheus remained private `ClusterIP` services and were accessed through port forwarding during validation.</p><p>In each region, Prometheus reported 27 healthy targets and zero unhealthy targets.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j6qRszScnnzwq2grtmC8hw.png" /><figcaption>Figure 4. Prometheus reporting 27 healthy scrape targets and zero unhealthy targets in the use1 cluster, confirming that the regional monitoring stack was collecting metrics successfully.</figcaption></figure><p>Four Kubernetes nodes and four Node Exporter targets were visible. RideShare pods and available replicas were observable through kube-state-metrics. Grafana provisioned 25 dashboards, and the only firing alert was `Watchdog` the intentionally active signal used to prove that an alerting pipeline is alive.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_MnKEQ5CbdZY6CBTbVT4Sw.png" /><figcaption>Figure 5. Prometheus showing the intentionally firing Watchdog alert, which confirms that alert evaluation is active and provides a continuous signal for validating the alerting pipeline.</figcaption></figure><p>Not every problem was in Kubernetes. In `use1`, the password stored in the Grafana Secret returned HTTP 401 because Grafana’s internal database password no longer matched the bootstrap Secret. I verified the failure through the Grafana API instead of repeatedly guessing in the browser, then realigned the internal password with the Secret.</p><p>At the time of writing, the core observability foundation was operational in both regions, with healthy Prometheus targets, provisioned Grafana dashboards, persistent monitoring storage, and independent regional monitoring stacks. Further platform-level instrumentation, including dedicated ServiceMonitors for ingress-nginx and cert-manager, remains part of the next iteration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aeBDOQE3XGmbpTd8i-kwxg.png" /><figcaption>Figure 6. Grafana displaying cluster-level CPU and memory utilisation across the use1 EKS namespaces, confirming that application, platform and monitoring workloads were successfully observable.</figcaption></figure><p>I chose to conclude this phase at a stable and validated checkpoint. The platform’s multi-region architecture, managed data services, delivery automation, rollback controls, and observability foundation had all been demonstrated with recorded evidence. The remaining work represents continued operational maturity rather than a gap in the architecture delivered by this project.</p><p><strong>How my troubleshooting approach evolved</strong></p><p>The project exposed a weakness common in complex infrastructure work which is an error near the end of a chain often originates much earlier.</p><p>A pod failing to start might be caused by an incorrect RDS endpoint. A Secret not appearing might originate in an OIDC trust condition. A `503` might mean the load balancer is healthy but the application is not. A Grafana login failure might mean the Secret is correct but its persistent database has a different password. A failed AWS CLI call might be an expired token rather than an EKS problem.</p><p>I became more disciplined about troubleshooting in layers:</p><p>1. <strong>Confirm context: </strong>Which AWS account, region, Kubernetes context, namespace, release, and revision am I touching?</p><p>2. <strong>Establish a baseline:</strong> What was healthy before the change?</p><p>3. <strong>Test one boundary at a time:</strong> DNS, TCP, TLS, authentication, authorisation, configuration, and application behaviour are different tests.</p><p>4. <strong>Prefer read-only evidence first:</strong> `describe`, `get`, `status`, `history`, `diff`, and API health queries reduce guesswork.</p><p>5. <strong>Make reversible changes:</strong> Retain the old data service, use additive storage, deploy to the lower-risk region first, and use atomic Helm upgrades.</p><p>6. <strong>Validate failure, not just success:</strong> A rollback mechanism that has never restored a service is still a hypothesis.</p><p>7. <strong>Stop at ambiguous authority boundaries:</strong> Invalid credentials and uncertain account state are reasons to pause.</p><p>I also learned not to confuse activity with progress. Re-running a failing command without changing the hypothesis is not troubleshooting. The better question is: <em>*What observation would distinguish the two most likely causes?</em></p><p><strong>What is complete and what is not complete</strong></p><p>The platform now has:</p><p>· Two standardised production EKS clusters</p><p>· Managed PostgreSQL and Redis dependencies through Amazon RDS and ElastiCache</p><p>· Private secret delivery through Secrets Manager and External Secrets Operator</p><p>· NGINX Ingress, automated TLS, health probes, HPAs, and PDBs</p><p>· Route 53 latency-based multi-region routing with application-aware health validation</p><p>· GitHub Actions deployments using AWS OIDC</p><p>· A protected production approval path</p><p>· Post-deployment application validation</p><p>· Tested automatic Helm rollback</p><p>· Regional Prometheus, Grafana, Alertmanager, kube-state-metrics, and Node Exporter foundations with encrypted persistent storage.</p><p>The project is not finished. Application-level metrics still need to be instrumented. Alertmanager needs real notification routes. Centralised logging and tracing remain. Backups and restoration require deeper operational exercises. SLIs, SLOs, error budgets, runbooks, and broader regional failure scenarios still need to be completed.</p><p>I prefer stating that plainly. “Production-oriented” is not the same as claiming the system is production-perfect.</p><h3>What this project ultimately demonstrated</h3><p>The most valuable outcome was not the number of AWS services deployed or Kubernetes manifests written. It was the way the platform was evolved.</p><p>I made decisions based on operational ownership rather than tool popularity. I preserved rollback paths while migrating state and adopted managed services without overlooking the shared dependencies they introduced. I treated IAM and OIDC as trust systems rather than copy-and-paste configuration. I tested DNS failover at the application layer, deliberately triggered a failed deployment to observe recovery, and kept the existing storage configuration untouched while validating its replacement. I also measured the monitoring stack instead of assuming that running pods meant working observability.</p><p>Ultimately, this project demonstrated more than the ability to build a platform. It demonstrated the engineering discipline required to evolve one while maintaining visibility, recoverability, and control of risk.</p><p>The architecture changed substantially from one cluster carrying application and stateful operational responsibility to a standardised, multi-region platform built around managed AWS services and regional observability.</p><p>My thinking has changed too. I started by asking, “How do I deploy this?” I now ask a harder set of questions:</p><p>· What failure domain am I creating?</p><p>· Who owns recovery at this layer?</p><p>· What evidence proves the change worked?</p><p>· How do I reverse it safely?</p><p>· What claim am I making about reliability, and have I actually tested it?</p><p>Those questions are the real foundation of Platform Engineering and SRE. The tools are how I expressed them.</p><p><strong>Technology used</strong></p><p>Amazon EKS, Amazon RDS for PostgreSQL, Amazon ElastiCache for Redis, Amazon ECR, Route 53, AWS Secrets Manager, IAM, OIDC, EBS CSI, Kubernetes, Helm, GitHub Actions, NGINX Ingress, cert-manager, External Secrets Operator, Prometheus, Alertmanager, Grafana, kube-state-metrics, and Node Exporter.</p><h3>Repository</h3><p>The complete implementation including the regional EKS configurations, Kubernetes manifests, Helm charts, GitHub Actions workflows, observability configuration, Architecture Decision Records, validation evidence, and operational documentation is available in the <a href="https://github.com/AdekunleDally/rideshare-platform">RideShare Platform GitHub repository</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=110d976a752d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Production-Grade Rideshare Platform on Kubernetes: Lessons From Running Microservices on…]]></title>
            <link>https://medium.com/@adekunledally/building-a-production-grade-rideshare-platform-on-kubernetes-lessons-from-running-microservices-on-5f596f4e4e75?source=rss-c685bf147b25------2</link>
            <guid isPermaLink="false">https://medium.com/p/5f596f4e4e75</guid>
            <category><![CDATA[amazon-web-services]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[cloud-native]]></category>
            <dc:creator><![CDATA[Lukmon Adeokun]]></dc:creator>
            <pubDate>Fri, 10 Jul 2026 10:04:07 GMT</pubDate>
            <atom:updated>2026-07-10T20:31:46.016Z</atom:updated>
            <content:encoded><![CDATA[<h3>Building a Production-Grade Rideshare Platform on Kubernetes: Lessons From Running Microservices on Amazon EKS with Helm, CloudNativePG, and Redis Operator</h3><h3>Introduction</h3><p>When people talk about Kubernetes projects, it is easy to focus on deploying containers and getting applications running. However, running a production-like platform requires much more than creating a Deployment and exposing a Service.</p><p>A real platform has to answer difficult questions:</p><ul><li>How do services communicate?</li><li>How do we manage databases?</li><li>How do we handle failures?</li><li>How do we securely manage secrets?</li><li>How do we scale when traffic increases?</li><li>How do we monitor what is happening inside the system and a lot more</li></ul><p>These questions became the motivation behind building a cloud-native rideshare platform.</p><p>This project explores how modern kubernetes operators can be used to build and operate a production-style platform in which both stateless applications and stateful services are managed declaratively within the kubernetes ecosystem.</p><p>The goal of this project is not to suggest that operators should replace managed cloud services, but to demonstrate how they simplify the operation of complex workloads while fitting naturally into a kubernetes-centric architecture</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M-qfqSlootlKuWvIlRpx3g.png" /><figcaption><strong>Figure 1</strong>. Overall Architecture of the Rideshare platform deployed on Amazon EKS.</figcaption></figure><p>The platform was built around:</p><ul><li>Amazon Elastic Kubernetes Service (EKS)</li><li>Helm for application deployment</li><li>CloudNativePG for PostgreSQL management</li><li>Redis Operator for Redis clustering</li><li>NGINX Ingress Controller</li><li>External Secrets Operator</li><li>AWS Secrets Manager</li><li>Kubernetes autoscaling mechanisms</li></ul><p>Throughout this journey, the biggest lessons came not from writing YAML manifests, but from understanding how different components work together to create a reliable platform and how to solve problems when these components experience downtime</p><h3>The Problem: Moving Beyond “It Runs on My Machine”</h3><p>Many applications begin as a single service running locally. A developer can run:</p><pre>docker-compose up</pre><p>and everything works. That approach is excellent for local development, but it begins to break down as applications become more distributed and operational requirements increase. Production environments demand reliability, scalability, observability, and resilience. These concerns are often hidden during local development.</p><p>The rideshare platform presented exactly these challenges. Unlike a simple web application, it consists of multiple services that must coordinate in real time while remaining independently deployable and resilient to failures. The rideshare platform has different requirements:</p><ul><li>Riders need to request rides</li><li>Drivers need real-time availability</li><li>Matching requires low-latency data access</li><li>Notifications need asynchronous processing</li><li>User data needs persistent storage</li><li>The system must survive failures</li></ul><p>Clearly, a simple deployment model quickly becomes insufficient. The platform needs a design where each responsibility could evolve independently. This naturally led to a microservices architecture.</p><h3>Rideshare Architecture</h3><p>The rideshare platform consists of multiple independent services:</p><ul><li>Frontend service</li><li>Rider service</li><li>Driver service</li><li>Matching service</li><li>Email service</li><li>Trip service</li></ul><p>Each service has its own responsibility and deployment lifecycle. At a high level, the request flow looks like this:</p><pre>Users</pre><pre> |</pre><pre> |</pre><pre>Ingress Controller</pre><pre> |</pre><pre> |</pre><pre>Application Services</pre><pre> |</pre><pre> ---------------------</pre><pre> |                   |</pre><pre>PostgreSQL          Redis</pre><pre>(Database)          (Real-time state)</pre><p>The application runs inside Amazon EKS, with Kubernetes responsible for:</p><ul><li>Scheduling containers</li><li>Restarting failed workloads</li><li>Managing networking</li><li>Scaling applications</li></ul><h3>How a Ride Request Flows Through the Platform</h3><p>While the architecture diagram illustrates how the platform is organised, it doesn’t fully explain how the individual microservices collaborate to process a ride request. Understanding this interaction is just as important as understanding the infrastructure itself.</p><p>The following diagram illustrates the end-to-end lifecycle of a ride request, from the moment a rider submits a request until a driver is matched, notified, and the trip is created.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f0pJEzJUnh3wis1Yrp8PuA.png" /><figcaption><strong>Figure 2.</strong> End-to-end request flow illustrating how a ride request is processed through the platform.</figcaption></figure><p>At a high level, the request follows these steps:</p><ol><li><strong>The rider submits a ride request.</strong><br>A rider enters a pickup and destination location in the frontend application. The request is sent to the platform through the public domain, which resolves via Route53 before reaching the external AWS Network Load Balancer that fronts the NGINX Ingress Controller.</li><li><strong>NGINX routes the request to the Rider Service.</strong><br>Acting as the platform’s API gateway, the NGINX Ingress Controller examines the request and forwards it to the appropriate backend service based on the configured routing rules.</li><li><strong>The Rider Service validates the request.</strong><br>The Rider Service authenticates the user, validates the incoming payload, and delegates trip creation to the Trip Service, ensuring that ride lifecycle management remains isolated within a dedicated microservice.</li><li><strong>The Trip Service creates a new trip.</strong><br>A new trip record is initialised with a status such as <strong>REQUESTED</strong> and persisted to PostgreSQL through the CloudNativePG-managed database cluster. At this stage, no driver has been assigned.</li><li><strong>The Matching Service searches for an available driver.</strong><br>The Matching Service retrieves real-time driver availability and location information from the Redis cluster managed by the Redis Operator. Using this low-latency data, it identifies the most suitable driver based on proximity and availability.</li><li><strong>The selected driver is notified.</strong><br>Once a match is found, the Driver Service and Notification Service work together to notify the selected driver of the new ride request. In a production environment, these notifications could be delivered through WebSockets, push notifications, SMS, or email.</li><li><strong>The trip is updated.</strong><br>After the driver accepts the request, the Trip Service updates the trip status and records the assigned driver. This information is persisted to PostgreSQL, ensuring the trip state remains durable even if pods are restarted or rescheduled.</li><li><strong>The rider receives the assignment.</strong><br>The Rider Service returns the assigned driver’s details and current trip status to the frontend application. From this point onward, subsequent events such as driver arrival, trip start, and trip completion continue updating the trip through the same set of microservices.</li></ol><p>Although the entire process typically completes within a few seconds, multiple independent services collaborate behind the scenes. Each service owns a specific business capability, allowing it to scale, evolve, and recover independently without affecting the rest of the platform. This separation of responsibilities is one of the key advantages of adopting a microservices architecture on Kubernetes.</p><h3>The Application in Action</h3><p>While much of this article focuses on the infrastructure powering the system, the ultimate objective was to build a fully functional rideshare application. Behind every Kubernetes resource, operator, and deployment manifest is an application that allows riders to request trips and drivers to manage ride assignments.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w-ckvWIIwd_2QpwuLEEokg.png" /><figcaption><strong>Figure 3. Homepage of rideshare application running on amazon EKS</strong></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LHCw-uXKTs4FYHvXaWBiSQ.png" /><figcaption><strong>Figure 4. Login page of rideshare application</strong></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kNHlv-SHQhjLpHna2k4mhQ.png" /><figcaption><strong>Figure 5. Rider request page</strong></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LFBZYbiDBXt4_F_-HOWq9Q.png" /><figcaption><strong>Figure 6. Ride History</strong></figcaption></figure><blockquote>The frontend serves as the primary entry point for users, communicating with the backend microservices through the NGINX Ingress Controller. Although the underlying architecture consists of multiple independently deployable services, the user experiences the platform as a single, cohesive application.</blockquote><p>Every ride request initiated through the interface triggers interactions across several backend services responsible for rider management, trip creation, driver matching, notifications, caching, and persistent data storage. Kubernetes orchestrates these services behind the scenes, ensuring they remain available, scalable, and resilient.</p><p>The application’s user interface represents the visible outcome of the cloud-native architecture discussed throughout this article, demonstrating how infrastructure, operators, and application services work together to deliver a seamless user experience.</p><p>Although users interact with a single web application, running the application reliably requires cloud infrastructure capable of orchestrating multiple services. Amazon EKS provides this foundation</p><h3>Why Amazon EKS?</h3><p>Running a distributed application locally is an excellent way to develop and test individual services, but it does not accurately reflect how production platforms are deployed and operated. As the rideshare application evolved into multiple independently deployable microservices, it became necessary to run the platform on infrastructure capable of providing high availability, scalability, secure networking, and integration with managed cloud services.</p><p>Amazon Elastic Kubernetes Service (EKS) provided that foundation. By managing the Kubernetes control plane, EKS removes much of the operational overhead associated with running Kubernetes while allowing engineers to retain full control over the worker nodes and application workloads. This makes it possible to focus on building and operating the platform rather than maintaining the Kubernetes control plane itself.</p><p>EKS also integrates naturally with the broader AWS ecosystem used throughout this project. Services such as Elastic Load Balancing, IAM, Route 53, AWS Secrets Manager, and Amazon EBS work seamlessly with Kubernetes, making it easier to implement secure networking, persistent storage, ingress management, and identity-based access control without introducing additional infrastructure complexity.</p><p>Beyond simplifying cluster management, EKS provided an environment that closely resembles how many organisations deploy cloud-native applications in production. This allowed the project to explore operational concerns such as autoscaling, high availability, secret management, ingress routing, and stateful workloads within a realistic production-style Kubernetes environment rather than a local development cluster.</p><p>The high-level infrastructure for the platform consists of an AWS Region containing a Virtual Private Cloud (VPC), an Amazon EKS cluster, managed worker nodes, and the application workloads running as Kubernetes pods. While AWS manages the Kubernetes control plane, the worker nodes host the rideshare microservices, CloudNativePG cluster, Redis cluster, ingress controller, and supporting platform components.</p><h3>Managing Rideshare Application with Helm</h3><p>Rideshare was deployed as microservice(loosely coupled services). However, as the number of services increased, manually managing Kubernetes manifests became difficult. The platform adopted Helm to package and deploy applications. The repository follows an umbrella chart approach:</p><pre>helm/</pre><pre>└── rideshare-chart</pre><pre>      ├── frontend</pre><pre>      ├── trip-service</pre><pre>      ├── rider-service</pre><pre>      ├── driver-service</pre><pre>      ├── matching-service</pre><pre>      └── email-service</pre><p>This provided several advantages:</p><h4>1. Consistent deployments</h4><p>A complete environment could be deployed using:</p><pre>helm install rideshare ./rideshare-chart</pre><h4>2. Configuration management</h4><p>Environment-specific values could be separated:</p><pre>values.yaml</pre><pre>values-production.yaml</pre><h4>3. Versioned releases</h4><p>Helm provides:</p><ul><li>Upgrade history</li><li>Rollbacks</li><li>Release tracking</li></ul><p>This made deployments safer and more predictable.</p><h3>The Database Challenge: Moving Beyond StatefulSets</h3><p>One of the biggest architectural decisions was database management. Initially, it is tempting to manually create PostgreSQL StatefulSets. However, production PostgreSQL requires much more:</p><ul><li>Replication</li><li>Failover</li><li>Backup management</li><li>Recovery procedures</li><li>Rolling upgrades</li></ul><p>Managing all of this manually creates operational overhead.</p><p>This is where CloudNativePG became valuable.</p><h3>PostgreSQL with CloudNativePG</h3><p>Instead of managing PostgreSQL directly, the platform uses the CloudNativePG operator. The architecture became:</p><pre>Application Services</pre><pre>        |</pre><pre>        |</pre><pre>PostgreSQL Service</pre><pre>        |</pre><pre>        |</pre><pre>CloudNativePG Cluster</pre><pre>        |</pre><pre> ----------------------</pre><pre> |          |          |</pre><pre>Primary  Replica   Replica</pre><p>The operator manages:</p><ul><li>PostgreSQL instances</li><li>Streaming replication</li><li>Primary election</li><li>Recovery workflows</li></ul><p>The key advantage is that PostgreSQL becomes Kubernetes-native. Instead of writing scripts to manage database lifecycle, we describe the desired state and allow the operator to reconcile it.</p><h3>Redis: The Heart of Real-Time Matching</h3><p>A rideshare platform requires fast access to dynamic data.</p><p>Examples:</p><ul><li>Available drivers</li><li>Driver locations</li><li>Active ride requests</li></ul><p>A traditional relational database is not ideal for these workloads.</p><p>Redis provides:</p><ul><li>Low latency</li><li>In-memory access</li><li>Geospatial capabilities</li></ul><p>The matching service relies heavily on Redis.</p><h3>Redis Operator Instead of Manual Management</h3><p>Redis introduces its own operational challenges:</p><ul><li>Cluster formation</li><li>Replication</li><li>Failover</li><li>Recovery</li></ul><p>Instead of manually creating Redis StatefulSets, the platform uses Redis Operator.</p><p>The operator manages:</p><pre>Redis Cluster</pre><pre>Master</pre><pre> |</pre><pre>Replica<br></pre><pre>Master</pre><pre> |</pre><pre>Replica<br></pre><pre>Master</pre><pre> |</pre><pre>Replica</pre><p>This approach follows the same philosophy as CloudNativePG: Let Kubernetes operators manage complex stateful systems.</p><h3>Secrets Management: No Credentials in Git</h3><p>A common mistake in Kubernetes projects is storing secrets directly inside:</p><ul><li>YAML files</li><li>Helm values</li><li>Git repositories</li></ul><p>The platform avoids this.</p><p>The secrets flow is:</p><pre>AWS Secrets Manager</pre><pre>        |</pre><pre>        |</pre><pre>External Secrets Operator</pre><pre>        |</pre><pre>        |</pre><pre>Kubernetes Secret</pre><pre>        |</pre><pre>        |</pre><pre>Application Pod</pre><p>This provides:</p><ul><li>Centralized secret management</li><li>Better auditing</li><li>Reduced credential exposure</li></ul><p>The application receives secrets without developers needing to store them inside source code.</p><h3>Handling External Traffic</h3><p>The platform uses NGINX Ingress Controller.</p><p>Traffic flow:</p><pre>Internet</pre><pre> |</pre><pre> |</pre><pre>AWS Load Balancer</pre><pre> |</pre><pre> |</pre><pre>NGINX Ingress</pre><pre> |</pre><pre> |</pre><pre>Kubernetes Services</pre><pre> |</pre><pre> |</pre><pre>Pods</pre><p>Ingress provides:</p><ul><li>Routing</li><li>TLS termination</li><li>Host-based traffic management</li></ul><p>This keeps application services internal while exposing only required endpoints.</p><h3>Scaling the Platform</h3><p>A production platform must handle changing workloads. Two scaling strategies were implemented.</p><h4>1. Horizontal Pod Autoscaler</h4><h4>Application workloads can scale based on resource utilisation.</h4><p>Example:</p><pre>High traffic</pre><pre>     |</pre><pre>     |</pre><pre>CPU increases</pre><pre>     |</pre><pre>     |</pre><pre>HPA creates more replicas</pre><h4>2. Cluster Autoscaler</h4><p>Sometimes pods cannot run because the cluster lacks capacity. Cluster Autoscaler handles infrastructure scaling:</p><pre>Pending Pods</pre><pre>      |</pre><pre>      |</pre><pre>Cluster Autoscaler</pre><pre>      |</pre><pre>      |</pre><pre>New Worker Node</pre><p>This allows the Kubernetes cluster itself to grow when needed.</p><p>By this point, the platform had evolved from a collection of Kubernetes manifests into a fully deployed environment running on Amazon EKS. However, designing an architecture is only part of building a production-ready platform. Equally important is verifying that every component has been deployed correctly, is communicating as expected, and can be observed and managed in a live Kubernetes cluster.</p><p>Before discussing the challenges encountered during development, it’s worth taking a look at how the deployment was validated in practice.</p><h3>Validating the Deployment on Amazon EKS</h3><p>Designing a cloud-native architecture is only one part of the engineering effort. Equally important is verifying that every component has been successfully deployed and is operating as expected within the Kubernetes cluster.</p><p>Throughout the project, Kubernetes CLI commands were used to validate workloads, networking, autoscaling, and the overall health of the platform. Rather than relying solely on architecture diagrams, these deployment checks confirmed that the platform was functioning correctly on Amazon EKS.</p><h3>Verifying Application Workloads</h3><p>After deploying the platform with Helm, the first validation step was confirming that all application workloads and supporting infrastructure were running successfully.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eipI-TtcErqxA6popP0YPA.png" /><figcaption><strong>Figure 7. EKS workloads</strong></figcaption></figure><p>The output confirms that the application services, supporting operators, ingress controller, monitoring stack, and Kubernetes system components were all running successfully. Seeing the complete set of workloads in a healthy state provided confidence that the platform had been deployed correctly.</p><h3>Verifying External Access</h3><p>Once the workloads were operational, the next step was validating external connectivity through the ingress layer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IjJPYhUMyF-XEBMxBbPtmg.png" /><figcaption><strong><em>Figure 8. NGINX Ingress configuration</em></strong></figcaption></figure><p>This confirmed that the application’s public endpoint had been configured correctly and that incoming traffic could be routed to the appropriate backend services through the NGINX Ingress Controller.</p><h3>Verifying Autoscaling</h3><p>To ensure the platform could adapt to changing workloads, Horizontal Pod Autoscalers (HPAs) were configured for the application services.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Mf4t79X8iX2XEI-CuuZLgQ.png" /><figcaption><strong><em>Figure 9. Horizontal Pod Autoscaler status</em></strong></figcaption></figure><p>The HPA resources continuously monitor CPU utilization and automatically adjust the number of application replicas when demand changes, improving both performance and resource efficiency.</p><h3>Challenges Encountered</h3><p>Building this platform was not without challenges.</p><h4>1. Understanding Kubernetes Operators</h4><p>Operators introduce a different way of thinking. Instead of manually controlling every action, you define the desired state and allow the operator to maintain it. This required changing from:</p><p>“How do I create this resource?”</p><p>to:</p><p>“What state should this system always maintain?”</p><h4>2. Stateful Applications Are Harder Than Stateless Applications</h4><p>Deploying a frontend container is relatively straightforward. Running databases inside Kubernetes requires deeper understanding.</p><p>Important concepts included:</p><ul><li>Persistent volumes</li><li>Storage classes</li><li>Replication</li><li>Failover</li><li>Backup strategy</li></ul><h4>3. Debugging Distributed Systems</h4><p>Failures rarely happen in isolation. A service failure could be caused by:</p><ul><li>Missing secrets</li><li>Database connectivity</li><li>Networking issues</li><li>Incorrect Helm values</li><li>Resource limitations</li></ul><p>Learning to troubleshoot systematically became one of the most valuable parts of the project. You can find the post-mortems in the github repo</p><h3>Key Lessons Learned</h3><h4>1. Kubernetes Is More Than Container Scheduling</h4><p>Kubernetes provides the foundation, but production systems require:</p><ul><li>Observability</li><li>Security</li><li>Backup strategy</li><li>Automation</li></ul><h4>2. Operators Reduce Operational Complexity</h4><p>CloudNativePG and Redis Operator demonstrated the power of Kubernetes operators.</p><p>Complex operational knowledge can be packaged into reusable controllers.</p><h4>3. Documentation Is Part of Engineering</h4><p>Creating:</p><ul><li>Architecture documentation</li><li>Deployment guides</li><li>Troubleshooting guides</li><li>Security documentation</li></ul><p>is not an afterthought. Good documentation reduces operational risk.</p><h4>4. Reliability Requires Planning</h4><p>Features like:</p><ul><li>PodDisruptionBudgets</li><li>Health probes</li><li>Autoscaling</li><li>Backups</li></ul><p>must be considered before failures happen.</p><h3>Final Thoughts</h3><p>Building this rideshare platform changed the way I thought about cloud engineering. The biggest lesson was that deploying an application is only a small part of running a platform. The real engineering work happens around:</p><ul><li>Reliability</li><li>Security</li><li>Scalability</li><li>Observability</li><li>Automation</li></ul><p>Using Kubernetes, Helm, CloudNativePG, and Redis Operator provided an opportunity to design a platform that behaves much closer to a real production environment. The project reinforced an important principle:</p><p><em>A successful cloud platform is not defined by how quickly it can deploy, but by how confidently it can operate.</em></p><p>There is still room for improvement:</p><ul><li>GitOps with ArgoCD</li><li>Progressive delivery</li><li>Service mesh adoption</li><li>Advanced security policies</li><li>Distributed tracing</li><li>The use of Elastic Cache instead of Redis Operator and Amazon RDS instead of CloudNativePG</li></ul><p>But the foundation demonstrates how modern cloud-native platforms are designed, deployed, and operated.</p><h3>Technologies Used</h3><ul><li>Amazon EKS</li><li>Kubernetes</li><li>Helm</li><li>Docker</li><li>CloudNativePG</li><li>Redis Operator</li><li>PostgreSQL</li><li>Redis</li><li>NGINX Ingress Controller</li><li>AWS Secrets Manager</li><li>External Secrets Operator</li><li>Cluster Autoscaler</li><li>Horizontal Pod Autoscaler</li></ul><h3>Repository</h3><p>The complete implementation, Kubernetes manifests, Helm charts, and operational documentation are available in the project repository.</p><p><a href="https://github.com/AdekunleDally/rideshare-pro">https://github.com/AdekunleDally/rideshare-pro</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f596f4e4e75" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploying a Microservices-Based Ecommerce Application on Kubernetes with Helm]]></title>
            <link>https://medium.com/@adekunledally/deploying-a-microservices-based-ecommerce-application-on-kubernetes-with-helm-9de969fce280?source=rss-c685bf147b25------2</link>
            <guid isPermaLink="false">https://medium.com/p/9de969fce280</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[helm]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Lukmon Adeokun]]></dc:creator>
            <pubDate>Tue, 16 Sep 2025 17:32:54 GMT</pubDate>
            <atom:updated>2025-09-16T17:32:54.420Z</atom:updated>
            <content:encoded><![CDATA[<p>Kubernetes has become the de facto standard for running containerised applications at scale, but managing multiple microservices in production can get complicated fast. This is where <strong>Helm</strong>, Kubernetes’ package manager, shines.</p><p>In this article, I’ll walk you through how I deployed an <strong>Ecommerce application</strong> built with multiple microservices on a local Kubernetes cluster using <strong>Helm umbrella and sub-charts</strong>. The project is based on Google’s popular <a href="https://github.com/GoogleCloudPlatform/microservices-demo">Online Boutique (microservices-demo)</a>, but packaged into a Helm chart to simplify deployment and management</p><p><strong>Project Overview</strong></p><p>The goal of this project was to demonstrate how <strong>Helm</strong> can simplify the deployment and management of complex, microservices-based applications.</p><ul><li>The application consists of services such as <strong>frontend, cartservice, productcatalogservice, adservice, checkoutservice, shippingservice</strong>, and more.</li><li>A <strong>Kind (Kubernetes-in-Docker)</strong> cluster was used for local testing.</li><li>The application was deployed using an <strong>umbrella Helm chart</strong> with subcharts for each microservice.</li></ul><p>This structure made the deployment modular, scalable, and easy to manage.</p><p><strong>Tools &amp; Components</strong></p><ul><li><strong>Kind</strong> → Used to set up and manage the local Kubernetes cluster.</li><li><strong>Helm</strong> → Package manager for Kubernetes, used to create the umbrella chart and subcharts.</li></ul><p><strong>Step 1: Creating the Umbrella Helm Chart</strong></p><p>The first step was to create the parent chart, which would act as an <strong>umbrella chart</strong> to manage all microservices:</p><p>helm create ecommerce . -n ecommerce-app</p><p>This generated the basic chart structure. A dedicated namespace (ecommerce-app) was also created to keep the deployment isolated.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d61SM1yM_gdeAhWvkh1OKw.png" /></figure><p><strong>Step 2: Adding Sub-charts</strong></p><p>Each microservice was created as a <strong>Helm subchart</strong> inside the charts/ directory of the umbrella chart. For example:</p><p><em>helm create frontend -n ecommerce-app # subchart for frontend</em></p><p><em>helm create cartservice -n ecommerce-app # subchart for cartservice</em></p><p><em>helm create productcatalogueservice -n ecommerce-app</em> # subchart for productcatalogueservice</p><p>…</p><p><em>helm create shippingservice -n ecommerce-app</em> # subchart for shippingservice</p><p><em>helm create emailservice -n ecommerce-app</em> # subchart for emailservice</p><p>In total, sub-charts were created for all the key services:<br> frontend, cartservice, productcatalogueservice, adservice, checkoutservice, currencyservice, emailservice, paymentservice, recommendationservice, shippingservice, loadgenerator, opentelemetry-collector, common.</p><p>This approach makes each service reusable and modular.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ud5O55SRdDII-VUR2HHTCA.png" /></figure><p><strong>Step 3: Managing Chart Dependencies</strong></p><p>The umbrella chart needs to know about its subcharts. This was done by adding a <strong>dependencies section</strong> in the Chart.yaml file of the parent chart.</p><p>Once the dependencies were defined, the following command updated the chart:</p><p><em>helm dependency update</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xnZ666H68It9xDRJgEDmFg.png" /></figure><p><strong>Step 4: Validating the Helm Chart</strong></p><p>Before deployment, the chart was validated using helm lint:</p><p><em>helm lint .</em></p><p>This step ensures that the templates and values are correctly structured and ready to be deployed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y8FdHUiobKWVHihgiKahYg.png" /></figure><p><strong>Step 5: Global Values</strong></p><p>A key advantage of using Helm umbrella charts is the ability to define <strong>global values</strong>.</p><p>For example, image repositories, replica counts, and tags were defined in the parent chart’s values.yaml file. Sub-charts automatically inherited these values, which removed duplication and simplified configuration management.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oQNRz94YUw5x4w88wymJjg.png" /></figure><p><strong>Step 6: Deploying the Application</strong></p><p>Finally, the full ecommerce application was deployed to the Kubernetes cluster with a single command:</p><p><em>helm install ecommapp . -n ecommerce-app</em></p><p>Helm packaged the umbrella chart and sub-charts, applied them to the namespace, and launched all services in the cluster.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d0qILyhcJ8pAzv59X7K6Rg.png" /></figure><p><strong>Results &amp; Benefits</strong></p><ul><li><strong>Single command deployment</strong> of 12+ microservices.</li><li>Centralized <strong>values management</strong> across all services.</li><li>Easy to extend and maintain via modular subcharts.</li><li>Reproducible deployments for local testing and future cloud deployments</li></ul><p><strong>Conclusion</strong></p><p>This project highlighted the power of Helm in managing complex, microservices-based applications on Kubernetes. By using an umbrella chart with sub-charts, I was able to streamline deployment, enforce consistency, and reduce operational overhead.</p><p>If you’re working with Kubernetes and microservices, I highly recommend exploring Helm for packaging and managing your applications — it can save you a lot of headaches</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9de969fce280" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementing Azure Firewall in an Azure Virtual Network]]></title>
            <link>https://medium.com/@adekunledally/implementing-azure-firewall-in-an-azure-firewall-subnet-7f8870c9f1f4?source=rss-c685bf147b25------2</link>
            <guid isPermaLink="false">https://medium.com/p/7f8870c9f1f4</guid>
            <category><![CDATA[azure-networking]]></category>
            <category><![CDATA[rdp-services]]></category>
            <category><![CDATA[azure-virtual-machines]]></category>
            <category><![CDATA[azure-firewall]]></category>
            <category><![CDATA[azure]]></category>
            <dc:creator><![CDATA[Lukmon Adeokun]]></dc:creator>
            <pubDate>Tue, 07 Nov 2023 11:39:28 GMT</pubDate>
            <atom:updated>2023-11-07T14:29:32.211Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Implementing Azure Firewall in an Azure Virtual Network" src="https://cdn-images-1.medium.com/max/807/1*C9r1D4jOKQ22VzSHmCF1OA.jpeg" /></figure><p>Azure virtual network is quite similar to the traditional network that we already know. It allows us perform subnetting, assign IP addresses to resources just like a traditional network. The key difference between both is that in Azure virtual network, the infrastructure needed to perform subnetting and other functions have been abstracted way leaving us to just provision isolated and connected networks within Azure. But of what use if we create virtual networks without adequately securing it?</p><p>Azure actually provides us with a few offerings to cater to this need. One of such offering is a firewall called Azure Firewall. Azure provides 3 Azure Firewall SKUs; basic, standard and premium. If you run a small to medium scale business, the basic sku is perhaps just right for you. The standard sku provides a more robust features while the premium provides fully comprehensive features such as signature-based Intrusion Detection Systems for very quick detection of cyber attacks</p><p>Azure firewall is a service provided by azure in order to help protect azure virtual network resources, data and application from unauthorised access as well as cyber threats. It provides a filtering feature at both the network layer and the application level. Crucially, it also provides an integration of threat intelligence directly from Microsoft and it is updated real time. This provides the ability to alert and also deny traffic from identified malicious ip address. In addition, it has monitoring capabilities. We can also integrate with azure monitor to capture firewall traffic</p><p>To implement azure firewall into a virtual network, we have to first create a virtual network which typically comes with a default subnet. We then create a second subnet which must be named <em>AzureFirewallSubnet.</em> The Azure firewall would reside in this <em>AzureFirewallSubnet</em> and any traffic from the default subnet is routed (through a route table) to the Azure firewall. It is recommended this second subnet have a CIDR notation of “/26”. The reason for placing the azure firewall in a smaller subnet (i.e., /26) with a limited number of IP addresses is to allow one to isolate and control traffic to and from the firewall more effectively. This helps to reduce the attack surface and potential exposure to cyber threats.</p><p>Consequently, we can then define NAT rules, application rules and network rules in rule collection to deny traffic or block malicious IPs.</p><p>In a situation whereby the basic <em>sku </em>is to be deployed, we create a third subnet which must be named <em>AzureFirewallManagementSubnet</em></p><p>This article looks at how a small business with a decent number of customers can implement azure firewall into its virtual network. We would be looking at how to use a firewall to perform network address translation (NAT). Network address translation is important for so many reasons</p><p>1. It provides a level of security by hiding the internal IP address of a device in a private network from cyber threat actors on the public internet making it more difficult to easily access the device.</p><p>2. By allowing a firewall share a single public IP address with multiple devices in a private network, this help conserve the limited pool of available public IP address which can be an issue in situations where IPV4 addresses is scarce.</p><p>3. It becomes easier to log and monitor more effectively by tracking the translation of private IP addresses to public addresses. The logs become useful when the need for troubleshooting arises</p><p><strong>AZURE FIREWALL IMPLEMENTATION STEPS</strong></p><ol><li>Create a virtual network called <em>WillyWonka-VNET</em> and rename its default subnet to <em>vm-SUBNET</em></li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*A-3Ap-hyHMobPlXhhKl8kQ.png" /><figcaption>Creating a virtual Network-1</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*P2nUmK5K7AzJ19wxQOH3Xg.png" /><figcaption>Creating a virtual Network-2</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*2lsMIJpgjsm51tcvYUpm6Q.png" /><figcaption>Azure Virtual Network Dashboard</figcaption></figure><p>2. Create a windows virtual machine and place it inside <em>vm-SUBNET</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*rQalncvxKRZO6EaOkA_V7Q.png" /><figcaption>Creating a vm</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*Lpt7r8HVUhmaYy-oD8ZdPA.png" /><figcaption>Placing the vm in the subnet called vm-SUBNET</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*rxrLydtLCC_dlo3E7x-1sg.png" /><figcaption>vm Dashboard</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*D-euwoIv1ixev8jjtT1QRg.png" /><figcaption>Logging in to the vm</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*ZOogPuBCToeLeTmdl-zjyw.png" /><figcaption>Successful Login using the public IP of the vm (40.124.143.179)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*aiWbd0pfn9_voPI_ZULGHQ.png" /><figcaption>Logging out of the vm</figcaption></figure><p>3. Add a subnet called AzureFirewallSubnet with a CIDR notation of /26</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*tEBiJTIkFa4A8ku7uPhTGA.png" /><figcaption>Adding the subnet called AzureFirewallSubnet</figcaption></figure><p>4.Add a third subnet called AzureFirewallManagementSubnet with a CIDR notation of /26</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*cmc9zgKDBafwfA9S1t85Mg.png" /><figcaption>Adding the subnet called AzureFirewallManagementSubnet</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*EbYQF4JWTDgsGFzilQUeUQ.png" /><figcaption>The 3 Subnets</figcaption></figure><p>5.Create a firewall and place it inside the subnet called AzureFirewallSubnet</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*FRNOTlNrrA2Dyak7tCsF1w.png" /><figcaption>Creating the firewall</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*Mmjps5_8NS9t61xFhh_YWA.png" /><figcaption>Creating a firewall-2</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*WGYcXEI6dhg3Cbx2KvWFVg.png" /><figcaption>“ww-FW” Firewall Dashboard</figcaption></figure><p>6.Create a route table so that the traffic from <em>vm-SUBNET </em>is routed to the firewall</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*ClhusG2tK_whbuXGVQ_rgw.png" /><figcaption>Creating a route-table called “ww-route-table”</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*zPk-ToPuDsuXZzBZH0xAIg.png" /><figcaption>ww-route-table Dashboard</figcaption></figure><p>7. Create a route in the route table which would route traffic from the VM-subnet to the private IP of the firewall</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*ODFLNwTCuUZhNjNxtIj0iA.png" /><figcaption>Adding the route to the route table</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*QSFgsAgyrfHzfvVHargRpg.png" /><figcaption>route-01</figcaption></figure><p>8.Make an association between the route table and the <em>vm-SUBNET </em>so that it applies the route to the subnet.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/861/1*eiVEkTS18S6a7MEA8n-jmA.png" /><figcaption>Associating route-01 to vm-SUBNET</figcaption></figure><p>9.Configure firewall rules in rule collection such that traffic when we <em>rdp</em> into the public IP of the firewall, we should be routed to the private IP of the windows virtual machine</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*cF-Lto0q3ySkjJMjo1kRdQ.png" /><figcaption>Creating the NAT rule</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*6VxMeog8f-u3FKAOXG-p_g.png" /><figcaption>Created NAT rule</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*qipdtDDb4F88GwTqmHjZoQ.png" /><figcaption>Failed attempt to login using the public IP of the vm</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*RurhhD0lglMaM3E_sE-5Dw.png" /><figcaption>Attempting to logon to the vm using the public IP address of the firewall</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*rt_EH4QMEuUZvaqYO_rjvw.png" /><figcaption>Successful Logon into the VM using the public IP of the Firewall</figcaption></figure><p>Conclusion</p><p>Azure provides Azure firewall; a cloud-based network security service whose aim is to protect your Azure virtual network and the resources in it. It achieves this by leveraging and providing users as well as businesses with a set of features for network security and traffic management</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7f8870c9f1f4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CONTAINERISATION: EXPLORING LXC/LXD CONTAINERS]]></title>
            <link>https://medium.com/@adekunledally/containerisation-exploring-lxc-lxd-containers-d7b28f8398e2?source=rss-c685bf147b25------2</link>
            <guid isPermaLink="false">https://medium.com/p/d7b28f8398e2</guid>
            <category><![CDATA[virtualisation]]></category>
            <category><![CDATA[lxc]]></category>
            <category><![CDATA[containerization]]></category>
            <category><![CDATA[lxd]]></category>
            <dc:creator><![CDATA[Lukmon Adeokun]]></dc:creator>
            <pubDate>Fri, 27 Oct 2023 08:44:18 GMT</pubDate>
            <atom:updated>2023-10-27T08:44:18.501Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LcBidFHWomJHzbRkmQu4Sg.jpeg" /><figcaption>lxd container</figcaption></figure><p>Today, whenever we think of containerisation, we almost always think first about Docker. LXC/LXD often times, comes second. Perhaps because it is Linux-based while docker on the other hand is cross-platform and distro-agnostic. LXC/LXD containers does beat docker in certain areas though. In terms of efficiency and performance, it tends to have a lesser overhead and provides an almost native performance at the operating system level, sharing the host’s kernel. In addition, Docker adds an extra layer which can introduce some performance overhead.</p><p>LXC container is an operating system level virtualisation solution. It allows you run multiple isolated Linux systems on a single Linux host. It allows one to use the Linux kernel underneath the host operating system</p><p>LXD container is a higher-level container management system built on top of LXC. It is user-friendly and also has an interface that is feature-rich. All these make it easier to manage and orchestrate.</p><p>LXC/LXD containers can be used to host a website, create a web cluster and even implement a backup solution.</p><p><strong>How to Serve a Website from a LXD Container</strong></p><p>Serving a website from a LXD container involves a series of steps. In this example, the LXD container would be based off an ubuntu image. Nginx server would also be installed inside the LXD container in order to access it using a public i.p. address via a web browser. The steps below describe how to host and serve a website from a LXD container.</p><ol><li>Install LXD on the Ubuntu terminal using the command below</li></ol><p><em>sudo snap install lxd –channel=3.0/stable</em></p><p><strong>2.</strong> Check the LXD version : <em>lxc -–version</em></p><p><strong>3.</strong> Add the user called cloud_user to the lxd group using the command</p><p><em>sudo usermod cloud_user -aG lxd</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*FepyAN-qB2pFVKhHL2_kgQ.png" /><figcaption>LXD Version</figcaption></figure><p>4.Initialise LXD in order for the LXD container to be placed in a storage pool and for it to have network access. Initialise LXD container using the command below:</p><p><em>lxd init</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/948/1*qCit3e_R85zD6PIF2l6TOw.png" /><figcaption>LXD Initialisation</figcaption></figure><p>5.Launch a LXC/LXD container off an ubuntu-based image using the lxc launch command below:</p><p><em>lxc launch images:ubuntu/20.04 myWeb-container</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*hK6a6HUgUiN8OfHvZxbRMw.png" /><figcaption>Launching the Container of an Ubuntu Image</figcaption></figure><p>6. Pull down the website folder from GitHub into the Ubuntu terminal</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*vazM8EV9hTRzCEwe6_gAgA.png" /><figcaption>Renaming the website folder from “website” to “myWeb”</figcaption></figure><p>7.Access the container using the <em>lxc exec</em> command to update the container and also install nginx using the command below</p><p><em>lxc exec myWeb-container — /bin/bash</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*fAYKdvdRF0NLwW9QFAJkcw.png" /><figcaption>Accessing the Lxd Container</figcaption></figure><p>8.Update and upgrade the ubuntu container using the following commands respectively</p><p><em>apt update</em></p><p><em>apt upgrade</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*S_W7WNH3x6qMT760XdbL4w.png" /><figcaption>Updating the Container</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*oZ-_buR50yHl41qLuRcNbQ.png" /><figcaption>Upgrading the Container</figcaption></figure><p>9.Push the <em>myWeb</em> folder on the Ubuntu terminal home directory to <em>www</em> folder which is located in the ubuntu-based container called <em>myWeb-container </em>using the lxc file push command</p><p><em>lxc file push myWeb/ myWeb-container/var/www/ — create-dirs -r</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*g-JBvav544bperumqSdkGQ.png" /><figcaption>Pushing the myWeb folder to the Container</figcaption></figure><p>10.Access the container and install nginx while inside the container using the apt install nginx command</p><p><em>apt install nginx</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*DFLD9UpxMANqEWMHR4swpQ.png" /><figcaption>Installing Nginx inside the container</figcaption></figure><p>11. 1. Nginx has a config file for a default server block. You need to edit this file to determine what would be served by nginx. This file is located in /etc/nginx/sites-available. Edit this file by using the command</p><p><em>vi /etc/nginx/sites-available/default</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*j3bJLgHWUMN3VEKfbGAjgQ.png" /><figcaption>Editing the file called default located in the sites-available folder</figcaption></figure><p>12.Add the following commands inside the ‘default’ file</p><p><em>root /var/www/myWeb/;</em></p><p><em>index index.html;</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*ZVnX1JSGkuKHsTlecb6JBA.png" /><figcaption>Adding the command the points nginx to the location of the files to be served</figcaption></figure><p>13. Install Uncomplicated firewall(ufw) and configure it. Ufw is used to configure firewall rules on the lxd container which in turn helps to control the incoming and outgoing traffic to and from the container. Install ufw using the commands below</p><p><em>sudo apt install ufw</em></p><p><em>sudo systemctl start ufw</em></p><p><em>sudo systemctl enable ufw</em></p><p><em>sudo ufw allow 80/tcp</em></p><p><em>sudo ufw enable</em></p><p><em>sudo ufw status</em></p><p><em>systemctl status nginx</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*lqWLteecNHvaMRszXW2dVQ.png" /><figcaption><em>Installing ufw</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*dM5YHPRYKvgYOa6ExzUXjA.png" /><figcaption><em>Starting ufw</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*Xd5AyuTWk5Vt3wQLdL78zQ.png" /><figcaption><em>Checking the status of ufw</em></figcaption></figure><p>14.Find out the private ip address of the container using the ‘lxc list’ command</p><p><em>lxc list</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*wtz8hLlvYEWJUxALcV8qaA.png" /><figcaption>Running “lxc list” command to know the private ip address(10.129.147.192) of the container</figcaption></figure><p>15. 1. Expose the web service running inside the container to the outside world. This allows incoming HTTP requests to be directed to the ubuntu container(myWeb-container), where Nginx web server can handle the requests. Run the command below to do this</p><p><em>lxc config device add myWeb-container myDevice proxy listen=tcp:0.0.0.0:80 connect=tcp:10.129.147.192:80</em></p><p>You need to add a proxy device to an LXC container in order to route traffic from a specific port (in this case, port 80) on the host to a port on the container. Here’s an explanation of the command:</p><p>· `lxc config device add myWeb-container myDevice proxy`: This part of the command instructs LXC to add a proxy device named “myDevice” to the container named “myWeb-container.”</p><p>· `listen=tcp:0.0.0.0:80`: This specifies that the proxy device should listen on all available network interfaces (`0.0.0.0`) on port 80 of the host. It means that incoming traffic on port 80 of the host will be redirected to the container.</p><p>· `connect=tcp:10.129.147.192:80`: This part indicates that the traffic received on the host’s port 80 should be connected (forwarded) to the container’s IP address 10.129.147.192 on port 80. In other words, it sets up port forwarding from the host to the ubuntu container.</p><p>· Make sure that the IP address and port numbers in the `connect` option correspond to the actual IP address and port where your web server or application is listening inside the container. Additionally, ensure that the firewall on the host is properly configured to allow incoming traffic on port 80.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PI3gvPobXzDYLYRgHL40Vg.png" /></figure><p>CONCLUSION</p><p>LXC/LXD containerisation is a technology that finds great use in today’s computing landscape. Asides web hosting, it also finds great use in microservices architecture,Database management, IoT and edge computing</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d7b28f8398e2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A project on Threat Detection and Automating the Response to the Threat using Azure Sentinel]]></title>
            <link>https://medium.com/@adekunledally/a-project-on-threat-detection-and-automating-the-response-to-the-threat-using-azure-sentinel-67c87f6b5b02?source=rss-c685bf147b25------2</link>
            <guid isPermaLink="false">https://medium.com/p/67c87f6b5b02</guid>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[sentinel]]></category>
            <category><![CDATA[cyberattack]]></category>
            <category><![CDATA[playbook]]></category>
            <dc:creator><![CDATA[Lukmon Adeokun]]></dc:creator>
            <pubDate>Sun, 08 Oct 2023 09:15:38 GMT</pubDate>
            <atom:updated>2023-10-08T09:15:38.333Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>INTRODUCTION</strong></p><p>Azure Sentinel is a cloud-based Security and Information and Event Management (SIEM) tool as well as a Security Orchestration Automation and Response tool. Essentially, it is a tool that would enable you do the following in your Azure cloud environment<br>• 1.Collect cloud data from numerous sources on a big scale.<br>• 2. Detect threats and automate response to the detected threats.</p><p><strong>METHODOLOGY</strong></p><p>We would need an active Azure subscription. We would also need a Log Analytics Workspace. This is a component of Azure that serves as a workspace for collecting, storing , analysing various kinds of data and telemetry. We would also need Azure Sentinel. As described above, it is designed to provide high level security analytics and threat detection across your environment.</p><p>Interestingly, there is a relationship between Log Analytics Workspace and Sentinel. Log Analytics Workspace serves as a data repository for an Azure Sentinel instance. Setting up an instance of Azure Sentinel means you have to create and connect Log Analytics Workspace to it. This workspace serves as a data repository to store security-related data which Azure Sentinel collects and analyses.</p><p>We would also use Data connectors which would be used to ingest data from relevant data sources or native azure services into the Log Analytics Workspace which in turn feeds Sentinel. Analytics rules would then be used to analyze the data and then executed on the data collected.<br>Based on this, Sentinel determines if an event is an incident or not.</p><p>Finally, a playbook (which is similar to Azure Logic apps) would be used to automate the response to threats reported by the automation rule in azure sentinel. This has the potential to reduce response time to threats you would face by at least 40 percent. The playbook is automatically<br>triggered if there is an incident.</p><h4><strong>Implementation of Threat Detection and Automating Response for a Scenario involving Sign-in Risk of Users Registered In Azure AD</strong></h4><p>Users were created before implementing threat detection and automated response on the project using Azure Sentinel.<br>The following users were created with the following details</p><p><strong>S/N Name User Principal Name</strong></p><p>1 Faheedah faheedah@adekunledallygmail.onmicrosoft.com</p><p>2 Sakinah Sakinahah@adekunledallygmail.onmicrosoft.com</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pSju2tuvm_a4RbH6evSWOw.png" /></figure><p><strong>CONFIGURING DATA CONNECTORS</strong><br>Data connectors was configured on Azure Sentinel. The Data connector enables us collect logs from the resource to be monitored(i.e. Azure Active directory) right into Sentinel through the Log Analytics Workspace. It was configured in Sentinel using the connector page. The Azure Active Directory data connector was selected to be configured. It enables us ingest Azure Active Directory Audit, Sign-in and Risk Events and Risky User/Service Principals logs using the diagnostic settings in Sentinel.</p><p>The connector was installed, configured and also the pre-requisite was met. In the connector page of Azure Active directory, the sign-in log , service principal and risky users log were selected. This means that these are the logs that would be connected from Azure active directory, passed through the data connectors and sent to the Log Analytics Workspace for central collection and analysis</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WYcXg1IwG9NlKI819eYIUw.png" /><figcaption><strong>Testing If the Logs have Been Ingested</strong></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/781/1*kXkxvOQCKb6qtAKx4gVelw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h9-HhxGOVHWAuWv1FTFYGQ.png" /></figure><p><strong>ANALYSING INGESTED LOGS</strong><br>Data is investigated in the LAW by writing queries in KQL. We can also use work books to display and analyse data collected</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WA8vPK-RxJgQC0OhoxRzIA.png" /><figcaption>Event Logs in Sentinel</figcaption></figure><p><strong>GENERATE RISK EVENTS</strong><br>Sentinel can help us detect sign in risks events. To do this, we use the TOR browser. This browser provides some form of anonymity when browsing the internet. We use the TOR browser to sign in anonymously using the accounts created in Azure AD. The risk event generated can be viewed<br>in risky user section which is located in security tab which is located in azure active directory.<br>Consequently, this event gets ingested into Log Analytics Workspace which in turn is used by Sentinel.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/627/1*YOxikqF6XeKC5RPfzJrcUA.png" /><figcaption><strong>Risky User Sign-in</strong></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*H2FUFnXandX79EdG1X8zeQ.png" /></figure><p><strong>CREATING ANALYTICS RULE</strong><br>We create analytics rule to analyse risky sign in event logs. This rule would trigger an alert based on the detected risk. We create a scheduled query analytics rule to do this. We also select to the tactic and techniques which is related to the MITRE attack framework</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*qeubwcwSPaOpZBSrhl5bxA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/822/1*UoyKwW9RT4E-L5yHnWzjwQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/941/1*KWA4RjWl6ltnTVCm806A7g.png" /></figure><p>We authenticate with the user account using TOR browser to generate alerts which are then grouped by the created analytics rule into incident</p><p>AUTOMATING THREAT RESPONSE<br>To automate threat response we do the following:<br>1. Create an Azure AD application that authenticates with Microsoft Graph API<br>2. Register application in Azure AD with specific permission<br>3. We register the application in the App Registration sec under Azure AD<br>4. We then go ahead to generate secret for this application<br>5. We then specify permissions for the application and grant permission<br>6. Copy tenantID, Application ID and Secret Value. These are required as the parameters<br>needed to generate access token and consequently call Microsoft Graph API using<br>Postman.<br>7. We configure Azure Playbook in Azure sentinel</p><p><strong>AUTOMATING THREAT RESPONSE WITH PLAYBOOK<br></strong>We create a playbook with an incident trigger. To see playbook in action we need to connect it to the previously create analytics rule.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*43KqGXNpPScEoAtQxV4IfA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v2-pPLgZMR9HKnc7YjUweQ.png" /><figcaption><strong>Designing the Playbook in the Playbook App Designer</strong></figcaption></figure><p>We then link the playbook to the Analytics rule earlier created in order to make the playbook functional. We also carry out all other necessary configurations</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2kBJvncLIyvReb_UL3zeIg.png" /></figure><p><strong>CONCLUSION</strong><br>Azure Sentinel provides us with the right resources and tools to detect and automate response to detected threat using playbooks. This has the potential to reduce the response time to threat significantly</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67c87f6b5b02" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SCANNING AND LOCATING NODES ON A NETWORK AS PART OF A SECURITY POSTURE ASSESSMENT]]></title>
            <link>https://medium.com/@adekunledally/scanning-and-locating-nodes-on-a-network-as-part-of-a-security-posture-assessment-add4c9c0ece0?source=rss-c685bf147b25------2</link>
            <guid isPermaLink="false">https://medium.com/p/add4c9c0ece0</guid>
            <category><![CDATA[security-posture]]></category>
            <category><![CDATA[cyber-security-tools]]></category>
            <dc:creator><![CDATA[Lukmon Adeokun]]></dc:creator>
            <pubDate>Thu, 13 Oct 2022 08:19:21 GMT</pubDate>
            <atom:updated>2022-10-13T08:19:21.747Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>SCANNING AND LOCATING NODES ON A NETWORK AS PART OF A SECURITY POSTURE ASSESSMENT</strong></p><p>Different tools and commands can be used to identify hosts on networks as part of the security posture assessment of our networks. A security posture assessment helps one know the current security posture as well possible vulnerabilities on our networks. By scanning and locating these nodes we can</p><ol><li>Identify the hosts on a network</li></ol><p>2 Enumerate the ports, states and services available on each host on a given network</p><p>By leveraging common network tools such as nmap, local commands such netdiscover and curl, we can find out so much about our network and start the process of mitigating potential vulnerabilities on our networks. For instance, nmap for me, is so apt .It helps a security professional know the weaknesses on a network. It also has a security engine feature which is used to automate diverse network tasks. Local commands such as netdiscover is used to discover online hosts and even display the vendor of each MAC address on our network</p><p>Banner grabbing is also another action that is important . We can use it to identify service versions. Attackers may use it to spot vulnerable machines on a network, Network Administrators can use it to ensure all services on a network are of the same version</p><p>Do enjoy the rest of your day!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=add4c9c0ece0" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>