Moysklad Migrates to GitLab CI/CD

🚀 Successful CI/CD Migration: From Jenkins to GitLab at Moysklad In the world of software development, optimizing continuous integration and deployment processes is key to efficiency. Recently, the Moysklad team shared their experience in transitioning from Jenkins to GitLab CI/CD, a decision that transformed their workflow. This change not only simplified the configuration but also improved scalability and collaboration in a microservices environment. 🔧 Initial Challenges with Jenkins - ⚠️ Complex configurations that required constant maintenance and were prone to errors. - ⏱️ Prolonged build times due to the monolithic architecture. - 👥 Difficulties in collaboration between distributed teams. 📈 Benefits of the Migration to GitLab - 🌐 Native integration with Git, allowing declarative and more intuitive YAML pipelines. - 🚀 Drastic reduction in execution times, with parallel builds and efficient caching. - 🔒 Greater security through environment variables and granular access roles. - 📊 Improved monitoring with integrated metrics and real-time notifications. The process involved a detailed evaluation, parallel testing, and a gradual migration to minimize disruptions. Today, Moysklad enjoys a more robust system that supports its growth, highlighting how GitLab accelerates innovation without sacrificing stability. For more information visit: https://enigmasecurity.cl #CICD #DevOps #GitLab #Jenkins #SoftwareDevelopment #Microservices If you're passionate about cybersecurity and development, support Enigma Security with a donation for more technical news: https://lnkd.in/er_qUAQh Connect with me on LinkedIn to discuss tech trends: https://lnkd.in/eXXHi_Rr 📅 Wed, 11 Mar 2026 06:36:24 GMT 🔗Subscribe to the Membership: https://lnkd.in/eh_rNRyt

🔄CI/CD starts with the right principles Join DevOpsCon speaker Nir Koren as he highlights an important idea: CI/CD is not just about tools. While tools like GitHub and Jenkins help implement CI/CD workflows, what really matters is the underlying principles for delivering software to production reliably and robustly. A strong CI/CD process ensures that code changes can move safely and efficiently from development to production. In the “CI/CD Workshop: From Zero to Continuous Integration and Continuous Delivery” at DevOpsCon, you’ll learn how to build and understand CI/CD pipelines from the ground up.  Key topics of the workshop: -  Understanding the core CI/CD concepts and mindset - Working with GitHub workflows - Installing and managing Jenkins pipelines -  Automating jobs using Jenkins DSL - Building and running your own Hello World CI/CD pipeline Take your CI/CD skills to the next level and build your first complete pipeline. 🔗 https://lnkd.in/deCgcDQV #DevOpsCon #CICD #DevOps #Jenkins #GitHub #Automation

🌟GitOps changed the way we deploy to Kubernetes. Traditional CI/CD pipelines push changes directly into the cluster. This approach works, but it introduces risks: • manual intervention • configuration drift • lack of deployment visibility • inconsistent environments GitOps solves this by making Git the single source of truth for the system state. This is where ArgoCD comes in. With ArgoCD, the workflow becomes declarative: 1- A developer commits infrastructure or application changes to GitHub 2- ArgoCD continuously pulls the desired state from the repository 3- It compares that state with the actual state running in Kubernetes 4- If a difference is detected, ArgoCD automatically synchronizes the cluster This creates a powerful operational model: • fully declarative deployments • automatic drift detection • version-controlled infrastructure • consistent environments across clusters Instead of pushing deployments to Kubernetes, I let the cluster pull its desired state from Git. That small shift fundamentally improves security, traceability, and reliability. In GitOps, Git is not just version control ,it becomes the control plane for your infrastructure. #GitOps #ArgoCD #Kubernetes #DevOps #CloudEngineering

Continuous Integration / Continuous Deployment (CI/CD) is magic. ✨ Pushing code to GitHub and having a server automatically run tests, build the image, and deploy to production within minutes gives you an incredible development velocity. If you haven't written a YAML workflow yet, start today. It changes everything. #DevOps #CICD #GitHubActions #CloudComputing

Why Jenkins is still the "Brain" of DevOps If Kubernetes is the engine, Jenkins is the driver. 🏎️ Last week, we explored the power of K8s. But here is the real question: How does your code actually get there? In 2026, many call Jenkins "legacy," yet it still powers 44% of the global CI/CD market. Why? Because it’s the only tool that gives you total control. 🛑 The "Before" (The Manual Chaos) ❌ Slow Velocity: Manual builds take 30+ minutes and are prone to human error. ❌ The "Wall" of Fear: Developers are afraid to deploy on Fridays. ❌ Security Gaps: Vulnerabilities are often found after the code is live. ✅ The "After" (The Automated Reality) Pipeline as Code: Using Jenkinsfiles means your entire build logic is version-controlled and transparent. Ephemeral Scalability: We don't run Jenkins on old VMs anymore. We use Kubernetes agents that spin up for a build and disappear the second it's done. 💨 DevSecOps Integration: Security scanning (SAST/DAST) happens inside the pipeline. If the code isn't safe, the build stops. Zero-Downtime Deploys: With Jenkins + K8s, we trigger rolling updates. If a health check fails, Jenkins triggers an automatic rollback. 🚀 The DevOps Impact Jenkins is the "glue." It connects your Git repo to your K8s cluster, turning manual nightmares into a 1-click reality. It moves the team from "praying it works" to "knowing it works." #DevOps #Jenkins #Kubernetes #CICD #Automation #CloudNative #SoftwareEngineering

