---
title: "kubernetes ingress on digitalocean: the ultimate setup guide you can’t afford to miss"
author: "pilput"
canonical: "https://pilput.net/pilput/kubernetes-ingress-on-digitalocean-the-ultimate-setup-guide-you-cant-afford-to-miss"
published: "2025-08-10T04:36:57.930714Z"
updated: "2025-08-10T04:36:57.930714Z"
description: "what is kubernetes ingress and why it matters for devops when diving into the world of devops and container orchestration, understanding kubernetes ingress is ..."
---
# kubernetes ingress on digitalocean: the ultimate setup guide you can’t afford to miss

## what is kubernetes ingress and why it matters for devops

when diving into the world of **devops** and container orchestration, understanding kubernetes ingress is a game-changer. ingress acts as a gateway to your kubernetes cluster, allowing external traffic to reach your services in a controlled and efficient way.

for **full stack developers** and engineers, ingress isn't just a networking tool—it's a critical piece in delivering scalable, secure, and maintainable applications. whether you're deploying a frontend react app or a backend api, ingress helps you manage routing rules, ssl termination, and path-based access—without exposing every service directly to the internet.

## why choose digitalocean for kubernetes?

digitalocean offers a simple, intuitive kubernetes experience that's perfect for beginners and seasoned developers alike. its managed kubernetes service (doks) reduces the complexity of setting up clusters, making it ideal for **students and coders** who want to focus on building instead of infrastructure maintenance.

with built-in integrations, affordable pricing, and seamless domain management, digitalocean is a strong choice for anyone practicing **coding** projects or learning **devops** workflows.

## prerequisites for setting up ingress on digitalocean

before we begin, make sure you have the following:

- a digitalocean account with billing enabled

- kubectl installed locally (`kubectl version --client`)

- doctl cli installed and authenticated (`doctl auth init`)

- a domain name (or subdomain) pointing to your digitalocean load balancer

- a running kubernetes cluster on digitalocean

## step 1: create a kubernetes cluster on digitalocean

navigate to the digitalocean control panel and click **“create” > “kubernetes”**. choose a cluster name, region, and node pool size (start with the smallest if you're learning).

once your cluster is active, download the kubeconfig file:

```
doctl kubernetes cluster kubeconfig save your-cluster-name
```

verify access with:

```
kubectl get nodes
```

you should see your nodes listed as `ready`.

## step 2: deploy a sample application

let’s deploy a simple nginx app to test our ingress setup.

create a file called `nginx-deployment.yaml`:

```
apiversion: apps/v1
kind: deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 2
  selector:
    matchlabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerport: 80
---
apiversion: v1
kind: service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: tcp
      port: 80
      targetport: 80
```

apply it:

```
kubectl apply -f nginx-deployment.yaml
```

verify it's running:

```
kubectl get pods,services
```

## step 3: install the nginx ingress controller

digitalocean recommends using the official nginx ingress controller. install it using helm for easier management:

```
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
helm install ingress-nginx ingress-nginx/ingress-nginx
```

this command deploys the ingress controller and creates a **loadbalancer** service. wait a moment and check:

```
kubectl get service ingress-nginx-controller
```

you’ll see an external ip assigned—this is your ingress endpoint.

## step 4: configure dns on digitalocean

log in to your digitalocean dashboard and go to **networking > domains**.

create a new domain or select an existing one. add an a record pointing to the external ip from the previous step:

- **hostname:** `*` or `example.yourdomain.com`

- **will direct to:** [your ingress ip]

- **type:** a

this wildcard or specific record ensures all subdomains route correctly through ingress.

## step 5: create an ingress resource

now define how traffic should be routed. create `ingress.yaml`:

```
apiversion: networking.k8s.io/v1
kind: ingress
metadata:
  name: app-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
spec:
  rules:
  - host: example.yourdomain.com
    http:
      paths:
      - path: /
        pathtype: prefix
        backend:
          service:
            name: nginx-service
            port:
              number: 80
```

apply it:

```
kubectl apply -f ingress.yaml
```

visit `http://example.yourdomain.com` in your browser—you should see the nginx welcome page!

### adding ssl with let's encrypt (bonus for seo & security)

secure your app using tls. install **cert-manager** to automate ssl with let's encrypt:

```
helm repo add jetstack https://charts.jetstack.io
helm repo update
helm install \
  cert-manager jetstack/cert-manager \
  --namespace cert-manager \
  --create-namespace \
  --version v1.12.0 \
  --set installcrds=true
```

then create a `clusterissuer` for let's encrypt:

```
apiversion: cert-manager.io/v1
kind: clusterissuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: admin@yourdomain.com
    privatekeysecretref:
      name: letsencrypt-prod
    solvers:
    - http01:
        ingress:
          class: nginx
```

update your ingress to request https:

```
apiversion: networking.k8s.io/v1
kind: ingress
metadata:
  name: app-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
spec:
  tls:
  - hosts:
      - example.yourdomain.com
    secretname: example-tls
  rules:
  - host: example.yourdomain.com
    http:
      paths:
      - path: /
        pathtype: prefix
        backend:
          service:
            name: nginx-service
            port:
              number: 80
```

## troubleshooting common ingress issues

- **ingress ip pending?** wait a few minutes—digitalocean may take time to assign the load balancer ip.

- **503 service unavailable?** double-check that your service name and port in the ingress exactly match the deployed service.

- **ssl not working?** verify your domain dns and ensure the email in clusterissuer is valid.

- use `kubectl describe ingress app-ingress` and `kubectl logs` on ingress controller pods to debug.

## final thoughts: mastering devops one step at a time

setting up kubernetes ingress on digitalocean is a powerful skill that bridges **coding** and real-world deployment. whether you're a student building your portfolio or a full stack engineer scaling an app, this setup enhances your **seo** strategy by ensuring your sites are secure, fast, and accessible.

remember: every expert was once a beginner. keep experimenting, break things, and rebuild. that’s how real **devops** mastery happens.

**pro tip:** document your journey. writing blogs about your kubernetes setup not only improves your learning but boosts your visibility—great for personal **seo** and showcasing your skills!