Crossplane Composition Remote Work Setup

Crossplane Composition Remote Work Setup คืออะไร

Crossplane เป็น open source Kubernetes add-on ที่เปลี่ยน Kubernetes cluster ให้เป็น universal control plane สำหรับจัดการ cloud infrastructure ผ่าน Kubernetes APIs Compositions คือ feature หลักที่ช่วยสร้าง abstractions สำหรับ infrastructure — รวมหลาย cloud resources เป็น single API Remote Work Setup คือการจัดสภาพแวดล้อมให้ทีม distributed ทำงานกับ cloud infrastructure ได้อย่างมีประสิทธิภาพ การรวมแนวคิดเหล่านี้ช่วยให้ทีม remote สร้าง self-service infrastructure platform ที่ developers สั่ง provision resources ผ่าน kubectl โดยไม่ต้องรู้ cloud provider details

Crossplane Architecture

# crossplane_arch.py — Crossplane architecture
import json

class CrossplaneArch:
    COMPONENTS = {
        "providers": {
            "name": "Providers",
            "description": "Plugins ที่เชื่อม Crossplane กับ cloud providers",
            "examples": ["provider-aws", "provider-gcp", "provider-azure", "provider-kubernetes"],
        },
        "managed_resources": {
            "name": "Managed Resources (MR)",
            "description": "Kubernetes CRDs ที่ represent cloud resources (1:1 mapping)",
            "examples": ["RDSInstance", "S3Bucket", "VPC", "GKECluster"],
        },
        "compositions": {
            "name": "Compositions",
            "description": "Template ที่รวมหลาย MRs เป็น single resource",
            "examples": ["CompositeDatabase (RDS + SecurityGroup + SubnetGroup)"],
        },
        "xrds": {
            "name": "CompositeResourceDefinitions (XRDs)",
            "description": "กำหนด API schema สำหรับ Composite Resources",
            "examples": ["XDatabase, XNetwork, XCluster"],
        },
        "claims": {
            "name": "Claims",
            "description": "Developer-facing API สำหรับขอ resources (namespace-scoped)",
            "examples": ["Database claim → provisions RDS + security group"],
        },
    }

    FLOW = """
    Crossplane Flow:
    
    [Developer] → kubectl apply -f database-claim.yaml
         ↓
    [Claim] → XDatabase (namespace-scoped)
         ↓
    [XRD] → validates schema
         ↓
    [Composition] → creates Managed Resources
         ↓
    [Provider-AWS] → provisions RDS + SecurityGroup + SubnetGroup
         ↓
    [AWS Cloud] → actual resources created
    """

    def show_components(self):
        print("=== Crossplane Components ===\n")
        for key, comp in self.COMPONENTS.items():
            print(f"[{comp['name']}]")
            print(f"  {comp['description']}")
            print(f"  Examples: {', '.join(comp['examples'][:2])}")
            print()

    def show_flow(self):
        print("=== Resource Provisioning Flow ===")
        print(self.FLOW)

arch = CrossplaneArch()
arch.show_components()
arch.show_flow()

Composition สำหรับ Remote Teams

# composition.py — Crossplane Compositions for remote teams
import json

class RemoteComposition:
    XRD = """
# xrd-database.yaml — CompositeResourceDefinition
apiVersion: apiextensions.crossplane.io/v1
kind: CompositeResourceDefinition
metadata:
  name: xdatabases.platform.example.com
spec:
  group: platform.example.com
  names:
    kind: XDatabase
    plural: xdatabases
  claimNames:
    kind: Database
    plural: databases
  versions:
    - name: v1alpha1
      served: true
      referenceable: true
      schema:
        openAPIV3Schema:
          type: object
          properties:
            spec:
              type: object
              properties:
                parameters:
                  type: object
                  properties:
                    engine:
                      type: string
                      enum: [postgres, mysql]
                      default: postgres
                    size:
                      type: string
                      enum: [small, medium, large]
                      default: small
                    region:
                      type: string
                      default: ap-southeast-1
                  required: [engine, size]
"""

    COMPOSITION = """
# composition-database.yaml — Composition template
apiVersion: apiextensions.crossplane.io/v1
kind: Composition
metadata:
  name: database-aws
  labels:
    provider: aws
spec:
  compositeTypeRef:
    apiVersion: platform.example.com/v1alpha1
    kind: XDatabase
  resources:
    - name: rds-instance
      base:
        apiVersion: rds.aws.crossplane.io/v1alpha1
        kind: RDSInstance
        spec:
          forProvider:
            dbInstanceClass: db.t3.micro
            engine: postgres
            engineVersion: "15"
            masterUsername: admin
            allocatedStorage: 20
            publiclyAccessible: false
            vpcSecurityGroupIds: []
          providerConfigRef:
            name: aws-provider
      patches:
        - fromFieldPath: spec.parameters.engine
          toFieldPath: spec.forProvider.engine
        - fromFieldPath: spec.parameters.size
          toFieldPath: spec.forProvider.dbInstanceClass
          transforms:
            - type: map
              map:
                small: db.t3.micro
                medium: db.t3.medium
                large: db.r6g.large
        - fromFieldPath: spec.parameters.region
          toFieldPath: spec.forProvider.region

    - name: security-group
      base:
        apiVersion: ec2.aws.crossplane.io/v1alpha1
        kind: SecurityGroup
        spec:
          forProvider:
            description: "Database security group"
            ingress:
              - fromPort: 5432
                toPort: 5432
                protocol: tcp
                cidrBlocks: ["10.0.0.0/8"]
"""

    CLAIM = """
# database-claim.yaml — Developer claim
apiVersion: platform.example.com/v1alpha1
kind: Database
metadata:
  name: my-app-db
  namespace: team-alpha
spec:
  parameters:
    engine: postgres
    size: small
    region: ap-southeast-1
  compositionSelector:
    matchLabels:
      provider: aws
"""

    def show_xrd(self):
        print("=== XRD (API Definition) ===")
        print(self.XRD[:500])

    def show_composition(self):
        print(f"\n=== Composition ===")
        print(self.COMPOSITION[:500])

    def show_claim(self):
        print(f"\n=== Developer Claim ===")
        print(self.CLAIM)

