שימוש ב-Claude Code לתהליכי DevOps — מדריך מעשי

Claude Code הוא כלי AI מבוסס שורת פקודה (CLI) של Anthropic שמשנה את הדרך שבה צוותי DevOps כותבים, בודקים ומתחזקים תשתיות. במקום לחפש Stack Overflow בשלוש בלילה כשה-Pipeline נשבר, אפשר לתת ל-Claude Code לנתח את ה-codebase, לכתוב Jenkinsfile או GitHub Actions workflow, לדבג קונפיגורציות Terraform, ולייצר סקריפטים של אוטומציה — ישירות מהטרמינל. המדריך הזה מראה בדיוק איך לעשות את זה, צעד אחרי צעד, עם דוגמאות קוד אמיתיות שאפשר להריץ עכשיו.

לפי סקר של GitLab מ-2024, 67% מצוותי DevOps כבר משלבים כלי AI כלשהו בתהליכי העבודה שלהם — אבל רק 23% מרגישים שהם מנצלים את הפוטנציאל המלא. הפער הזה הוא בדיוק מה שנסגור כאן. לא תיאוריה, לא הבטחות — פרקטיקה.

Claude Code הוא agentic coding tool — כלומר הוא לא רק משלים שורות קוד כמו Copilot. הוא מבין את כל מבנה הפרויקט שלכם/ן, יכול לקרוא קבצים, להריץ פקודות, ולבצע שינויים מורכבים שמשתרעים על פני מספר קבצים. בהקשר של DevOps, זה אומר שהוא יכול לקרוא את ה-Dockerfile שלכם, להבין את ה-docker-compose, לנתח את ה-CI pipeline, ולהציע תיקונים שמתייחסים לכל הרכיבים יחד.

בניגוד לממשק הצ'אט הרגיל של Claude, Claude Code רץ בטרמינל ומקבל גישה ישירה לקבצי הפרויקט ולסביבת ההרצה. זה ההבדל בין לשאול מישהו "מה דעתך על ה-YAML הזה?" לבין לתת למישהו לשבת ליד המחשב שלכם ולתקן את הבעיה בעצמו.

התקנה והגדרה ראשונית

ההתקנה פשוטה ודורשת Node.js בגרסה 18 ומעלה. הנה הצעדים:

# התקנת Claude Code גלובלית
npm install -g @anthropic-ai/claude-code

# מעבר לתיקיית הפרויקט שלכם
cd /path/to/your/devops-project

# הפעלה ראשונית — תתבקשו לאמת מול Anthropic
claude

# לחילופין, הגדרת API key מראש
export ANTHROPIC_API_KEY="sk-ant-your-key-here"
claude

ברגע שאתם/ן בפנים, Claude Code סורק את מבנה הפרויקט ומבין את ההקשר. אפשר להתחיל לדבר איתו בעברית או באנגלית — הוא מבין שתיהן. אבל לצורך דיוק טכני, אנגלית עדיפה בפקודות עצמן.

הגדרת CLAUDE.md לפרויקט DevOps

קובץ CLAUDE.md הוא כמו README אבל עבור Claude Code עצמו. תשימו אותו ב-root של הפרויקט ותגדירו בו את הכללים והקונבנציות של התשתית שלכם/ן. זה משפר דרמטית את איכות התוצאות.

# CLAUDE.md — DevOps Project Guidelines

## Infrastructure
- Cloud provider: AWS (eu-west-1 region, Israeli workloads)
- IaC: Terraform 1.7+ with remote state in S3
- Container orchestration: EKS (Kubernetes 1.29)
- CI/CD: GitHub Actions (main) + ArgoCD (GitOps deployment)

## Conventions
- All Terraform modules follow: modules/{service}/{main,variables,outputs}.tf
- Docker images tagged with git SHA: ${ECR_REPO}:${GITHUB_SHA::8}
- Branch strategy: main → staging → production (promotion via PR)
- Secrets managed via AWS Secrets Manager, referenced in k8s via External Secrets Operator

