DEV Community: Aria Eslami

Building a Fully Private CI/CD Pipeline with GitLab & SonarQube: A Real-World Guide

Aria Eslami — Thu, 07 Aug 2025 20:49:58 +0000

As engineering teams scale and software complexity grow, having a robust, automated CI/CD pipeline is no longer a luxury; it's a necessity. In this article, I’ll take you through the complete journey of setting up a fully private, self-hosted CI/CD pipeline using GitLab CI/CD, Docker-based runners, and SonarQube for code quality analysis.

This isn't another theoretical guide. Everything here is built in a real-world scenario, inside an isolated internal network with zero reliance on public SaaS.

Why Self-Hosted?

Sometimes the cloud isn’t an option. Whether due to security policies, compliance, or architecture decisions, many teams must operate entirely within internal infrastructure.

This setup solves for:

Air-gapped environments
Internal-only GitLab & SonarQube servers
Fully containerized runners
Controlled traffic and secrets

The Tech Stack

Components & Purpose:

GitLab CE – Source control + CI/CD engine
GitLab Runner – Executes jobs in Docker
SonarQube – Code quality & static analysis
SonarScanner CLI – CLI for analysis, runs in CI

We use Docker images for everything, keeping the runner nodes clean and stateless.

Project Structure & CI/CD Workflow

Sample .gitlab-ci.yml

stages:
  - sonar

variables:
  GIT_DEPTH: "0"
  SONAR_HOST_URL: "https://sonarqube.internal"

sonarqube:
  stage: sonar
  image: sonarsource/sonar-scanner-cli:latest
  script:
    - sonar-scanner -Dsonar.token="$SONAR_TOKEN"

SONAR_TOKEN is stored as a GitLab CI/CD variable.

Key Concepts:

stages: CI jobs are grouped into stages and run sequentially.
image: Docker image for the job, here sonar-scanner-cli.
script: Actual commands to execute inside the container.

If this job fails (e.g., scanner fails or SonarQube is unreachable), the pipeline will stop at this stage.

Understanding GitLab Runner

GitLab Runner is a background service that polls GitLab for jobs. Once it picks up a job:

It downloads the project source
Starts a Docker container with the image defined in the CI file
Executes the job commands
Returns logs and status to GitLab

Docker Executor

We use the Docker executor mode, which isolates each job in a clean container environment.

Tip: For internal domains, configure Docker runner with extra_hosts to resolve local services like git.internal or sonarqube.internal.

Deep Dive: How SonarQube Analysis Works

SonarQube analyzes source code and returns metrics on:

Code smells
Bugs
Duplications
Test coverage
Security hotspots

Supported file types (in our Laravel + Vue project):

PHP: app/, routes/, tests/
JS/Vue: resources/js/, *.vue

Config File: sonar-project.properties

