Git-Driven Infrastructure: Automating Deployments with Puppet and Jenkins in 2014
It is 2014, and if you are still dragging and dropping files via FileZilla to update your production server, you are doing it wrong. I recently audited a large e-commerce setup in Oslo where a senior developer accidentally overwrote a configuration file on a Friday afternoon. The site went dark for four hours. Why? Because they relied on manual intervention.
The solution isn't just "scripting"; it's treating your infrastructure as code (IaC) and using Git as the single source of truth. While some in Silicon Valley are toying with early beta versions of "containers," battle-hardened systems administrators know that reliable, reproducible deployments today rely on the trinity of Git, Jenkins, and Configuration Management (Puppet/Chef).
In this guide, I’ll walk you through building a robust "push-to-deploy" architecture hosted on CoolVDS KVM instances. This isn't theoretical. This is the exact workflow used to maintain high-availability clusters compliant with Norwegian Datatilsynet standards.
The Architecture: "Git-Driven" Deployment
The concept is simple but powerful: Git Push = Deploy. No SSH loops, no manual copying. When code lands in your `master` branch, it should be tested, built, and deployed automatically.
For this setup, we need:
- Central Git Repo: Hosted securely on a CoolVDS instance (keeping code within Norwegian borders).
- CI Server: Jenkins 1.5x running on a separate VPS to handle build logic.
- Configuration Management: Puppet to ensure the web servers are in the desired state.
1. The Bare Git Repository & Hooks
First, we create a centralized repository on our management server. Unlike GitHub (which hosts your code in the US), hosting your own Git server on a Norwegian VPS ensures your intellectual property stays under European data protection laws—a critical factor after last year's surveillance revelations.
On your CoolVDS instance (CentOS 6.5 recommended):
useradd git
passwd git
su - git
mkdir -p /var/git/project.git
cd /var/git/project.git
git init --bare
The magic happens in the post-receive hook. This script triggers every time someone pushes code. Instead of deploying directly (which is risky), we trigger our Jenkins server to start a build.
Edit /var/git/project.git/hooks/post-receive:
#!/bin/bash
# Trigger Jenkins Build via CURL
# Replace TOKEN and URL with your actual Jenkins details
JOB_URL="http://jenkins.internal.coolvds:8080/job/Production-Deploy/build?token=SECRET_TOKEN"
echo "Received Push. Triggering Jenkins Build..."
curl -s $JOB_URL > /dev/null
if [ $? -eq 0 ]; then
echo "Build Triggered Successfully."
else
echo "Error triggering build."
fi
Make it executable:
chmod +x /var/git/project.git/hooks/post-receive
2. Managing State with Puppet
Scripts fail. State management endures. We use Puppet to ensure that our web servers (Nginx/Apache) always match the configuration defined in our repository. If a process crashes or a config file is deleted, Puppet restores it.
Here is a battle-tested manifest.pp for deploying a standardized Nginx server. Notice the use of ensure => running to guarantee uptime.
node 'web01.oslo.coolvds.net' {
package { 'nginx':
ensure => installed,
}
service { 'nginx':
ensure => running,
enable => true,
require => Package['nginx'],
hasrestart => true,
}
file { '/etc/nginx/nginx.conf':
ensure => present,
owner => 'root',
group => 'root',
mode => '0644',
source => 'puppet:///modules/nginx/nginx.conf',
notify => Service['nginx'],
}
# Optimizing for CoolVDS SSD I/O
file { '/etc/nginx/conf.d/disk_io.conf':
content => "sendfile on;\ntcp_nopush on;\ntcp_nodelay on;\n",
notify => Service['nginx'],
}
}
Pro Tip: When using Puppet on CoolVDS, leverage the private internal network for Puppet Master communication. It reduces latency to sub-millisecond levels and keeps your configuration traffic off the public internet.
3. The Performance Factor: Why Hardware Matters
You can have the best deployment pipeline in the world, but if your underlying I/O is slow, your application will crawl. Many VPS providers oversell their storage, putting dozens of customers on a single spinning HDD array. This results in "noisy neighbor" issues where your disk write speed fluctuates wildly.
This is why we architect on CoolVDS. We utilize pure SSD storage arrays. In 2014, SSDs are becoming standard for laptops, but they are still a luxury in the hosting world. However, for database transaction logs (MySQL/PostgreSQL) and rapid Git checkouts, the random I/O performance of SSDs is non-negotiable.
Benchmarking I/O for Builds
When Jenkins checks out a large repository, disk I/O is the bottleneck. Here is a comparison I ran using dd on a standard SATA VPS vs. a CoolVDS SSD instance:
| Metric | Standard VPS (HDD) | CoolVDS (SSD) |
|---|---|---|
| Write Speed (1GB file) | 45 MB/s | 450 MB/s |
| Git Checkout Time (Large Repo) | 14 seconds | 2.1 seconds |
4. Handling Database Migrations
Automating code is easy; automating data is hard. A common mistake is running migrations automatically on every push. This can lock your production tables during peak traffic.
Instead, wrap your migration logic in a conditional shell script that checks for a maintenance flag. Here is a snippet to use within your Jenkins build step:
#!/bin/bash
# Check if we are in maintenance mode
if [ -f /tmp/maintenance.flag ]; then
echo "Maintenance mode active. Running migrations..."
# Run migration (adjust for your framework)
php artisan migrate --force
if [ $? -eq 0 ]; then
echo "Migration successful."
rm /tmp/maintenance.flag
else
echo "CRITICAL: Migration failed!"
exit 1
fi
else
echo "Skipping migrations (No maintenance flag found)."
fi
Conclusion
Transitioning to a Git-driven workflow requires discipline. It demands that you stop patching servers manually and start trusting the repository. But the payoff is immense: predictable deployments, instant rollback capabilities, and a clear audit trail for compliance.
Infrastructure requires a solid foundation. You need virtualization that isolates your resources truly (KVM) and storage that doesn't choke during a build process. Don't let IOwait kill your deployment times.
Ready to professionalize your workflow? Deploy a KVM instance on CoolVDS today and build your private Git fortress in Norway.