## Security Requirements
- No hardcoded credentials — ever
- All containers run as non-root
- Network policies required for every namespace
- Terraform plan must run before any apply

## Naming Convention
- Resources: {env}-{service}-{component} (e.g., prod-api-gateway-alb)
- Namespaces: {env}-{team} (e.g., staging-backend)

הקובץ הזה הוא המפתח. בלעדיו, Claude Code עדיין יעבוד — אבל עם הקובץ, התוצאות רלוונטיות בצורה מדהימה לפרויקט הספציפי שלכם/ן. חברות כמו Wiz ו-Snyk בישראל כבר משתמשות בגישות דומות של "AI context files" כדי לשמור על עקביות בצוותים גדולים.

בואו נצלול לתרחישים אמיתיים. לא demo יפה — עבודה אמיתית שקורה כל יום בצוותי DevOps בחברות ישראליות.

תרחיש 1: כתיבת CI/CD Pipeline מאפס

נניח שיש לכם/ן מיקרו-סרביס חדש ב-Python שצריך pipeline של build, test ו-deploy. במקום לכתוב את ה-YAML בעצמכם/ן ולדבג את השגיאות של "invalid workflow syntax" חמש פעמים, הנה מה שעושים:

# בתוך Claude Code, פשוט מבקשים:
> Look at the Python service in ./services/payment-api/ and create a complete
> GitHub Actions workflow that: builds a Docker image, runs pytest with coverage,
> pushes to ECR, and deploys to EKS staging via ArgoCD image updater.
> Follow the conventions in CLAUDE.md.

Claude Code יקרא את הקבצים, יבין את מבנה הפרויקט, ויייצר workflow מלא. הנה דוגמה לפלט שתקבלו — ושימו לב, זה קוד אמיתי שאפשר להריץ:

# .github/workflows/payment-api-ci.yml
name: Payment API CI/CD

on:
  push:
    branches: [main, staging]
    paths:
      - 'services/payment-api/**'
  pull_request:
    branches: [main]
    paths:
      - 'services/payment-api/**'

env:
  AWS_REGION: eu-west-1
  ECR_REPOSITORY: payment-api
  EKS_CLUSTER: prod-main-eks

jobs:
  test:
    runs-on: ubuntu-latest
    defaults:
      run:
        working-directory: services/payment-api
    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
          cache: 'pip'

      - name: Install dependencies
        run: |
          pip install -r requirements.txt
          pip install -r requirements-dev.txt

      - name: Run tests with coverage
        run: |
          pytest --cov=app --cov-report=xml --cov-fail-under=80 tests/

      - name: Upload coverage
        uses: codecov/codecov-action@v4
        with:
          file: services/payment-api/coverage.xml

  build-and-push:
    needs: test
    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/staging'
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: read
    outputs:
      image-tag: ${{ steps.meta.outputs.tags }}
    steps:
      - uses: actions/checkout@v4

      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: arn:aws:iam::${{ secrets.AWS_ACCOUNT_ID }}:role/github-actions-ecr
          aws-region: ${{ env.AWS_REGION }}

      - name: Login to Amazon ECR
        id: login-ecr
        uses: aws-actions/amazon-ecr-login@v2

      - name: Build and push Docker image
        id: meta
        env:
          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
          IMAGE_TAG: ${{ github.sha }}
        run: |
          cd services/payment-api
          docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:${IMAGE_TAG::8} .
          docker push $ECR_REGISTRY/$ECR_REPOSITORY:${IMAGE_TAG::8}
          echo "tags=$ECR_REGISTRY/$ECR_REPOSITORY:${IMAGE_TAG::8}" >> $GITHUB_OUTPUT

  deploy-staging:
    needs: build-and-push
    if: github.ref == 'refs/heads/staging'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Update ArgoCD image tag
        run: |
          cd k8s/overlays/staging
          kustomize edit set image payment-api=${{ needs.build-and-push.outputs.image-tag }}

      - name: Commit and push
        run: |
          git config user.name "github-actions"
          git config user.email "actions@github.com"
          git add .
          git commit -m "chore: update payment-api image to ${{ needs.build-and-push.outputs.image-tag }}"
          git push

