<?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 Yağız Küçükkambak on Medium]]></title>
        <description><![CDATA[Stories by Yağız Küçükkambak on Medium]]></description>
        <link>https://medium.com/@yagizkucukkambak?source=rss-692abde0c1f6------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*W0c0F8W94E02P0KpmBJbsg.jpeg</url>
            <title>Stories by Yağız Küçükkambak on Medium</title>
            <link>https://medium.com/@yagizkucukkambak?source=rss-692abde0c1f6------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 07:38:17 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@yagizkucukkambak/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[Before You Hand an Agent Your Repo]]></title>
            <link>https://yagizkucukkambak.medium.com/before-you-hand-an-agent-your-repo-067601cd0493?source=rss-692abde0c1f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/067601cd0493</guid>
            <category><![CDATA[sdlc]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[generative-ai]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Yağız Küçükkambak]]></dc:creator>
            <pubDate>Sun, 01 Nov 2026 10:18:33 GMT</pubDate>
            <atom:updated>2026-11-01T10:18:33.075Z</atom:updated>
            <content:encoded><![CDATA[<p>Hi everyone. I’ve been trying to write about DevOps in my own words, as best I can. Today I’d like to step away from the technical side a little and talk about how SDLC processes are evolving (or failing to evolve) as AI usage grows.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_N2vaVwfskBz-px0ihlB1Q.png" /><figcaption>Software Development Life Cycle 6 Phases</figcaption></figure><h3>First, what is SDLC?</h3><p>SDLC (Software Development Life Cycle) is the full set of stages an idea or product goes through, from having its requirements defined to going live. In its classic form, it consists of the following steps:</p><ol><li>Requirements</li><li>Design</li><li>Development</li><li>Testing</li><li>Deployment</li><li>Maintenance</li></ol><p>It shouldn’t be thought of as a single method. It can run under the waterfall model, an agile approach, or DevOps practices. The order, duration, and names of the stages vary, but each one has a purpose: making sure the software does the right thing, does it the right way, and can go live safely.</p><p>SDLC is often seen as bureaucracy. In reality, it is a system of controls we set up to catch mistakes before they reach production.</p><h3>Look at the Scoreboard: Google’s DORA Report</h3><p>AI has genuinely sped up software development. Google Cloud’s DORA team, in its 2025 report, analyzed a survey of roughly 5,000 technology professionals along with more than 100 hours of qualitative data. 90% of respondents use AI in their work, and Google says that is a 14% increase over last year. More than 80% believe their productivity has gone up. The analysis found a positive relationship between AI use and delivery throughput.</p><p>But the same report says one more thing: there is still a relationship pointing toward lower delivery stability as AI use grows. 30% of respondents, three out of every ten, trust AI-generated code only a little or not at all. The report also points to this: AI speeds up development, but without control mechanisms like test automation, version control, and fast feedback, the growing volume of change makes the system unstable. The report’s main takeaway is, in fact, one of my reasons for writing this piece: AI doesn’t fix a team, it scales it as it is. A process that works well gets better, and one that falters becomes more visible.</p><h3>Cheat Code: Speed Always Wins?</h3><p>Given my age, I see myself as a Millennial and Gen Z hybrid, so I want to open this section with an Age of Empires cheat code. In Age of Empires III, when we typed “speed always wins,” the game literally sped up 100x. Suddenly all our resources shot up, we could pump out soldiers easily, and we could attack the opponent sooner. So what happened at that point?</p><p>At 100x, the opponent was at 100x too. This time, managing things at that reckless speed got harder, which meant the player had to play well. Speed was no longer an advantage; everyone had it. The difference came from who could manage that speed.</p><p>What we’re living through with AI today looks a lot like this. The tool that speeds things up is now in the hands of the vast majority of technology professionals. So at this speed, which links of the SDLC still keep us standing?</p><h3>Those who decide: Requirements and Design</h3><p>The first two stages of the SDLC ask two questions: are we doing the right thing, and are we building it the right way? AI can code a requirement very quickly, but whether it can decide that the requirement is actually the right one is debatable. The person who can make that call is the one who carries the context of the work.</p><p>An architectural decision belongs to the Architect, who knows the system’s context and is accountable for the outcome. AI can suggest an option, but it can’t own that decision.</p><h3>Those who verify: Development and Testing</h3><p>This is where AI’s speed is felt the most. Around me, I’ve seen people rewrite an application from scratch with AI, ship a product that meets a need without looking at the code, and open a merge request (MR) in a language they’re not experts in. I don’t dismiss any of it. But writing code has become cheap. Verifying it still takes effort.</p><p>According to Veracode’s 2026 report, models produce nearly flawless code in terms of syntax, but when no security guidance is given, they fail security tests about 44% of the time. In Faros’s two-year data, within the same organizations, when AI usage was high, task throughput rose 33.7% compared to low usage, while bugs per MR rose 28.7%.</p><p>AI can write tests very quickly too. But a high number of tests, or high coverage, doesn’t mean the tests measure the right thing. Verifying AI-written code with AI-written tests can become circular.</p><p>Back to the example of opening an MR in a language you don’t know: if neither the author nor the reviewer knows that language, there is effectively no control layer.</p><h3>Those who carry responsibility: Deployment and Maintenance</h3><p>The Deployment stage hinges on a change actually going live correctly and in a healthy way. Looking at CircleCI’s 2026 report, which analyzed about 28.7 million workflows run in September 2025, we see that the average number of daily workflows grew 59% year over year, while the workflow success rate on the main branch fell to 70.8%, the lowest level in five years. CircleCI interprets this as roughly 30% of the changes going to the main branch failing, and attributes the picture to AI-driven code generation. A failing CI run isn’t always bad; it catches real mistakes before production. Still, we are well aware that the volume of change has grown, but the healthy flow of that volume into the main branch hasn’t moved in the same direction. It has gone backwards.</p><p>Giving an agent access to a repo is no different from adding a new user to the team. What identity does it run under, which secrets can it access, can it write directly to main, who approves the changes it makes? If there are no answers to these questions, the real risk is what the agent can touch when it’s wrong. Since 2025, in several publicly reported incidents, we’ve seen AI coding agents delete production databases.</p><p>The Maintenance stage, for its part, asks who will read and maintain this code three months from now. In GitClear’s study of 211 million changed lines of code from 2020 to 2024, we see that in 2024 copy-pasted lines outnumbered moved lines, meaning refactored ones. GitClear links this shift to the spread of AI coding assistants. In my view, the real problem is the accumulation of code that nobody has fully read.</p><p>Let’s consider a concrete scenario. Imagine a team that hands the output of an automated scan to an AI tool and merges the resulting changes in bulk, without the people who own the affected code reviewing them. The intent is reasonable: close the vulnerabilities quickly. But a change produced to fix a vulnerability needs to be verified just as much as the code itself. In this scenario, there is speed but no control layer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*C8Pv_ZhukhBt7d1n" /><figcaption>Photo by <a href="https://unsplash.com/@sanjeevan_s?utm_source=medium&amp;utm_medium=referral">Sanjeevan SatheesKumar</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>So what path should we follow?</h3><p>To underline it: this is not a “let’s drop AI” post. To get value from AI, the SDLC has to keep up with AI’s speed. Google’s DORA post points the industry in a similar direction: clarify AI policies, prioritize foundational engineering practices, and strengthen safety nets. Here is what can be done toward that:</p><ol><li><strong>Agents can be used as service accounts.</strong> They can open branches and MRs under their own identities, but they have no merge rights. Their access to secrets and production is kept limited, and deploy permission stays with the pipeline, not with the agent.</li><li><strong>A size limit can be set on MRs opened by agents.</strong> A change too large to review is, in practice, a change that wasn’t reviewed.</li><li><strong>Acceptance criteria can be written before the code.</strong> If tests are tied to behavior defined by humans, the risk of verifying AI-written code with AI-written tests goes down.</li><li><strong>Gates can be mandatory for agent MRs too.</strong> Lint, tests, secret scanning and security scanning run on agent MRs just as they do on human MRs, and approval comes from a human.</li><li><strong>Start with a pilot and measure.</strong> Run a pilot in a limited area, track predefined metrics such as main branch success rate and MTTR, and expand the scope if the results are good.</li><li><strong>Agent rules can be written down.</strong> What the agent can and cannot touch can be documented in a file like AGENTS.md and shared with the team.</li></ol><h3>Does speed always win?</h3><p>The cheat code in the game was in everyone’s hands, and what decided the winner was the player who could manage that speed. With AI we’re at a similar point: the tool that speeds things up is now in the hands of the vast majority of technology professionals, and the difference comes from who can manage that speed.</p><p>At the start, we talked about how the SDLC is evolving (or failing to evolve). The stages stay the same; what needs to evolve are the control mechanisms in each stage. Teams that build AI into this system gain from the speed, while those that skip it accumulate risk faster.</p><p>Before handing a repo to an agent, you have to ask this question: who will verify what AI wrote, and against what standard?</p><p><strong>Sources</strong></p><ul><li>Google Cloud, <a href="https://cloud.google.com/blog/products/ai-machine-learning/announcing-the-2025-dora-report">Announcing the 2025 DORA Report: State of AI-Assisted Software Development</a></li><li>Google, <a href="https://blog.google/technology/developers/dora-report-2025/">How are developers using AI? Inside our 2025 DORA report</a></li><li>Veracode, <a href="https://www.veracode.com/news/llms-are-getting-smarter-but-not-safer-veracode-2026-genai-code-security-report-finds-ai-generated-code-security-has-stalled-at-56%25-pass-rate/">2026 GenAI Code Security Report</a></li><li>Faros AI, <a href="https://www.faros.ai/research/ai-acceleration-whiplash">The Acceleration Whiplash, AI Engineering Report Q2 2026</a></li><li>CircleCI, <a href="https://circleci.com/resources/2026-state-of-software-delivery/">The 2026 State of Software Delivery</a></li><li>GitClear, <a href="https://www.gitclear.com/ai_assistant_code_quality_2025_research">AI Copilot Code Quality 2025</a></li><li>LeadDev, <a href="https://leaddev.com/technical-direction/how-ai-generated-code-accelerates-technical-debt">How AI-generated code compounds technical debt</a></li><li>OECD AI Incident Monitor, <a href="https://oecd.ai/en/incidents/2025-07-19-1eb1">Replit incident, July 2025</a>, and <a href="https://oecd.ai/en/incidents/2026-04-27-6153">PocketOS incident, April 2026</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=067601cd0493" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[B/G Release Management w/GitOps]]></title>
            <link>https://yagizkucukkambak.medium.com/b-g-release-management-w-gitops-a64ef3c15a2a?source=rss-692abde0c1f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/a64ef3c15a2a</guid>
            <category><![CDATA[gitops]]></category>
            <category><![CDATA[argo-rollouts]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[argo-cd]]></category>
            <category><![CDATA[gitlab]]></category>
            <dc:creator><![CDATA[Yağız Küçükkambak]]></dc:creator>
            <pubDate>Thu, 16 Jul 2026 15:37:27 GMT</pubDate>
            <atom:updated>2026-07-16T15:37:27.597Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>This article is entirely based on how theoretical knowledge can be exemplified with a simple practical example. You can contact me for a more detailed discussion.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*aHyTCNxYo1iDLKkH" /><figcaption>Photo by <a href="https://unsplash.com/@hassaanhre?utm_source=medium&amp;utm_medium=referral">Hassaan Here</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Kubernetes’ built-in RollingUpdate strategy, when configured correctly, genuinely is zero-downtime — but it would be wrong to equate uninterrupted service with a safe, clean release. RollingUpdate doesn&#39;t give you three things:</p><ol><li><strong>Atomicity</strong></li><li><strong>Fast-Rollback</strong></li><li><strong>Verification</strong></li></ol><p>Blue/Green exists precisely to close these three gaps. In this article, I’ll position GitLab as the source of truth, ArgoCD as the GitOps engine, and Argo Rollouts as the controller managing Blue/Green — and walk you through the Commit → Sync → Preview &amp; Verification → Atomic Cutover → Fast Rollback flow end to end, at a 101 level, on a local cluster.</p><h4>Rollout vs. B/G Deployment, which one is better?</h4><blockquote>A rolling update allows a Deployment update to take place with zero downtime. It does this by incrementally replacing the current Pods with new ones. The new Pods are scheduled on Nodes with available resources, and Kubernetes waits for those new Pods to start before removing the old Pods.</blockquote><p>And that’s absolutely true. With readinessProbe and maxSurge/maxUnavailable defined, and a proper graceful shutdown in place, RollingUpdate never drops the service during a deploy; not a single request is lost. The Kubernetes documentation isn&#39;t wrong to call it &quot;zero-downtime&quot; — and for most simple stateless services, it&#39;s more than enough.</p><p>The real issue is mistaking <strong>uninterrupted service</strong> for <strong>a safe release</strong>. There are two separate questions here:</p><ol><li><strong>Did the service stay up?</strong></li><li><strong>What is guaranteed during the release itself?</strong></li></ol><p>RollingUpdate answers the first; but it doesn&#39;t give you three things — <strong>Atomicity, Fast-Rollback, Verification</strong> — and Blue/Green exists precisely for these:</p><p><strong>Atomicity</strong> — RollingUpdate progresses incrementally: while the rollout is in flight, the old and new versions receive live traffic side by side for a while. There is never a definitive moment where you can say &quot;everyone is on the new version now, and no one is hitting the old one.&quot; In Blue/Green, the switch is binary — either 0% or 100%.</p><p><strong>Fast-Rollback</strong> — Undoing a RollingUpdate means running the same incremental process again, in reverse; until the old pods come back up, the broken version stays live. In Blue/Green, the old environment (blue) is kept warm, so going back is simply a matter of pointing traffic at it again — a single selector swap.</p><p><strong>Verification</strong> (validating before taking traffic) — In RollingUpdate, a new pod starts receiving live users the moment it passes its readinessProbe. But readiness only answers &quot;is the process up?&quot;, not &quot;does this version work correctly?&quot;. In Blue/Green, green is put through smoke tests and metric analysis via the preview — without a single real user ever seeing it — and only then does it take traffic.</p><p>Let’s make this concrete. During a rolling update, the Service sits in front of both the old (v1) and the new (v2) pods at the same time — they both carry the same app label, so the selector matches all of them. The Service spreads incoming requests across this mixed pool; even two consecutive requests from the same user can land on different versions.</p><p>Picture this: the user’s browser has loaded the new version of your frontend, and that UI calls a backend endpoint that only exists in v2. But the backend’s rollout isn’t finished yet — so if the request lands on a v1 pod that’s still up, that endpoint isn’t there → error. Not a single pod has crashed; the service is technically “up” (zero-downtime holds); yet that user just got a broken response.</p><p>That is exactly what the “version skew window” is: for the duration of the rollout, which request hits which version is unpredictable. In Blue/Green, this window never opens — the active Service points at exactly one version at any moment, and because the cutover goes from 0% to 100% in a single step, no request ever meets a half-updated pod group.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*53NCqdhhhjPkWChgRlBTGg.png" /><figcaption>Rolling Update | Blue/Green Deployment</figcaption></figure><h4>Same Cycle, different approaches</h4><h4>1. The RollingUpdate cycle</h4><p>When a Deployment is updated, the controller manages <strong>two ReplicaSets</strong> at once: the old (v1) and the new (v2). The cycle is governed by maxSurge and maxUnavailable (25%/25% by default). The steps repeat:</p><ol><li>Create a few new (v2) pods — it may go up to maxSurge above the desired count.</li><li>Wait until these new pods pass their readiness probe.</li><li>As soon as the new pods are Ready, take down the same number of old (v1) pods.</li><li>Repeat 1–3 until v2 = desired replicas and v1 = 0.</li></ol><p>The critical property of this cycle: <strong>throughout steps 1–4, v1 and v2 sit behind the same Service and receive live traffic simultaneously</strong> (both carry the same app label, so the selector matches both). In other words, version skew is not a side effect — it is the <strong>nature</strong> of the cycle, and it lasts for the entire roll (seconds to minutes, depending on pod count, startup time, and image pulls).</p><h4>2. The same cycle in Blue/Green</h4><p>With the blueGreen strategy, Argo Rollouts performs the same transition in a completely different order:</p><ol><li>The new (green) ReplicaSet comes up <strong>all at once, at full replica count</strong> — but the <strong>preview</strong> Service points at it, not the active one. Active still points at blue, at full capacity.</li><li>While the green pods are becoming Ready, live users never land on green. Version skew simply never happens for real traffic.</li><li>(Optional) verification via preview / prePromotionAnalysis — smoke tests, metric gates — still with zero user traffic.</li><li><strong>Promote = an atomic selector swap.</strong> The active Service’s selector flips from blue’s pod-hash to green’s. A single moment: 0% → 100%.</li><li>The old blue ReplicaSet stays on standby for scaleDownDelaySeconds (pods still running).</li><li>If needed, rollback = flip the selector back to blue → instant, because there is nothing to rebuild.</li><li>When the delay expires, blue scales down to 0.</li></ol><h4>Comparing the cycle phase by phase</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j_OJijLnIWehJxqm595pxA.png" /></figure><p>The same pattern shows up in every row: the RollingUpdate cycle preserves uninterrupted service but carries a “risk surface” in every phase (version skew, no atomic moment, no verification, slow rollback). Blue/Green arranges the same phases specifically to <strong>close</strong> those risk surfaces.</p><blockquote><strong><em>Cost: Compute.</em></strong><em> Blue/Green doesn’t hand out these guarantees for free. With RollingUpdate, peak pod count ≈ desired + </em><em>maxSurge (e.g. ~125%); old pods drain as new ones arrive, so </em><strong><em>two full environments never run at once</em></strong><em>. With Blue/Green, both full environments are up for the duration of the transition </em><strong><em>plus</em></strong><em> the </em><em>scaleDownDelaySeconds window — that is, </em><strong><em>~2× replicas</em></strong><em>. The cost is temporary (only the transition + standby window), but on large or expensive workloads it is real. The trade is clear: you buy &quot;no version skew + atomic cutover + instant rollback + pre-release verification&quot; at the price of &quot;~2× compute during the transition.&quot;</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GaZgZXmN2xPbMcON" /><figcaption>Photo by <a href="https://unsplash.com/@klarin_steffens?utm_source=medium&amp;utm_medium=referral">Klarin Steffens</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Demo Section</h4><p>In this section, assuming you already have a local Kubernetes setup that works for you, we’ll install Argo Rollouts and ArgoCD and create our GitLab repository. Then we’ll observe the B/G deployment process in action.</p><h4>1. Installing Argo Rollouts</h4><p>Let’s apply the Argo Rollouts manifest directly with kubectl:</p><pre>kubectl create namespace argo-rollouts<br>kubectl apply -n argo-rollouts -f https://github.com/argoproj/argo-rollouts/releases/latest/download/install.yaml</pre><p>Install the kubectl plugin (for macOS use -darwin-amd64/-darwin-arm64):</p><pre>curl -LO https://github.com/argoproj/argo-rollouts/releases/latest/download/kubectl-argo-rollouts-linux-amd64<br>chmod +x kubectl-argo-rollouts-linux-amd64<br>sudo mv kubectl-argo-rollouts-linux-amd64 /usr/local/bin/kubectl-argo-rollouts<br>kubectl argo rollouts version</pre><p>To access the Argo Rollouts UI:</p><pre># You can access from http://localhost:3100/rollouts<br>kubectl argo rollouts dashboard</pre><h4>2. Installing ArgoCD</h4><p>Let’s install ArgoCD with kubectl as well:</p><pre>kubectl create namespace argocd<br>kubectl apply -n argocd --server-side \<br>  -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml</pre><blockquote><strong><em>Why </em></strong><strong><em>--server-side?</em></strong><em> Client-side </em><em>kubectl apply writes the entire manifest it applies into the </em><em>last-applied-configuration annotation. ArgoCD&#39;s </em><em>applicationsets CRD is so large that this annotation exceeds Kubernetes&#39; 256 KB limit and you get a </em><em>metadata.annotations: Too long error. Server-side apply never writes that annotation, which eliminates the problem entirely.</em></blockquote><p>To reach the UI and grab the admin password:</p><pre># Port Forwarding<br>kubectl -n argocd port-forward svc/argocd-server 8080:443<br><br># Grab the admin password<br>kubectl -n argocd get secret argocd-initial-admin-secret \<br>  -o jsonpath=&quot;{.data.password}&quot; | base64 -d; echo</pre><h4>3. Creating the demo repository on GitLab</h4><p>Create a repository on GitLab (e.g. blue-green-release-management) with the following structure:</p><pre>blue-green-release-management/<br>└── deploy/<br>    ├── namespace.yaml<br>    ├── rollout.yaml<br>    └── services.yaml</pre><p>In this demo we’ll use Argo Project’s own demo application: argoproj/rollouts-demo.</p><p><strong>deploy/namespace.yaml</strong></p><pre>apiVersion: v1<br>kind: Namespace<br>metadata:<br>  name: demo</pre><p><strong>deploy/rollout.yaml</strong> — a Rollout instead of a Deployment. I&#39;m keeping the manifest close to production standards: both probes, resource requests/limits, a basic securityContext, and an immutable image tag (never latest).</p><pre>apiVersion: argoproj.io/v1alpha1<br>kind: Rollout<br>metadata:<br>  name: bluegreen-demo<br>  namespace: demo<br>spec:<br>  replicas: 3<br>  revisionHistoryLimit: 3<br>  selector:<br>    matchLabels:<br>      app: bluegreen-demo<br>  template:<br>    metadata:<br>      labels:<br>        app: bluegreen-demo<br>    spec:<br>      securityContext:<br>        runAsNonRoot: true<br>        seccompProfile:<br>          type: RuntimeDefault<br>      containers:<br>        - name: bluegreen-demo<br>          image: argoproj/rollouts-demo:blue<br>          ports:<br>            - containerPort: 8080<br>          resources:<br>            requests:<br>              cpu: &quot;50m&quot;<br>              memory: &quot;64Mi&quot;<br>            limits:<br>              cpu: &quot;200m&quot;<br>              memory: &quot;128Mi&quot;<br>          readinessProbe:<br>            httpGet:<br>              path: /<br>              port: 8080<br>            initialDelaySeconds: 5<br>            periodSeconds: 10<br>          livenessProbe:<br>            httpGet:<br>              path: /<br>              port: 8080<br>            initialDelaySeconds: 10<br>            periodSeconds: 15<br>          securityContext:<br>            allowPrivilegeEscalation: false<br>            capabilities:<br>              drop: [&quot;ALL&quot;]<br>  strategy:<br>    blueGreen:<br>      activeService: bluegreen-demo-active<br>      previewService: bluegreen-demo-preview<br>      autoPromotionEnabled: false<br>      scaleDownDelaySeconds: 30</pre><blockquote><strong><em>Note on </em></strong><strong><em>runAsUser:</em></strong><em> the </em><em>rollouts-demo image is built to run as root, so </em><em>runAsNonRoot: true alone would make the kubelet reject the container with </em><em>CreateContainerConfigError. Forcing a non-root UID with </em><em>runAsUser/</em><em>runAsGroup fixes it — a lesson worth knowing, since plenty of third-party images want root.</em></blockquote><p><strong>deploy/services.yaml</strong> — the heart of Blue/Green: two Services. Argo Rollouts injects the pod-hash into these Services&#39; selectors itself to route to the correct ReplicaSet; there&#39;s no hash in my manifest.</p><h4>4. Creating the ArgoCD Application manifest</h4><p>Let’s create the application.yaml that tells ArgoCD to watch this repo, and apply it manually:</p><pre>apiVersion: argoproj.io/v1alpha1<br>kind: Application<br>metadata:<br>  name: bluegreen-demo<br>  namespace: argocd<br>spec:<br>  project: default<br>  source:<br>    repoURL: https://gitlab.com/&lt;kullanıcı-adın&gt;/bluegreen-demo.git<br>    targetRevision: main<br>    path: deploy<br>  destination:<br>    server: https://kubernetes.default.svc<br>    namespace: demo<br>  syncPolicy:<br>    automated:<br>      prune: true<br>      selfHeal: true<br>    syncOptions:<br>      - CreateNamespace=true</pre><pre>kubectl apply -f application.yaml</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aqRiSCdsiIwXQePAuw8zww.png" /></figure><h4>5. Let’s See</h4><p>Within a few seconds, ArgoCD will pick up the repo, create the demo namespace, and apply the Rollout. Watch the status:</p><pre>kubectl argo rollouts get rollout bluegreen-demo -n demo --watch</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I2WtxpnshrGL2oaBOd3F0Q.png" /></figure><p>You should see Status: ✔ Healthy and a single revision (blue). Open the application through the active Service:</p><pre>kubectl -n demo port-forward svc/bluegreen-demo-active 8081:80</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jzOfn-yqPzA-cmV3p2datw.png" /></figure><p>Now let’s observe a Blue/Green deployment using the very core of GitOps.</p><p><strong>1. Change the image tag.</strong> Update the image value in deploy/rollout.yaml:</p><pre># image: argoproj/rollouts-demo:blue<br>image: argoproj/rollouts-demo:green</pre><p><strong>2. ArgoCD syncs.</strong> It detects the change and updates the Rollout. Argo Rollouts brings up the new (green) ReplicaSet.</p><ul><li><strong>Preview Service</strong> → <strong>green</strong> (the new version)</li><li><strong>Active Service</strong> → still <strong>blue</strong> (live users keep seeing blue)</li></ul><p>The Rollout enters the Paused state, because autoPromotionEnabled: false.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PWDw1ljoZbSbv7TvX4ACUg.png" /></figure><p><strong>3. Verify green through the preview</strong> — without putting live traffic at any risk:</p><pre>kubectl -n demo port-forward svc/bluegreen-demo-preview 8082:80<br># http://localhost:8082 → green dots (only you can see them for now)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NZTLLNwqo7fTldeJ4lL15A.png" /></figure><p><strong>4. Promote — the atomic cutover:</strong></p><pre>kubectl argo rollouts promote bluegreen-demo -n demo</pre><p>The active Service now points at green. :8081 turns green on the next refresh. Thanks to scaleDownDelaySeconds: 30, the old blue ReplicaSet stays up for another 30 seconds — that&#39;s the safety cushion that lets you roll back instantly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GbaI-OYHAYcJrHCDzQ5CLw.png" /></figure><h3>Conclusion</h3><p>Blue/Green is one of the safest strategies for critical services that need “instant cutover + instant rollback,” and it works without a traffic manager — which makes it an ideal place to start. Argo Rollouts makes the pattern declarative; ArgoCD anchors it in a GitOps flow; and GitLab serves as both the source of truth and the automation engine.</p><h4><strong>Repository</strong></h4><p><a href="https://gitlab.com/yagizkambak/blue-green-release-management">Sign in · GitLab</a></p><h4>If you would like to read my other articles</h4><ul><li><a href="https://yagizkucukkambak.medium.com/canary-release-management-w-gitops-e0713ca182d4">Canary Release Management w/GitOps</a></li><li><a href="https://yagizkucukkambak.medium.com/enhancing-terraform-with-terragrunt-0d0b66d590b1">Enhancing Terraform with Terragrunt</a></li><li><a href="https://yagizkucukkambak.medium.com/list/5fcb3c5d1180">GitOps 101</a></li></ul><h4><strong>References</strong></h4><ul><li>Kubernetes — Performing a Rolling Update (source of the opening quote)<br><a href="https://kubernetes.io/docs/tutorials/kubernetes-basics/update/update-intro/">https://kubernetes.io/docs/tutorials/kubernetes-basics/update/update-intro/</a></li><li>Kubernetes — Deployments (RollingUpdate, maxSurge/maxUnavailable)<br><a href="https://kubernetes.io/docs/concepts/workloads/controllers/deployment/">https://kubernetes.io/docs/concepts/workloads/controllers/deployment/</a></li><li>Argo Rollouts — BlueGreen Deployment Strategy<br> <a href="https://argo-rollouts.readthedocs.io/en/stable/features/bluegreen/">https://argo-rollouts.readthedocs.io/en/stable/features/bluegreen/</a></li><li>Argo Rollouts — Concepts<br><a href="https://argo-rollouts.readthedocs.io/en/stable/concepts/">https://argo-rollouts.readthedocs.io/en/stable/concepts/</a></li><li>Argo Rollouts — Kubectl Plugin &amp; Dashboard<br><a href="https://argo-rollouts.readthedocs.io/en/stable/features/kubectl-plugin/">https://argo-rollouts.readthedocs.io/en/stable/features/kubectl-plugin/</a></li><li>Argo Rollouts — Analysis &amp; Progressive Delivery (prePromotionAnalysis)<br><a href="https://argo-rollouts.readthedocs.io/en/stable/features/analysis/">https://argo-rollouts.readthedocs.io/en/stable/features/analysis/</a></li><li>Argo CD — Getting Started<br><a href="https://argo-cd.readthedocs.io/en/stable/getting_started/">https://argo-cd.readthedocs.io/en/stable/getting_started/</a></li><li>Argo CD — Declarative Setup (the Application manifest)<br><a href="https://argo-cd.readthedocs.io/en/stable/operator-manual/declarative-setup/">https://argo-cd.readthedocs.io/en/stable/operator-manual/declarative-setup/</a></li><li>Kubernetes — Server-Side Apply (background for the — server-side note)<br><a href="https://kubernetes.io/docs/reference/using-api/server-side-apply/">https://kubernetes.io/docs/reference/using-api/server-side-apply/</a></li><li>Demo application — argoproj/rollouts-demo<br><a href="https://github.com/argoproj/rollouts-demo">https://github.com/argoproj/rollouts-demo</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a64ef3c15a2a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Canary Release Management w/GitOps]]></title>
            <link>https://yagizkucukkambak.medium.com/canary-release-management-w-gitops-e0713ca182d4?source=rss-692abde0c1f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/e0713ca182d4</guid>
            <category><![CDATA[argo-cd]]></category>
            <category><![CDATA[argo-rollouts]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[gitops]]></category>
            <dc:creator><![CDATA[Yağız Küçükkambak]]></dc:creator>
            <pubDate>Sun, 08 Feb 2026 22:32:20 GMT</pubDate>
            <atom:updated>2026-02-08T22:32:20.848Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>This article is entirely based on how theoretical knowledge can be exemplified with a simple practical example. You can contact me for a more detailed discussion.</blockquote><p>In today’s world, where software development processes have reached a breakneck speed, even the smallest error in CI/CD pipelines can lead to critical business disruptions. It is no longer enough to simply say, “the code I developed works”; our primary focus is now on how this code reaches the end-user and the extent of the impact — the <strong>blast radius</strong> — should a failure occur.</p><p>In critical sectors such as Fintech, E-commerce, and SaaS, where the margin for error must be near zero, the need for modern deployment strategies to minimize risks is greater than ever. At this point, <strong>Canary Release</strong> stands out as one of the best solutions to meet this need.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KsDsT5Ez1vtl8hmd" /><figcaption>Image taken from Unsplash</figcaption></figure><h4>To Define Canary Release:</h4><p><strong>Canary Release</strong> is a gradual deployment strategy aimed at minimizing the risk of a new software version, taking its name from the canaries that miners used to carry underground to detect toxic gases in advance. The core logic is simple: we direct a very small percentage of production traffic to the new version. If everything is going well, we gradually increase the traffic; if we sense something is wrong (i.e., if the canary dies), we immediately roll the traffic back to the previous version.</p><h4>A Look Back at the Pre-GitOps Era</h4><p>Today, we can automate this process in seconds with tools like Argo Rollouts. However, before the GitOps approach and modern controllers entered our lives, this was more of a complicated and exhausting operational process than true automation.</p><ul><li><strong>Manual Load Balancer Management:</strong> Configuring Load Balancers (Nginx, HAProxy, F5) correctly while deploying new versions was critical. Manual rules were written to redirect 5% of the traffic, and in the event of an error, those same rules were frantically rolled back by hand.</li><li><strong>Balancing Ratios via Replica Counts:</strong> In the early years of Kubernetes, traffic splitting depended on how many pods were running for v1 vs. v2. For example, to send 10% of traffic to the new version, you would run 9 old pods and 1 new pod. This led to significant resource waste and made it impossible to achieve precise ratios like 1%.</li><li><strong>Splitting at the DNS Level:</strong> Sometimes, attempts were made to split traffic via DNS. However, due to DNS caching issues, it was nearly impossible to pull traffic back instantly during a failure. Waiting for users’ DNS records to refresh was not a viable approach.</li></ul><p>These human-dependent decision mechanisms, slow rollback operations, and unmanageable complexity turned the process into total chaos for teams. Now, leaving the past behind, let’s look at how we handle this process with <strong>Argo Rollouts</strong>.</p><h4>What is Argo Rollouts?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ui9osGMOLMtzIOV_LQAqqA.png" /></figure><p>Developed by the Argo Project, this solution is an advanced Kubernetes operator that modernizes standard deployment processes. It allows you to manage application updates using <strong>Canary</strong> or <strong>Blue/Green</strong> strategies and enables progressive delivery through automated analysis capabilities. While ArgoCD is not a requirement to use Argo Rollouts, combining the two offers a much more effective solution if you want to manage Canary Releases within <strong>GitOps</strong> principles and visualize the entire process end-to-end.</p><p>Then, let’s quickly perform the ArgoCD and Argo Rollouts installation on our Kubernetes clusters.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RqP2qgRHMwSk_oz_JdrK1w.png" /><figcaption>ArgoCD &amp; Argo Rollouts Installation</figcaption></figure><p>Now that we have access to the ArgoCD and Argo Rollouts interfaces, we can discuss how to update an application with a <strong>Canary Release</strong> strategy using an <strong>Abstract Helm Chart</strong>. As the first step, let’s create a workload.yaml <strong>template</strong> within the <strong>Helm Chart</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nnh5HLOaDsLaDhW6eB8QZQ.png" /><figcaption>templates/workload.yaml</figcaption></figure><p>This workload.yaml file will allow me to create a customized <strong>Canary Release</strong> for each application within my <strong>Helm Chart</strong>. For example, let&#39;s say I have a <strong>frontend</strong> service; the corresponding values.yaml content for this <strong>frontend</strong> service is as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TxzYr1MQTYXZ0zAhwlXysA.png" /><figcaption>values.yaml for nextjs-frontend</figcaption></figure><p>As for my <strong>backend</strong> services, my <strong>Canary Release</strong> management could be as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yOp8LuXtydh6lZ3gVJux7A.png" /><figcaption>values.yaml definition for .NET Application</figcaption></figure><p>You can achieve a much more detailed <strong>deployment</strong> process by expanding your <strong>Abstract Helm Chart</strong> with further <strong>templates</strong>. However, our primary goal in this article is to demonstrate how we perform a <strong>Canary Release</strong> via <strong>Argo Rollouts</strong>. Therefore, let’s quickly create our <strong>App of Apps pattern</strong> in <strong>ArgoCD</strong> and proceed with a <strong>deployment</strong> using <strong>Canary Release</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uPy_2MFoaVeLR9FAyDS67Q.png" /><figcaption>Root YAML file for App of Apps Pattern</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vhKPoKI-iUBqfIPIe2ghew.png" /><figcaption>Application definition for Backend Services</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OMgk8fohNZniaeOdFV0clw.png" /><figcaption>Application definition for Frontend Services</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LsDbPZ-MB4ZS1encv2BaiQ.png" /><figcaption>Application definition for NextJS Frontend Application</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sGeCX2bZtq56R2JfyuQ0jw.png" /><figcaption>Application definition for .NET Backend Application</figcaption></figure><p>Our <strong>App of Apps Pattern</strong> has reached the following structure:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/974/1*Nt8kySdPjZ6fOhDGE1S0pw.png" /></figure><p>To summarize the steps we have taken so far:</p><ul><li>We installed <strong>ArgoCD</strong> and <strong>Argo Rollouts</strong> on <strong>Kubernetes</strong>.</li><li>We connected our <strong>GitLab Repository</strong>, which contains our <strong>ArgoCD YAML</strong> files, to <strong>ArgoCD</strong> (assuming this step is already completed).</li><li>We created the structure through the <strong>ArgoCD UI</strong> by referencing the root.yaml file (alternatively, we could use the <strong>ArgoCD CLI</strong> with the argocd app create command).</li><li>We executed our <strong>CI/CD Pipeline</strong> in <strong>GitLab</strong> following the <strong>GitOps methodology</strong> and upgraded our <strong>Frontend</strong> application version from v1.0.0 to v1.0.1 (assuming this process is also finished).</li></ul><p>Now that the version has been upgraded, we can observe how this process appears on the <strong>Argo Rollouts Dashboard</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I_iqd75ilPiB110uciHbtg.png" /><figcaption>Argo Rollouts UI</figcaption></figure><p>Thus, we have successfully updated our application using the <strong>Canary Release</strong> method with <strong>ArgoCD</strong> and <strong>Argo Rollouts</strong>.</p><p>I hope this article helps you design secure and sustainable <strong>deployment</strong> processes in the <strong>GitOps</strong> world. I am sharing a sample <strong>Repository</strong> for you to examine the process mentioned in this post. Additionally, reading our <strong>GitOps 101</strong> article series may help you understand the processes here more deeply.</p><ul><li><a href="https://gitlab.com/yagizkambak/canary-release-mangement-with-gitops">Yağız Küçükkambak / Canary Release Mangement With Gitops · GitLab</a></li><li><a href="https://github.com/yagizkambak/canary-release-mangement-with-gitops">GitHub - yagizkambak/canary-release-mangement-with-gitops: This repository demonstrates a modern, scalable, and hierarchical &quot;App of Apps&quot; pattern using ArgoCD and Argo Rollouts for Canary Release deployments. It includes a NextJS frontend and two .NET backend services.</a></li><li><a href="https://yagizkucukkambak.medium.com/list/5fcb3c5d1180">GitOps 101</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e0713ca182d4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Enhancing Terraform with Terragrunt]]></title>
            <link>https://yagizkucukkambak.medium.com/enhancing-terraform-with-terragrunt-0d0b66d590b1?source=rss-692abde0c1f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/0d0b66d590b1</guid>
            <category><![CDATA[terragrunt]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[iac]]></category>
            <dc:creator><![CDATA[Yağız Küçükkambak]]></dc:creator>
            <pubDate>Wed, 05 Feb 2025 15:42:45 GMT</pubDate>
            <atom:updated>2025-02-05T15:42:45.594Z</atom:updated>
            <content:encoded><![CDATA[<h4>Keeping DRY and Dynamic</h4><h4>Introduction</h4><p>As the technology world rapidly progresses today, it has become inevitable for infrastructure management to be more efficient and automated. Traditional manual infrastructure setups not only cause time loss but also increase the risk of errors. This is where managing infrastructure as code comes into play. With <strong>IaC</strong>, infrastructure management can be easily automated.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7o38RtRBbUgpu2k3QMjjqg.png" /></figure><p>We also know that many different tools are available to implement this approach. For example, solutions provided by cloud providers such as <strong>CloudFormation</strong> in <strong>AWS</strong>, <strong>Azure Resource Manager</strong> in <strong>Azure</strong>, and <strong>Deployment Manager</strong> in <strong>GCP </strong>stand out, while <strong>cloud-agnostic</strong> options like <strong>Pulumi</strong>, <strong>Crossplane</strong>, and <strong>OpenTofu/Terraform</strong> are also commonly preferred. While each tool has its own unique advantages, this diversity can sometimes create challenges. Learning different solutions, creating separate definitions for each environment, and constantly dealing with code duplication can be exhausting for IT developers (SRE/DevOps/Cloud Engineers).</p><p><strong>In fact</strong>, our fundamental expectation is quite simple: To use a single tool that ensures infrastructure written once works consistently across different environments without code duplication and manages the entire process from a single code repository. Achieving this goal will simplify processes and help teams work faster and more effectively.</p><p>Among these tools, <strong>OpenTofu/Terraform</strong> is the most popular. However, the vanilla version of <strong>OpenTofu/Terraform </strong>unfortunately does not fully meet our expectations. But we can address this by using a small helper tool called <strong>Terragrunt</strong>. So, what is <strong>Terragrunt</strong>?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y3Gx3LzSCnSpYF7dsA_3Jw.png" /></figure><h4>What is Terragrunt?</h4><p><strong>Terragrunt</strong> is a flexible orchestration tool designed to scale Infrastructure as Code (IaC) with <strong>OpenTofu/Terraform</strong>. We can actually see that <strong>Terragrunt </strong>is different from the tools we mentioned earlier through this definition. Instead of providing IaC itself, it is designed as an orchestrator for <strong>OpenTofu/Terraform</strong>. In this case, we can easily say that the primary goal of <strong>Terragrunt </strong>is to extend the capabilities of <strong>OpenTofu/Terraform</strong>. Let’s briefly summarize what additional features <strong>Terragrunt </strong>brings to <strong>OpenTofu/Terraform</strong>:</p><ol><li><strong>DRY (Don’t Repeat Yourself) Principle</strong>: It reduces code duplication by defining common configurations once and reusing them across different environments and modules.</li><li><strong>Remote State Management</strong>: Simplifies the configuration and management of remote states, ensuring teams can collaborate effectively and maintain consistent infrastructure states.</li><li><strong>Dependency Management</strong>: Manages dependencies between modules, ensuring operations are carried out in the correct order and according to dependencies.</li><li><strong>Before and After Hooks</strong>: Allows you to run custom scripts or commands before or after running Terraform commands, providing flexibility in your infrastructure deployment process.</li><li><strong>Environment-Specific Configurations</strong>: This makes it easier to create environment-specific configurations (such as release, test, and production) using HCL (HashiCorp Configuration Language) interpolation, ensuring consistent environments are maintained.</li></ol><p>You can use the <a href="https://terragrunt.gruntwork.io/docs/getting-started/install/"><strong>documentation</strong></a><strong> </strong>for setting up <strong>Terragrunt</strong>. Please remember that <strong>OpenTofu/Terraform</strong> needs to be installed in order to use <strong>Terragrunt</strong>.</p><h4>Example Scenario</h4><p>After briefly discussing <strong>Terragrunt</strong> and its features, we can apply it through a simple example. Let’s say we want to set up a <strong>VPC </strong>on a cloud platform (for example, <strong>Google Cloud Platform</strong>) for our <strong><em>Test</em></strong>, <strong><em>Release</em></strong>, and <strong><em>Production </em></strong>environments. In that case, we first need to design the <strong>VPC</strong> module by creating a vpc folder inside a modules folder.</p><pre>└── modules/<br>    └── vpc/<br>        ├── main.tf<br>        ├── provider.tf<br>        └── variables.tf</pre><p>If we take a brief look at the files contained in our VPC module:</p><ol><li><strong>main.tf</strong>: This file includes the definitions of the resources (in this scenario, only the VPC) provided by the provider we are using.</li><li><strong>provider.tf</strong>: Here, we will define and configure the google provider for the <strong>Google Cloud Platform</strong>.</li><li><strong>variables.tf</strong>: In this file, we will define the variables to be used in both main.tf and provider.tf.</li></ol><p>We can start by designing the provider.tf file for our module. In this scenario, we mentioned that we would be using <strong>Google Cloud Platform</strong>. Therefore, we need to define the google provider here.</p><pre>terraform {<br>  required_providers {<br>    google = {<br>      source = &quot;hashicorp/google&quot;<br>      version = &quot;6.14.1&quot;<br>    }<br>  }<br>}<br><br>provider &quot;google&quot; {<br>  project = var.project_id<br>  region  = var.region<br>}</pre><p>In main.tf, let’s define the necessary configurations for the <strong>VPC</strong> by utilizing the resources provided by this provider.</p><pre>resource &quot;google_compute_network&quot; &quot;vpc_network&quot; {<br>  name                    = var.network_name<br>  auto_create_subnetworks = false<br>}<br><br>resource &quot;google_compute_firewall&quot; &quot;default&quot; {<br>  name    = &quot;${var.env}-gke-firewall&quot;<br>  network = google_compute_network.vpc_network.name<br>  source_tags = [&quot;medium-article-demo&quot;]  <br>  allow {<br>    protocol = &quot;icmp&quot;<br>  }<br>  allow {<br>    protocol = &quot;tcp&quot;<br>    ports    = [&quot;80&quot;, &quot;443&quot;]<br>  }<br>}<br><br>resource &quot;google_compute_subnetwork&quot; &quot;subnetwork&quot; {<br>  name          = var.subnetwork_name<br>  ip_cidr_range = var.subnetwork_cidr<br>  region        = var.region<br>  network       = google_compute_network.vpc_network.id<br>}</pre><p>After creating the provider.tf and main.tf files, we realize some attributes have undefined values. To assign values to these attributes, we used variables. However, for <strong>Terraform</strong> to recognize these variables, we first need to define them in a file. For this purpose, we should create the variables.tf file and define these variables in it.</p><pre>variable &quot;network_name&quot; {}<br>variable &quot;subnetwork_name&quot; {}<br>variable &quot;subnetwork_cidr&quot; {}<br>variable &quot;region&quot; {}<br>variable &quot;project_id&quot; {}<br>variable &quot;env&quot; {}</pre><p>Thus, we have created the template for our VPCmodule. You can further expand and customize this VPCmodule if desired. Now it’s time to incorporate <strong>Terragrunt</strong> into this scenario. We mentioned that we want to use this template across three different environments in our scenario. In that case, we should outline the following template for this scenario.</p><pre>└── environments/<br>    ├── test/<br>    │   └── vpc/<br>    │       └── terragrunt.hcl<br>    ├── release/<br>    │   └── vpc/<br>    │       └── terragrunt.hcl<br>    └── production/<br>        └── vpc/<br>            └── terragrunt.hcl</pre><p><strong>Terragrunt </strong>is used with files that have an HCL extension. Since we will use three different environments in this scenario, each environment may have different VPCconfigurations. Therefore, we need to create separate terragrunt.hcl files for each environment, where we can define the corresponding values for the variables assigned to the attributes.</p><pre>terraform {<br>  source = &quot;&lt;your-vpc-module-path&gt;&quot;<br>}<br><br>inputs = {<br>  network_name    = &quot;medium-article-dev-vpc&quot;<br>  subnetwork_name = &quot;medium-article-dev-subnet&quot;<br>  subnetwork_cidr = &quot;10.1.0.0/16&quot;<br>  region = &quot;us-west1&quot;<br>  zone = &quot;us-west1-b&quot;<br>  project_id = &quot;your-google-project-id&quot;<br>  env = &quot;development&quot;<br>}</pre><p>By updating these configurations for each environment, we can now create VPCs in our desired regions for projects within the GCP environment.</p><p>The <strong>CLI</strong> commands for <strong>Terraform</strong> and <strong>Terragrunt</strong> are similar. However, you cannot use <strong>Terraform CLI</strong> commands with <strong>Terragrunt</strong>. Therefore, to use <strong>Terragrunt</strong>, you need to initiate processes using its own CLI commands. In the directory corresponding to the environment where you want to operate (e.g., <strong>environments/development/vpc</strong>), you can run the following commands to use <strong>Terragrunt</strong>.</p><pre>$ terragrunt plan<br>$ terragrunt apply</pre><p>If you want to run it without navigating to the relevant directory, you can use it as shown below.</p><pre>$ terragrunt run-all plan --terragrunt-include-dir .\environments\development\vpc<br>$ terragrunt run-all apply --terragrunt-include-dir .\environments\development\vpc</pre><p><strong>Bonus:</strong> If you want to run the VPCs for all environments at once without navigating to the relevant directories, you can use the following command.</p><pre>$ terragrunt run-all plan --terragrunt-include-dir .\environments\**\vpc<br>$ terragrunt run-all apply --terragrunt-include-dir .\environments\**\vpc</pre><h4>Conclusion</h4><p>To sum up, managing infrastructure as code has become essential for driving automation and minimizing human errors in modern IT environments. Many tools have been developed and are used both by cloud providers and third-party providers. However, learning and developing so many tools often results in additional costs for <strong>DevOps/SRE</strong> developers who push these processes forward. At this point, the use of orchestrator tools that can enhance the capabilities of a de facto product is crucial from a cost management perspective. <strong>By adopting the DRY code principle</strong>, <strong>managing dependencies, and ensuring consistent environments, Terragrunt enables OpenTofu/Terraform to be used more effectively and dynamically.</strong> As infrastructure complexity increases, using orchestration tools like <strong>Terragrunt</strong> will be a critical factor in simplifying management processes and ensuring the long-term success of IT teams.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0d0b66d590b1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GitOps 101 — Deployment and Results (Part 5)]]></title>
            <link>https://yagizkucukkambak.medium.com/gitops-101-deployment-and-results-part-5-cf0cd50ef690?source=rss-692abde0c1f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/cf0cd50ef690</guid>
            <category><![CDATA[gitops]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Yağız Küçükkambak]]></dc:creator>
            <pubDate>Fri, 13 Jan 2023 14:32:37 GMT</pubDate>
            <atom:updated>2024-07-17T14:48:24.041Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>GitOps 101 — Deployment and Results (Part 5)</strong></h3><blockquote>This series was written by Alper Peker and Yağız Küçükkambak</blockquote><p>In our previous article, we mentioned how <strong>ArgoCD </strong>applications can be created and briefly the <strong>App of Apps</strong> pattern. Now it’s time to define the <strong>deploy job</strong> definition, which is the last part of our <strong>CI/CD</strong> step, and see the results of an <strong>end-to-end</strong> <strong>GitOps </strong>approach.</p><p>First, let’s complete the last step of our <strong>CI/CD</strong> Pipeline. In the deploy job process, we expect that the information of our new <strong>docker </strong>image created in the pipeline <strong>should be added</strong>/<strong>updated </strong>in the <strong>ArgoCD </strong>repository, which also contains the <strong>manifests </strong>of <strong>ArgoCD</strong>. So our <strong>deploy </strong>script will consist of a series of <strong>bash </strong>and <strong>git</strong> commands.</p><p>The definition for <strong>Image </strong>was on <strong>“deployment.yaml”</strong>. We should add the definition of the current version and push the line of the image on this file to the <strong>ArgoCD </strong>repository.</p><pre>deploy-job:      <br>  stage: deploy  <br>  image:<br>    name: alpine/git:latest<br>    entrypoint: [&quot;&quot;]<br>  variables:<br>    DOCKER_REGISTRY: $CI_REGISTRY<br>    DOCKER_IMAGE_URI: &quot;${DOCKER_REGISTRY}/${CI_PROJECT_PATH}/${CI_COMMIT_REF_SLUG}&quot;<br>  needs:<br>    - job: docker<br>      artifacts: false<br>  before_script:<br>    - export DOCKER_IMAGE_TAG=${CI_COMMIT_TAG:=&quot;${CI_COMMIT_SHORT_SHA}&quot;}<br>  script:<br>    - git clone --depth 1 https://gitlab-ci-token:${CI_JOB_TOKEN}@${CI_SERVER_HOST}/***/gitops-argo-cd.git<br>    - IMAGE=&quot;${DOCKER_IMAGE_URI}:${DOCKER_IMAGE_TAG}&quot;<br>    - DEPLOYMENT_FILE=&quot;gitops-argo-cd/charts/gitops-react-app/deployment.yaml&quot;<br>    - &#39;sed -i &quot;s#image: .*#image: $IMAGE#&quot; $DEPLOYMENT_FILE&#39;<br>    - cd gitops-argo-cd<br>    - git config user.email &quot;***@***.com&quot;<br>    - git config user.name &quot;CI Automation Bot&quot;<br>    - git commit -am &quot;app updated to version:${CI_COMMIT_SHORT_SHA}&quot;<br>    - git remote set-url origin https://gitlab-ci-token:$PAT_TOKEN@$CI_SERVER_HOST/***/gitops-argo-cd.git<br>    - git push</pre><p>After the <strong>deploy job </strong>definition runs, the line for the <strong>image </strong>definition in the <strong>“deployment.yaml”</strong> file should have changed in the repository where the <strong>Kubernetes manifest files </strong>of the application are located.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/991/1*AQ1OMtIEUxm6QVyVhMZ8_w.png" /><figcaption>ArgoCD Manifest Repository Update</figcaption></figure><p>Now that we have completed the<strong> deploy-job </strong>definition, we can now observe a summary of an <strong>end-to-end GitOps</strong> approach. First, let’s look at the final version of our <strong>“React Application”</strong> repository:</p><pre>├── .gitignore<br>├── .gitlab-ci.yml<br>├── Dockerfile<br>├── README.md<br>├── package-lock.json<br>├── package.json<br>├── public<br>└── src<br>    ├── App.css<br>    ├── App.js<br>    ├── App.test.js<br>    ├── index.css<br>    ├── index.js<br>    ├── logo.svg<br>    ├── reportWebVitals.js<br>    └── setupTests.js</pre><p>We created and added the <strong>“.gitlab-ci.yml”</strong> file to our <strong>“React Application”</strong> so that our <strong>CI/CD</strong> pipeline could run, and the <strong>“Dockerfile”</strong> file to create the <strong>Docker image</strong>. When you look at the <strong>CI/CD -&gt; Pipelines</strong> section from the <strong>GitLab </strong>menu, our pipeline will appear as formed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*N5cjowuvTdzL9T59io69lw.png" /></figure><p>Then we created our repository containing the manifest files that will run on <strong>ArgoCD</strong>. There are <strong>manifest files </strong>required for <strong>ArgoCD </strong>deployments in our “<strong>apps</strong>” folder, and thanks to these <strong>manifest</strong> <strong>files</strong>, we direct to <strong>Kubernetes manifest files </strong>of our applications. There were <strong>Kubernetes manifest</strong> files in the “<strong>gitops-react-app</strong>” folder in the “<strong>charts</strong>” folder to which we were redirecting. <strong>ArgoCD</strong> will <strong>pull</strong> these files from the repository and start the <strong>apply</strong>/<strong>replace </strong>operation in <strong>Kubernetes</strong>.</p><pre>├── apps<br>│   ├── app-of-apps.yaml<br>│   └── projects<br>│       └── gitops-react-app.yaml<br>└── charts<br>    └── gitops-react-app<br>        ├── autoscaler.yaml<br>        ├── configmap.yaml<br>        ├── credentials.yaml<br>        ├── deployment.yaml<br>        ├── ingress.yaml<br>        ├── kustomization.yaml<br>        ├── secret.yaml<br>        └── service.yaml</pre><p>After the processes are completed, we can see our application with the <strong>App of Apps</strong> pattern on <strong>ArgoCD</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*dXU1pkGP717bqi3mZFxfxg.png" /><figcaption>gitops-react-app on ArgoCD</figcaption></figure><p>In this series of articles, <strong>we tried to explain how we can create and use GitOps, one of the DevOps approaches, at a basic level.</strong> You can access the repository we created in this series on <strong>GitHub</strong>. In addition to this series of articles, you can also access our article about <strong>ArgoCD</strong>. Thank you for reading our articles.</p><p>You can access the repository of the sample application here:</p><ul><li><a href="https://github.com/yagizkambak/gitops-react-app">GitHub - yagizkambak/gitops-react-app: This repository was created by Alper Peker and Yağız Küçükkambak for the GitOps101 article series we created on Medium.</a></li><li><a href="https://github.com/yagizkambak/gitops-argo-cd">GitHub - yagizkambak/gitops-argo-cd: This repository was created by Alper Peker and Yağız Küçükkambak for the GitOps101 article series we created on Medium.</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cf0cd50ef690" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GitOps 101 — App of Apps Pattern on ArgoCD (Part 4)]]></title>
            <link>https://yagizkucukkambak.medium.com/gitops-101-app-of-apps-pattern-on-argocd-part-4-4a702b2f0353?source=rss-692abde0c1f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/4a702b2f0353</guid>
            <category><![CDATA[gitops]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Yağız Küçükkambak]]></dc:creator>
            <pubDate>Fri, 13 Jan 2023 13:47:25 GMT</pubDate>
            <atom:updated>2024-07-17T14:48:08.289Z</atom:updated>
            <content:encoded><![CDATA[<h3>GitOps 101 — App of Apps Pattern on ArgoCD (Part 4)</h3><blockquote>This series was written by Alper Peker and Yağız Küçükkambak</blockquote><p>In our previous article, we explained how to create the necessary manifest files for our <strong>“React Application” </strong>to be deployed via <strong>ArgoCD</strong>. In this article, we will explain that we will create the <strong>manifest files</strong> of the <strong>“React Application”</strong> to be created for <strong>ArgoCD</strong>. While applying these manifest files, we will apply the <strong>ArgoCD pattern</strong>, <strong>the App of Apps pattern</strong>, and we will explain this pattern at a <strong>basic level</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9bILAW83TkpbnIGl.png" /></figure><p>First of all, we need to answer the question of what these <strong>manifest files</strong> do. These manifest files in <strong>YAML </strong>format contain information on how the application will be located on <strong>ArgoCD</strong>. <strong>ArgoCD</strong> runs these manifest definitions and sends deployment instructions to <strong>Kubernetes</strong>.</p><p>The <strong>App of Apps</strong> pattern, on the other hand, is a managerial approach where we gather your applications under a single application. It will be easier and more understandable for the person who will manage the applications to collect the <strong>microservices </strong>of your application within the framework of such a <strong>pattern</strong>. To make a hierarchy, we need to reference all applications with a <strong>manifest root file</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EKtF4-OY_7ePMhRv.png" /><figcaption>App of Apps Pattern Example</figcaption></figure><p>In the manifest file, <strong>we refer to the applications</strong>, we need to<strong> define the</strong> <strong>metadata </strong>of the application that is the root and <strong>the specs of this root application</strong>. There are definitions such as where the application should be deployed, what are the <strong>sync policies</strong>, which directory the<strong> manifest files </strong>of the applications are in, etc. in this <strong>root manifest</strong> <strong>file</strong>.</p><pre>apiVersion: argoproj.io/v1alpha1<br>kind: Application<br>metadata:<br>  name: app-of-apps<br>  namespace: argocd<br>spec:<br>  destination:<br>    server: https://kubernetes.default.svc<br>    namespace: argocd<br>  project: gitops # you can change the project name<br>  source:<br>    path: applications-manifest-folder-path<br>    repoURL: https://gitlab.com/group/subgroup-if-any/gitops-argo-cd.git<br>    targetRevision: HEAD<br>  syncPolicy:<br>    automated:<br>      prune: true<br>      selfHeal: true<br>      allowEmpty: true</pre><p>With the definitions we made in the <strong>root manifest</strong>, we have referred to the directory where the <strong>manifests </strong>of the <strong>applications </strong>are located. Now let’s create our application<strong> manifest file</strong> and make the necessary definitions for the <strong>“React Application”</strong>.</p><pre>apiVersion: argoproj.io/v1alpha1<br>kind: Application<br>metadata:<br>  name: gitops-react-app<br>spec: <br>  destination:<br>    namespace: gitops<br>    server: https://kubernetes.default.svc<br>  project: gitops<br>  source:<br>    path: charts/gitops-react-app<br>    repoURL: &#39;https://gitlab.com/devops-obss/demos/gitops-argo-cd.git&#39;<br>    targetRevision: HEAD<br>  syncPolicy:<br>    automated:<br>      prune: true<br>      selfHeal: true<br>      allowEmpty: true<br>    syncOptions:<br>      - CreateNamespace=true</pre><p>The biggest <strong>difference </strong>in our <strong>application manifest</strong>, which contains a <strong>similar </strong>structure to the root manifest, is that the directory where we define the path refers to the <strong>Kubernetes manifest YAML files </strong>we created in our previous article. In this way, <strong>ArgoCD </strong>starts the deployment process by receiving the <strong>manifest files </strong>at the referenced points.</p><p>You can implement the <strong>App of Apps pattern</strong> through the <strong>UI </strong>and the <strong>ArgoCD CLI</strong>. You can execute the following command on the <strong>CLI</strong> to create the application:</p><pre>argocd app create -f root.yaml</pre><p>After executing the command, applications will be created automatically on <strong>ArgoCD UI</strong>. If you define <strong>sync policies correctly</strong>, applications on <strong>Kubernetes </strong>will start the <strong>automatic deployment </strong>process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e5GgffgyBXD12FdWfMwEpg.png" /><figcaption>ArgoCD output with App of Apps Pattern</figcaption></figure><p>In our next article, we will define a <strong>deploy job </strong>in our <strong>CI/CD</strong> structure so that the <strong>GitOps </strong>system can work, and after this definition, we will observe how an <strong>end-to-end GitOps </strong>solution works together with the results. Thanks for reading our article.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4a702b2f0353" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GitOps 101– Create the CI/CD for GitOps (Part 2)]]></title>
            <link>https://yagizkucukkambak.medium.com/gitops-101-create-the-ci-cd-for-gitops-part-2-672ea174c27?source=rss-692abde0c1f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/672ea174c27</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[gitops]]></category>
            <dc:creator><![CDATA[Yağız Küçükkambak]]></dc:creator>
            <pubDate>Fri, 13 Jan 2023 07:00:25 GMT</pubDate>
            <atom:updated>2024-07-17T14:47:52.432Z</atom:updated>
            <content:encoded><![CDATA[<h3>GitOps 101<strong>– Create the CI/CD Pipeline (Part 2)</strong></h3><blockquote>This series was written by Alper Peker and Yağız Küçükkambak</blockquote><p>In this series, we will create the <strong>CI/CD</strong> pipeline structure to achieve the <strong>GitOps </strong>approach. As we mentioned in our previous article, we chose to develop a “<strong>React Application”</strong>, use <strong>GitLab</strong> as a development environment, <strong>Kubernetes </strong>as a deployment environment, and <strong>ArgoCD </strong>tool for the <strong>GitOps </strong>approach.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2LLfH9f9IXFth2S-" /><figcaption>Photo by <a href="https://unsplash.com/@timelabpro?utm_source=medium&amp;utm_medium=referral">Timelab Pro</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>In order to deploy a <strong>“React Application”</strong> into the <strong>Kubernetes </strong>environment, the code must be compiled and dockerized. For this reason, we need a <strong>build stage </strong>to compile our code, an <strong>image stage </strong>to dockerize, and a deploy stage to allow <strong>ArgoCD </strong>to update our deployment. Then we can write these steps as stages when creating our <strong>“.gitlab-ci.yml” </strong>file.</p><pre>stages:<br>  - build<br>  - image<br>  - deploy</pre><blockquote><strong>Note: </strong>In the <strong>image stage</strong>, you can compile your project in the <strong>Dockerfile </strong>file you will use and create the docker image <strong>if you want.</strong> In this way, you can also make an edit <strong>consisting of only Image and Deploy stages</strong>.</blockquote><p>First of all, Our <strong>“React Application”</strong> in the repository at the <strong>build stage </strong>should be able to compile without errors, and the output artifacts must be kept. Therefore, the necessary npm packages should be installed first and then the build script should run. (These are defined in the <strong>package.json</strong> file). We also need to make a definition for the output artifacts of the build script. <strong>We will use these stored artifacts in the image stage in our Dockerfile.</strong></p><pre>build-job:<br>  stage: build<br>  image: node:14.17-alpine<br>  script:<br>    - npm install<br>    - npm run-script build<br>  artifacts:<br>    when: on_success<br>    paths:<br>    - &quot;build&quot;<br>    - &quot;public&quot;</pre><blockquote><strong>Note:</strong> We <strong>recommend </strong>adding a condition for the build job to create the artifacts folders only on a successful build as they may have already been created or they may contain old artifacts. Defining only the directories containing only the required files <strong>reduces the artifacts’ size and the time spent</strong> in the pipeline.</blockquote><p>After the aforementioned <strong>“React Application”</strong> is successfully compiled and the artifacts are created, we can move on to our next stage, the <strong>Image stage</strong>. We will create an image in accordance with the naming convention we have set with the help of<strong> docker-cli </strong>commands from the <strong>Dockerfile </strong>file, which is used to produce a container image (containing our application), on the<strong> image stage.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5BhQf5uSdNB8cxRI" /></figure><p>To make this step wait for the <strong>build process</strong>, we can add the completion of the <strong>build job, as a requirement.</strong> Then, we add the necessary condition to our job’s <em>needs</em> section to make it use the artifacts created in the build stage. We need various information when we build our Docker image and upload it on “<strong>GitLab Registry</strong>”. We should set this information in a job as a variable.</p><blockquote><strong>Note: </strong>If you are doing this work in <strong>GitLab</strong>, you may not want to keep sensitive information in the pipeline. In such cases, you can define a variable in the <strong>CI/CD</strong> section of the repository setting and prevent these variables from appearing in the job’s output. In addition, if you are going to run <strong>GitLab Runner</strong> on a <strong>Docker Container</strong>, <strong>the dind (docker in docker)</strong> service must be defined, for <strong>Docker </strong>commands to run.</blockquote><pre>docker:<br>  stage: package<br>  image: docker:stable<br>  needs:<br>    - job: build-job<br>      artifacts: true<br>  variables:<br>    DOCKER_BUILD_DIR: &quot;.&quot;<br>    DOCKER_BUILD_FILE: &quot;Dockerfile&quot;<br>    DOCKER_HOST: tcp://docker:2375<br>    DOCKER_TLS_CERTDIR: &quot;&quot;<br>    DOCKER_USER: $CI_REGISTRY_USER<br>    DOCKER_PASSWORD: $CI_REGISTRY_PASSWORD<br>    DOCKER_REGISTRY: $CI_REGISTRY<br>    DOCKER_IMAGE_URI: &quot;${DOCKER_REGISTRY}/${CI_PROJECT_PATH}/${CI_COMMIT_REF_SLUG}&quot;<br>  services:<br>    - name: docker:20.10.16-dind<br>      entrypoint: [&quot;dockerd-entrypoint.sh&quot;, &quot;--tls=false&quot;]<br>  before_script:<br>    - export DOCKER_IMAGE_TAG=${CI_COMMIT_TAG:=&quot;${CI_COMMIT_SHORT_SHA}&quot;}<br>  script:<br>    - docker login -u $DOCKER_USER -p $DOCKER_PASSWORD $DOCKER_REGISTRY<br>    - |<br>      docker build -t &quot;${DOCKER_IMAGE_URI}:${DOCKER_IMAGE_TAG}&quot; -f &quot;${DOCKER_BUILD_DIR}/${DOCKER_BUILD_FILE}&quot; ${DOCKER_BUILD_DIR}<br>      docker push &quot;${DOCKER_IMAGE_URI}:${DOCKER_IMAGE_TAG}&quot;</pre><p>Since we store the output of the code compiled at the <strong>build stage </strong>as artifacts, defining the base image in the <strong>Dockerfile </strong>and copying these artifacts to the right place will be sufficient.</p><pre>FROM nginx:alpine<br>COPY /build/* /usr/share/nginx/html/</pre><p>When the image stage is completed, a ready-to-use <strong>docker image</strong> should be created.</p><p>Before moving on to the deployment stage, we need to see how this structure is created on <strong>ArgoCD </strong>and how the relevant <strong>ArgoCD </strong>repository is designed, in order to better understand the job specific definitions we will make in this stage.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*B1sPpUY-4zzYKReg" /><figcaption>Photo by <a href="https://unsplash.com/@frederikloewer?utm_source=medium&amp;utm_medium=referral">Frederik Löwer</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>In our next article, we will explain how to create our <strong>Kubernetes YAML</strong> files for our “<strong>React Application”, </strong>which will be used in the deployment stage. Thanks for followings us.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=672ea174c27" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GitOps 101— Introduction (Part 0)]]></title>
            <link>https://yagizkucukkambak.medium.com/gitops-101-introduction-part-0-1b0c06887194?source=rss-692abde0c1f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/1b0c06887194</guid>
            <category><![CDATA[gitops]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Yağız Küçükkambak]]></dc:creator>
            <pubDate>Wed, 11 Jan 2023 18:11:29 GMT</pubDate>
            <atom:updated>2024-07-17T14:47:33.623Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>This series was written by Alper Peker and Yağız Küçükkambak</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*MStkZ4JJqDiyhcMC.png" /><figcaption>This image is taken from AWS</figcaption></figure><p><em>Before we get into </em><strong><em>GitOps</em></strong><em>, we need to explain what </em><strong><em>DevOps </em></strong><em>is and why we need </em><strong><em>DevOps</em></strong><em>.</em></p><h3>What is DevOps?</h3><p><strong>DevOps </strong>is simply the cultural philosophy that automates software development lifecycle processes among IT teams when developing software products. <strong>DevOps </strong>ensures healthy communication and collaboration among the IT team in an organization. Adopting this cultural philosophy, DevOps does not hesitate to take advantage of 3rd party products (<strong>GitLab</strong>, <strong>GitHub</strong>, <strong>Jenkins</strong>, <strong>Terraform</strong>, etc.). <strong>DevOps </strong>approach can be used in on-premises and cloud environments (such as <strong>AWS</strong>, <strong>Azure</strong>, and <strong>GCP</strong>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*__tYyExLKRuwspdR.jpg" /></figure><h3>So why should we use DevOps?</h3><p>With the increasing number of products in recent years, the concepts that are priorities in many companies have started to come to the fore as <strong>stability</strong>, <strong>continuity</strong>, and <strong>speed</strong>. With this situation, an ideal environment for <strong>DevOps </strong>has been created in companies. According to data fro <a href="https://inthecloud.withgoogle.com/hbr-report-19/dl-cd.html"><strong>Google</strong></a>, 77% of organizations adopt the <strong>DevOps </strong>approach for their deployment processes or plan to use it soon. <strong>DevOps </strong>approach appears to be a game-changer for companies at this point.</p><h3>What is GitOps? What is the difference between DevOps?</h3><p>After the <strong>DevOps</strong> approach was adopted so quickly, new concepts began to emerge within <strong>DevOps</strong>. Like <strong>DevSecOps </strong>when security is involved, and <strong>MLOps </strong>when machine learning is involved. One of these concepts is <strong>GitOps</strong>. <strong>GitOps </strong>is a <strong>DevOps </strong>approach used for application development such as <strong>version control</strong>, <strong>collaboration</strong>, <strong>compliance</strong>, and <strong>CI/CD</strong> tooling, and applies them to infrastructure automation. This approach is based on the idea that all process management can be controlled by <strong>Git</strong>. This allows for <strong>better collaboration</strong> and <strong>faster coordination </strong>between teams and results in fewer errors and problems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LbLg9sihIUZW1exB_oZJKA.png" /></figure><p>Although <strong>GitOps</strong> provides the entire workload datum using <strong>Git</strong>, 3rd party tools are used for deployment processes. Two of the most heard from these 3rd party tools are <strong>ArgoCD </strong>and <strong>FluxCD</strong>. Being an application distribution tool based on <strong>Git</strong>, these applications automatically deploy and control the application resources available in their corresponding <strong>Git </strong>repositories. In this way, when application developers change their code, these products <strong>automatically detect </strong>these changes and distribute the updated applications. Applications such as <strong>ArgoCD </strong>and <strong>FluxCD </strong>make it easy to deploy <strong>Kubernetes-based</strong> applications.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Pc1SR7NJFq5xdf5wC8wlLw.png" /></figure><p>After making a brief introduction to <strong>GitOps</strong>, one of the <strong>DevOps </strong>approaches, we will continue by creating an <strong>end-to-end</strong> <strong>GitOps </strong>process in our next article. Thanks for reading.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1b0c06887194" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bir Mesaj Broker Sistemi: RabbitMQ]]></title>
            <link>https://yagizkucukkambak.medium.com/bir-mesaj-broker-sistemi-rabbitmq-e087bf5be393?source=rss-692abde0c1f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/e087bf5be393</guid>
            <category><![CDATA[message-broker]]></category>
            <category><![CDATA[rabbitmq]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Yağız Küçükkambak]]></dc:creator>
            <pubDate>Thu, 30 Sep 2021 14:08:52 GMT</pubDate>
            <atom:updated>2024-11-17T07:59:35.352Z</atom:updated>
            <content:encoded><![CDATA[<h3>Bir Message Broker Sistemi: RabbitMQ</h3><p>Selamlar herkese,</p><p>Bu yazımda RabbitMQ’ya basit bir giriş yapmaya çalışacağım. Öncelikle RabbitMQ’nun basitçe bir tanımını yapacak olursak, açık kaynak kodlu (open-source) bir mesaj kuyruk sistemidir. Erlang dilinde yazılan RabbitMQ, başlarda her ne kadar mesajlaşma sistemlerinde kullanılmak için geliştirildiyse de zaman içerisinde uygulamaların ölçeklerinin büyümesi, istek (request) yoğunluğunun artması ve bu isteklere verilen cevap (response) sürelerinin uzaması kaynaklı hizmetlerin aksamaması için tercih edilmeye başlanmıştır. Bankacılık sektöründen, sigortacılık sektörüne, sigortacalık sektöründen e-ticaret sektörüne kadar bir çok alanda geliştirilen ve yoğun trafik alan çeşitli projelerde RabbitMQ ve alternatiflerinin kullanıldığını gözlemlemekteyiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/725/1*7e4oQkig0t_45ql2Dlc0Pg.png" /></figure><p>Peki RabbitMQ nasıl çalışmaktadır? RabbitMQ yapısında Redis’te olduğu gibi bir <strong>Publisher/Subscriber</strong> yapısı mevcuttur. RabbitMQ’da Publisher konumunda Producer ve Subscriber konumunda Consumer vardır. Producer ile Consumer arasında bir RabbitMQ broker’ı çalışır. Producer tarafından iletilen veri öncelikle bu broker’da kendisinin bağlı olduğu Exchange Type’a ulaşır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E3Num5ZHzZIc3s914JB_2g.png" /><figcaption><em>Producer sadece bir Exchange Type’a bağlanabilir.</em></figcaption></figure><p>İletilecek veride tanımlanan binding key ile kuyruğa gidecek binding key eşleştiği takdirde veri kuyruğa aktarılır. Kuyruklar FIFO(First In First Out) yapısında çalışmaktadır. Bağlı oldukları Consumer ya da Consumer’lara bu kurala göre veri aktarımını sağlarlar. RabbitMQ’ya ait Exchange Type’ları biraz inceleyelim. RabbitMQ, Redis ve Kafka’nın aksine kendine ait 3 farklı Exchange Type çözümü kullanmaktadır. Bunlar:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3iOU_KtuOauYCs8O06HBBg.png" /><figcaption><strong>RabbitMQ Çalışma Yapısı</strong></figcaption></figure><p><strong>Direct Exchange:</strong> Producer tarafından iletilen veride bir routing key mevcuttur. Direct Exchange ile bu veri routing key’i eşleşen ilgili kuyruğa veriyi aktarır ve kuyruk bağlı olduğu Consumer’a veriyi iletilir. Alttaki diyagramdaki örneği inceleyecek olursak bir Producer tarafından gönderilen verinin routing key tanımı mevcut ve bu veri direct exchange metodu ile iletilmek istenmektedir. Bu key tanımı ile eşleşen kuyruk yapısı veriyi alır ve kendisine bağlı olan Consumer’a bu veriyi aktarır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XC6PsW-fyRyRmbLgs0uvFQ.png" /><figcaption>Direct Exchange Diagram</figcaption></figure><p><strong>Topic Exchange: </strong>Producer tarafından iletilen veride amaç, verinin bir veya birden fazla kuyruğa gitmesidir. Routing key ile işeleşen pattern’ler ile veri ilgili kuyruğa aktarılır. Eğer ilgili veri birkaç Consumer’ı ilgilendiriyorsa bu metod en uygun kullanım olacaktır. İlgili diyagram incelenecek olursa Producer tarafından iletilen veriye ait routing key pattern’inde 3 farklı katman mevcut ve bu topic exchange metodu ile aktarılmak isteniyor. Bu pattern ile eşleşen iki farklı kuyruk mevcuttur. Bu iki kuyruğun ortak özelliği spesifik biçimde tanımlanan katmanları dışındaki katmanlarda herhangi bir tanıma izin vermeleridir. Verinin iletilemediği kuyrukta ise üçüncü katmanda belirtilen “<strong>new</strong>” pattern’inden dolayı veriye ait routing key eşleşmemekte ve bu kuyruk yapısına veri aktarılamamaktadır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A-KzyHa_w1HeCZb_3QHNRQ.png" /><figcaption>Topic Exchange Diagram</figcaption></figure><p><strong>Fanout Exchange: </strong>Daha çok broadcast yayınlar için kullanılan bir exchange tipidir. Routing Key kullanılmaz. Producer tarafından gönderilen veri, Exchange Type’a bağlı olan kuyruklara iletilir ve kuyruk da bağlı olduğu Consumer’a bu veriyi iletilir. Aşağıdaki diyagramdaki örnekte de görüldüğü gibi veriye ait bir routing key tanımı mevcut olmadığı için fanout exchange’e bağlı olan tüm kuyruklar veriyi alır ve kendilerine bağlı olan Consumer’a veriyi aktarır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IN4S5k5z6ZJWAiakpOiGZw.png" /><figcaption>Fanout Exchange Diagram</figcaption></figure><p>RabbitMQ’nun çalışma yapısını online olarak simule etmek isterseniz <a href="http://tryrabbitmq.com/"><strong>tryrabbitmq</strong></a> simülatörünü kullanabilirsiniz. Ayrıca RabbitMQ broker tercih ettiğiniz bir ortama kurup deneyimleyebilirsiniz de. Single node olarak çalışabileceği gibi birden fazla node üzerinde cluster yapısında da çalışabilmektedir. Master/Slave yapısı da olmadığı için herhangi bir node’un çalışmama durumunda diğer node’ların yeni bir master seçimi durumu ile karşılaşılmaz ve süre kaybı yaşanmadan çalışmaya devam eder.</p><p>Sonuç olarak; eğer ölçeklenebilir bir ortam sağlamak istiyorsak, gerçek zamanlı bir işlem gerektirmiyorsa ve sunucu maliyetini minimum düzeyde tutmak istiyorsak RabbitMQ en ideal opsiyonlardan birisi olacaktır. Bu yazımda özetle RabbitMQ özelinde bilgi aktarmaya çalıştım. Umarım faydalı olmuştur. Bir sonraki yazımda görüşmek üzere.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e087bf5be393" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Docker ile JIRA DC Mimarisi]]></title>
            <link>https://yagizkucukkambak.medium.com/docker-ile-jira-dc-mimarisi-f062c0d53f5e?source=rss-692abde0c1f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/f062c0d53f5e</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[jira]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[atlassian]]></category>
            <dc:creator><![CDATA[Yağız Küçükkambak]]></dc:creator>
            <pubDate>Fri, 25 Jun 2021 13:25:35 GMT</pubDate>
            <atom:updated>2024-11-17T08:00:05.464Z</atom:updated>
            <content:encoded><![CDATA[<p>Selamlar herkese,</p><p>Bu yazımda, <strong>Atlassian JIRA Data Center </strong>yapısını <strong>Docker </strong>üzerinde nasıl kurgulayabileceğimizden bahsedeceğim. Öncelikle <strong>Atlassian</strong>’ın, <strong>JIRA </strong>için best-practice olarak gösterdiği yapıyı inceleyelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*p8tjboU1xzrTx0Ru.png" /><figcaption><strong>Atlassian JIRA DC Yapısı</strong></figcaption></figure><p>Bu yapıyı incelediğimizde <strong>JIRA</strong>’nın kurulmuş olduğu <strong>node’</strong>lar, bu <strong>node</strong>’ların bağlı olduğu bir <strong>ortak veritabanı</strong> ve bir <strong>paylaşılabilir dosya alanı sistemi </strong>(Ör: NFS)<strong> </strong>içerdiğini görüyoruz. Bu bileşenleri bir load balancer (Ör: HAProxy) arkasında konumlandırarak data center yapısınındaki kurulumumuzu network üzerinden erişilebilir hale getiriyoruz. Sistemimiz tam olarak hazır hale gelmiş oluyor.</p><p>Orijinal kurguyu şimdi biraz değiştireceğiz. İlk değişikliğimiz <strong>JIRA Cluster</strong> <strong>Node</strong>’larımız olacak. Bu makineler üzerine <strong>Docker </strong>ve <strong>Docker Compose </strong>kuracağız ve bu makinelerde oluşturduğumuz Docker Compose konfigürasyon dosyaları (<strong>docker-compose.yml</strong>) üzerinden <strong>JIRA </strong>instance’larımızı<strong> </strong>konteyner olarak çalıştıracağız. Konfigürasyon dosyalarımızda<strong> </strong>dosyalarımızda <strong>JIRA </strong>için <strong>Atlassian</strong>’ın<strong> </strong><a href="https://hub.docker.com/r/atlassian/jira-software"><strong>DockerHub</strong></a> üzerinde paylaştığı official imajı kullanacağız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tvMeg-gd7XD0sotF_Dyjwg.png" /><figcaption><strong>Node 1 Üzerindeki JIRA’ya Ait docker-compose.yml</strong></figcaption></figure><p><strong>Node 1 </strong>üzerindeki JIRA’ya ait<strong> docker-compose.yml</strong> dosyamız üzerinde <strong>jira-node1 </strong>servisine ait tanımlarımıza bakacak olursak:</p><p><strong>image: Atlassian</strong>’a ait official <strong>Docker</strong> imajını tanımladık.<br><strong>conatiner_name:</strong> <strong>Docker Compose</strong> ile ayağa kaldıracağımız <strong>JIRA</strong> konteynerinin adını tanımlıyoruz.<br><strong>network_mode:</strong> Oluşacak konteynere ait network modu. Biz bu örnekte konteynerimizi makinenin kendisiymiş gibi tanıtmak istediğimiz için host modunu tercih ediyoruz.<br><strong>volumes:</strong> <strong>JIRA</strong> konteyneri içerisindeki ortak alan klasörünün, fiziksel makine üzerinde bind edileceği klasörü tanımlıyoruz.<br><strong>environment:</strong> Ortam değişkenleri aracılığıyla spesifik <strong>JIRA </strong>konfigürasyonumuzu yapıyoruz.</p><p>Kısaca buradaki <strong>environment</strong> altındaki tanımlamalarımızı da özetleyecek olursak:</p><p><strong>CLUSTERED: </strong>Bu tanım ile <strong>JIRA’</strong>nın <strong>Cluster</strong> olarak çalışıp çalışmayacağını belirleyebiliyoruz. Data Center yapısı için bu tanımı <strong>true </strong>olarak set ediyoruz.<br><strong>JIRA_SHARED_HOME:</strong> Bu tanım ile <strong>JIRA</strong>’nın diğer node’lar ile paylaşacağı dosyaların dizinini belirtiyoruz. Bu kısım önemli çünkü <strong>Shared-File System</strong> kısmına bağlanacak yer burası.<br><strong>JIRA_NODE_ID:</strong> <strong>JIRA</strong>’ya ait node üzerinde tanımlanan spesifik id‘yi belirtiyoruz. Bu tanımı boş bırakırsanız <strong>JIRA</strong>’ya ait konteyner her oluşturulduğunda farklı bir unique id’ye sahip olacaktır.<br><strong>EHCACHE_LISTENER_HOSTNAME:</strong> Cache iletişimi için <strong>JIRA</strong> konteynerinin çalıştığı makinenin ismi. Bu kısım tanımlanmaz ise <strong>JIRA</strong> bunu otomatik olarak çözümleyecektir.<br><strong>EHCACHE_LISTENER_PORT:</strong> Cache iletişimi için node’un dinleyeceği port tanımı. Default değer olan <strong>40001</strong> port’unu kullanıyoruz.<br><strong>EHCACHE_OBJECT_PORT: </strong>Aramaların/işlemlerin registry üzerinde remote objelerin bağlı olduğu port’a ait tanımı. <br><strong>EHCACHE_PEER_DISCOVERY:</strong> Node’ların birbirlerini network’te nasıl bulacağını tanımladığımız kısım. Buradaki değeri bu örnek için <strong>default</strong> olarak bırakabiliriz.</p><p>Tanımlamalarımızı bitirdikten sonra <strong>docker-compose</strong> komutu kullanarak <strong>Node 1</strong> üzerinde <strong>JIRA </strong>konteynerimizi ayağa kaldırmış oluyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/661/1*wGBqlrduvHslLOSJIUnMxw.png" /><figcaption><strong>Node 1&#39;e Ait Docker Compose Komutu</strong></figcaption></figure><p><strong>Docker Compose</strong> ile <strong>JIRA </strong>konteynerimizi ayağa kaldırdıktan sonra standart <strong>JIRA</strong> kurulum işlemlerini tamamlayabiliriz. <strong>Node 1</strong> üzerindeki <strong>JIRA</strong> kurulumunu bitirdikten sonra diğer node’larda da aynı şekilde <strong>JIRA</strong> instance’ları ayağa kaldırıp bir cluster oluşturacak şekilde birbirlerine bağlanmalarını sağlayacağız. Her join edeceğimiz instance özelinde benzer adımlar işletileceği için sadece<strong> Node 2&#39;</strong>deki adımlardan bahsedeceğim.</p><p>Öncelikle <strong>Node 2 </strong>makinesinde bir <strong>docker-compose</strong> dosyası oluşturarak <strong>Node 1 </strong>makinesinde yazdığımız tanımların bir kısmını değiştireceğiz ve ek tanımlamalar yapacağız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/965/1*8_GtIAx_cZBRSS4yTj2_Hg.png" /><figcaption><strong>Node 2 Üzerindeki JIRA’ya Ait docker-compose.yml</strong></figcaption></figure><p><strong>Node 1</strong> üzerindeki <strong>JIRA</strong>’ya ait yaptığımız aynı tanımlardan <strong>EHCAHCE_LISTENER_PORT</strong> ve <strong>EHCACHE_OBJECT_PORT</strong> tanımlarımız her bir node üzerinde farklı olması gerektiği için değişiklik yaptık. Bu konu ile alakalı daha detaylı bilgiye <a href="https://developer.atlassian.com/server/jira/platform/configuring-a-jira-cluster/"><strong>buradan</strong></a><strong> </strong>ulaşabilirsiniz. <strong>Node 1&#39;</strong>de olmayan ve join olacak olan her node üzerinde bulunması gereken <strong>environment</strong> tanımlarını beraber inceleyelim.</p><p><strong>ATL_JDBC_URL</strong> : Cluster‘daki node’lar tarafından kullanılacak database adresi. <br><strong>ATL_JDBC_USER:</strong> Database bağlantısını kurmak için kullanıcak kullanıcı<br><strong>ATL_JDBC_PASSWORD:</strong> Database bağlantısını kurmak için kullanılacak kullanıcıya ait şifre<br><strong>ATL_DB_DRIVER:</strong> Veritabanı bağlantısı sırasında kullanılacak driver. Burada örnek olarak PostgreSQL driver’ını kullanıyoruz.<br><strong>ATL_DB_TYPE:</strong> PostgreSQL kullandığımız için type olarak postgres72 kullanıyoruz.<br><strong>ATL_DB_SCHEMA_NAME:</strong> public schema üzerine kurulum gerçekleştirdiğimiz için public olarak belirtiyoruz.</p><p>Tanımlamalarımızı bitirdikten sonra aşağıdaki komutu kullanarak <strong>Node 2 </strong>üzerinde yeni bir <strong>JIRA</strong> konteyneri ayağa kaldırıyoruz. Ayağa kalkan JIRA instance’ı otomatik olarak <strong>JIRA DC</strong> yapısına join oluyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/628/1*v3QmRteFQJWPPV_n7KC7Qw.png" /><figcaption><strong>Node 2&#39;ye Ait Docker Compose Komutu</strong></figcaption></figure><blockquote><strong>Not:</strong> Node 2&#39;yi join ederken Node 1&#39;deki JIRA konteynerinin kapalı olması gerekmektedir. Node 2&#39;ye ait JIRA konteyneri kurulumu tamamlandığında Node 1&#39;e ait olan JIRA konteynerini tekrardan çalıştırabilirsiniz.</blockquote><p><strong>Node 2</strong>&#39;de işletttiğimiz adımları takip ederek birden fazla <strong>JIRA instance’ı </strong>ayağa kaldırıp <strong>cluster</strong>’a<strong> </strong>join edebilirsiniz. Ayrıca diğer <strong>Atlassian DC</strong> ürünleri için de benzer bir yapı kurmak mümkün.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HYKhYCSGkcWi_wl8RiWZ5g.png" /><figcaption><strong>Atlassian DC Docker Mimarisi</strong></figcaption></figure><p>Özetle <strong>Atlassian</strong>’ın en önemli ürünlerinden biri olan <strong>JIRA</strong>’yı data center mimarisinde Docker konteyner halinde nasıl kurabileceğinizi anlatmaya çalıştım. Umarım faydalı olmuştur. GitHub reposunu da <a href="https://github.com/yagizkambak/dockerwithjiradc"><strong>buraya</strong></a><strong> </strong>bırakıyorum. Bir sonraki yazımda görüşmek üzere.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f062c0d53f5e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>