Что такое Ingress в OpenShift?

Question

claude-haiku-4.5 · Accepted Answer

# Что такое Ingress в OpenShift/Kubernetes

Ingress — это **объект, который управляет внешним доступом к сервисам** внутри кластера. Он маршрутизирует HTTP/HTTPS трафик извне на нужные сервисы внутри кластера.

## Аналогия

```
Without Ingress:  HTTP трафик → напрямую на IP:порт (сложно, небезопасно)
With Ingress:     HTTP трафик → Ingress → маршрутизация → нужный Service
```

## Проблема, которую решает Ingress

### Без Ingress

```yaml
apiVersion: v1
kind: Service
metadata:
  name: my-app
spec:
  type: LoadBalancer      # Создаёт отдельный IP для каждого сервиса
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: my-app
```

**Проблемы:**
- Каждый сервис получает свой IP адрес (дорого в облаке)
- Нельзя использовать domain names с HTTPS
- Нельзя маршрутизировать по URL path

### С Ingress

```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
spec:
  rules:
  - host: "api.example.com"
    http:
      paths:
      - path: /users
        pathType: Prefix
        backend:
          service:
            name: users-service
            port:
              number: 8080
      - path: /products
        pathType: Prefix
        backend:
          service:
            name: products-service
            port:
              number: 8080
  - host: "admin.example.com"
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: admin-service
            port:
              number: 8080
```

**Преимущества:**
- Один IP для всех сервисов (через Ingress Controller)
- HTTPS поддержка
- Маршрутизация по domain и path
- Более гибко и дёшево

## Как работает Ingress

```
1. Пользователь: curl https://api.example.com/users
   ↓
2. DNS: api.example.com → 1.2.3.4 (IP Ingress Controller)
   ↓
3. HTTP request идёт на Ingress Controller (обычно это nginx или другой reverse proxy)
   ↓
4. Ingress Controller читает Ingress manifest:
   "api.example.com + /users → users-service:8080"
   ↓
5. Маршрутизирует на соответствующий Service (ClusterIP)
   ↓
6. Service балансирует трафик между Pods
   ↓
7. Response возвращается пользователю
```

## Компоненты

### 1. Ingress Manifest (правила маршрутизации)

```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: app-ingress
spec:
  ingressClassName: nginx  # Какой Ingress Controller использовать
  rules:
  - host: "myapp.com"
    http:
      paths:
      - path: "/"
        pathType: Prefix
        backend:
          service:
            name: app-service
            port:
              number: 8080
```

### 2. Ingress Controller (реализует правила)

Это обычно **nginx**, **HAProxy** или другой reverse proxy, который:
- Читает Ingress манифесты
- Конфигурирует себя для маршрутизации
- Принимает внешний трафик

```bash
# В OpenShift обычно уже есть встроенный Router (OpenShift Router = Ingress Controller)
# Проверить:
oc get ingresscontroller -n openshift-ingress
```

### 3. Service (бэкенд для Ingress)

```yaml
apiVersion: v1
kind: Service
metadata:
  name: app-service
spec:
  selector:
    app: my-app
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 8080
  type: ClusterIP  # ← ВАЖНО! ClusterIP, не LoadBalancer
```

## Примеры использования

### Пример 1: Простая маршрутизация по domain

```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: simple-ingress
spec:
  rules:
  - host: "frontend.example.com"
    http:
      paths:
      - path: "/"
        pathType: Prefix
        backend:
          service:
            name: frontend
            port:
              number: 3000
  
  - host: "api.example.com"
    http:
      paths:
      - path: "/"
        pathType: Prefix
        backend:
          service:
            name: api
            port:
              number: 8080
```

### Пример 2: Маршрутизация по path

```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: path-based-ingress
spec:
  rules:
  - host: "myapp.com"
    http:
      paths:
      - path: "/api"
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 8080
      
      - path: "/admin"
        pathType: Prefix
        backend:
          service:
            name: admin-service
            port:
              number: 8080
      
      - path: "/"
        pathType: Prefix
        backend:
          service:
            name: frontend-service
            port:
              number: 3000
```

### Пример 3: HTTPS с TLS

```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: tls-ingress
spec:
  tls:
  - hosts:
    - "myapp.com"
    - "www.myapp.com"
    secretName: myapp-tls-secret  # Secret с сертификатом
  
  rules:
  - host: "myapp.com"
    http:
      paths:
      - path: "/"
        pathType: Prefix
        backend:
          service:
            name: app-service
            port:
              number: 8080
  
  - host: "www.myapp.com"
    http:
      paths:
      - path: "/"
        pathType: Prefix
        backend:
          service:
            name: app-service
            port:
              number: 8080
```