שימו לב שה-workflow כבר כולל OIDC authentication (בלי access keys!), path filtering, coverage threshold, ו-GitOps deployment pattern. Claude Code עשה את זה כי הוא קרא את CLAUDE.md והבין את הקונבנציות.

תרחיש 2: דיבוג תשתית Terraform

אחד הכאבים הגדולים ב-DevOps: ה-terraform plan עובר, ה-apply נכשל, וההודעה אומרת משהו קריפטי על IAM permissions. הנה איך Claude Code עוזר:

# מריצים terraform plan ומעבירים את הפלט ל-Claude Code
terraform plan -no-color 2>&1 | tee /tmp/tf-plan.txt

# בתוך Claude Code:
> Read /tmp/tf-plan.txt and analyze the Terraform plan output.
> Identify any security issues, cost implications, and potential
> problems. Also check if the changes align with our CLAUDE.md conventions.

Claude Code יזהה בעיות כמו security groups פתוחים מדי, משאבים ללא tags, או שינויים שעלולים לגרום ל-downtime. לפי מחקר של HashiCorp מ-2024, 41% מתקלות התשתית נובעות מ-misconfigurations שניתן היה לזהות בשלב ה-plan — וזה בדיוק מה ש-Claude Code תופס.

תרחיש 3: כתיבת סקריפטי אוטומציה

נגיד שצריך סקריפט שמנקה Docker images ישנים מ-ECR, שומר רק את 10 האחרונים לכל repository, ושולח התראה ל-Slack אם נמחקו images. הנה האינטראקציה:

# בתוך Claude Code:
> Write a bash script that:
> 1. Lists all ECR repositories in eu-west-1
> 2. For each repo, keeps only the 10 most recent images (by push date)
> 3. Deletes older images
> 4. Sends a summary to Slack webhook with count of deleted images
> 5. Has dry-run mode with --dry-run flag
> Make it production-ready with error handling and logging.

והתוצאה — סקריפט שאפשר להריץ ישר:

#!/usr/bin/env bash
set -euo pipefail

# ECR Cleanup Script — keeps N most recent images per repository
# Usage: ./ecr-cleanup.sh [--dry-run] [--keep N] [--region REGION]

KEEP=10
REGION="eu-west-1"
DRY_RUN=false
SLACK_WEBHOOK="${SLACK_WEBHOOK_URL:-}"
TOTAL_DELETED=0
LOG_FILE="/var/log/ecr-cleanup-$(date +%Y%m%d-%H%M%S).log"

log() {
  echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
}

# Parse arguments
while [[ $# -gt 0 ]]; do
  case $1 in
    --dry-run)  DRY_RUN=true; shift ;;
    --keep)     KEEP="$2"; shift 2 ;;
    --region)   REGION="$2"; shift 2 ;;
    *)          log "ERROR: Unknown option $1"; exit 1 ;;
  esac
done

log "Starting ECR cleanup (keep=$KEEP, region=$REGION, dry_run=$DRY_RUN)"

# Get all repositories
repos=$(aws ecr describe-repositories \
  --region "$REGION" \
  --query 'repositories[].repositoryName' \
  --output text)

