Jenkins Pipeline 100% Done by Claude: From One EC2 to a Working Pipeline

In short: start one EC2, open VS Code with Claude Code, give Claude your key file and the server IP, and let it build the whole Jenkins pipeline. You stay in control by approving each command.

Why do it this way

Setting up Jenkins by hand has many small steps. It is easy to miss one. Letting Claude run the steps over SSH is fast and repeatable. You read each command before it runs, so you learn and stay safe.

What these words mean

• EC2: one rented Linux server on AWS (Amazon Web Services).
• SSH: a safe way to run commands on a far server from your computer.
• .pem key: a secret file that proves it is you when you SSH. Keep it private.
• Claude Code: Anthropic's coding tool. It runs as a VS Code extension (a chat panel) and also as a CLI (a claude command in the terminal).
• Jenkins: a free tool that builds and tests your code automatically (CI/CD).
• Docker: a tool that runs apps in small boxes called containers.

The whole flow, top to bottom

Setup — VS Code with Claude Code

You need VS Code 1.94 or later and a paid Claude plan (Pro, Max, Team or Enterprise) or a Claude Console account. No API key is needed; you sign in.

1. Install the extension. In VS Code press Ctrl+Shift+X, search "Claude Code", click Install. Click the Spark icon to open the panel and sign in.
2. Install the CLI too (for the terminal). macOS/Linux/WSL: curl -fsSL https://claude.ai/install.sh | bash. Windows PowerShell: irm https://claude.ai/install.ps1 | iex. The extension does not add claude to your PATH, so this separate install lets you run claude in the integrated terminal.
3. Open your project folder in VS Code, open the terminal with Ctrl+`, and run claude to start a session.

Step 1 (the only manual step): launch one EC2

1. Open the AWS Console → EC2 → Launch instance.
2. Choose Amazon Linux 2023, size t3.small (enough for Jenkins + Docker).
3. Create or pick a key pair. Download the .pem file, e.g. to ~/Downloads/mykey.pem.
4. Security group: allow SSH (port 22) from your IP only. We open 8080 later, also to your IP only.
5. Launch, then copy the public IP. In this guide the example IP is 3.3.3.3 and the login user is ec2-user.

Optional: launch the EC2 using Claude (AWS CLI)

If you set up the AWS CLI, Claude can create the server too. It writes the command, you approve, it runs.

aws ec2 run-instances --image-id resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-x86_64 \
  --instance-type t3.small --key-name mykey --security-group-ids sg-0123456789 \
  --count 1 --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=jenkins-demo}]'

The master prompt (copy-paste)

Open the Claude Code panel (or run claude) in VS Code and paste this. Change the IP and key path to yours.

The real commands Claude runs (over SSH)

chmod 400 ~/Downloads/mykey.pem
ssh -i ~/Downloads/mykey.pem ec2-user@3.3.3.3

sudo wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo
sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io-2023.key
sudo dnf install -y java-17-amazon-corretto
sudo dnf install -y jenkins
sudo systemctl enable --now jenkins

sudo dnf install -y docker
sudo systemctl enable --now docker
sudo usermod -aG docker jenkins
sudo systemctl restart jenkins   # so the new group takes effect

aws ec2 authorize-security-group-ingress --group-id sg-0123456789 \
  --protocol tcp --port 8080 --cidr 203.0.113.5/32   # your IP/32

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

# install plugins without the web wizard
sudo jenkins-plugin-cli --plugins git workflow-aggregator docker-workflow credentials configuration-as-code
# tell Jenkins to skip the setup wizard and read a JCasC file
echo 'JAVA_OPTS="-Djenkins.install.runSetupWizard=false -Dcasc.jenkins.config=/var/lib/jenkins/casc.yaml"' | sudo tee /etc/sysconfig/jenkins.override
sudo systemctl restart jenkins

jenkins:
  securityRealm:
    local:
      allowsSignup: false
      users:
        - id: "admin"
          password: "${ADMIN_PASS}"   # from an env var, not typed in chat
  authorizationStrategy:
    loggedInUsersCanDoAnything:
      allowAnonymousRead: false

jobs:
  - script: >
      pipelineJob('my-app') {
        definition {
          cpsScm {
            scm { git('https://github.com/you/my-app.git') }
            scriptPath('Jenkinsfile')
          }
        }
      }

A sample Jenkinsfile (in your repo)

pipeline {
  agent any
  stages {
    stage('Checkout') { steps { checkout scm } }
    stage('Build')    { steps { sh 'docker build -t my-app:latest .' } }
    stage('Test')     { steps { sh 'docker run --rm my-app:latest npm test' } }
    stage('Deploy')   { when { branch 'main' } steps { sh './deploy.sh' } }
  }
  post { success { echo 'Done.' } failure { echo 'Open the red stage log.' } }
}

Guardrails: keep full AI access safe

You are giving an AI a lot of power. Do not rely on polite words alone. Use layers. If one layer misses, the next one blocks. Build them in this order.

1. Claude Code permission rules (hard block, enforced by the tool, not the model). Put a .claude/settings.json in your project. Rules are checked in the order deny → ask → allow, so a deny always wins. .claude/settings.json

   {
     "permissions": {
       "allow": ["Bash(ssh -i * ec2-user@*)", "Read(./Jenkinsfile)"],
       "ask":   ["Bash(aws *)", "Bash(sudo *)"],
       "deny":  ["Read(./*.pem)", "Read(~/.aws/credentials)",
                 "Bash(rm -rf *)", "Bash(mysql *)"]
     }
   }

   Note: a deny on Read(./*.pem) stops Claude from opening your key. Bash pattern matching is limited, so to truly stop dangerous SQL, block it at the database (step 3), not only here.
2. A CLAUDE.md rule file (soft guide). Put plain rules Claude should follow, e.g. "Always ask before any sudo. Never read *.pem or .env. Never drop a database." Important: this is guidance that shapes what Claude tries to do — it is not a hard block. The real wall is the permission rules above.
3. A dedicated Linux user for the AI with a small sudo allowlist. Do not let it be full root. /etc/sudoers.d/aiops

   # user 'aiops' may run ONLY these, nothing else
   aiops ALL=(root) NOPASSWD: /usr/bin/systemctl restart jenkins, \
     /usr/bin/dnf install -y *, /usr/bin/jenkins-plugin-cli *

4. Protect the database with grants (the strongest SQL guard). Give the AI a user that cannot touch production, and an app user that can only insert and read. MySQL

   -- read-only helper with NO grants on prod_db at all
   CREATE USER 'ai_ro'@'%' IDENTIFIED BY '••••';
   -- (grant nothing on prod_db, so it simply cannot read or change it)
   
   -- app user: INSERT + SELECT only, no UPDATE/DELETE/DROP
   CREATE USER 'ai_app'@'%' IDENTIFIED BY '••••';
   GRANT INSERT, SELECT ON app.* TO 'ai_app'@'%';
   FLUSH PRIVILEGES;

   Because ai_app has no UPDATE, DELETE or DROP, even a wrong AI command cannot delete or drop data.
5. AWS IAM least privilege with an explicit Deny on the scary actions and the protected resource. IAM policy

   {
     "Version": "2012-10-17",
     "Statement": [
       { "Sid": "AllowDailyWork", "Effect": "Allow",
         "Action": ["ec2:Describe*","ec2:RunInstances","s3:GetObject","s3:PutObject","rds:Describe*"],
         "Resource": "*" },
       { "Sid": "DenyDangerous", "Effect": "Deny",
         "Action": ["rds:DeleteDBInstance","s3:DeleteObject"],
         "Resource": ["arn:aws:rds:ap-south-1:123456789012:db:prod-db",
                      "arn:aws:s3:::prod-bucket/*"] }
     ]
   }

   In IAM an explicit Deny always beats an Allow, so the production DB and bucket are safe.
6. Take a backup first. Before any AI run: an RDS snapshot, an EBS snapshot, and a git commit. If something goes wrong, you restore in minutes.

   aws rds create-db-snapshot --db-instance-identifier prod-db --db-snapshot-identifier pre-ai-$(date +%F)
   aws ec2 create-snapshot --volume-id vol-0123 --description "pre-ai"

Safety checklist (quick)

Save tokens and money

1. One master prompt, then short replies. After the first prompt, answer "yes" or "next" instead of re-explaining.
2. Paste only the error lines when a step fails, not the whole log.
3. Start a fresh chat for a new server so old text is not resent each time.

Quick quiz

Save these cards