Skaffold is a command-line tool from Google that automates the inner development loop for Kubernetes applications: it watches your source files for changes, rebuilds container images, re-runs tests, and redeploys to your cluster — all in a single continuous process with a single command. Instead of manually running docker build, docker push, and kubectl apply every time you save a file, Skaffold handles the entire cycle in seconds. This dramatically shortens the feedback loop when developing microservices, making local Kubernetes development nearly as fast as traditional local server development. This guide covers installing Skaffold on Red Hat Enterprise Linux 9, configuring it for a sample application, and using it with a local k3s cluster for rapid iteration.

Prerequisites

  • RHEL 9 server with sudo or root access
  • Docker or Podman installed and running for local image builds
  • A local Kubernetes cluster — k3s is recommended for its low overhead (curl -sfL https://get.k3s.io | sh -)
  • kubectl configured to connect to your cluster (kubectl get nodes should succeed)
  • A sample application with a Dockerfile and Kubernetes manifests (Deployment + Service YAML)

Step 1 — Install Skaffold

Skaffold distributes a single static binary for Linux. Download the latest release directly from Google Cloud Storage, make it executable, and move it into your PATH.

curl -Lo skaffold 
  https://storage.googleapis.com/skaffold/releases/latest/skaffold-linux-amd64

chmod +x skaffold
sudo mv skaffold /usr/local/bin/

skaffold version

Step 2 — Set Up a Sample Application

Create a minimal project directory with a Go HTTP server, a Dockerfile, and a Kubernetes Deployment manifest. Skaffold works with any language — Go is used here for its small compiled binary and fast build times.

mkdir ~/skaffold-demo && cd ~/skaffold-demo

# main.go — simple HTTP server
cat > main.go < Dockerfile < k8s/deployment.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: skaffold-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: skaffold-demo
  template:
    metadata:
      labels:
        app: skaffold-demo
    spec:
      containers:
        - name: app
          image: skaffold-demo
          ports:
            - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: skaffold-demo
spec:
  selector:
    app: skaffold-demo
  ports:
    - port: 80
      targetPort: 8080
  type: ClusterIP
EOF

Step 3 — Create the skaffold.yaml Configuration

The skaffold.yaml file describes how to build your image and how to deploy it. The build section specifies the image name and build method; the deploy section points to your Kubernetes manifests. For local development with k3s, set the build destination to the local Docker daemon or use k3s’s built-in containerd import.

# skaffold.yaml
cat > skaffold.yaml <<'EOF'
apiVersion: skaffold/v4beta11
kind: Config
metadata:
  name: skaffold-demo

build:
  artifacts:
    - image: skaffold-demo
      docker:
        dockerfile: Dockerfile
  local:
    push: false        # don't push to registry — import directly into k3s

deploy:
  kubectl:
    manifests:
      - k8s/*.yaml

portForward:
  - resourceType: service
    resourceName: skaffold-demo
    namespace: default
    port: 80
    localPort: 8080
EOF

For Helm-based deployments, replace the deploy section with a helm block:

deploy:
  helm:
    releases:
      - name: skaffold-demo
        chartPath: charts/skaffold-demo
        valuesFiles:
          - values.yaml

Step 4 — Run skaffold dev for Continuous Development

skaffold dev is the primary development command. It builds the image, deploys it to the cluster, streams logs to your terminal, and watches for file changes. On every save, it triggers an incremental rebuild and redeployment automatically. The port-forward configuration makes the service reachable at localhost:8080.

# For k3s: export the kubeconfig so Skaffold can reach the cluster
export KUBECONFIG=/etc/rancher/k3s/k3s.yaml

# Start the development loop
skaffold dev

# Skaffold will:
# 1. Build the Docker image
# 2. Import it into k3s (no registry push needed for local clusters)
# 3. Apply k8s/deployment.yaml
# 4. Forward localhost:8080 -> service port 80
# 5. Stream pod logs to the terminal
# 6. Watch for file changes and repeat steps 1-5 on save

# Test the running service (in a second terminal)
curl http://localhost:8080

Step 5 — One-Shot Build and Cleanup with skaffold run and skaffold delete

skaffold run performs a single build-and-deploy cycle without entering the watch loop — useful in scripts and CI pipelines. skaffold delete removes all resources that Skaffold deployed.

# One-shot deploy (no file watching)
skaffold run

# View the deployed resources
kubectl get deployment,service skaffold-demo

# Tear down everything Skaffold deployed
skaffold delete

# Build the image without deploying (useful for CI artifact creation)
skaffold build --file-output=build-artifacts.json

# Render manifests to stdout without applying (dry run)
skaffold render

Conclusion

You now have Skaffold installed on RHEL 9 and integrated with a local k3s cluster, enabling a continuous development loop where saving a source file automatically triggers a full rebuild and redeployment in seconds. The key workflow is skaffold dev during active development for instant feedback, and skaffold run in CI pipelines for deterministic single-shot deployments. Skaffold’s profile system (skaffold.yaml profiles section) lets you maintain separate configurations for local, staging, and production environments in one file, switching with --profile=prod. Pair Skaffold with Argo CD: use Skaffold in the CI stage to build and push images, then let Argo CD handle the GitOps-style synchronization to production clusters.

Next steps: How to Install k3s for Lightweight Kubernetes on RHEL 9, How to Set Up Argo CD for GitOps on Kubernetes on RHEL 9, and How to Set Up a CI/CD Pipeline with Tekton on Kubernetes on RHEL 9.