for repo in $repos; do
  log "Processing repository: $repo"

  # Get images sorted by push date (oldest first), skip the N most recent
  images_to_delete=$(aws ecr describe-images \
    --region "$REGION" \
    --repository-name "$repo" \
    --query "sort_by(imageDetails, &imagePushedAt)[:-${KEEP}].imageDigest" \
    --output text 2>/dev/null || echo "")

  if [[ -z "$images_to_delete" || "$images_to_delete" == "None" ]]; then
    log "  No images to delete in $repo"
    continue
  fi

  count=0
  image_ids=""
  for digest in $images_to_delete; do
    image_ids+="imageDigest=$digest "
    ((count++))
  done

  if [[ "$DRY_RUN" == true ]]; then
    log "  [DRY RUN] Would delete $count images from $repo"
  else
    aws ecr batch-delete-image \
      --region "$REGION" \
      --repository-name "$repo" \
      --image-ids $image_ids > /dev/null
    log "  Deleted $count images from $repo"
  fi

  TOTAL_DELETED=$((TOTAL_DELETED + count))
done

# Send Slack notification
if [[ -n "$SLACK_WEBHOOK" && "$TOTAL_DELETED" -gt 0 ]]; then
  mode="deleted"
  [[ "$DRY_RUN" == true ]] && mode="would delete (dry run)"

  curl -s -X POST "$SLACK_WEBHOOK" \
    -H 'Content-Type: application/json' \
    -d "{
      \"text\": \"🧹 ECR Cleanup: ${mode} ${TOTAL_DELETED} images across $(echo $repos | wc -w) repositories (region: ${REGION})\"
    }" > /dev/null
fi

log "Cleanup complete. Total images processed: $TOTAL_DELETED"

הסקריפט הזה כבר כולל error handling עם set -euo pipefail, לוגים מסודרים, dry-run mode, ופרמטרים גמישים. זה לא pseudocode — זה production-ready.

השוק מוצף בכלי AI, אז בואו נשווה בצורה ישרה — מה עובד למה:

השורה התחתונה: Claude Code מנצח כשאתם/ן צריכים/ות agent שמבין את כל הפרויקט ויכול לבצע שינויים מורכבים. Copilot CLI מנצח לפקודות מהירות. ChatGPT מנצח ללימוד. Amazon Q מנצח אם אתם/ן 100% AWS.

שימוש ב-slash commands ו-hooks

Claude Code תומך ב-custom slash commands שאפשר להגדיר בפרויקט. זה נהדר ליצירת workflows שחוזרים על עצמם:

# יצירת תיקיית commands בפרויקט
mkdir -p .claude/commands

# יצירת custom command לבדיקת אבטחה
cat > .claude/commands/security-check.md << 'EOF'
Analyze the following aspects of our infrastructure code:
1. Check all Dockerfiles for: running as root, using latest tag, unnecessary packages
2. Check Terraform files for: open security groups, unencrypted resources, missing tags
3. Check K8s manifests for: missing resource limits, privileged containers, missing network policies
4. Check CI/CD workflows for: hardcoded secrets, missing pinned action versions

Report findings in a table format with severity (HIGH/MEDIUM/LOW) and specific file:line references.
EOF

# עכשיו אפשר להריץ בתוך Claude Code:
> /project:security-check

ה-hooks feature מאפשר להריץ פעולות אוטומטיות לפני או אחרי כל אינטראקציה עם Claude Code. לדוגמה, אפשר להגדיר hook שמריץ terraform validate אוטומטית אחרי כל שינוי בקבצי Terraform.

אינטגרציה עם CI/CD — Claude Code ב-Headless Mode

אחד הפיצ'רים החזקים ביותר: אפשר להריץ Claude Code בתוך pipeline בלי אינטראקציה אנושית. זה פותח אפשרויות מטורפות:

# GitHub Actions step — Claude Code כ-automated code reviewer
- name: AI Infrastructure Review
  env:
    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
  run: |
    npm install -g @anthropic-ai/claude-code
    
    # הרצה בודדת עם פרומפט ספציפי ופלט ל-file
    claude -p "Review the changes in this PR. Focus on:
      1. Security implications of infrastructure changes
      2. Cost impact of new/modified resources
      3. Compliance with our CLAUDE.md conventions
      Output a markdown summary." \
      --output-format text > review.md
    
    # פרסום כתגובה ל-PR
    gh pr comment ${{ github.event.pull_request.number }} \
      --body-file review.md

