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:
- Kubernetes manifests live in a Git repository
- ArgoCD watches the repository
- 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 revertrestores 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 logsandkubectl 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:
- Developer writes code and pushes to GitHub
- GitHub Actions builds the container image
- Image is pushed to the registry
- Manifest file is updated with the new tag (manually or automatically)
- ArgoCD rolls out the change
- 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:
- Package your application into a container
- Write a Kubernetes manifest
- Deploy, via
kubectl applyor 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 →