comp = RemoteComposition()
comp.show_xrd()
comp.show_composition()
comp.show_claim()

Self-Service Platform

# platform.py — Self-service platform for remote teams
import json

class SelfServicePlatform:
    RESOURCES = {
        "database": {
            "claim_kind": "Database",
            "sizes": {"small": "db.t3.micro (2 vCPU, 1GB)", "medium": "db.t3.medium (2 vCPU, 4GB)", "large": "db.r6g.large (2 vCPU, 16GB)"},
            "engines": ["postgres", "mysql"],
        },
        "cache": {
            "claim_kind": "Cache",
            "sizes": {"small": "cache.t3.micro", "medium": "cache.t3.medium", "large": "cache.r6g.large"},
            "engines": ["redis", "memcached"],
        },
        "storage": {
            "claim_kind": "ObjectStore",
            "options": {"private": "Private bucket + encryption", "public": "Public read CDN"},
            "features": ["versioning", "lifecycle rules", "replication"],
        },
        "network": {
            "claim_kind": "Network",
            "options": {"dev": "Single AZ, no NAT", "staging": "Multi-AZ, NAT", "production": "Multi-AZ, NAT, VPN"},
        },
    }

    BACKSTAGE_INTEGRATION = """
# backstage-template.yaml — Backstage + Crossplane integration
apiVersion: scaffolder.backstage.io/v1beta3
kind: Template
metadata:
  name: provision-database
  title: Provision Database
spec:
  owner: platform-team
  type: infrastructure
  parameters:
    - title: Database Configuration
      properties:
        engine:
          type: string
          enum: [postgres, mysql]
          default: postgres
        size:
          type: string
          enum: [small, medium, large]
          default: small
        team:
          type: string
          description: Your team namespace
  steps:
    - id: apply-claim
      name: Create Database Claim
      action: kubernetes:apply
      input:
        manifest:
          apiVersion: platform.example.com/v1alpha1
          kind: Database
          metadata:
            name: "}-db"
            namespace: "}"
          spec:
            parameters:
              engine: "}"
              size: "}"
"""

    def show_resources(self):
        print("=== Self-Service Resources ===\n")
        for key, res in self.RESOURCES.items():
            print(f"[{res['claim_kind']}]")
            if "sizes" in res:
                for size, spec in res["sizes"].items():
                    print(f"  {size}: {spec}")
            print()

    def show_backstage(self):
        print("=== Backstage Integration ===")
        print(self.BACKSTAGE_INTEGRATION[:500])

platform = SelfServicePlatform()
platform.show_resources()
platform.show_backstage()

GitOps Workflow

# gitops.py — GitOps workflow for Crossplane
import json

class GitOpsWorkflow:
    WORKFLOW = {
        "step1": {"name": "Developer creates PR", "action": "Add/modify claim YAML in Git repo"},
        "step2": {"name": "PR Review", "action": "Platform team reviews infrastructure request"},
        "step3": {"name": "Merge to main", "action": "ArgoCD/Flux detects change"},
        "step4": {"name": "Sync to cluster", "action": "Claim applied to Kubernetes"},
        "step5": {"name": "Crossplane provisions", "action": "Cloud resources created/updated"},
        "step6": {"name": "Status update", "action": "Claim status shows Ready=True"},
    }

    ARGOCD_APP = """
# argocd-app.yaml — ArgoCD Application for Crossplane claims
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: team-alpha-infra
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/company/infra-claims.git
    targetRevision: main
    path: teams/alpha
  destination:
    server: https://kubernetes.default.svc
    namespace: team-alpha
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true
"""

    REPO_STRUCTURE = """
    infra-claims/
    ├── teams/
    │   ├── alpha/
    │   │   ├── database.yaml      # Database claim
    │   │   ├── cache.yaml         # Cache claim
    │   │   └── storage.yaml       # S3 bucket claim
    │   ├── beta/
    │   │   ├── database.yaml
    │   │   └── network.yaml
    │   └── gamma/
    │       └── database.yaml
    ├── platform/
    │   ├── compositions/          # Composition templates
    │   ├── xrds/                  # XRD definitions
    │   └── providers/             # Provider configs
    └── .github/
        └── workflows/
            └── validate.yml       # PR validation
    """

    def show_workflow(self):
        print("=== GitOps Workflow ===\n")
        for key, step in self.WORKFLOW.items():
            print(f"  [{step['name']}] → {step['action']}")

    def show_argocd(self):
        print(f"\n=== ArgoCD App ===")
        print(self.ARGOCD_APP[:400])

    def show_structure(self):
        print(f"\n=== Repo Structure ===")
        print(self.REPO_STRUCTURE)