חברות כמו Orca Security ו-Fireblocks בישראל כבר מריצות automated AI reviews על שינויי תשתית. לפי דוח של Gartner מ-2024, ארגונים שמשלבים AI review בתהליכי IaC מצמצמים misconfigurations ב-34% בממוצע.

עבודה עם Kubernetes — דיבוג ואופטימיזציה

Claude Code מצטיין בדיבוג בעיות Kubernetes כי הוא יכול לקרוא manifests, להריץ kubectl, ולהצליב מידע:

# בתוך Claude Code — דיבוג pod שלא עולה
> Run kubectl describe pod payment-api-7d4f8b6c9-x2k4m -n staging-backend
> and kubectl logs payment-api-7d4f8b6c9-x2k4m -n staging-backend --previous
> Then analyze why the pod is in CrashLoopBackOff and suggest a fix.
> Check our k8s manifests in k8s/overlays/staging/ for the root cause.

# או — אופטימיזציית resource requests
> Analyze the output of 'kubectl top pods -n production-backend' and compare
> with the resource requests/limits defined in our k8s manifests.
> Suggest optimized values based on actual usage patterns.
> Consider that we're running on spot instances and need headroom for bursts.

הכוח האמיתי כאן הוא ב-cross-referencing: Claude Code רואה גם את ה-manifests וגם את המצב בפועל, ויכול לזהות פערים שלוקח לבן-אדם שעות למצוא.

כללי זהב לעבודה יעילה

אחרי חודשים של שימוש ועבודה עם צוותים שמטמיעים את הכלי, הנה מה שלמדנו:

כן לעשות: תמיד תשתמשו ב-CLAUDE.md — זה משפר את התוצאות בסדר גודל. כתבו פרומפטים ספציפיים עם הקשר ("fix the Terraform module in modules/vpc/ that fails on plan with error X") במקום כלליים ("fix my terraform"). תבקשו מ-Claude Code להסביר את השינויים — לא רק לבצע אותם.

לא לעשות: לעולם אל תריצו terraform apply או kubectl delete בלי לעבור על הפלט קודם. Claude Code הוא כלי — לא תחליף לשיפוט אנושי. אל תדביקו secrets בפרומפטים. ואל תסמכו על זה ב-production בלי review.

אבטחה ופרטיות

נקודה קריטית שצריך להבין: כשאתם/ן מריצים/ות Claude Code, הקוד שלכם/ן נשלח לשרתי Anthropic לעיבוד. לצוותים שעובדים עם מידע רגיש (ובמיוחד בתעשייה הישראלית, עם רגולציית הגנת פרטיות ודרישות אבטחה מחמירות), חשוב להבין את ההשלכות:

השתמשו ב-permissions system המובנה של Claude Code — הוא שואל אישור לפני הרצת פקודות הרסניות. הגדירו allowlist ו-denylist ברורים. אל תתנו ל-Claude Code גישה לסביבות production ישירות — תמיד דרך CI/CD עם approval gates.

האם Claude Code יכול להחליף DevOps Engineer?

לא. ובטח שלא כרגע. Claude Code הוא מכפיל כוח — הוא הופך DevOps engineer טוב ליותר פרודוקטיבי. הוא מצטיין במשימות שחוזרות על עצמן, בכתיבת boilerplate, ובדיבוג — אבל ההחלטות הארכיטקטוניות, הבנת הביזנס, ושיפוט בזמן אמת עדיין דורשים בן אדם. חשבו על זה כמו IDE חכם — אף אחד לא אומר ש-VS Code החליף מתכנתים/ות.

כמה עולה להשתמש ב-Claude Code לצוות DevOps?

