Posts Tagged ‘ContinuousDeployment’
[DevoxxFR2014] Git-Deliver: Streamlining Deployment Beyond Java Ecosystems
Lecturer
Arnaud Bétrémieux is a passionate developer with 18 years of experience, including 8 professionally, specializing in open-source technologies, GNU/Linux, and languages like Java, PHP, and Lisp. He works at Key Consulting, providing development, hosting, consulting, and expertise services. Sylvain Veyrié, with nearly a decade in Java platforms, serves as Director of Delivery at Transparency Rights Management, focusing on big data, and has held roles in development, project management, and training at Key Consulting.
Abstract
This article investigates git-deliver, a deployment tool leveraging Git’s integrity guarantees for simple, traceable, and atomic deployments across diverse languages. It dissects the tool’s mechanics, from remote setup to rollback features, and discusses customization via scripts and presets, emphasizing its role in replacing ad-hoc scripts in dynamic language projects.
Core Principles and Setup
Git-deliver emerges as a Bash script extending Git with a “deliver” subcommand, aiming for simplicity, reliability, efficiency, and universality in deployments. Targeting non-Java environments like Node.js, PHP, or Rails, it addresses the pitfalls of custom scripts that introduce risks in traceability and atomicity.
A deployment target equates to a Git remote over SSH. For instance, creating remotes for test and production environments involves commands like git remote add test deliver@test.example.fr:/appli and git remote add prod deliver@example.fr:/appli. Deliveries invoke git deliver <remote> <version>, where version can be a branch, commit SHA, or tag.
On the target server, git-deliver initializes a bare Git repository alongside a “delivered” directory containing clones for each deployment. Each clone includes Git metadata and a working copy checked out to the specified version. Symbolic links, particularly “current,” point to the latest clone, ensuring a fixed path for applications and atomic switches— the link updates instantaneously, avoiding partial states.
Directory names incorporate timestamps and abbreviated SHAs, facilitating quick identification of deployed versions. This structure preserves history, enabling audits and rollbacks.
Information Retrieval and Rollback Mechanisms
To monitor deployments, git-deliver offers a “status” option. Without arguments, it surveys all remotes, reporting the current commit SHA, tag if applicable, deployment timestamp, and deployer. It also verifies integrity, alerting to uncommitted changes that might indicate manual tampering.
Specifying a remote yields a detailed history of all deliveries, including directory identifiers. Additionally, git-deliver auto-tags each deployment in the local repository, annotating with execution logs and optional messages. Pushing these tags to a central repository shares deployment history team-wide.
Rollback supports recovery: git deliver rollback <remote> reverts to the previous version by updating the “current” symlink to the prior clone. For specific versions, provide the directory name. This leverages preserved clones, ensuring exact restoration even if files were altered post-deployment.
Customization and Extensibility
Deployments divide into stages (e.g., init-remote for first-time setup, post-symlink for post-switch actions), allowing user-provided scripts executed at each. For normal deliveries, scripts might install dependencies or migrate databases; for rollbacks, they handle reversals like database adjustments.
To foster reusability, git-deliver introduces “presets”—collections of stage scripts for frameworks like Rails or Flask. Dependencies between presets (e.g., Rails depending on Ruby) enable modular composition. The “init” command copies preset scripts into a .deliver directory at the project root, customizable and versionable via Git.
This extensibility accommodates varied workflows, such as compiling sources on-server for compiled languages, though git-deliver primarily suits interpreted ones.
Broader Impact on Deployment Practices
By harnessing Git’s push mechanics and integrity checks, git-deliver minimizes errors from manual interventions, ensuring deployments are reproducible and auditable. Its atomic nature prevents service disruptions, crucial for production environments.
While not yet supporting distributed deployments natively, scripts can orchestrate multi-server coordination. Future enhancements might incorporate remote groups for parallel pushes.
In production at Key Consulting, git-deliver demonstrates maturity beyond prototyping, offering a lightweight alternative to complex tools, promoting standardized practices across projects.
Links:
[DevoxxFR2012] Nagios checks via NRPE
package “nagios-nrpe-server”
“`
He demonstrates real-time dashboards that correlate application metrics with infrastructure health, enabling rapid incident response and informed scaling decisions.
Economic and Organizational Impact: Beyond Technical Excellence
Bertrand Paquet concludes with a quantitative analysis of the pipeline’s impact: deployment frequency increased from weekly to multiple times daily, mean time to recovery decreased from hours to minutes, and infrastructure costs became predictable and scalable. He argues that these technical achievements enable organizational agility—new features can be tested in production with real users within hours of conception, creating tight feedback loops that drive product excellence.
Links:
[DevoxxFR2012] The Five Mercenaries of DevOps: Orchestrating Continuous Deployment with a Multidisciplinary Team
Lecturer
Henri Gomez is Senior Director of IT Operations at eXo, with over 20 years in software, from financial trading to architecture. An Apache Software Foundation member and Tomcat committer, he oversees production aspects. Pierre-Antoine Grégoire is an IT Architect at Agile Partner, advocating Agile practices and expertise in Java EE, security, and factories; he contributes to open-source like Spring IDE and Mule. Gildas Cuisinier, a Luxembourg-based consultant, leads Developpez.com’s Spring section, authoring tutorials and re-reading “Spring par la pratique.” Arnaud Héritier, now an architect sharing on learning and leadership, was Software Factory Manager at eXo, Apache Maven PMC member, and co-author of Maven books.
Abstract
This article dissects Henri Gomez, Pierre-Antoine Grégoire, Gildas Cuisinier, and Arnaud Héritier’s account of a DevOps experiment with a five-member team—two Java developers, one QA, one ops, one agile organizer—for continuous deployment of a web Java app to pre-production. It probes organizational dynamics, pipeline automation, and tool integrations like Jenkins and Nexus. Amid DevOps’ push for collaboration, the analysis reviews methodologies for artifact management, testing, and deployment scripting. Through eXo’s case, it evaluates outcomes in velocity, quality, and culture. Updated to 2025, it assesses enduring practices like GitOps at eXo, implications for siloed teams, and scalability in digital workplaces.
Assembling the Team: Multidisciplinary Synergy in Agile Contexts
DevOps thrives on cross-functional squads; the mercenaries exemplify: Developers craft code, QA validates, ops provisions, organizer facilitates. Jeff outlines Scrum with daily standups, retrospectives—roles fluid, e.g., devs pair with ops on scripts.
Challenges: Trust-building—initial resistance to shared repos. Solution: Visibility via dashboards, empowering pull-based access. At eXo, this mirrored portal dev, where 2025’s eXo 7.0 emphasizes collaborative features like integrated CI.
Metrics: Cycle time halved from weeks to days, fostering ownership.
Crafting the Continuous Deployment Pipeline: From Code to Pre-Prod
Pipeline: Git commits trigger Jenkins builds, Maven packages WARs to Nexus. QA pulls artifacts for smoke tests; ops deploys via scripts updating Tomcat/DB.
Key: Non-intrusive—push to repos, users pull. Arnaud details Nexus versioning, preventing overwrites. Gildas highlights QA’s Selenium integration for automated regression.
Code for deployment script:
#!/bin/bash
VERSION=$1
wget http://nexus/repo/war-$VERSION.war
cp war-$VERSION.war /opt/tomcat/webapps/
service tomcat restart
mysql -e "UPDATE schema SET version='$VERSION';"
2025 eXo: Pipeline evolved to Kubernetes with Helm charts, but core pull-model persists for hybrid clouds.
Tooling and Automation: Jenkins, Nexus, and Scripting Harmonics
Jenkins orchestrates: Jobs fetch from Git, build with Maven, archive to Nexus. Plugins enable notifications, approvals.
Nexus as artifact hub: Promoted releases feed deploys. Henri stresses idempotent scripts—if [ ! -f war.war ]; then wget; fi—ensuring safety.
Testing: Unit via JUnit, integration with Arquillian. QA gates: Manual for UAT, auto for basics.
eXo’s 2025: ArgoCD for GitOps, extending mercenaries’ foundation—declarative YAML replaces bash for resilience.
Lessons Learned: Cultural Shifts and Organizational Impacts
Retrospectives revealed: Early bottlenecks in handoffs dissolved via paired programming. Value: Pre-prod always current, with metrics (build success, deploy time).
Scalability: Model replicated across teams, boosting velocity 3x. Challenges: Tool sprawl—mitigated by standards.
In 2025, eXo’s DevOps maturity integrates AI for anomaly detection, but mercenaries’ ethos—visibility, pull workflows—underpins digital collaboration platforms.
Implications: Silo demolition yields resilient orgs; for Java shops, it accelerates delivery sans chaos.
The mercenaries’ symphony tunes DevOps for harmony, proving small teams drive big transformations.