🔧 Small Git Automation That Improved Our Commit Workflow While working on a recent project, I noticed a small but common problem in our development workflow. 📌 The situation Our team links every code change to a ticket (Jira / GitLab / Azure DevOps). So every commit message should include the ticket number like: #216 fix: validate webhook payload But developers had to add the ticket manually. ⚠️ The problem This caused a few issues: • Developers sometimes forgot to add the ticket number • Commit history became inconsistent • Harder to trace changes back to tasks or bug reports It’s a small issue, but over time it affects code traceability and project tracking. 💡 The solution I implemented a simple Git automation using a prepare-commit-msg hook. The hook automatically: ✔ Extracts the ticket number from the branch name ✔ Adds it as a prefix to the commit message ✔ Keeps the commit title within 100 characters ✔ Skips merge commits ✅ Result: Every commit is automatically linked to the correct ticket without relying on developers to remember it. Sometimes small automation like this can significantly improve developer productivity and code traceability. #Git #DevOps #SoftwareEngineering #DeveloperProductivity #Automation

GitOps simplifies the deployment model by establishing your Git repository as the single source of truth. A tool like ArgoCD or Flux continuously reconciles your cluster state with what is declared in Git. The magic of GitOps includes: - Full audit trail (who changed what when) - Easy rollbacks (git revert) - Environment promotion via pull requests - Security through separation of duties It's not a new technology; rather, it's a workflow that leverages existing tools more effectively. Have you made the GitOps shift? #GitOps #Kubernetes #DevOps #CICD #InfrastructureAsCode

🔄 Understanding CI/CD Workflow with Jenkins Let’s take a deeper look at how a real CI/CD workflow operates using Jenkins 🚀 👨💻 Step 1: Development & Code Push A developer writes code and pushes it to a repository (e.g., GitHub). 🔗 Step 2: Triggering the Pipeline Once the code is pushed, GitHub automatically triggers Jenkins through a webhook. ➡️ This is where the magic begins: CI/CD pipeline is activated instantly. ⚙️ Step 3: Jenkins Pipeline Execution Jenkins reads the Jenkinsfile, which defines: The pipeline stages What actions should happen in each stage 📌 Example pipeline stages: 🔨 Build the application 🐳 Build a Docker image 📦 Push the image to Docker Hub 🧪 Run tests 📄 Generate documentation 🤔 What happens if multiple developers push code at the same time? Let’s say: Developer A pushes code Developer B pushes code shortly after 🔄 Jenkins handles this intelligently: Jobs are queued if resources are limited Jenkins distributes tasks across multiple VMs (agents) Each VM is assigned a specific role (build, test, docs, etc.) 💡 Scenario: If only one VM is available → Developer B’s job waits until A finishes If multiple VMs are available → Both pipelines can run in parallel ⚡ Key Takeaways Jenkins automates the full CI/CD lifecycle Pipelines are defined clearly using a Jenkinsfile Supports scalability using multiple agents (VMs) Handles concurrent builds efficiently 🌍 Result? Faster builds, parallel execution, and a scalable system that grows with your team. 🔥 In the next post, we’ll break down a real Jenkinsfile and build our first pipeline step by step! #CICD #Jenkins #DevOps #Automation #ContinuousIntegration #ContinuousDeployment #Docker #Maven #GitHub #SoftwareEngineering #CloudComputing

🚀 Deployed and configured a Jenkins CI/CD Server Using Docker. I recently worked on setting up a fully functional Jenkins instance using Docker, and it was a great hands-on experience in containerization and DevOps practices. 🔧 In this task, I Pulled the official Jenkins Docker image Created a persistent Docker volume for data storage Deployed Jenkins with proper port mapping Accessed and configured the Jenkins web interface Resolved common issues like authentication errors and CSRF (crumb) protection 💡 This setup clearly shows how quickly a CI/CD environment can be established using containerization, making the process efficient, portable, and scalable. ✨ Key Takeaways: Faster and simplified Jenkins deployment Persistent and secure data handling using volumes Real-world troubleshooting experience Strong foundation in CI/CD workflows 📌 Overall, this project strengthened my understanding of DevOps tools and highlighted how containerization simplifies complex setups. #Jenkins #Docker #DevOps #CICD #Automation #CloudComputing #Learning #HandsOnExperience #SoftwareDevelopment 🚀

CI/CD pipelines, when implemented using tools like Jenkins, GitHub Actions, or GitLab CI, significantly boost developer productivity by automating the build, test, and deployment processes. For instance, with Jenkins, developers can create a pipeline that automatically builds and tests their code every time they push changes to a Git repository. This ensures that potential issues are caught early, reducing the chances of errors creeping into the production environment. For example, let's consider a web application development team using GitHub Actions. After committing new features or bug fixes, the CI/CD pipeline automatically builds the app, runs unit tests, and deploys it to a staging environment for review. This automation saves developers from manually executing these tasks, allowing them to focus on more creative aspects of their work. Moreover, by integrating these pipelines with various third-party tools like Slack or Jira, teams can receive notifications about the status of builds and deployments. This transparency and immediate feedback help teams respond quickly to issues, further enhancing productivity #CICD #DevOps #Automation.