### Пример 4: Создание TLS Secret

```bash
# Из файлов сертификата
kubectl create secret tls myapp-tls-secret \
  --cert=path/to/tls.crt \
  --key=path/to/tls.key \
  -n default

# Или с Let's Encrypt (с cert-manager)
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: myapp-cert
spec:
  secretName: myapp-tls-secret
  issuerRef:
    name: letsencrypt-prod
    kind: ClusterIssuer
  dnsNames:
  - myapp.com
  - www.myapp.com
```

## OpenShift Route vs Kubernetes Ingress

OpenShift имеет свой собственный объект **Route**, который похож на Ingress, но более мощный:

```yaml
# OpenShift Route (специфично для OpenShift)
apiVersion: route.openshift.io/v1
kind: Route
metadata:
  name: my-route
spec:
  host: myapp.example.com
  to:
    kind: Service
    name: my-service
  tls:
    termination: edge           # TLS termination on the edge
    insecureEdgeTerminationPolicy: Allow
```

```yaml
# Kubernetes Ingress (стандартный)
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
spec:
  rules:
  - host: myapp.example.com
    http:
      paths:
      - path: "/"
        backend:
          service:
            name: my-service
```

## pathType: разница

```yaml
paths:
- path: "/api/v1"
  pathType: Exact      # Точно /api/v1, не /api/v1/users
  
- path: "/api"
  pathType: Prefix     # /api, /api/v1, /api/users и т.д.
  
- path: "/api.*"
  pathType: ImplementationSpecific  # Зависит от Ingress Controller
```

## Практический пример Java приложения

```yaml
# 1. Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: java-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: java-app
  template:
    metadata:
      labels:
        app: java-app
    spec:
      containers:
      - name: app
        image: my-registry/java-app:1.0
        ports:
        - containerPort: 8080

---
# 2. Service (ClusterIP)
apiVersion: v1
kind: Service
metadata:
  name: java-app-service
spec:
  selector:
    app: java-app
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 8080
  type: ClusterIP

---
# 3. Ingress (маршрутизация)
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: java-app-ingress
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - "api.mycompany.com"
    secretName: api-tls
  rules:
  - host: "api.mycompany.com"
    http:
      paths:
      - path: "/"
        pathType: Prefix
        backend:
          service:
            name: java-app-service
            port:
              number: 8080
```

## Команды для работы с Ingress

```bash
# Посмотреть Ingress
kubectl get ingress
oc get route  # В OpenShift

# Описание
kubectl describe ingress my-ingress
oc describe route my-route

# Логи Ingress Controller
kubectl logs -n ingress-nginx deployment/nginx-ingress-controller

# Тестирование
curl https://api.example.com/users  # Если уже настроен DNS
curl -H "Host: api.example.com" https://localhost/users  # Локально
```

## Когда использовать Ingress

✅ Много микросервисов на одном IP
✅ HTTPS/TLS нужен
✅ Маршрутизация по domain/path
✅ Production системы

❌ Простое приложение с одним Service
❌ Потоковые данные (WebSocket лучше через Service)

## Проблемы и troubleshooting

```bash
# Ingress не получает внешний IP
$ kubectl get ingress
NAME      CLASS   HOSTS     ADDRESS   PORTS
my-ingress  nginx   api.com   <pending> 80

# Решение: проверить Ingress Controller
kubectl get ingressclass
kubectl get pods -n ingress-nginx

# Тестировать внутри кластера
kubectl run -it --rm debug --image=busybox --restart=Never -- sh
curl http://java-app-service:8080/
```

## Итог

Ingress — это **маршрутизатор трафика** для Kubernetes:
- Принимает внешний HTTP/HTTPS
- Маршрутизирует на нужные Services
- Поддерживает multiple domains, paths, TLS
- Экономит IP адреса (один Ingress для всех сервисов)

Для Java разработчика важно понимать, как настроить Ingress для своего приложения в K8s/OpenShift.

Что такое Ingress в OpenShift?

Комментарии (1)

Аналогия

Проблема, которую решает Ingress

Без Ingress

С Ingress

Как работает Ingress

Компоненты

1. Ingress Manifest (правила маршрутизации)

2. Ingress Controller (реализует правила)

3. Service (бэкенд для Ingress)

Примеры использования

Пример 1: Простая маршрутизация по domain

Пример 2: Маршрутизация по path

Пример 3: HTTPS с TLS

Пример 4: Создание TLS Secret

OpenShift Route vs Kubernetes Ingress

pathType: разница

Практический пример Java приложения

Команды для работы с Ingress

Когда использовать Ingress

Проблемы и troubleshooting

Итог