MyAIDevelopment · Product · Operations notes

Cloud and Kubernetes: AWS · Google Cloud · Azure · Korean Clouds

The three major clouds use different service names, but they offer parts of the same shape that solve the same problems. Learn the mapping before memorizing names.

Big Three Mapping

Area AWS Google Cloud Azure
VM Amazon EC2 Compute Engine Azure Virtual Machines
Managed Kubernetes Amazon EKS GKE AKS
Serverless Container Amazon ECS (Express Mode, Fargate) Cloud Run Azure Container Apps
Functions AWS Lambda Cloud Run functions Azure Functions
Object Storage Amazon S3 Cloud Storage Azure Blob Storage
Seoul region ap-northeast-2 asia-northeast3 Korea Central

How to Choose

Design Criteria: Well-Architected

The AWS Well-Architected Framework reviews a design against six pillars.

Pillar Question
Operational Excellence Can we run, observe and improve it?
Security Does it protect information, systems and assets?
Reliability Does it recover from failures and handle changing demand?
Performance Efficiency Does it use resources efficiently?
Cost Optimization Is value per cost maximized?
Sustainability Does it reduce energy and resource use?

The pillars involve trade-offs. Multi-region, for example, raises reliability but also raises cost and operational complexity. Google Cloud and Azure provide similar architecture frameworks.

Korean Clouds and the Public Sector

Provider Verified facts
NAVER Cloud Ncloud Kubernetes Service. CI/CD can be built with SourceCommit · SourceBuild · SourceDeploy · SourcePipeline
NHN Cloud NHN Kubernetes Service (NKS) and a Deploy service. NHN Cloud for public institutions obtained CSAP certification in 2022-12 (per the company)
KT Cloud Reported (2024-02) as one of the "big three" in the Korean public cloud market with NAVER Cloud and NHN Cloud. In 2026-03 it was reported to have obtained CSAP certification for its in-house "kt cloud PLATFORM" (OpenStack rebuilt on Kubernetes)
KakaoCloud Run by Kakao Enterprise. Offers Kubernetes Engine, a managed Kubernetes service. Its predecessor, Kakao i Cloud, was reported in 2022-06 to have passed a CSAP follow-up audit with Kubernetes-based IaaS

CSAP (Cloud Security Assurance Program) is a Korean certification, based on the Act on the Development of Cloud Computing and Protection of its Users, that certifies whether clouds supplied to public institutions meet information security criteria.

flowchart LR
    R[Requirements] --> P{Public-sector customer?}
    P -->|Yes| C[Check the required CSAP grade]
    P -->|No| G{Large share of overseas users?}
    G -->|Yes| H[Global cloud + consider multi-region]
    G -->|No| K[Seoul region: global or Korean cloud]

Containers: Build Once, Deploy Many Times

A container image is an immutable artifact that bundles the runtime environment. Promoting the same image from Dev → Staging → Production reduces "it worked on my machine" problems.

FROM node:22-slim
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY . .
USER node
CMD ["node", "server.js"]

Put a .dockerignore next to the Dockerfile.

node_modules
.env
.git

COPY . . copies the whole build context into the image. Without .dockerignore, a local node_modules overwrites the result of npm ci so the production image ships different dependencies, and secrets from .env and the .git history stay in an image layer. A smaller build context also builds faster.

Core Kubernetes Concepts

Concept Role
Pod The unit that runs containers
Deployment Manages desired Pod count, version and rolling updates
Service Gives a group of Pods a stable internal address
Ingress / Gateway API Connects external HTTP traffic to Services
ConfigMap / Secret Injects configuration and sensitive data
HorizontalPodAutoscaler Adjusts Pod count with load

Minimal Manifest: Deployment + Service

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 2
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      terminationGracePeriodSeconds: 30
      containers:
        - name: web
          image: registry.example.com/web@sha256:<digest>
          ports:
            - containerPort: 8080
          lifecycle:
            preStop:
              sleep:
                seconds: 5
          readinessProbe:
            httpGet:
              path: /healthz/ready
              port: 8080
            periodSeconds: 5
          livenessProbe:
            httpGet:
              path: /healthz/live
              port: 8080
            initialDelaySeconds: 10
            periodSeconds: 10
          resources:
            requests:
              cpu: 250m
              memory: 256Mi
            limits:
              memory: 512Mi
---
apiVersion: v1
kind: Service
metadata:
  name: web
spec:
  selector:
    app: web
  ports:
    - port: 80
      targetPort: 8080
Missing What happens
No readinessProbe The container counts as Ready as soon as it starts. Traffic reaches Pods that are still initializing, so errors spike on every rolling update
No resources.requests The scheduler packs Pods onto one node without knowing what they need. When the node runs short, Pods using more than they requested are evicted first, and Pods that requested nothing (BestEffort) are first in line
replicas: 1 Whenever that Pod restarts, is evicted or its node is drained, nothing is left to serve traffic. A rollout also depends on a single new Pod's readiness, so an inaccurate probe means an outage

Kubernetes Versions and Lifespan (as of 2026-09-28)

Ingress NGINX Retirement

In 2025-11 the Kubernetes project announced the retirement of the widely used Ingress NGINX controller. Best-effort maintenance ran until 2026-03; after that there are no releases, bug fixes or security fixes. The recommended path is migrating to the Gateway API or another ingress controller, and the conversion tool Ingress2Gateway 1.0 was released in 2026-03.

Bad Example / Good Example

Bad:  Two services and three developers, yet we build our own Kubernetes cluster
      and run the same version for two years with no upgrade plan.
Good: Start on serverless containers, and move to managed Kubernetes when services,
      traffic and team size grow enough to need shared operations.

Signals That You Need Kubernetes

References