Claude Code כלול במנוי Claude Pro ($20/חודש למשתמש/ת) או Claude Max ($100/חודש לשימוש כבד). לצוותים, Anthropic מציע Claude for Teams ב-$30/חודש למשתמש/ת עם ניהול מרכזי. ל-headless mode ב-CI/CD, משלמים לפי שימוש ב-API. רוב הצוותים שעבדנו איתם מדווחים שההשקעה מחזירה את עצמה תוך שבועיים מבחינת שעות חסכון.

האם אפשר להשתמש ב-Claude Code עם GitLab CI ולא רק GitHub Actions?

בהחלט. Claude Code הוא tool-agnostic — הוא עובד עם כל קובץ שנמצא ב-repo. הוא מכיר .gitlab-ci.yml באותה רמה שהוא מכיר GitHub Actions workflows. גם Jenkins, CircleCI, ו-Azure DevOps. פשוט תציינו ב-CLAUDE.md שלכם/ן באיזה CI/CD system אתם/ן משתמשים/ות, והוא יתאים את עצמו.

איך Claude Code מתמודד עם Terraform state ומידע רגיש?

Claude Code לא צריך גישה ל-state file עצמו ברוב המקרים — הוא עובד עם קבצי ה-.tf. כשצריך לנתח plan output, אפשר להריץ terraform plan -no-color ולהעביר את הטקסט. מומלץ מאוד לא לתת ל-Claude Code גישה ישירה ל-state שמכיל secrets. השתמשו ב-terraform output לחלץ רק את המידע הנדרש.

האם Claude Code עובד עם Ansible ו-Pulumi, או רק Terraform?

Claude Code עובד מצוין עם כל כלי IaC — Terraform, Pulumi, Ansible, CloudFormation, CDK, ואפילו Crossplane. אם הוא רואה playbooks של Ansible ב-repo, הוא יבין את ההקשר ויכתוב tasks תקינים. עם Pulumi הוא אפילו יכול לכתוב IaC בשפת התכנות שאתם/ן מעדיפים/ות — Python, TypeScript, Go.

מה ההבדל בין Claude Code לבין לשאול את Claude בצ'אט רגיל?

ההבדל הוא עצום. Claude בצ'אט רואה רק מה שאתם/ן מדביקים/ות — ותכתובת Terraform של 50 קבצים לא נכנסת לחלון צ'אט. Claude Code רואה את כל ה-repo, מבין את מבנה הפרויקט, יכול להריץ פקודות, ולערוך קבצים ישירות. זה ההבדל בין להתייעץ עם מישהו בטלפון לבין שהוא יושב ליד המחשב שלכם.

האם יש סיכון שClaude Code ימחק או ישבור משהו?

Claude Code מבקש אישור לפני הרצת פקודות שמשנות state. ברמת ברירת המחדל, הוא פועל ב-mode זהיר. עם זאת — תמיד תוודאו שאתם/ן עובדים/ות על branch נפרד, שיש לכם/ן state backup, ושפקודות הרסניות (delete, destroy, apply) עוברות דרככם/ן קודם. שום AI tool לא צריך לקבל terraform destroy ללא supervision.

אז ככה — Claude Code הוא לא קסם, והוא לא יחליף את הידע שלכם/ן. אבל הוא ישנה את המהירות שבה אתם/ן עובדים/ות. את הבעיות שלוקח שעה לדבג, הוא פותר בדקות. את ה-YAML שאתם/ן שונאים/ות לכתוב — הוא מייצר ברגע. והוא משתפר ככל שאתם/ן מלמדים/ות אותו את הפרויקט שלכם/ן דרך CLAUDE.md. אנחנו ב-Linnovate רואים את הכלים האלה כל יום בעבודה עם צוותי DevOps ופיתוח, ואם אתם/ן רוצים/ות להעמיק — בואו נדבר. הדלת פתוחה.

• קורס סייבר ואבטחת מידע
• קורס Real Time Embedded
• קורס דאטה סיינס
• קורס למידת מכונה AI
• קורס דאטה אנליסט
• קורס DEVOPS
• קורס IT
• קורס אוטומציה
• קורס Full Stack
• קורס בניית אתרים