gitops = GitOpsWorkflow()
gitops.show_workflow()
gitops.show_argocd()
gitops.show_structure()

Monitoring & Troubleshooting

# monitoring.py — Crossplane monitoring
import json
import random

class CrossplaneMonitoring:
    def resource_status(self):
        print("=== Resource Status ===\n")
        resources = [
            {"team": "alpha", "type": "Database", "name": "app-db", "ready": True, "synced": True, "age": "5d"},
            {"team": "alpha", "type": "Cache", "name": "app-cache", "ready": True, "synced": True, "age": "3d"},
            {"team": "beta", "type": "Database", "name": "api-db", "ready": True, "synced": True, "age": "10d"},
            {"team": "beta", "type": "Network", "name": "vpc", "ready": random.choice([True, False]), "synced": True, "age": "15d"},
            {"team": "gamma", "type": "Database", "name": "ml-db", "ready": True, "synced": True, "age": "2d"},
        ]
        for r in resources:
            ready = "Ready" if r["ready"] else "NOT_READY"
            print(f"  [{ready:>9}] {r['team']}/{r['type']}/{r['name']} (age: {r['age']})")

    def troubleshooting(self):
        print(f"\n=== Common Issues ===")
        issues = [
            {"issue": "Claim stuck in Creating", "fix": "kubectl describe  → check events, provider credentials"},
            {"issue": "Provider not installed", "fix": "kubectl get providers → install missing provider"},
            {"issue": "Composition not matching", "fix": "Check compositionSelector labels match composition labels"},
            {"issue": "Cloud quota exceeded", "fix": "Check cloud provider quotas, request increase"},
        ]
        for i in issues:
            print(f"  Issue: {i['issue']}")
            print(f"  Fix: {i['fix']}")
            print()

    def useful_commands(self):
        print("=== Useful Commands ===")
        cmds = [
            "kubectl get managed                    # All managed resources",
            "kubectl get composite                  # All composite resources",
            "kubectl get claim --all-namespaces     # All claims",
            "kubectl describe database my-db -n team-alpha  # Claim details",
            "kubectl get events --field-selector involvedObject.name=my-db",
        ]
        for cmd in cmds:
            print(f"  {cmd}")

mon = CrossplaneMonitoring()
mon.resource_status()
mon.troubleshooting()
mon.useful_commands()

FAQ - คำถามที่พบบ่อย

Q: Crossplane กับ Terraform อันไหนดี?

A: Crossplane: Kubernetes-native, continuous reconciliation, self-service claims Terraform: mature, HCL language, state management, module ecosystem ใช้ Crossplane: K8s-centric teams, self-service platform, GitOps, continuous drift detection ใช้ Terraform: multi-tool teams, complex provisioning, one-time infrastructure หลายทีมใช้ทั้งคู่: Terraform สำหรับ foundational infra + Crossplane สำหรับ app-level resources

Q: Remote team ใช้ Crossplane ยากไหม?

A: สำหรับ platform team (สร้าง Compositions): ต้องเรียนรู้ Crossplane concepts สำหรับ developers (ใช้ Claims): ง่ายมาก — เขียน simple YAML apply ด้วย kubectl Self-service: developer ไม่ต้องรู้ cloud provider details GitOps: ทุกอย่างผ่าน Git PR — remote-friendly

Q: Crossplane รองรับ multi-cloud ไหม?

A: รองรับ — เป็น key feature ของ Crossplane Providers: AWS, GCP, Azure, Kubernetes, Helm, etc. Composition เดียว provision ข้าม clouds ได้ ใช้ compositionSelector เลือก provider ตามต้องการ เหมาะสำหรับ organizations ที่ใช้หลาย clouds

Q: Production-ready ไหม?

A: Crossplane: CNCF incubating project, ใช้ใน production หลายบริษัทใหญ่ Providers: maturity ไม่เท่ากัน (AWS provider mature ที่สุด) แนะนำ: เริ่มด้วย non-critical resources → ค่อยขยาย สำคัญ: ตั้ง RBAC, backup provider credentials, monitor resources