sonar.projectKey=my-project
sonar.projectName=My Project
sonar.sources=app,resources/js
sonar.tests=tests
sonar.exclusions=node_modules/**,public/**,storage/**
sonar.php.file.suffixes=.php
sonar.javascript.file.suffixes=.js,.vue

SonarScanner reads this config and sends data to the SonarQube server over HTTP. The token ensures it’s authenticated.

Lessons Learned

CI variables make sensitive info (tokens, secrets) safe
GIT_DEPTH: 0 is critical for full branch history in analysis
Each stage only runs if the previous one succeeds
SonarScanner must be configured with a valid token sonar.login is deprecated
Docker containers may need --add-host to resolve internal hosts

Benefits of This Setup

Private and secure — all services are internal
Modular — easy to extend with deploy/test/build stages
Fast feedback for developers — bugs & smells caught early
Language-agnostic — works for PHP, JS, Java, Python, etc. This isn’t just a pipeline it’s a foundation for DevOps culture.

What’s Next?

From here, we can expand into:

Automated unit testing (PHPUnit, Jest, etc.)
Docker image builds and artifact publishing
Automatic deploys to staging/prod
More granular SonarQube quality gates
Pipeline optimization with cache and parallel jobs

Final Thoughts

Building a self-hosted CI/CD + SonarQube pipeline taught me more than any cloud-based service ever could. From Docker networking to GitLab internals to Sonar’s scanning engine it’s been a true DevOps deep dive.

Whether you're starting fresh or replacing legacy scripts, this setup will help your team build faster, safer, and with confidence.

If you found this useful, follow me for future deep dives into CI/CD, DevOps tooling, infrastructure, and open-source pipelines.

The Case Against Windows: A Hilariously Serious Guide to Profound Alternatives

Aria Eslami — Fri, 22 Dec 2023 09:47:28 +0000

Introduction:

In the spectacular opera of operating systems, Windows has played the lead role for years, captivating audiences worldwide. However, as the tech world morphs into a more diverse landscape, the time has come to explore the comedic intricacies and serious considerations for choosing alternatives to the Windows blockbuster. Join us on this rollercoaster ride through the realms of security, resource efficiency, cost-effectiveness, customization, software compatibility, community support, and a few more surprises that make the case for alternative operating systems more amusingly compelling.

1. Security Concerns:

Windows, the A-lister of operating systems, can sometimes feel like the VIP party everyone wants to crash. Unfortunately, that includes hackers and malware, turning your computing experience into a never-ending red carpet event for cyber threats. Enter Linux, the undercover superhero with a mask of open-source secrecy. With its robust security features and fewer paparazzi flashes, Linux ensures your professional data stays away from the gossip columns of the hacking world.

2. Resource Intensiveness:

Windows, with its flair for extravagant demands, is like the celebrity who insists on a personal entourage just to check emails. In the professional world where efficient resource management is key, Windows might be that friend who demands a dressing room filled with only green M&Ms. Linux, on the other hand, is the minimalist friend who can pull off a killer performance without the unnecessary drama. Efficient, resource-friendly, and no diva tantrums – that's the Linux way.

3. Cost Factor:

Windows, with its commercial glam, often comes with a price tag that could make even a Kardashian flinch. For the discerning professional on a budget, Linux is the frugal fashionista, offering a front-row seat to the tech show without the hefty ticket price. It's like getting a VIP pass to the computing gala without having to mortgage your tech soul.

4. Customization and Control:

Windows, with its polished exterior, might sometimes feel like being dressed for a black-tie event when you're in the mood for casual Fridays. Linux is the fashion-forward friend who lets you mix and match your desktop environment and software like a tech runway show. Want a sleek minimalist look or a wild, neon-infused experience? Linux says, "Dress your computer however you want – it's your time to shine!"

5. Software Compatibility:

Windows, the trendsetter of software fashion, has closets full of options. But hold the applause; Linux is having a style revival! With cross-platform and web-based applications, plus the ability to run Windows apps with Wine, Linux is the new haute couture of compatibility. It's like Linux raided Windows' closet, found some hidden gems, and turned them into the coolest tech accessories.

6. Community Support:

In the glittering world of Windows, finding personalized support can sometimes feel like trying to get a selfie with a celebrity who's too busy signing autographs. Enter the Linux community – the squad of tech cheerleaders, always ready with virtual pom-poms and IT wisdom. Linux users form a community that's more supportive than a group therapy session for tech enthusiasts, ensuring your computing journey is filled with laughter, shared insights, and maybe a few memes.

7. Updates Drama:

Windows updates can sometimes feel like the unexpected plot twists in a soap opera. Just when you think you're getting the hang of things, a mandatory update crashes the party. Linux, however, offers updates that are more like reliable co-stars – they show up, do their job, and don't steal the spotlight. No sudden plot twists, just a smooth, drama-free performance.

8. System Resource Management:

Windows, with its grandiose presence, tends to be a bit of a resource glutton. It's like that friend who insists on having the biggest dressing room and the most elaborate entourage. In the professional world, where efficient resource management is crucial for a seamless performance, Windows might feel like the celebrity who demands an entire floor of the hotel just for their wardrobe. Linux, on the other hand, is the minimalist virtuoso who can deliver a stellar performance without demanding a truckload of resources. It's the friend who says, "Let's keep it simple and make sure the real stars shine."

9. Virtualization and Containers:

In the age of virtualization and containerization, where businesses aim for flexibility and scalability, Windows can sometimes feel like that friend who insists on bringing their antique furniture to every house party. Linux, with its native support for virtualization technologies like KVM and container orchestration tools like Docker and Kubernetes, is the contemporary friend who knows how to pack light and adapt to any setting. It's like having the tech equivalent of a pop-up shop – quick, efficient, and ready for anything.

10. Command Line Magic:

For professionals who appreciate the beauty of automation and scripting, the command line is the wand that turns mundane tasks into magical performances. Windows PowerShell is like a modern magician – powerful but sometimes a bit tricky to master. Linux, with its command line (bash) prowess, is like having a wizard's spellbook at your fingertips. The command line on Linux is a symphony of efficiency, allowing professionals to orchestrate complex tasks with a few elegant keystrokes.

11. Server Dominance:

In the backstage of the digital world, where servers rule the show, Windows Server is a familiar face. However, Linux servers are like the unsung heroes, quietly powering the majority of the internet and cloud infrastructure. From web servers to data centers, Linux is the backbone of the backstage crew, working tirelessly behind the scenes to ensure a smooth and reliable performance for businesses and users alike.

12. Open Source Philosophy:

For professionals who appreciate transparency and collaboration, the open-source philosophy of Linux is a breath of fresh air. It's like attending a tech conference where everyone shares ideas, code, and improvements. Windows, with its closed-source nature, can sometimes feel like an exclusive club with a members-only handshake. Linux, on the other hand, invites professionals to join a global community where innovation knows no borders.

Conclusion:

As the tech comedy-drama unfolds, exploring alternative operating systems becomes a journey into a realm where humor and professionalism coexist harmoniously. From resource efficiency and server dominance to the magic of the command line and the open-source philosophy, alternative operating systems, especially Linux, offer a plethora of reasons for professionals to consider a switch. So, as you navigate the ever-changing landscape of computing, remember that the show must go on, and there's a whole world of operating systems ready to bring both smiles and serious solutions to your tech endeavors. After all, why settle for a one-dimensional performance when the tech world can be a rich tapestry of laughter, learning, and limitless possibilities?

The .NET Core Conundrum: A Humorous Expedition into the "Why Nots"

Aria Eslami — Fri, 22 Dec 2023 00:31:37 +0000

Welcome, brave readers, to a comedic journey through the curious realm of .NET Core. Buckle up as we explore the wacky world of reasons why one might consider steering clear of this development wonder (with a wink and a nod, of course).

1. .NET Core is Like the Overenthusiastic Labrador of Frameworks
Picture this: you just wanted to write some code, but .NET Core is there, wagging its tail, ready to fetch everything you could possibly need. It's so eager to please, it practically anticipates your next move. Developers beware—it might be too enthusiastic for its own good!

2. The "Core" Sounds Like a Fitness Class You Can Never Quite Master
Whoever named it .NET Core must have been a fan of fitness trends. It sounds like a core workout routine that promises a chiseled codebase, but in reality, you find yourself perpetually stuck in a loop of squats trying to understand the intricacies.

3. The Constant Updates: A Comedy of Errors or a Tragicomedy?
.NET Core loves to keep things fresh with frequent updates. It's like the friend who changes their hairstyle every week. Just when you get comfortable, bam! A new version drops, and you're left scrambling to update, wondering if your code will still recognize you.

4. "Core" - It's Not Just for Apples Anymore
In a world full of fruit-named operating systems, .NET Core boldly claims its spot. Move over, Granny Smith! Now, developers can debate the virtues of their favorite cores—Granny Smith, Red Delicious, or .NET Core. Spoiler alert: .NET Core doesn't taste great with peanut butter.

5. It's So Cross-Platform, It Might Be an Overachiever
.NET Core's cross-platform capabilities are impressive, but it's like that friend who insists on being the life of every party. "Cross-platform? Oh, you mean it works on Windows, Linux, and macOS? Is there a platform it can't conquer?" It's almost exhausting how versatile it is.

6. When .NET Core Feels Like a Parent: "Did You Finish Your Updates, Honey?"
.NET Core is that parent who checks in on you, ensuring you've done your updates and that everything is running smoothly. It's like having a digital mom or dad, making sure your code is tucked in and ready for bedtime. "Sweet dreams, little application."

7. It's So Lightweight, It Might Float Away
.NET Core prides itself on being lightweight, but sometimes you wonder if it might float away in a gentle breeze. You'll find yourself clutching your code, hoping it doesn't get carried off by a particularly strong gust.

8. It's So Open Source, You Might Mistake It for a Neighborhood Potluck
.NET Core's open-source nature is like a community potluck. Everyone contributes a little something, and you're left with a feast of code. Just be careful—it's so communal that your code might come back with a dash of unexpected spice, courtesy of the friendly neighborhood developers.

9. Naming Conventions: Is it .NET Core, .NET 5, or Just a Midlife Crisis?
.NET Core has had its fair share of identity crises, evolving from .NET Core to .NET 5 and beyond. It's like it decided to throw a midlife crisis party and change its name to stay hip with the cool frameworks. Who knew frameworks could have a rebellious phase?

10. Dependency Injection: Because Who Doesn't Want More Dependencies in Life?
.NET Core loves its dependency injection, making sure your code gets its daily dose of dependencies. It's like a health-conscious friend who insists on everyone taking their vitamins, except in this case, the vitamins are other people's code.

11. Command-Line Interface (CLI): It's Like a Magic Wand for Wizards
.NET Core's CLI is like a wizard's wand, enabling developers to conjure applications with a few incantations. But beware, with great power comes great responsibility. One wrong spell, and your application might turn into a pumpkin—or worse, Windows 95.

12. It's So Good, It's Like Coding with a Cup of Coffee
.NET Core is the equivalent of coding with a cup of coffee—warm, reliable, and comforting. But wait, isn't it supposed to be a humorous critique? Well, some things are just too good not to appreciate. So here's to coding with .NET Core and a good cup of coffee—because every developer knows they go hand in hand.

Conclusion: The Comedy Continues, .NET Core Style
In this satirical exploration of the .NET Core universe, we've uncovered its quirks, playfully poked fun at its eccentricities, and even found a bit of endearing charm. Whether it's the overenthusiastic Labrador tendencies, the ever-changing names, or the neighborhood potluck of open-source contributions, .NET Core is a unique and lovable character in the grand play of software development.

As developers, let's not forget to embrace the humor embedded in our coding adventures. After all, laughter is the best medicine for those inevitable moments of debugging despair. So, as you embark on your coding escapades with .NET Core, may your code be merry, your bugs be few, and your laughter be plentiful. Happy coding!