Back to blog

Container Deployment Without a DevOps Team

Kubernetes has a reputation problem. Mention the name and people think of hundreds of YAML files, multi-day cluster setups, and job postings requiring three years of Kubernetes experience.

That perception isn’t wrong if you’re running a cluster from scratch. But it’s misleading when all you want is to get containers reliably into production.

A managed Kubernetes namespace takes cluster operations off your hands. That puts Kubernetes within reach of teams without dedicated DevOps staff.

What a DevOps Team Actually Does

In a Kubernetes context, a DevOps team is responsible for two areas:

Cluster administration (completely eliminated with a managed namespace):

  • Upgrading Kubernetes versions
  • Maintaining and backing up the etcd cluster
  • Managing node pools (scaling, OS updates, kernel patches)
  • Configuring network policies and CNI plugins
  • Operating ingress controllers / Gateway API
  • Certificate management (cert-manager)
  • Monitoring stack (Prometheus, Grafana, Alertmanager)
  • Log aggregation for the cluster (Loki, ELK, Fluentd)
  • Implementing backup strategies for the cluster and volumes

Application deployment (stays with you, but simplified):

  • Writing Dockerfiles
  • Maintaining Kubernetes manifests
  • Configuring CI/CD pipelines
  • Managing secrets

ITSH operates the cluster, the nodes, monitoring, backups of volumes and namespace config, and certificates. What stays with you is what already belongs to development: packaging and deploying your own application.

One clarification: the monitoring stack belongs to the platform, not to your namespace. ITSH monitors the cluster and nodes around the clock, but you get no Grafana access, no ingest endpoint of your own, and you cannot create ServiceMonitors or PrometheusRules. For your own workloads, you see pods, logs, events, and usage in the customer portal. Logs are not archived: the portal and kubectl show what the container currently holds. If you need log history, you set it up yourself.

From Code to Deployment in 30 Minutes

Say you want to deploy a Go API as a container. Here is the path from code to a running application in an ITSH namespace. To try it out, you can follow along at no cost on the free tier.

0. Preparation: Namespace and Kubeconfig

Create a namespace in the portal, the free one if you are just trying this out, and download its kubeconfig in the Kubernetes section. How to set up kubectl with it is described in Access and kubectl.

1. Create a Dockerfile (5 minutes)

FROM golang:1.27-alpine AS build
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN go build -buildmode=pie -ldflags="-s -w" -trimpath -o /app ./cmd/server

FROM alpine:3.24
COPY --from=build /app /app
USER 65534:65534
EXPOSE 8080
ENTRYPOINT ["/app"]

The USER line makes the container run as non-root. The securityContext in the manifest below requires that.

2. Build and Push the Container Image (5 minutes)

# Build and push to a container registry (e.g. GitHub Container Registry)
docker build -t ghcr.io/my-org/api:1.0.0 .
docker push ghcr.io/my-org/api:1.0.0

3. Write a Kubernetes Manifest (10 minutes)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
spec:
  replicas: 1
  selector:
    matchLabels:
      app: api
  template:
    metadata:
      labels:
        app: api
    spec:
      containers:
        - name: api
          image: ghcr.io/my-org/api:1.0.0
          ports:
            - name: http
              containerPort: 8080
          env:
            - name: DATABASE_URL
              valueFrom:
                secretKeyRef:
                  name: app-secrets
                  key: database-url
          securityContext:
            allowPrivilegeEscalation: false
            runAsNonRoot: true
            seccompProfile:
              type: RuntimeDefault
            capabilities:
              drop: ["ALL"]
          resources:
            requests:
              cpu: 50m
              memory: 128Mi
            limits:
              cpu: 100m
              memory: 256Mi
          readinessProbe:
            httpGet:
              path: /readyz
              port: http
            initialDelaySeconds: 3
            periodSeconds: 5
          livenessProbe:
            httpGet:
              path: /healthz
              port: http
            initialDelaySeconds: 10
            periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: api
spec:
  selector:
    app: api
  ports:
    - name: http
      port: 80
      targetPort: http
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: api
  annotations:
    cert-manager.io/cluster-issuer: "auto"
spec:
  parentRefs:
    - name: default
      namespace: nginx-gateway
      sectionName: https-api-my-namespace-itsh-dev
  hostnames:
    - api.my-namespace.itsh.dev
  rules:
    - backendRefs:
        - name: api
          port: 80

Replace my-namespace in the hostname and in the sectionName with the name of your namespace. The hostname sits under your namespace’s subdomain and is reachable right away, with no DNS setup. On the free tier it ends in itsh-apps.dev instead of itsh.dev, and the sectionName follows it: every dot in the hostname becomes a hyphen. The annotation turns on automatic HTTPS. A custom domain has to be added in the portal first, which the free tier does not allow: Gateway API.

The resource values fit a free-tier namespace too. On a paid plan, size them for your application.

4. Deploy (2 minutes)

First create the app-secrets secret the manifest refers to. The command is further down, under secrets.

kubectl apply -f k8s/ -n my-namespace

Or, if GitOps is switched on for your namespace: your CI builds the image and writes the new tag into the manifest, and ArgoCD syncs the namespace to the new state in the repository.

5. Verify (2 minutes)

# Pods running?
kubectl get pods -n my-namespace

# Check logs
kubectl logs -n my-namespace deployment/api

# Deployment status
kubectl rollout status deployment/api -n my-namespace

You don’t need Terraform, Ansible, node configuration, ingress classes or a cert-manager installation of your own. The complete example with every detail explained is in First deployment.

GitOps: Deployments via Git Push

