<?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 Muralish Clinton on Medium]]></title>
        <description><![CDATA[Stories by Muralish Clinton on Medium]]></description>
        <link>https://medium.com/@muralishclint?source=rss-6149505ac645------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*wt3QHh3uFPqN6s3ozbK0Gg.jpeg</url>
            <title>Stories by Muralish Clinton on Medium</title>
            <link>https://medium.com/@muralishclint?source=rss-6149505ac645------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 07:10:44 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@muralishclint/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[Modern day Developer Collaboration in the Age of AI]]></title>
            <link>https://levelup.gitconnected.com/modern-day-developer-collaboration-in-the-age-of-ai-246a94297354?source=rss-6149505ac645------2</link>
            <guid isPermaLink="false">https://medium.com/p/246a94297354</guid>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[developer-experience]]></category>
            <dc:creator><![CDATA[Muralish Clinton]]></dc:creator>
            <pubDate>Sat, 18 Apr 2026 07:46:01 GMT</pubDate>
            <atom:updated>2026-04-20T14:24:49.627Z</atom:updated>
            <content:encoded><![CDATA[<h4>Shift Together</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Jtr0jAsYuSZ-7Q9Z" /><figcaption>Photo by <a href="https://unsplash.com/@omilaev?utm_source=medium&amp;utm_medium=referral">Igor Omilaev</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Software delivery has reached a new level.</p><p>With the rise of AI coding assistants like GitHub Copilot, Cursor, and Codeium, we can produce code much faster. Teams are shipping more, moving quickly, and expanding what small groups can achieve.</p><p>However, something else is occurring beneath this speed.</p><blockquote>Understanding is lagging behind.</blockquote><p>For years, developer experience has focused on removing obstacles in the path to production. We adopted concepts like shift-left testing to catch issues early and shift-right observability to learn from production. These ideas worked in a time when speed was the main concern.</p><p>That isn’t the case anymore.</p><blockquote>Today, the main issue is comprehension.</blockquote><p>Pull requests are growing larger, often created partially or fully by AI. Systems are more distributed than ever. A single change can affect services, APIs, and data flows in ways that aren’t clear right away. Reviewing code on platforms like GitHub increasingly feels like trying to guess intent from the outputs instead of understanding a well-explained design.</p><p>Even debugging hasn’t changed much. Despite powerful tools like Datadog and Grafana, we still spend a lot of time figuring out what happened afterward such as reading logs, connecting traces, and trying to reproduce issues in isolated settings.</p><p>We’ve optimized for speed but not for shared understanding.</p><p><em>This is where a new model starts to take shape: </em><strong><em>working sessions.</em></strong></p><h4>Working Sessions</h4><p>A working session is more than just another tool or dashboard. It changes how we interact with software systems and with each other. Instead of depending mostly on asynchronous workflows, like PR comments, Slack threads, and delayed feedback loops, a working session creates a shared, real-time context for developers, AI agents, and running systems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*iE_YPqsOYcuzJ1hX" /><figcaption>Photo by <a href="https://unsplash.com/@maxsaeling?utm_source=medium&amp;utm_medium=referral">Max Saeling</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>In a working session, you don’t just read code; you experience its behavior.</p><p>Imagine reviewing a change not by scanning a diff but by stepping into a live environment where that change is already active. You can trigger flows, see outputs, check the state, and understand the impact instantly. Instead of asking, “what does this do?” you’ll know, “this is what it does.”</p><p>Debugging becomes a collaborative effort. Rather than one developer trying to replicate an issue while others wait, multiple people can join the same session, connect to the same runtime, and explore the problem together. Breakpoints, logs, and traces are no longer personal tools but shared artifacts in a collective investigation.</p><p>AI takes on a different role too. Instead of just generating code, AI agents participate in the session. They can explain execution paths, highlight risks, or point out performance issues in real time, based on the system’s actual behavior rather than static code analysis.</p><p>Perhaps most importantly, working sessions cut down on guessing. Instead of trying to recreate a bug from incomplete information, teams can replay real traffic or mirror production scenarios directly within the session. The classic “it works on my machine” issue diminishes when everyone is literally looking at the same machine or the same running context.</p><blockquote>The effects of this shift are important.</blockquote><h4>What does it mean for you?</h4><p>For businesses, it means faster and more reliable delivery. When teams spend less time interpreting changes and more time understanding them, feedback cycles shorten and confidence grows. This leads to faster releases and fewer defects reaching production.</p><p>For developers, it lightens the mental load. Modern systems are complex enough without having engineers mentally simulate every possible execution path. Being able to see and explore behavior directly allows developers to focus on solving problems, not reconstructing them.</p><p>For engineering leaders, it offers a more predictable execution model. Many delays in software delivery arise not from technical challenges but from misalignment and unclear communication. Working sessions provide a shared space where alignment happens naturally, in real time.</p><p>Interestingly, the industry already has many of the building blocks for this future, but they are isolated. Tools like ngrok and Cloudflare Tunnel make it easy to expose local services. Platforms like Gitpod and Codespaces offer on-demand environments. Collaborative tools like Visual Studio Live Share enable shared editing experiences.</p><p>However, none of these create a single, cohesive layer where code, runtime, observability, collaboration, and AI work together smoothly.</p><p>That gap is where the next evolution of developer experience will occur.</p><blockquote>If shift-left was about moving earlier in the lifecycle and shift-right was about learning later in production, then what we’re starting to see is different. Not a shift in time, but a shift in how we work together.</blockquote><p>A shift from isolated workflows to shared ones.</p><p>A shift from asynchronous interpretation to real-time understanding.</p><p>Not a shift left or right, but <strong>together</strong>.</p><p>As AI continues to speed up how quickly we can build, the true competitive advantage will belong to teams that can understand, validate, and adapt just as quickly.</p><p>Working sessions are a step in that direction.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=246a94297354" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/modern-day-developer-collaboration-in-the-age-of-ai-246a94297354">Modern day Developer Collaboration in the Age of AI</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Landed a Job in Tech the Unconventional Way]]></title>
            <link>https://medium.com/swlh/how-i-landed-a-job-in-tech-the-unconventional-way-f02e6347f2c7?source=rss-6149505ac645------2</link>
            <guid isPermaLink="false">https://medium.com/p/f02e6347f2c7</guid>
            <category><![CDATA[jobs]]></category>
            <category><![CDATA[personal-development]]></category>
            <category><![CDATA[self-improvement]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Muralish Clinton]]></dc:creator>
            <pubDate>Tue, 21 Oct 2025 13:24:57 GMT</pubDate>
            <atom:updated>2025-10-21T13:24:57.016Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dlzl93EdctOCOlH9WLgZAQ.jpeg" /></figure><p>China isn’t the easiest place to land a job, especially if you’re a foreigner. Most roles require a high level of Chinese language proficiency, a strong local network, and most importantly — a company willing to sponsor your visa.</p><p>Back then, I was working remotely for a few organizations while pursuing a degree in Mechatronics. It was a balancing act of studying during the day, building things at night, and freelancing in between. But eventually, reality hit me: if I wanted to stay and grow professionally, I needed a <strong>work visa</strong>.</p><p>So, I started applying through the usual channels : LinkedIn, job portals, referrals.<br>The results? A few low-profile offers, none with sponsorships. That’s when I realized that if I kept playing by the same rules as everyone else, I’d keep getting the same results.</p><h3>Thinking Outside the Box</h3><p>I decided to approach the job hunt differently — like a product launch.<br>I made a <strong>list of foreign companies</strong> operating in China and Tier 1 cities (Beijing, Shanghai, Shenzhen, Guangzhou). These cities were more open to hiring international talent and had better chances for sponsorships.</p><p>Next, I began <strong>networking intentionally</strong>.<br>I reached out to HRs, decision-makers, and team leads on LinkedIn not to ask for a job right away, but to build genuine connections and understand what challenges they were facing.</p><p>Meanwhile, I doubled down on <strong>building my portfolio</strong>.<br>Data science was booming at the time, so I focused on how <strong>data and automation</strong> could solve real business problems. I wasn’t just coding , instead I was creating frameworks and end-to-end solutions that demonstrated how technology could drive measurable impact.</p><p>It wasn’t only about being technically good; it was about understanding how <strong>tech fits into the business narrative</strong>.</p><h3>Selling Myself Differently</h3><p>With every conversation I had, I refined my pitch to not just who I was, but what I could <strong>bring to the table</strong>.</p><p>When I reached out to companies from my list, I didn’t send generic resumes. I tailored each message to explain how the tools and frameworks I built could help them optimize their operations, automate their processes, or make smarter decisions.</p><blockquote>I didn’t <em>apply</em> for roles; I <em>proposed value</em>.</blockquote><h3>The Breakthrough</h3><p>One day, I connected with a decision-maker at a company that didn’t even have a tech role open. The only available position was in <strong>presales</strong>.</p><p>Most people might’ve walked away.<br>Instead, I saw an opportunity.</p><p>I pitched how my mix of technical and analytical tools could actually <strong>enhance their presales process</strong>, and how this role could be shaped to let me contribute both technically and commercially.</p><p>Surprisingly, they agreed.</p><p>I got hired for the presales position, but with the freedom to keep working on my tools, explore how they could support the business, and learn the fundamentals of <strong>tech sales and presales</strong> from scratch.</p><p>That experience became one of the most pivotal moments in my journey, a blend of <strong>engineering, storytelling, and business acumen</strong> that continues to help me today.</p><h3>Looking Back</h3><p>When I think about it now, the lesson is simple yet powerful:</p><blockquote><em>Sometimes the straight road doesn’t lead you to the destination. You’ve got to carve your own path.</em></blockquote><p>Building my own projects, pitching my own ideas, and creating value before being asked for it changed everything.</p><p>And today, whenever I face uncertainty, I remind myself of one thing I learned through that chapter:</p><blockquote><strong><em>Trust the process and the results will someday find you.</em></strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f02e6347f2c7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/swlh/how-i-landed-a-job-in-tech-the-unconventional-way-f02e6347f2c7">How I Landed a Job in Tech the Unconventional Way</a> was originally published in <a href="https://medium.com/swlh">The Startup</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementing a Custom Circuit Breaker for Third Party API Calls]]></title>
            <link>https://levelup.gitconnected.com/implementing-a-custom-circuit-breaker-for-third-party-api-calls-f4d2fcc16580?source=rss-6149505ac645------2</link>
            <guid isPermaLink="false">https://medium.com/p/f4d2fcc16580</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[gcp]]></category>
            <category><![CDATA[go]]></category>
            <category><![CDATA[platform]]></category>
            <dc:creator><![CDATA[Muralish Clinton]]></dc:creator>
            <pubDate>Thu, 25 Jul 2024 10:18:48 GMT</pubDate>
            <atom:updated>2024-07-26T15:03:41.605Z</atom:updated>
            <content:encoded><![CDATA[<h4>Building a Resilient Third-Party API Handling System with Golang and GCP Pub/Sub</h4><p>While service mesh solutions like Istio provide excellent circuit breaking capabilities for internal services, they fall short when it comes to managing calls to external third-party APIs.</p><p>In this article, we’ll explore how to implement a custom circuit breaker using Golang and Google Cloud Pub/Sub to handle critical calls to external APIs, store states locally, and implement a choreography system for retrying failed calls.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*M0l73reQ3sv4E8xr" /><figcaption>Photo by <a href="https://unsplash.com/@callmefred?utm_source=medium&amp;utm_medium=referral">Call Me Fred</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Problem Statement</h3><p>When dealing with external APIs, we need a way to:</p><ol><li>Detect failures and prevent cascading failures</li><li>Store the state of our calls locally</li><li>Implement a retry mechanism for failed calls</li><li>Gradually recover from failures</li></ol><p>We’ll create a custom circuit breaker that uses Golang for the core logic and GCP Pub/Sub for the choreography system. Here’s an overview of the components:</p><ol><li>Circuit Breaker: Manages the state of the external API calls</li><li>Local State Store: Keeps track of the circuit breaker’s state</li><li>Pub/Sub Topic: Stores failed requests for later retry</li><li>Api Service: Ties together the circuit breaker, state store, and Pub/Sub components</li><li>Retry Worker: Processes failed requests from the Pub/Sub topic</li></ol><h4>Circuit Breaker Implementation</h4><p>The circuit breaker pattern helps prevent cascading failures by temporarily disabling calls to a failing service. It has three states: Closed (normal operation), Open (calls are blocked), and Half-Open (testing if the service has recovered).</p><p>Key points:</p><ul><li>Tracks failures and opens the circuit when a threshold is reached</li><li>Automatically attempts recovery after a specified time</li><li>Prevents unnecessary calls to a known-failing service</li></ul><pre>type CircuitBreaker struct {<br>    state           State<br>    failureThreshold int<br>    resetTimeout    time.Duration<br>    failures        int<br>    lastFailure     time.Time<br>    mu              sync.Mutex<br>}<br><br>func (cb *CircuitBreaker) Execute(fn func() error) error {<br>    // Implementation logic here<br>}</pre><h4>Local State Store</h4><p>A local state store helps maintain the current status of external services without making additional network requests. This can be used for quick decision-making and historical analysis.</p><p>Key points:</p><ul><li>Provides fast access to service status</li><li>Supports informed decision-making</li><li>Useful for analyzing patterns in API reliability</li></ul><pre>type StateStore struct {<br>    store map[string]interface{}<br>    mu    sync.RWMutex<br>}<br><br>func (s *StateStore) Set(key string, value interface{}) {<br>    // Implementation logic here<br>}<br><br>func (s *StateStore) Get(key string) (interface{}, bool) {<br>    // Implementation logic here<br>}</pre><h4>Pub/Sub Integration</h4><p>Google Cloud Pub/Sub is used to implement a reliable retry mechanism. Failed requests are published to a topic and can be processed later by a separate worker.</p><p>Key points:</p><ul><li>Decouples retry logic from main application flow</li><li>Allows for flexible retry strategies</li><li>Provides persistence for failed requests</li></ul><pre>func PublishFailedRequest(ctx context.Context, client *pubsub.Client, topicID string, req FailedRequest) error {<br>    // Implementation logic here<br>}<br><br>func SubscribeToFailedRequests(ctx context.Context, client *pubsub.Client, subID string, handler func(FailedRequest) error) error {<br>    // Implementation logic here<br>}</pre><h4>API Service</h4><p>The API Service ties together the circuit breaker, state store, and Pub/Sub components to create a resilient system for handling external API calls.</p><p>Key points:</p><ul><li>Uses circuit breaker to manage API call attempts</li><li>Stores call results in the state store</li><li>Publishes failed requests to Pub/Sub for later retry</li></ul><pre>type APIService struct {<br>    cb           *circuitbreaker.CircuitBreaker<br>    stateStore   *statestore.StateStore<br>    pubsubClient *pubsub.Client<br>}<br><br>func (s *APIService) CallExternalAPI(apiName string, payload []byte) error {<br>    // Implementation logic here<br>}</pre><h4>Retry Worker</h4><p>The retry worker subscribes to the Pub/Sub topic and attempts to retry failed requests. This allows for gradual recovery and prevents overwhelming the external service.</p><p>Key points:</p><ul><li>Processes failed requests asynchronously</li><li>Implements backoff strategy for retries</li><li>Limits the number of retry attempts</li></ul><pre>func retryWorker(service *APIService) {<br>    err := pubsub.SubscribeToFailedRequests(context.Background(), service.pubsubClient, &quot;failed-requests-sub&quot;, func(req FailedRequest) error {<br>        // Retry logic here<br>    })<br>    // Error handling<br>}</pre><h3>Conclusion</h3><p>By combining these components, we’ve created a system that can:</p><ol><li>Detect and prevent cascading failures using the circuit breaker pattern</li><li>Store the state of API calls locally for quick decision-making</li><li>Implement a reliable retry mechanism using Pub/Sub</li><li>Gradually recover from failures with the circuit breaker’s half-open state</li></ol><p>This system provides a solid foundation for building resilient applications that depend on external APIs. Remember to adapt this solution to your specific needs, implement proper error handling, and consider using distributed caching for the state store in production environments.</p><p>Refer my previous article on how a Circuit Breaker can be implemented with RabbitMQ — <a href="https://medium.com/p/a8cc1ebd3c7c">https://medium.com/p/a8cc1ebd3c7c</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f4d2fcc16580" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/implementing-a-custom-circuit-breaker-for-third-party-api-calls-f4d2fcc16580">Implementing a Custom Circuit Breaker for Third Party API Calls</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Enhancing Digital Operational Resilience with Platform Engineering]]></title>
            <link>https://levelup.gitconnected.com/enhancing-digital-operational-resilience-with-platform-engineering-bb2d5265dabd?source=rss-6149505ac645------2</link>
            <guid isPermaLink="false">https://medium.com/p/bb2d5265dabd</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[banking]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[digital-transformation]]></category>
            <dc:creator><![CDATA[Muralish Clinton]]></dc:creator>
            <pubDate>Mon, 22 Jul 2024 05:45:17 GMT</pubDate>
            <atom:updated>2024-07-23T15:38:51.285Z</atom:updated>
            <content:encoded><![CDATA[<h4>Lessons from the CrowdStrike BSOD Incident</h4><p>In our increasingly digital world, the resilience of IT systems isn’t just a technical concern — it’s a business imperative. The recent CrowdStrike incident, where a routine software update led to widespread system crashes, serves as a stark reminder of why robust governance and control mechanisms are crucial. It’s precisely the kind of scenario that the Digital Operational Resilience Act (DORA) aims to prevent.</p><p>Let’s dive into what happened with CrowdStrike and explore how platform engineering can help us meet DORA’s requirements and fortify our digital defenses.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vvQWNAZeOWthvRTy" /><figcaption>Photo by <a href="https://unsplash.com/@choys_?utm_source=medium&amp;utm_medium=referral">Conny Schneider</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>The CrowdStrike Incident: A Case Study</h3><h4>The Incident</h4><p>On July 19, 2024, CrowdStrike released a sensor configuration update to Windows systems as part of their ongoing operations. This update triggered a logic error, resulting in a system crash and BSOD on affected systems. The specific update, identified as Channel File 291, was designed to target newly observed malicious named pipes used by common Command and Control (C2) frameworks. The update led to a logic error in evaluating named pipe execution, causing the operating system to crash.</p><h4>The Impact</h4><p>The incident affected systems running Falcon sensor for Windows version 7.11 and above that downloaded the update between 04:09 UTC and 05:27 UTC on July 19, 2024. These systems experienced crashes due to the faulty configuration update. The issue was not related to a cyberattack but was purely a result of the update’s logic error .</p><h4>The Technical Details</h4><p>Channel Files, residing in C:\Windows\System32\drivers\CrowdStrike\, are part of the behavioral protection mechanisms used by the Falcon sensor. The impacted Channel File 291, ending with a .sys extension, controls how Falcon evaluates named pipe execution on Windows systems. The update caused a logic error in this evaluation process, leading to the system crash .</p><h4>Remediation</h4><p>CrowdStrike addressed the issue by correcting the logic error in Channel File 291. Systems that were not affected continue to operate normally, and the updated Channel File ensures no recurrence of this specific issue. A thorough root cause analysis is ongoing to identify foundational or workflow improvements .</p><h3>Enforcing Digital Operational Resilience with Platform Engineering</h3><p>The CrowdStrike incident underscores the importance of the Digital Operational Resilience Act (DORA). But how can we use platform engineering to meet DORA’s requirements and build more resilient systems?</p><ol><li><strong>ICT Risk Management</strong> <br>Platform engineering can create a robust, scalable, and secure infrastructure foundation. This involves designing architectures that incorporate security best practices, implementing proper access controls, and ensuring system redundancy.</li><li><strong>Incident Response and Reporting</strong><br>By implementing comprehensive monitoring and logging systems, platform engineers can enable quick detection of anomalies and automate initial response procedures. This could include setting up tools like ELK stack (Elasticsearch, Logstash, Kibana) or using cloud-native monitoring solutions.</li><li><strong>Digital Operational Resilience Testing</strong><br>Platform engineers can create automated testing environments that simulate various scenarios, including cyber-attacks. This could involve setting up CI/CD pipelines that include security testing, performance testing, and chaos engineering practices.</li><li><strong>Third-Party Risk Management</strong><br>Platform engineering can establish processes for vetting and integrating third-party tools, ensuring they meet security standards. This might involve creating sandboxed environments for testing new tools before full integration.</li><li><strong>Resilience Metrics and KPIs</strong><br>Engineers can implement systems to track and visualize key metrics like MTTD and MTTR. This could involve setting up dashboards using tools like Grafana or cloud provider-specific solutions.</li><li><strong>Disaster Recovery Simulation</strong><br>Platform engineers can design and implement regular DR drills, including automated failover and failback procedures. This involves setting up separate DR environments and ensuring data replication mechanisms are in place.</li></ol><h3>Putting It Into Practice</h3><h4>Automated Testing and Validation</h4><ul><li><strong>CI/CD Pipelines</strong>: Implementing Continuous Integration and Continuous Deployment (CI/ CD) pipelines ensures that updates and patches are automatically tested in staging environments before reaching production. This could have detected the logic error in CrowdStrike’s update, preventing the release of the faulty configuration.</li><li><strong>Advanced Testing Frameworks</strong>: Utilizing advanced testing frameworks, including threat- led penetration testing (TLPT) and scenario-based testing, helps identify and mitigate potential vulnerabilities before they impact production systems .</li></ul><h4>Robust Monitoring and Incident Response</h4><ul><li><strong>Real-Time Monitoring</strong>: Setting up real-time monitoring systems to detect anomalies and potential issues immediately. Tools like extended detection and response (XDR) and security information and event management (SIEM) provide comprehensive visibility into system health and security events.</li><li><strong>Automated Incident Response</strong>: Developing automated incident response mechanisms to quickly isolate and remediate affected systems. This minimizes downtime and reduces the impact of incidents similar to the CrowdStrike BSOD issue.</li></ul><h4>Enhanced Governance and Compliance</h4><ul><li><strong>Policy Enforcement</strong>: Using Infrastructure as Code (IaC) and policy-as-code frameworks to enforce governance policies ensures that all infrastructure changes comply with security and compliance standards.</li><li><strong>Audit and Compliance Tools</strong>: Implementing tools that automatically audit and generate compliance reports helps organizations stay aligned with DORA requirements, tracking configuration changes, user activities, and system health metrics.</li></ul><h4>Resilient Architecture Design</h4><ul><li><strong>Microservices and Containerization</strong>: Designing applications using microservices and containerization improves fault isolation, ensuring that a failure in one component does not bring down the entire system.</li><li><strong>Redundancy and Failover Mechanisms</strong>: Implementing redundancy and failover mechanisms ensures service availability even during partial system failures, which is critical for maintaining operational continuity during incidents.</li></ul><h3>Conclusion</h3><p>The CrowdStrike BSOD incident serves as a wake-up call for the importance of rigorous update processes and robust digital resilience. By embracing platform engineering principles, we can meet DORA’s requirements and build systems that can weather the storm of operational disruptions.</p><p>Through smart testing, vigilant monitoring, quick incident response, tight governance, and resilient design, we’re not just ticking compliance boxes — we’re building a stronger, more secure digital future. In this rapidly evolving digital landscape, that’s not just an advantage — it’s a necessity.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bb2d5265dabd" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/enhancing-digital-operational-resilience-with-platform-engineering-bb2d5265dabd">Enhancing Digital Operational Resilience with Platform Engineering</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Transitioning from a Software Developer to a Product Engineer]]></title>
            <link>https://levelup.gitconnected.com/transitioning-from-a-software-developer-to-a-software-engineer-caa0b6ba9f90?source=rss-6149505ac645------2</link>
            <guid isPermaLink="false">https://medium.com/p/caa0b6ba9f90</guid>
            <category><![CDATA[engineering-mangement]]></category>
            <category><![CDATA[business-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[Muralish Clinton]]></dc:creator>
            <pubDate>Tue, 16 Jul 2024 13:51:19 GMT</pubDate>
            <atom:updated>2024-07-18T14:10:41.145Z</atom:updated>
            <content:encoded><![CDATA[<h4>Expanding Your Impact and Perspective</h4><p>As software professionals progress in their careers, many find themselves at a crossroads: continue as a developer or evolve into a product engineer. While these titles are often used interchangeably, there’s a distinct shift in mindset and responsibilities that comes with becoming a true product engineer. This article explores key areas to focus on during this transition, helping you broaden your impact and become a more well-rounded professional.</p><h4>Embracing the Full Product Lifecycle</h4><p>The first step in transitioning from a developer to an engineer is to expand your involvement throughout the entire product lifecycle. As a developer, your focus might have been primarily on coding and implementation. To become an engineer, start participating in requirement gathering and analysis, contribute to system design and architecture discussions, engage in testing strategies, and take part in deployment planning and post-release monitoring.</p><p>This broader involvement allows you to see the bigger picture and understand how your work fits into the overall product strategy. It also enables you to make more informed decisions and contribute valuable insights at various stages of development.</p><h4>Developing a Questioning Mindset</h4><p>Instead of simply accepting tasks as they’re assigned, start diving deeper into the “why” behind each project or feature. Ask about the business goals driving specific features, understand how your work fits into the larger product strategy, and explore the reasoning behind technical decisions and constraints.</p><p>This questioning mindset will not only help you make better technical decisions but also position you as a thoughtful contributor to the team. As you gain more context, you’ll be better equipped to:</p><ul><li>Propose alternative approaches to solving problems</li><li>Present pros and cons of different technical solutions</li><li>Initiate discussions on emerging technologies or methodologies that could benefit the project</li></ul><h4>Connecting with End Users and Understanding Impact</h4><p>Building a strong connection to your end users is crucial for any product engineer. Attend user research sessions or customer meetings, when possible, review user feedback and feature requests, and consider usability and user experience in your technical decisions.</p><p>Beyond this, think critically about the impact of your work:</p><ul><li>Analyze how your changes will affect different user segments</li><li>Consider performance implications across various devices or network conditions</li><li>Anticipate potential edge cases or unforeseen consequences of new features</li></ul><p>By staying connected to the end user and understanding the impact of your changes, you’ll be able to make more informed decisions and create solutions that truly meet user needs.</p><h4>Becoming a T-Shaped Engineer</h4><p>While deepening your expertise in specific areas, also work on broadening your knowledge to become a T-shaped engineer. This means having deep knowledge in your primary area of expertise (the vertical bar of the T) while also developing a broad understanding of related fields (the horizontal bar of the T).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5uHtmkhoSHyXumur" /><figcaption>Photo by <a href="https://unsplash.com/@benhershey?utm_source=medium&amp;utm_medium=referral">Ben Hershey</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Learn about adjacent technologies and frameworks, understand the basics of UX design, product management, and data analytics. Explore cloud infrastructure, security principles, and scalability concepts. This broader knowledge will enable you to communicate more effectively with cross-functional teams and make more holistic decisions in your work.</p><h4>Focus on Resilience, Reliability, and Quality</h4><p>As you transition to a product engineer role, shift your mindset from “making it work” to “making it work well.” This involves:</p><ul><li>Implementing robust error handling and logging</li><li>Designing for fault tolerance and graceful degradation</li><li>Prioritizing performance optimization and efficient resource usage</li></ul><p>Additionally, champion clean code practices and design patterns, advocate for comprehensive test coverage, and prioritize documentation and knowledge sharing. These practices will help ensure the long-term sustainability and maintainability of your projects.</p><h4>Collaboration and Agile Mindset</h4><p>Work closely with product managers to shape the roadmap. Help prioritize features based on technical feasibility and impact, suggest technical improvements that align with product goals, and participate actively in sprint planning and backlog grooming sessions.</p><p>Embrace an agile mindset beyond just following a specific methodology. Be adaptable to changing requirements and priorities, encourage continuous feedback and iteration, and foster a culture of transparency and open communication.</p><h4>Systems Thinking and Business Acumen</h4><p>Develop a holistic view of your software ecosystem by understanding how different services and components interact. Consider integration points and potential bottlenecks and think about scalability and future extensibility in your designs.</p><p>Additionally, work on developing your business acumen. Understand your company’s business model and revenue streams, learn about key performance indicators (KPIs) that drive decision-making, and consider cost implications of technical choices.</p><h3>Conclusion</h3><p>As you grow in your role, take on the responsibility of mentoring others. Offer guidance to junior developers, conduct code reviews with a focus on teaching, and share your learnings through team presentations or technical blog posts.</p><p>Embrace the journey, stay curious, and never stop learning. The evolution doesn’t happen overnight, but with consistent effort and a willingness to push yourself out of your comfort zone, you’ll find yourself growing into the role of a true product engineer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=caa0b6ba9f90" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/transitioning-from-a-software-developer-to-a-software-engineer-caa0b6ba9f90">Transitioning from a Software Developer to a Product Engineer</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mono Repo Templating Engine in Go]]></title>
            <link>https://levelup.gitconnected.com/mono-repo-templating-engine-in-go-e5927e924c12?source=rss-6149505ac645------2</link>
            <guid isPermaLink="false">https://medium.com/p/e5927e924c12</guid>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[go]]></category>
            <dc:creator><![CDATA[Muralish Clinton]]></dc:creator>
            <pubDate>Tue, 14 May 2024 16:23:36 GMT</pubDate>
            <atom:updated>2024-05-14T16:23:36.348Z</atom:updated>
            <content:encoded><![CDATA[<h4>Making Project Templating Easier With GO</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vC8lLdGGboyYNHep" /><figcaption>Photo by <a href="https://unsplash.com/@agk42?utm_source=medium&amp;utm_medium=referral">Alex Knight</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>What is a MonoRepo?</h3><p>Monorepo is a packaging convention used to package multiple services of an application within the same repository. All services in a monorepo can be made to function independently, hence separating the business logic.</p><p>Monorepos are sometimes called monolithic repositories, but they should not be confused with monolithic architecture, which is a software development practice for writing self-contained applications.</p><h3>Why use a MonoRepo?</h3><ol><li>Visibility — Everyone working in the domain/project has visibility of everything that goes on in the repository.</li><li>Standardized coding practices — You can establish some project standards and you need not reinvent the wheel for each project individually and ensure the standards are followed.</li><li>Simpler dependency management — All dependencies are managed in the same place, making it easier for versioning and updates.</li><li>Single Source of Truth — The single repo can act as the source of truth for the whole project.</li><li>Unified CI/CD — Since all the services are within the same repository, it’s easier to coordinate and automate build, test, and deployment processes.</li><li>Improved collaboration — Since everyone is working on the same repo, the sense of ownership across teams is improved, and developers can easily discover, review, and contribute to the code.</li></ol><h3>Project Structure</h3><p>A naive monorepo project structure can look as follows, such that each service is located within its service directory with its own set of APIs, handler functions, domain logic, model layer, interfaces, etc. A separate Dockerfile is used so that each individual service within the monorepo can be independently deployed without having to package the whole repository.</p><p>It’s also easier to manage shared code, as everything is located within the same repository, and referencing and managing dependencies is streamlined.</p><p>Whether to have the same go.mod file for all projects or to separate it is subjective based on project requirements, and it’s always easier to do either based on requirements.</p><pre>my-project/<br>  |- services/<br>  |   |- service1/<br>  |   |   |- cmd/<br>  |   |   |   |- main.go<br>  |   |   |- internal/<br>  |   |   |   |- auth.go<br>  |   |   |- api/<br>  |   |   |   |- handler.go<br>  |   |   |   |- router.go<br>  |   |   |- Dockerfile<br>  |   |<br>  |   |- service2/<br>  |   |   |- ...<br>  |   |<br>  |   |- ...<br>  |<br>  |- pkg/<br>  |   |- utils/<br>  |   |   |- utils.go<br>  |<br>  |- Makefile<br>  |- go.mod<br>  |- go.sum</pre><h3>Github Project</h3><p>The<a href="https://github.com/mcmuralishclint/go-mono-repo-templater"> go-mono-repo-templater</a> is an open-source project aimed at making life easier for organizations by standardizing the monorepo template format and using it as a tool for creating new repositories.</p><p>With the rise of platform engineering, this templating engine can be integrated into an internal developer platform (IDP). Developers can then easily create monorepos without having to navigate through the hassle of reading standards from Confluence documents and fixing typos.</p><p>This templating engine’s usage is as simple as running a ‘go install’ command and executing the binary to create the repository in your intended directory. By leveraging platform engineering and an IDP, organizations can further streamline their development processes and empower developers to focus more on building quality software.”</p><pre>go get -u github.com/mcmuralishclint/go-mono-repo-templater<br>go-mono-repo-templater -dir /path/to/ -services service1,service2,service3</pre><p>The project can be further extended to create templates based on various architecture patterns such as clean code, hexagonal, onion, etc.</p><h3>Conclusion</h3><p>With the rise of platform engineering, organizations are moving towards automating mundane tasks and standardizing practices across the company so that engineers can bypass the tedious work and concentrate on the crucial domain logic for the applications they are working on.</p><p>Templating is a good starting point to introduce standardization across the organization and eventually provide a seamless way for engineers to utilize them without any hassle.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e5927e924c12" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/mono-repo-templating-engine-in-go-e5927e924c12">Mono Repo Templating Engine in Go</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Concurrency in Ruby]]></title>
            <link>https://levelup.gitconnected.com/concurrency-in-ruby-487eb43f043f?source=rss-6149505ac645------2</link>
            <guid isPermaLink="false">https://medium.com/p/487eb43f043f</guid>
            <category><![CDATA[ruby]]></category>
            <category><![CDATA[concurrency]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[multithreading]]></category>
            <category><![CDATA[ruby-on-rails]]></category>
            <dc:creator><![CDATA[Muralish Clinton]]></dc:creator>
            <pubDate>Tue, 26 Mar 2024 17:30:05 GMT</pubDate>
            <atom:updated>2024-03-26T17:30:05.957Z</atom:updated>
            <content:encoded><![CDATA[<h4>Navigating the Threads of Performance</h4><p>Ruby, with its elegant syntax and focus on simplicity and productivity, has long been a favorite among developers for building web applications, automation tools, and more. However, when it comes to concurrency, Ruby’s model is often misunderstood or underutilized, leading some to believe it’s not up to the task. This perception couldn’t be further from the truth. In this article, we’ll dive into the world of concurrency in Ruby, exploring its capabilities, challenges, and how you can effectively harness its power to build responsive, scalable applications.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HMUOjHbVbBFH702g" /><figcaption>Photo by <a href="https://unsplash.com/@nhoizey?utm_source=medium&amp;utm_medium=referral">Nicolas Hoizey</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Understanding Concurrency</h4><p>Concurrency involves performing multiple tasks at the same time within a single process. It’s crucial for improving the performance of IO-bound and high-latency operations, making applications more responsive and faster. Ruby implements concurrency through threads, which are separate execution contexts within the same process.</p><h4>Ruby Threads: The Basics</h4><p>Ruby’s standard implementation, MRI (Matz’s Ruby Interpreter), supports threads but with a caveat. It uses a Global Interpreter Lock (GIL), also known as the Global VM Lock (GVL), which allows only one thread to execute at a time. This might seem like a bottleneck, but for IO-bound tasks, where the main delay comes from waiting for file operations, database queries, or HTTP requests, threads can significantly improve performance by allowing other operations to progress while waiting.</p><p>For CPU-bound tasks, the CRuby implementation might not offer true parallelism due to the GVL. However, alternative implementations like JRuby and Rubinius provide native threads support without a GVL, enabling true parallel execution.</p><h4>Concurrency Models in Ruby</h4><p>Ruby offers several concurrency models, each with its own set of advantages and use cases:</p><ol><li>Thread-based Concurrency: This is the most straightforward approach, where you manually manage threads. It’s powerful but comes with complexity, especially around shared resources and data consistency.</li><li>Fiber-based Concurrency: Fibers are lightweight concurrency primitives that are manually scheduled, offering more controlled concurrency than threads. They are useful for IO-bound tasks and cooperative multitasking.</li><li>EventMachine and Async IO: Libraries like EventMachine provide an event-driven IO model, making it possible to handle a large number of connections with a single thread. This model is particularly suited for web servers and real-time web applications.</li><li>Guilds in Ruby 3.x: Ruby 3 aims to introduce “Guilds,” a new concurrency model that promises safe parallel execution without the pitfalls of threads, by ensuring data isolation between concurrent parts of code.</li></ol><h4>Best Practices for Concurrency in Ruby</h4><ol><li>Understand Your Application’s Needs: Choose the concurrency model based on your application’s requirements. For IO-bound tasks, threads or Fibers can be highly effective. For CPU-bound tasks in a multi-core environment, consider JRuby or Rubinius for true parallelism.</li><li>Manage Shared State Carefully: Concurrency introduces complexity, especially around shared data. Use mutexes and other synchronization primitives to protect shared state or design your application to minimize shared state.</li><li>Monitor and Test: Concurrency can introduce subtle bugs that are hard to reproduce. Monitor your application for deadlocks and race conditions and write thorough tests to cover concurrent operations.</li><li>Leverage Existing Libraries and Frameworks: Many Ruby libraries and frameworks offer abstractions that simplify concurrent programming. Explore options like Sidekiq for background jobs or AnyCable for scalable WebSocket communication.</li></ol><h4>Conclusion</h4><p>Concurrency in Ruby is both powerful and accessible, thanks to a variety of models and tools that cater to different needs. By understanding the nuances of Ruby’s concurrency primitives and choosing the right approach for your application, you can unlock new levels of performance and responsiveness. As with any complex feature, concurrency requires careful consideration and testing, but the rewards in terms of efficiency and user experience can be substantial.</p><blockquote>Embrace the concurrent capabilities of Ruby, and let your applications flourish in the realm of high performance and scalability.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=487eb43f043f" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/concurrency-in-ruby-487eb43f043f">Concurrency in Ruby</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Streamlining Secret Management with Rails Credentials and AWS Secrets]]></title>
            <link>https://levelup.gitconnected.com/streamlining-secret-management-with-rails-credentials-and-aws-secrets-60bc5788e313?source=rss-6149505ac645------2</link>
            <guid isPermaLink="false">https://medium.com/p/60bc5788e313</guid>
            <category><![CDATA[security]]></category>
            <category><![CDATA[ruby]]></category>
            <category><![CDATA[rails]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[secrets]]></category>
            <dc:creator><![CDATA[Muralish Clinton]]></dc:creator>
            <pubDate>Sun, 24 Mar 2024 20:18:55 GMT</pubDate>
            <atom:updated>2024-03-24T20:18:55.206Z</atom:updated>
            <content:encoded><![CDATA[<h4>Secret Management Made Easy</h4><p>I remember beginning my Ruby on Rails development journey by using encrypted secrets, which are packaged as part of the application. I then moved on to using environment variables and eventually to using a file with all the secrets, which is packaged during compile time in the build pipeline.</p><p>Though these strategies seem straightforward, they also come with several vulnerabilities. I’d like to discuss a strategy through which we can store and consume secrets better in Ruby on Rails 7.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KGoabex3a5uwvFoa" /><figcaption>Photo by <a href="https://unsplash.com/@jdent?utm_source=medium&amp;utm_medium=referral">Jason Dent</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Credentials were introduced to Ruby on Rails in version 5.2, and in subsequent major versions, we have witnessed significant improvements to credential management within the framework. I’m excited to see how it will evolve in the upcoming versions.</p><h4>How to get started with Credentials?</h4><p>Rails stores secrets in config/credentials.yml.enc, which is encrypted and hence cannot be edited directly. Rails uses config/master.key or alternatively looks for the environment variable ENV[&quot;RAILS_MASTER_KEY&quot;] to encrypt the credentials file. Because the credentials file is encrypted, it can be stored in version control, as long as the <strong><em>master key is kept safe</em></strong>.</p><p>By default, the credentials file contains the application’s secret_key_base. It can also be used to store other secrets such as access keys for external APIs.</p><p>The following command will create the credentials file (e.g: config/credentials.yml.enc) if it does not exist. Additionally, this command will create config/master.key if no master key is defined.</p><pre>rails credentials:edit</pre><p>credentials.yml.enc file will contain a string which when decrypted will revert back to the actual configs. The configs before encrypting will look as follows:</p><pre>secret_key_base: 3b7cd72...<br>some_api_key: SOMEKEY<br>system:<br>  access_key_id: 1234AB</pre><h4>How is the credential stored?</h4><blockquote>Rails uses AES with GCM for encrypting the credentials</blockquote><p>AES cipher is still the most current symmetric cipher widely used today. In encryption there are several modes for symmetric block encryption and most of them are good until used properly. Very often neglected property of encryption is using authenticated encryption. It means making sure, that the ciphertext was not changed.</p><p>AES-GCM has the cipher authentication built-in in the specification. AES-GCM is in top shelf if you need symmetric block encryption.</p><p>Also, a separate file will be maintained within the config folder for each environment that will be spun up.</p><h4>How does the application access the encrypted credentials?</h4><p>Rails.application.credentials.some_api_key returns &quot;SOMEKEY&quot;. Rails.application.credentials.system.access_key_id returns &quot;1234AB&quot;.</p><p>If you want an exception to be raised when some key is blank, you can use the bang version:</p><pre># When some_api_key is blank...<br>Rails.application.credentials.some_api_key! # =&gt; KeyError: :some_api_key is blank</pre><h4>How to securely store the master key?</h4><p>A suggested way of storing the master key is in environment variables but this defeats the purpose of moving away from using environment variables to more secure ways. Therefore, we could make use of AWS Secret Manager and define an IAM role to the application instance to read from the secret manager and retrieve the master key which will later be used to decrypt the credentials file and make use of the secrets.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/454/1*EaSnwT-Bdy3MjW4HyDgqtA.png" /><figcaption>Allowing the EC2 instance to read from Secret Manager via IAM</figcaption></figure><p>A commonly asked questions is:</p><blockquote><em>“If we are making use of IAM roles, why do we need to go through the pain of maintaining the secrets within the application? Why don’t we store all the secrets in the secret manager?</em></blockquote><p>Yes indeed! This is possible but my personal preference is to make use of the credentials feature provided by the framework and not bloat the secret manager hence reducing the maintenance overhead in the long run.</p><h3>Conclusion</h3><p>There are several advantages of using the Rails Credentials and AWS Secret manager together and some of my personal favorite reasons are:</p><ol><li>All the credentials are encrypted: No one will be able to decrypt your credentials without the key.</li><li>The encrypted credentials are saved in the repository, and we’ll be able to track changes easily.</li><li>Since we deploy new credentials together with the code, the overhead of change management is reduced as everything is in one central place.</li></ol><p>Though this method is interesting, the topic of secret management is rapidly evolving, and there will definitely be better ways existing or emerging. Stay tuned to learn more about this.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=60bc5788e313" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/streamlining-secret-management-with-rails-credentials-and-aws-secrets-60bc5788e313">Streamlining Secret Management with Rails Credentials and AWS Secrets</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Enabling a Go app on GKE using Backstage templates and Github actions]]></title>
            <link>https://levelup.gitconnected.com/enabling-a-go-app-on-gke-using-backstage-templates-and-github-actions-f29130be8e75?source=rss-6149505ac645------2</link>
            <guid isPermaLink="false">https://medium.com/p/f29130be8e75</guid>
            <category><![CDATA[go]]></category>
            <category><![CDATA[gke]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[backstage]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Muralish Clinton]]></dc:creator>
            <pubDate>Sun, 25 Feb 2024 20:03:43 GMT</pubDate>
            <atom:updated>2024-02-25T20:47:19.134Z</atom:updated>
            <content:encoded><![CDATA[<h4>From repo creation to enabling CI/CD pipeline and deploying on Kubernetes</h4><h3>Introduction</h3><p>Backstage is an open-source platform for constructing Internal Developer Portals (IDPs). Internal Developer Portals serve as a one-stop shop, that provides a unified view of all our resources. IDPs enable us to seamlessly create, manage, monitor, and document our software resources from a single location. The primary goal of the IDP is to eliminate the reliance on the connection between DevOps and developers.</p><p>I want to explore setting up a GO boilerplate application, complete with a CI/CD pipeline and deployment to GKE, all achievable with the click of a button to enhance developer efficiency.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DYeQMXkhav0eIa3AcFSTcg.png" /></figure><h3>Prerequisites</h3><ol><li>Setup Backstage locally — <a href="https://backstage.io/docs/getting-started/">Getting Started | Backstage Software Catalog and Developer Platform</a></li><li>Have a GCP account with enough credits to run GKE — <a href="https://www.geeksforgeeks.org/how-to-create-a-free-tier-account-on-gcp/">How To Create a Free Tier Account on GCP? — GeeksforGeeks</a></li><li>Integrated GitHub Auth with Backstage — <a href="https://roadie.io/blog/github-auth-backstage/">Using GitHub Auth with Backstage | Roadie</a></li><li>Generate a service account key to deploy from Github Actions to GKE — <a href="https://cloud.google.com/artifact-registry/docs/docker/authentication">Set up authentication for Docker | Artifact Registry documentation | Google Cloud</a></li></ol><h3>Deep Dive</h3><h4>Set up GO boilerplate</h4><ul><li>Create a templates folder on the root of the backstage application and create files as</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/347/1*vGL6a1suN56bEdEneKARGg.png" /></figure><ul><li>catalog.info — contains the information to display once the component created via the template is registered on the catalog</li></ul><pre>apiVersion: backstage.io/v1alpha1<br>kind: Component<br>metadata:<br>  name: ${{values.name | dump}}<br>  description: ${{values.description | dump}}<br>  annotations:<br>    github.com/project-slug: ${{values.destination.owner + &quot;/&quot; + values.destination.repo}}<br>    github.com/actions-workflow: https://github.com/${{values.destination.owner}}/${{values.destination.repo}}/actions<br>spec:<br>  type: service<br>  lifecycle: experimental<br>  owner: ${{values.owner | dump}}</pre><ul><li>Dockerfile — Contains the script to containerize the application</li></ul><pre># Start from a Debian-based image with Go installed<br>FROM golang:1.17 AS build<br><br># Set the working directory inside the container<br>WORKDIR /app<br><br># Copy the Go module files<br>COPY go.mod .<br># COPY go.sum .<br><br># Download and install dependencies<br>RUN go mod download<br><br># Copy the source code into the container<br>COPY . .<br><br># Build the Go application<br>RUN go build -o app .<br><br># Start a new stage from a lightweight base image<br>FROM debian:buster-slim<br><br># Set the working directory inside the container<br>WORKDIR /app<br><br># Copy the built executable from the previous stage<br>COPY --from=build /app/app .<br><br># Expose port 8080 to the outside world<br>EXPOSE 8080<br><br># Command to run the executable<br>CMD [&quot;./app&quot;]</pre><ul><li>template.yaml — contains the workflows to execute when running the boilerplate template</li></ul><pre>apiVersion: scaffolder.backstage.io/v1beta3<br>kind: Template<br>metadata:<br>  name: go-repo-template<br>  title: GO Template<br>  description: This repository template provides a framework for generating a Golang HTTP server with a clean architecture. Clean architecture emphasizes separation of concerns and maintainability by organizing code into distinct layers, making it easier to understand, test, and modify.<br>  tags:<br>  - recommended<br>  - clean<br>  - go<br>spec:<br>  owner: muralish<br>  type: service<br><br>  parameters:<br>  - title: Fill in some steps<br>    required:<br>    - name<br>    - description<br>    properties:<br>      name:<br>        title: Name<br>        type: string<br>        description: Unique name of the component<br>        ui:field: EntityNamePicker<br>        ui:autofocus: true<br>      description:<br>        title: Description<br>        type: string<br>        description: A description for the component<br>      owner:<br>        title: Owner<br>        type: string<br>        description: Owner of the component<br>        ui:field: OwnerPicker<br>        ui:options:<br>          allowedKinds:<br>          - Group<br>  - title: Choose a location<br>    required:<br>    - repoUrl<br>    properties:<br>      repoUrl:<br>        title: Repository Location<br>        type: string<br>        ui:field: RepoUrlPicker<br>        ui:options:<br>          allowedHosts:<br>          - github.com<br><br>  # This template is meant to be used on top of an existing template.<br>  # By adding the following and fetching from an absolute URL you can<br>  # add in the docs template<br>  steps:<br>  - id: fetch<br>    name: Template Docs Skeleton<br>    action: fetch:template<br>    input:<br>      url: ./skeleton<br>      values:<br>        name: ${{ parameters.name }}<br>        description: ${{ parameters.description }}<br>        destination: ${{ parameters.repoUrl | parseRepoUrl }}<br>        owner: ${{ parameters.owner }}<br><br>  - id: publish<br>    name: Publish<br>    action: publish:github<br>    input:<br>      allowedHosts: [&#39;github.com&#39;]<br>      description: This is ${{ parameters.name }}<br>      repoUrl: ${{ parameters.repoUrl }}<br><br>  - id: register<br>    name: Register<br>    action: catalog:register<br>    input:<br>      repoContentsUrl: ${{ steps.publish.output.repoContentsUrl }}<br>      catalogInfoPath: &#39;/catalog-info.yaml&#39;<br><br>  output:<br>    links:<br>    - title: Repository<br>      url: ${{ steps.publish.output.remoteUrl }}<br>    - title: Open in catalog<br>      icon: catalog<br>      entityRef: ${{ steps.register.output.entityRef }}</pre><p>Replace the following with your own boilerplate.</p><ul><li>main.go — a sample code to initialize and run the application.</li><li>go.mod — is generated as a result of running go mod init and go mod tidy.</li><li>add.go — contains a sample go function to add 2 numbers.</li><li>add_test.go — contains the unit test to test the unit test pipeline.</li></ul><h4>Setup Github Actions</h4><ul><li>.github/workflows/unit-test.yaml — runs the unit test every time code is pushed to master.</li></ul><pre># This workflow will build a golang project<br># For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-go<br><br>name: Go<br><br>on:<br>  push:<br>    branches: [ &quot;master&quot; ]<br>  pull_request:<br>    branches: [ &quot;master&quot; ]<br><br>jobs:<br><br>  build:<br>    runs-on: ubuntu-latest<br>    steps:<br>    - uses: actions/checkout@v3<br><br>    - name: Set up Go<br>      uses: actions/setup-go@v4<br>      with:<br>        go-version: &#39;1.20&#39;<br><br>    - name: Build<br>      run: go build -v ./...<br><br>    - name: Test<br>      run: go test -v ./...</pre><ul><li>.github/workflows/deployment.yaml — creates a trigger to deploy the application on GKE.</li></ul><pre>---<br>  name: Build and Push GO Image to Google Cloud Platform<br>  on:<br>    workflow_dispatch:<br>  jobs:<br>    build-push-gcr:<br>      name: Build and Push to GCP<br>      runs-on: ubuntu-latest<br>      env:<br>        IMAGE_NAME: backstage<br>        PROJECT_ID: prj-dev-platform-next<br>      steps:<br>      - name: Checkout<br>        uses: actions/checkout@v2<br>  <br>      - uses: google-github-actions/setup-gcloud@v0<br>        with:<br>          service_account_key: ${{ secrets.SERVICE_ACCOUNT_KEY }}<br>          project_id: prj-dev-platform-next<br>          export_default_credentials: true<br>          install_components: &#39;gke-gcloud-auth-plugin&#39;<br>  <br>      - name: Build Docker Image<br>        run: docker build -t $IMAGE_NAME:latest .<br>  <br>      - name: Configure Docker Client<br>        run: |-<br>          gcloud auth configure-docker --quiet<br>          gcloud auth configure-docker us-west2-docker.pkg.dev --quiet<br>  <br>      - name: Push Docker Image to Container Registry (GCR)<br>        env:<br>          GIT_TAG: v0.1.0<br>        run: |-<br>          docker tag $IMAGE_NAME:latest gcr.io/$PROJECT_ID/$IMAGE_NAME:latest<br>          docker tag $IMAGE_NAME:latest gcr.io/$PROJECT_ID/$IMAGE_NAME:$GIT_TAG<br>          docker push gcr.io/$PROJECT_ID/$IMAGE_NAME:latest<br>          docker push gcr.io/$PROJECT_ID/$IMAGE_NAME:$GIT_TAG<br>  <br>      - name: Push Docker Image to Artifact Registry<br>        env:<br>          GIT_TAG: v0.1.0<br>        run: |-<br>          docker tag $IMAGE_NAME:latest us-west2-docker.pkg.dev/$PROJECT_ID/images/$IMAGE_NAME:latest<br>          docker tag $IMAGE_NAME:latest us-west2-docker.pkg.dev/$PROJECT_ID/images/$IMAGE_NAME:$GIT_TAG<br>          docker push us-west2-docker.pkg.dev/$PROJECT_ID/images/$IMAGE_NAME:latest<br>          docker push us-west2-docker.pkg.dev/$PROJECT_ID/images/$IMAGE_NAME:$GIT_TAG<br>  <br>      - name: Deploy to Kubernetes<br>        run: |<br>          gcloud container clusters get-credentials go-app --region us-west2<br>          kubectl apply -f .github/manifests/deployment.yaml --validate=false</pre><ul><li>.github/manifests/deployment.yaml — kubernetes yaml to deploy the containerized application on Kubernetes.</li></ul><pre>---<br>apiVersion: v1<br>kind: Service<br>metadata:<br>  name: go-app<br>spec:<br>  type: LoadBalancer<br>  selector:<br>    app: go-app<br>  ports:<br>  - port: 8080<br>    targetPort: 8080<br>---<br>apiVersion: apps/v1<br>kind: Deployment<br>metadata:<br>  name: go-app<br>  labels:<br>    app: go-app<br>spec:<br>  replicas: 1<br>  selector:<br>    matchLabels:<br>      app: go-app<br>  template:<br>    metadata:<br>      labels:<br>        app: go-app<br>    spec:<br>      containers:<br>      - name: go-app<br>        image: gcr.io/prj-dev-platform-next/backstage:latest</pre><h4>Link the GO app template on Backstage</h4><ul><li>Update the app-config.yaml to contain the following in the catalog section. Reference the template.yaml file from the templates folder you had created.</li></ul><pre>catalog:<br>  locations:<br>  - type: file<br>    target: C:\Users\Muralish\Downloads\backstage\backstage\templates\go-boilerplate\template.yaml<br>  rules:<br>  - allow: [Component, Group, User, Resource, Location, Template]</pre><h4>Setup GKE &amp; Container Registry</h4><ol><li>Go to Google Cloud Console.</li><li>Browse container registry, enable it and create a folder called backstage to store the docker images.</li><li>Browse Kubernetes Engine and create a new cluster — Choose autopilot mode and configure with the same settings as mentioned in .github/workflows/deployment.yaml.</li><li>Provide sufficient resources for the application to run and/or enable autoscaling.</li></ol><h3>Test</h3><ol><li>Run <em>yarn dev </em>to start the backstage application.</li><li>Click on create on the sidebar and select the GO template that shows up on the main page.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/402/1*yRh2zmN_D1tj6MoCG5h0kw.png" /></figure><p>3. Fill out the info that’s being prompted and confirm the creation</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DgMqzbPw39lpx9D8jGl0jA.png" /></figure><p>4. Once the application is created, you can view the application on the catalog page including ci/cd status.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pqHUBYHoShaYafC871rZ3g.png" /></figure><p>5. Add the SERVICE_ACCOUNT_KEY in the GitHub actions secrets of the newly created repo</p><p>6. The CD pipeline can be triggered from the GitHub actions view.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7bVp_lLJKG9sFInFDMJbWw.png" /></figure><h3>Summary</h3><p>The application is created in a way that allows you to generate a Go boilerplate code with best practices for your organization, eliminating the need to worry about setting up the CI/CD and infrastructure. Backstage will completely automate this process for you and handle all the necessary configurations.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f29130be8e75" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/enabling-a-go-app-on-gke-using-backstage-templates-and-github-actions-f29130be8e75">Enabling a Go app on GKE using Backstage templates and Github actions</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Effortless Deployment: Launching Your Ruby on Rails App in 10 Minutes]]></title>
            <link>https://levelup.gitconnected.com/effortless-deployment-launching-your-ruby-on-rails-app-in-10-minutes-1d7914269eed?source=rss-6149505ac645------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d7914269eed</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[ruby]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[ruby-on-rails]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Muralish Clinton]]></dc:creator>
            <pubDate>Thu, 04 Jan 2024 15:45:49 GMT</pubDate>
            <atom:updated>2024-01-04T15:45:49.809Z</atom:updated>
            <content:encoded><![CDATA[<h4>Step-by-Step Guide Using AWS EC2 and Docker Compose for Seamless Deployment</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7jESYWPfJxuQVxpV" /><figcaption>Photo by <a href="https://unsplash.com/@exdigy?utm_source=medium&amp;utm_medium=referral">Dominik Lückmann</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>At times, deploying a Ruby on Rails app can be daunting, especially when setting up intricate configurations like web servers and dedicated application servers. However, if you’re aiming to showcase or understand the behavior of your app post-deployment without diving into complex configurations, there’s a simpler approach.</p><blockquote>Containerization has streamlined this process, allowing you to roll out your application swiftly as a minimum viable product.</blockquote><p>Allow me to guide you through the process for my example application, which utilizes both SQLite and MongoDB as its databases.</p><h3>Step 1 — Dockerize your application</h3><p>Once you’re done developing your application, start dockerizing it.</p><h4>Create a dockerfile in the root of your repository</h4><p>Take a look at <a href="https://docs.docker.com/get-started/02_our_app/">https://docs.docker.com/get-started/02_our_app/</a> for further insights on containerizing a Ruby application. Below is a basic Dockerfile to initiate a Ruby on Rails application on port 3000.</p><pre># Make sure it matches the Ruby version in .ruby-version and Gemfile<br>ARG RUBY_VERSION=3.2.2<br>FROM ruby:$RUBY_VERSION</pre><pre># Install libvips for Active Storage preview support<br>RUN apt-get update -qq &amp;&amp; \<br>    apt-get install -y build-essential libvips &amp;&amp; \<br>    apt-get clean &amp;&amp; \<br>    rm -rf /var/lib/apt/lists/* /usr/share/doc /usr/share/man</pre><pre># Rails app lives here<br>WORKDIR /rails</pre><pre># Set environment variables<br>ENV RAILS_LOG_TO_STDOUT=&quot;1&quot; \<br>    RAILS_SERVE_STATIC_FILES=&quot;true&quot;</pre><pre># Install application gems<br>COPY Gemfile Gemfile.lock ./<br>RUN bundle install</pre><pre># Copy application code<br>COPY . .</pre><pre># Prepare the db<br>RUN bundle exec rails db:prepare</pre><pre># Start the server by default, this can be overwritten at runtime<br>EXPOSE 3000<br>CMD [&quot;bundle&quot;,  &quot;exec&quot;, &quot;rails&quot;, &quot;server&quot;, &quot;-e&quot;, &quot;development&quot;, &quot;-b&quot;, &quot;0.0.0.0&quot;]</pre><h4>Create a docker compose for your dockerfile</h4><p>Create a docker-compose.yml file in the root of your application.</p><p><em>Docker Compose is a tool used to define and manage multi-container Docker applications. It allows you to describe a set of related services (containers) that make up your application in a YAML file. With Docker Compose, you can specify the services, their dependencies, networks, volumes, and other configurations needed to run a multi-container Docker application.</em></p><p>I’ve created an example docker-compose file that makes use of Mongodb.</p><pre>version: &#39;3.3&#39;</pre><pre>services:<br>  my-rails-app:<br>    image: .<br>    ports:<br>      - &quot;3000:3000&quot;<br>    volumes:<br>      - .:/rails<br>    environment:<br>      RAILS_ENV: development<br>      RAILS_HOST: 0.0.0.0<br>    depends_on:<br>      - mongo<br>  mongo:<br>    image: mongo<br>    ports:<br>      - &quot;27017:27017&quot;</pre><h3>Step 2 — Create an AWS Account</h3><ol><li><strong>Sign Up for AWS:</strong> Go to the AWS Free Tier page and create an account.</li><li><strong>Access IAM:</strong> In the AWS Management Console, go to IAM (Identity and Access Management).</li><li><strong>Create IAM User:</strong> Add a user with programmatic access. Attach policies like “AmazonEC2FullAccess.”</li><li><strong>Get Credentials: </strong>Download or copy the access key ID and secret access key for API access.</li><li>Login to your IAM account</li></ol><h3>Step 3 — Create an EC2 Instance</h3><ol><li><strong>Navigate to EC2: </strong>Go to the EC2 Dashboard.</li><li><strong>Launch an EC2 Instance:<br></strong>Click on “Launch Instance.”<br>Choose the Amazon Linux AMI and click “Select.”<br>Select a free instance type and click “Next: Configure Instance Details.”</li><li><strong>Create a new key pair</strong></li><li><strong>Configure network settings</strong></li><li><strong>Configure Storage</strong></li><li><strong>Launch Instance</strong></li></ol><p>Go to the instance dashboard and wait until the EC2 instance has come to Running state. Click on the instance id and connect to it using EC2 instance connect.</p><h3>Step 4 — Setup Dependancies</h3><h4>Install environment dependencies</h4><pre>sudo amazon-linux-extras install docker<br>sudo yum update -y<br>sudo service docker start<br>sudo usermod -a -G docker ec2-user</pre><pre>sudo yum -y install docker-compose<br>sudo curl -L <a href="https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname">https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname</a> -s)-$(uname -m) -o /usr/local/bin/docker-compose<br>sudo chmod +x /usr/local/bin/docker-compose</pre><h4>Add SSH Key</h4><p>Add ssh key of the EC2 instance to your github profile — <a href="https://docs.github.com/en/authentication/connecting-to-github-with-ssh/adding-a-new-ssh-key-to-your-github-account">https://docs.github.com/en/authentication/connecting-to-github-with-ssh/adding-a-new-ssh-key-to-your-github-account</a></p><h4>Clone your repository</h4><p>git clone &lt;repo link&gt; &amp;&amp; cd &lt;repo-name&gt;</p><h3>Step 5 — Run the container</h3><p>Run docker-compose up -d to build the image and run the container.</p><p>Get the public IP of the EC2 instance and visit &lt;Public IP&gt;:3000 on your browser!</p><blockquote>Congrats you’ve successfully deployed your ROR Application on an EC2 instance!</blockquote><h3>Conclusion</h3><p>By dockerizing your application, you’ve encapsulated its dependencies, making it portable and easily deployable across environments. The use of Docker Compose further streamlines the setup, defining the services and configurations needed for your multi-container application, such as your Rails app and MongoDB.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WoY5eoz1LlzsXcSJ" /><figcaption>Photo by <a href="https://unsplash.com/@lazizli?utm_source=medium&amp;utm_medium=referral">Lala Azizli</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>This method simplifies deploying an application for demonstration or initial insights into post-deployment behavior. However, real-world deployment complexities far exceed this approach. I’ll explore a production-grade deployment in a forthcoming article, unveiling the intricacies involved.</p><p>Stay tuned for a deeper dive into deploying applications in a robust, enterprise-ready environment.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d7914269eed" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/effortless-deployment-launching-your-ruby-on-rails-app-in-10-minutes-1d7914269eed">Effortless Deployment: Launching Your Ruby on Rails App in 10 Minutes</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>