Running kubectl apply manually works, but it’s not ideal for teams. ArgoCD makes the deployment process declarative and auditable. On ITSH you switch it on per namespace in the portal.

How it works:

  1. Kubernetes manifests live in a Git repository
  2. ArgoCD watches the repository
  3. On every change to the configured branch, ArgoCD syncs the cluster state

Important: the repository must be readable without credentials, which in practice means public. If your manifests are private, deploy with kubectl apply from your CI pipeline instead. Both ways are described in the documentation.

Benefits for teams without DevOps:

  • Audit trail: Every deployment is a Git commit with author, timestamp, and diff.
  • Rollback via Git: git revert restores the previous state.
  • No cluster access needed: Developers push manifests, ArgoCD handles the rest.
  • Drift detection: ArgoCD notices when cluster state diverges from Git.
# Update the image tag in the manifest
# (or automate via CI/CD pipeline)
sed -i 's|api:1.0.0|api:1.1.0|' k8s/deployment.yaml
git add k8s/deployment.yaml
git commit -m "chore: update api to 1.1.0"
git push
# ArgoCD rolls out automatically

Common Concerns and Why They Don’t Apply to Managed Namespaces

“Kubernetes is too complex for our team”

A full cluster: yes. A namespace: no. You need to understand three concepts: Deployment, Service, HTTPRoute. That’s an afternoon of learning.

“We have no one who can debug Kubernetes issues”

The most common problems with application deployments are:

  • Image can’t be pulled -> Check registry credentials
  • Pod won’t start -> kubectl logs and kubectl describe pod
  • Application isn’t reachable -> Check service selector and port

These are application problems, not cluster problems. Cluster problems (node failures, network partitions, etcd corruption) are handled by the ITSH team. More failure patterns, sorted by symptom, are in Troubleshooting.

“What about secrets and sensitive data?”

Kubernetes Secrets are isolated within the namespace. You create them once with kubectl:

kubectl create secret generic app-secrets \
  --from-literal=database-url='postgres://user:pass@db:5432/mydb' \
  -n my-namespace

Secrets don’t belong in the Git repository. Create them with kubectl and keep them out of the synced path; a sync leaves secrets created by hand untouched.

“Do we need a container registry?”

Any public or private registry works: GitHub Container Registry (ghcr.io), Docker Hub, or a self-hosted solution. For private images, add an image pull secret to your namespace.

How Much Time Cluster Operations Take

The time a team doesn’t spend on cluster maintenance goes into product development. A conservative estimate:

Task Hours/Month (Self-Hosted) Hours/Month (Managed)
Kubernetes upgrades 4 to 8 h 0 h
Node maintenance 2 to 4 h 0 h
Monitoring (ongoing) 2 h 0 h
Certificate management 1 to 2 h 0 h
Backup verification 2 to 4 h 0 h
Incident response (cluster) 2 to 8 h 0 h
Total per month 13 to 28 h 0 h

Self-hosting adds a one-off monitoring setup of about 4 to 8 h.

The right-hand column covers cluster operations. What stays with you is backing up your database, including a restore test, and renewing the kubeconfig once a year.

At an assumed hourly rate of €90, that’s €1,170 to €2,520 of working time per month. What the infrastructure itself costs is worked out for a self-hosted cluster, AWS EKS and a managed namespace in What Does Kubernetes Cost for Small Businesses?.

A Realistic Setup for a Three-Person Team

Scenario: An agency runs a client platform with an API, frontend, and background jobs.

Infrastructure on ITSH:

  • 1 namespace with PAYG billing
  • 3 deployments (API, frontend, worker)
  • 1 PostgreSQL database through the preinstalled CloudNativePG operator, with a scheduled backup to an S3 bucket of your own (here’s how)
  • ArgoCD for automatic deployments, switched on in the portal
  • Daily namespace backups by the platform, restores via support

Workflow:

  1. Developer writes code and pushes to GitHub
  2. GitHub Actions builds the container image
  3. Image is pushed to the registry
  4. Manifest file is updated with the new tag (manually or automatically)
  5. ArgoCD rolls out the change
  6. Pods, logs, and events in the customer portal show whether the rollout completed

Not a single step in this workflow requires cluster administration knowledge.

Monthly costs:

  • ITSH namespace: about €30 to €50 gross per month (depending on resource usage)
  • GitHub Actions: The free tier is often enough for small projects
  • Total: about €30 to €50 gross per month for a production-ready Kubernetes environment, plus storage for the database backup in the S3 bucket

When a Managed Namespace Is Not the Right Fit

A namespace is a separated part of a shared cluster, not a cluster of your own. That sets two limits:

  • No CRDs, operators or cluster-wide objects of your own. You use the operators the platform provides, for PostgreSQL for example. A tool that ships its own CRDs cannot be installed in the namespace.
  • No access to the monitoring stack. Grafana, ServiceMonitors and PrometheusRules are not available to you.

If your setup depends on either, you need a cluster of your own.

Conclusion

Container hosting on Kubernetes doesn’t need a DevOps team when the platform handles cluster operations. Dockerfiles, manifests and CI/CD are within reach of any development team.

A managed namespace on ITSH reduces the entry point to three steps:

  1. Package your application into a container
  2. Write a Kubernetes manifest
  3. Deploy, via kubectl apply or GitOps

Everything else (cluster updates, monitoring of the cluster and nodes, daily namespace backups, TLS certificates) runs in the background.

Read next: Kubernetes in Production: Databases, HTTPS, and Autoscaling and What Does Kubernetes Cost for Small Businesses?

Create a free namespace and rebuild the example →

Or run the numbers first: Costs for your setup in the pricing calculator →