Ở bài trước chúng ta đã Triển Khai Hệ Thống CI/CD Với Jenkins, Kubernetes (K3s), Terraform và AWS RDS , tuy nhiên đó là tất cả với hệ sinh thái AWS và chưa thực sự private khóa riêng các tài nguyên với nhau, ở bài này chúng ta cùng triển khai hệ thống mới với Jenkins riêng không thuộc tài nguyên của AWS nhé.

🏗️ TỔNG QUAN KIẾN TRÚC LAB (OriShop on AWS)

Dự án e-commerce OriShop (Spring Boot Java) được triển khai theo chuẩn Cloud-Native trên AWS:

• Mã nguồn: Quản lý trên GitHub.

• CI/CD: Dùng Jenkins dựng trên VPS riêng, kích hoạt tự động qua GitHub Webhook.

• Hạ tầng (IaC): Dùng Terraform để dựng toàn bộ AWS VPC, EKS, RDS (MySQL), S3 và IAM.

• Lưu trữ: RDS cho Database, S3 để chứa ảnh Media (truy cập Public).

• Bảo mật: Dùng chuẩn IRSA (IAM Roles for Service Accounts) để Pod trên EKS gọi API vào S3 một cách an toàn nhất, không lộ Access Key.

• Xử lý sự kiện (Event-Driven): Mỗi khi một tấm ảnh được upload thành công lên S3 từ EKS, S3 sẽ "bắn" một tín hiệu (Event) kích hoạt AWS Lambda.

• Nhiệm vụ của Lambda: Tự động tối ưu hóa ảnh, tạo ảnh thu nhỏ (Thumbnail) hoặc đóng dấu (Watermark) cho sản phẩm OriShop mà không làm tốn tài nguyên của cụm EKS chính. Điều này giúp hệ thống tiết kiệm RAM/CPU cho các tác vụ bán hàng.

📜 PHẦN 1: Cấu hình Jenkins (VPS) & Phân quyền AWS

Đây là trạm trung chuyển, nơi biến code từ GitHub thành Docker Image và đẩy lên EKS.

1. Tạo IAM User trên AWS:

   • Tạo một user (vd: jenkins-deployer) với quyền Programmatic Access.

   • Cấp quyền đủ để quản lý EKS (hoặc AdministratorAccess cho môi trường Lab).

   • Lấy Access Key ID và Secret Access Key.

2. Cài đặt máy chủ Jenkins:

   • Đảm bảo VPS đã cài đặt sẵn Java, Docker, AWS CLI, và kubectl.

   • Cấu hình aws configure trên VPS Jenkins bằng bộ Key vừa lấy để Jenkins có quyền ra lệnh cho AWS.

3. Cấu hình trên giao diện Jenkins:

   • Lưu thông tin đăng nhập Docker Hub (tobi1008) vào mục Credentials.

   • Lưu thông tin kubeconfig hoặc AWS Credentials vào Jenkins để Pipeline có thể kết nối với EKS.

   • Cài đặt các Plugin cần thiết: AWS Credentials, Docker Pipeline, Kubernetes CLI.

📜 PHẦN 2: Triển khai Hạ tầng với Terraform (IaC)

Biến toàn bộ giao diện click chuột của AWS thành code. Cấu trúc thư mục của chúng ta gồm:

• providers.tf: Khai báo nhà cung cấp AWS và khu vực (ap-southeast-1).

• vpc.tf: Dựng mạng ảo riêng biệt, chia subnet Public/Private, cấu hình Internet Gateway và NAT Gateway cho EKS và RDS.

• eks.tf: Dựng cụm Kubernetes (EKS Cluster) và Node Group (máy chủ t3.micro). Quan trọng: Phải kích hoạt bộ nhận diện OIDC Provider tại đây để dùng cho IRSA.

• rds.tf: Dựng Database MySQL.

• s3_iam.tf: File "hành xác" nhất nhưng xịn nhất:

  • Tạo bucket S3 ngẫu nhiên (com-quyenlt-media-...).

  • Dùng block aws_s3_bucket_public_access_block và aws_s3_bucket_policy để mở khóa Public Access, cho phép thế giới xem ảnh.

  • Thiết lập thuật toán IRSA (sts:AssumeRoleWithWebIdentity) kết nối OIDC của EKS với IAM Role.

  • Cấp chính xác quyền s3:PutObject, GetObject cho cái Role đó.

• lambda.tf / variables.tf: Khai báo các hàm không máy chủ (nếu có dùng cho các task nền) và các biến môi trường động.

📜 PHẦN 3: Cấu hình K8s & Mã nguồn Java (App Configuration)

Để Spring Boot chạy mượt trên EKS và chơi chung được với S3.

1. File orishop-eks.yaml:

   • Tạo Deployment chạy Docker Image tobi1008/orishop.

   • Tạo Service (thường là LoadBalancer hoặc NodePort) để xuất web ra ngoài.

   • Điểm mấu chốt: Tạo ServiceAccount (vd: orishop-sa) và gắn thẻ Annotation trỏ về cái ARN của IAM Role mà Terraform sinh ra. Phải map đúng cái serviceAccountName này vào trong spec của Pod.

2. Sửa mã nguồn Java (application.properties):

   • Nâng giới hạn upload file của Tomcat: spring.servlet.multipart.max-file-size=10MB.

   • Cập nhật URL kết nối đến RDS Endpoint thật.

3. Sửa mã nguồn Java (pom.xml):

   • Thêm thư viện aws-java-sdk-sts. Đây là "kính lúp" bắt buộc phải có để ứng dụng Java đọc được Token mà Kubernetes cấp cho nó.

📜 PHẦN 4: CI/CD Pipeline (Tự động hóa)

• Jenkinsfile: Viết các Stage rõ ràng: Checkout Code -> Build bằng Maven (tạo file .jar) -> Build Docker Image -> Push Image lên Docker Hub tobi1008/orishop:latest (hoặc build ID) -> Chạy lệnh kubectl apply và kubectl rollout restart để ép EKS cập nhật bản mới.

• GitHub Webhook: Lên kho code GitHub của dự án OriShop, mục Settings -> Webhooks, trỏ về URL của Jenkins VPS (kèm path /github-webhook/). Mỗi lần Tobi push code là Jenkins tự động rít lên làm việc.

📜 PHẦN 5: Vận hành & Cập nhật Database

1. Kết nối cụm EKS từ máy Mac:

   • Chạy lệnh: aws eks update-kubeconfig --region ap-southeast-1 --name <tên-cluster> để lấy file cấu hình, từ đó dùng được lệnh kubectl để soi Pod, check Log.

2. Import Dữ liệu:

   • Dùng DBeaver hoặc MySQL Workbench kết nối thẳng vào Endpoint của RDS.

   • Import file .sql ban đầu (hoặc để Flyway trong Spring Boot tự động chạy file migration).

Thực Hành

1.Cấu hình Jenkins (VPS) & Phân quyền AWS

Bước 1: Cấp "Hộ chiếu AWS" cho Jenkins Như đã bàn, vì VPS này nằm ngoài AWS, bạn cần:

1. Đăng nhập AWS Console, vào IAM -> Tạo một User tên là jenkins-deployer.
2. Cấp quyền AdministratorAccess 

Tạo Access Key và Secret Access Key.

Vào giao diện web của Jenkins -> Manage Jenkins -> Credentials -> Thêm cặp khóa này vào dưới dạng Secret text hoặc Username with password để lát nữa Pipeline lấy ra dùng.

Bạn hãy điền nốt 2 ô còn lại như sau trước khi bấm Create nhé:

1. ID: Bạn gõ chính xác chữ aws-credentials (viết liền, không dấu cách). Lát nữa code của chúng ta sẽ gọi đúng cái tên này ra để mở khóa AWS.

2. Description: Ghi chú cho dễ nhớ, ví dụ: Key AWS để deploy EKS.

Bước 2: Cấp chìa khóa kho Docker Hub Tương tự, Jenkins cần mật khẩu để đẩy Image lên kho tobi1008. Bạn cũng vào Credentials của Jenkins và lưu Username/Password của Docker Hub vào đó nhé.

bạn bấm Add credentials làm thêm y hệt một cái nữa cho Docker Hub nhé:

• Kind: Vẫn chọn Username with password.

• Username: Tên đăng nhập Docker Hub của bạn (hôm qua là tobi1008).

• Password: Mật khẩu Docker Hub của bạn.

• ID: Gõ chính xác chữ docker-hub-credentials.

• Description: Tai khoan Docker Hub.

Bước 3 : Kịch bản Jenkinsfile 

Bạn hãy tạo một file có tên là Jenkinsfile (chữ J viết hoa, không có đuôi mở rộng) nằm ngay thư mục gốc trong source code dự án của bạn, và dán toàn bộ nội dung này vào:

pipeline {
    agent {
        kubernetes {
            yaml '''
            apiVersion: v1
            kind: Pod
            spec:
              containers:
              - name: docker-cli
                image: docker:24.0.5
                command: ["cat"]
                tty: true
              - name: dind
                image: docker:24.0.5-dind
                securityContext:
                  privileged: true
                env:
                - name: DOCKER_TLS_CERTDIR
                  value: ""
              - name: k8s-tools
                image: alpine/k8s:1.28.2
                command: ["cat"]
                tty: true
            '''
        }
    }

    environment {
        DOCKER_HOST = 'tcp://localhost:2375'
        IMAGE_NAME = "tobi1008/orishop:latest"
        DOCKER_CREDS = credentials('docker-hub-credentials')
        AWS_CREDS = credentials('aws-credentials')
        AWS_REGION = "ap-southeast-1"
        EKS_CLUSTER_NAME = "quyenlt-eks-cluster"
    }

    stages {
        stage('1. Kéo mã nguồn') {
            steps {
                checkout scm
                echo "--- Đã lấy mã nguồn com.quyenlt mới nhất ---"
            }
        }

        stage('2. Đóng gói & Đẩy Image') {
            steps {
                container('docker-cli') {
                    script {
                        echo "--- Đang đợi Docker Daemon nổ máy (waitUntil) ---"
                        
                        // Jenkins sẽ lặp lại đoạn này cho đến khi return true
                        waitUntil {
                            def status = sh(script: "docker version", returnStatus: true)
                            if (status == 0) {
                                return true
                            } else {
                                echo "Docker chưa sẵn sàng, đang thử lại sau 5s..."
                                sleep 5
                                return false
                            }
                        }

                        echo "--- Docker đã sẵn sàng! Bắt đầu Build Image ---"
                        sh "docker build -t ${IMAGE_NAME} ."
                        sh "echo ${DOCKER_CREDS_PSW} | docker login -u ${DOCKER_CREDS_USR} --password-stdin"
                        sh "docker push ${IMAGE_NAME}"
                    }
                }
            }
        }

        stage('3. Triển khai lên AWS EKS') {
            steps {
                container('k8s-tools') {
                    script {
                        echo "--- Đang kết nối tới cụm EKS: ${EKS_CLUSTER_NAME} ---"
                        withEnv(["AWS_ACCESS_KEY_ID=${AWS_CREDS_USR}", "AWS_SECRET_ACCESS_KEY=${AWS_CREDS_PSW}"]) {
                            
                            sh "aws eks update-kubeconfig --region ${AWS_REGION} --name ${EKS_CLUSTER_NAME}"
                            
                            echo "--- Đang nạp file cấu hình vào EKS (Phòng default) ---"
                            sh "kubectl apply -f orishop-eks.yaml -n default"
                            sh "kubectl rollout restart deployment/orishop-app -n default"
                            
                            echo "--- Kiểm tra trạng thái các Pod ---"
                            sh "kubectl get pods -n default"
                            
                            echo "--- Triển khai lên AWS EKS thành công rực rỡ! ---"
                        }
                    }
                }
            }
        }
    }
}

Commit file này lên github, nhớ là file Jenkinsfile đặt trong mã nguồn code nhé.

Bước 4: Kích hoạt Jenkins

Vào giao diện web của Jenkins, tạo một New Item -> Chọn Pipeline -> Trỏ đường dẫn GitHub của bạn vào để Jenkins đọc cái Jenkinsfile này.

1. Ở phần General (Đang mở)

• Bạn nên tích vào ô Discard old builds (Xóa các bản build cũ).

• Trong mục Max # of builds to keep (Số bản build tối đa giữ lại), bạn điền số 5 hoặc 10. Điều này giúp ổ cứng VPS của bạn không bị rác sau hàng chục lần chạy test.

• Phần Triggers (Tự động kích hoạt): Tạm thời để trống. Lần đầu tiên chúng ta sẽ tự bấm nút chạy (Build Now) để kiểm soát lỗi. (Sau này chạy mượt rồi, mình sẽ hướng dẫn bạn móc nối Webhook để cứ gõ git push là Jenkins tự chạy).

2. Bước Quyết Định: Chuyển sang mục "Pipeline"

Bạn nhìn sang cột menu bên trái, click vào chữ Pipeline (ngay dưới chữ Triggers). Đây mới là phần linh hồn để móc nối với GitHub của bạn:

• Definition: Bấm vào menu thả xuống, đổi từ Pipeline script thành Pipeline script from SCM (Lấy kịch bản từ Source Control).

• SCM: Chọn Git.

• Repository URL: Dán đường dẫn link GitHub chứa source code com.quyenlt của bạn vào đây (ví dụ: https://github.com/tobi1008/orishop.git).

• Branch Specifier: Chỗ này cực kỳ quan trọng! Jenkins mặc định để là */master. Nếu nhánh trên GitHub của bạn tên là main, bạn phải sửa lại thành */main nhé.

• Script Path: Giữ nguyên chữ Jenkinsfile (đây là lý do lúc nãy mình dặn viết đúng chữ J hoa).

Cấu hình xong phần Pipeline này, bạn tự tin bấm nút Save màu xanh dương ở góc dưới cùng nhé!

2.Triển khai Hạ tầng với Terraform (IaC)

📁 Cấu trúc thư mục Terraform:

• providers.tf: Khai báo nhà cung cấp (AWS).

• variables.tf: Chứa các biến dùng chung (Tên cụm, Region) để dễ đổi sau này.

• vpc.tf: Hạ tầng mạng (Đường xá, cầu cống).

• eks.tf: Cụm Kubernetes (Khu công nghiệp).

• rds.tf: Database (Kho dữ liệu).

• s3_iam.tf: Chỗ lưu ảnh và Phân quyền IRSA.

1. File providers.tf (Kết nối với AWS)

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = var.aws_region
}

2. File variables.tf (Trạm điều khiển trung tâm)

variable "aws_region" {
  description = "Region triển khai"
  default     = "ap-southeast-1"
}

variable "cluster_name" {
  description = "Tên cụm EKS khớp với Jenkinsfile"
  default     = "quyenlt-eks-cluster"
}

3. File vpc.tf (Xây dựng mạng lưới Network) Lưu ý: Mình dùng module chuẩn của AWS để code ngắn gọn và an toàn nhất.

module "vpc" {
  source  = "terraform-aws-modules/vpc/aws"
  version = "~> 5.0"

  name = "quyenlt-vpc"
  cidr = "10.0.0.0/16"

  azs             = ["${var.aws_region}a", "${var.aws_region}b"]
  private_subnets = ["10.0.1.0/24", "10.0.2.0/24"]
  public_subnets  = ["10.0.101.0/24", "10.0.102.0/24"]

  # Bật NAT Gateway để Node ẩn danh vẫn ra được Internet tải Docker Image
  enable_nat_gateway   = true
  single_nat_gateway   = true # Dùng 1 cái cho rẻ
  enable_dns_hostnames = true

  # Tag bắt buộc để EKS biết đường gắn Load Balancer
  public_subnet_tags = {
    "kubernetes.io/role/elb" = 1
  }
  private_subnet_tags = {
    "kubernetes.io/role/internal-elb" = 1
  }
}

4. File eks.tf (Triệu hồi K8s)

module "eks" {
  source  = "terraform-aws-modules/eks/aws"
  version = "~> 20.0"

  cluster_name    = "quyenlt-eks-cluster"
  cluster_version = "1.29"

  # Cho phép người tạo Cluster (là máy Mac của bạn) có quyền Admin mặc định
  enable_cluster_creator_admin_permissions = true

  cluster_endpoint_public_access = true

  vpc_id     = module.vpc.vpc_id
  subnet_ids = module.vpc.private_subnets

  # Cấu hình Node Group (Các máy chủ chạy App)
  eks_managed_node_groups = {
    orishop_nodes = {
      min_size     = 1
      max_size     = 3
      desired_size = 2

      # Đã sửa thành t3.micro để vượt qua rào cản Free Tier của AWS
      instance_types = ["t3.micro"]
      capacity_type  = "ON_DEMAND"
    }
  }

  # 🔐 CẤP QUYỀN CHO JENKINS
  access_entries = {
    jenkins_admin = {
      kubernetes_groups = []
      principal_arn     = "arn:aws:iam::808999395759:user/jenkins-deployer"

      policy_associations = {
        admin_policy = {
          # Đã sửa lỗi chính tả từ aws:iam thành aws:eks
          policy_arn = "arn:aws:eks::aws:cluster-access-policy/AmazonEKSClusterAdminPolicy"
          access_scope = {
            type = "cluster"
          }
        }
      }
    }
  }

  tags = {
    Environment = "dev"
    Project     = "com.quyenlt"
  }
  enable_irsa = true
}

terraform init

terraform apply -auto-approve

# 1. Bức tường lửa bảo vệ Database (Chỉ nhận Traffic từ trong VPC)
resource "aws_security_group" "rds_sg" {
  name        = "quyenlt-rds-sg"
  description = "Allow MySQL traffic from EKS nodes"
  vpc_id      = module.vpc.vpc_id

  ingress {
    description = "MySQL from VPC"
    from_port   = 3306
    to_port     = 3306
    protocol    = "tcp"
    # Chỉ cho phép các IP nằm trong dải mạng của VPC được kết nối
    cidr_blocks = [module.vpc.vpc_cidr_block] 
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

# 2. Nhóm các Private Subnet để giấu Database
resource "aws_db_subnet_group" "quyenlt_db_subnet" {
  name       = "quyenlt-db-subnet-group"
  subnet_ids = module.vpc.private_subnets
  description = "Subnet group for com.quyenlt RDS"
}

# 3. Tạo máy chủ MySQL 8.0
resource "aws_db_instance" "orishop_db" {
  identifier             = "orishop-db"
  engine                 = "mysql"
  engine_version         = "8.0"
  instance_class         = "db.t3.micro" # Dùng gói rẻ nhất cho Lab
  allocated_storage      = 20
  storage_type           = "gp2"
  
  db_name                = "orishop" # Tên Database tạo sẵn để Spring Boot kết nối
  username               = "admin"
  password               = "OriShop12345!" # Mật khẩu giống cấu hình hôm trước
  
  db_subnet_group_name   = aws_db_subnet_group.quyenlt_db_subnet.name
  vpc_security_group_ids = [aws_security_group.rds_sg.id]
  
  publicly_accessible    = false # Tuyệt đối không đưa ra Internet
  skip_final_snapshot    = true  # Bắt buộc True để lúc gõ destroy không bị kẹt báo lỗi
}
output "RDS_ENDPOINT" {
  value = aws_db_instance.orishop_db.endpoint
}

# 1. Tạo đuôi ngẫu nhiên chống trùng lặp tên S3
resource "random_string" "suffix" {
  length  = 6
  special = false
  upper   = false
}

# 2. Xây kho chứa ảnh (S3 Bucket)
resource "aws_s3_bucket" "orishop_media" {
  bucket = "com-quyenlt-media-${random_string.suffix.result}"
  
  # Cực kỳ quan trọng khi làm Lab: Cho phép Terraform xóa Bucket ngay cả khi có ảnh bên trong
  force_destroy = true 
}

# 3. Viết giấy phép (Policy): Chỉ cho phép Đọc/Ghi vào đúng Bucket này
resource "aws_iam_policy" "s3_access_policy" {
  name        = "quyenlt-s3-access-policy"
  description = "Cho phep EKS Pods doc/ghi vao S3 cua orishop"

  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Effect = "Allow"
        Action = [
          "s3:PutObject",
          "s3:GetObject",
          "s3:DeleteObject",
          "s3:ListBucket"
        ]
        Resource = [
          aws_s3_bucket.orishop_media.arn,
          "${aws_s3_bucket.orishop_media.arn}/*"
        ]
      }
    ]
  })
}

# 4. Thuật toán IRSA (Biến Service Account của K8s thành Thẻ nhân viên AWS)
data "aws_iam_policy_document" "irsa_trust_policy" {
  statement {
    actions = ["sts:AssumeRoleWithWebIdentity"]
    effect  = "Allow"

    condition {
      test     = "StringEquals"
      # Kết nối với hệ thống nhận diện OIDC của cụm EKS
      variable = "${replace(module.eks.cluster_oidc_issuer_url, "https://", "")}:sub"
      # Quy định: Chỉ có Pod nào dùng Service Account tên là 'orishop-sa' mới được xài thẻ này
      values   = ["system:serviceaccount:default:orishop-sa"]
    }

    principals {
      identifiers = [module.eks.oidc_provider_arn]
      type        = "Federated"
    }
  }
}

# Tạo cái Thẻ (Role) từ thuật toán trên
resource "aws_iam_role" "orishop_s3_role" {
  name               = "quyenlt-orishop-s3-role"
  assume_role_policy = data.aws_iam_policy_document.irsa_trust_policy.json
}

# Ép Giấy phép (Policy) vào cái Thẻ (Role)
resource "aws_iam_role_policy_attachment" "orishop_s3_attach" {
  role       = aws_iam_role.orishop_s3_role.name
  policy_arn = aws_iam_policy.s3_access_policy.arn
}

# 5. IN RA KẾT QUẢ ĐỂ MANG ĐI CẤU HÌNH JAVA VÀ K8S
output "S3_BUCKET_NAME" {
  value = aws_s3_bucket.orishop_media.bucket
}

output "IRSA_ROLE_ARN" {
  value = aws_iam_role.orishop_s3_role.arn
}
# --- THÊM 3 BLOCK NÀY VÀO DƯỚI CÙNG FILE s3_iam.tf ---

# 1. Tắt tính năng chặn Public Access mặc định của AWS S3
resource "aws_s3_bucket_public_access_block" "orishop_media_public" {
  bucket = aws_s3_bucket.orishop_media.id

  block_public_acls       = false
  block_public_policy     = false
  ignore_public_acls      = false
  restrict_public_buckets = false
}

# 2. Bật lại quyền kiểm soát ACL (Cần thiết để Spring Boot nhét ảnh vào)
resource "aws_s3_bucket_ownership_controls" "orishop_media_ownership" {
  bucket = aws_s3_bucket.orishop_media.id
  rule {
    object_ownership = "BucketOwnerPreferred"
  }
}

# 3. Viết giấy phép cho phép CẢ THẾ GIỚI được xem ảnh trên Web
resource "aws_s3_bucket_policy" "public_read_policy" {
  depends_on = [aws_s3_bucket_public_access_block.orishop_media_public]
  bucket     = aws_s3_bucket.orishop_media.id

  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Sid       = "PublicReadGetObject"
        Effect    = "Allow"
        Principal = "*"
        Action    = "s3:GetObject"
        Resource  = "${aws_s3_bucket.orishop_media.arn}/*"
      }
    ]
  })
}

# 1. Tạo "Thẻ nhân viên" (IAM Role) cho Lambda
resource "aws_iam_role" "lambda_role" {
  name = "quyenlt-lambda-s3-role"
  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Action = "sts:AssumeRole"
      Effect = "Allow"
      Principal = { Service = "lambda.amazonaws.com" }
    }]
  })
}

# Cấp quyền cơ bản: Cho phép Lambda ghi Log ra CloudWatch để Tobi đọc
resource "aws_iam_role_policy_attachment" "lambda_logs" {
  role       = aws_iam_role.lambda_role.name
  policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
}

# Cấp quyền nâng cao: Cho phép Lambda đọc ảnh từ S3
resource "aws_iam_role_policy" "lambda_s3_read" {
  name   = "quyenlt-lambda-s3-read-policy"
  role   = aws_iam_role.lambda_role.id
  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Action   = ["s3:GetObject"]
      Effect   = "Allow"
      Resource = "${aws_s3_bucket.orishop_media.arn}/*"
    }]
  })
}

# 2. Đóng gói đoạn code Python xử lý ảnh thành file ZIP ngay tại chỗ
data "archive_file" "lambda_zip" {
  type        = "zip"
  output_path = "lambda_function.zip"
  source {
    filename = "index.py"
    content  = <<-EOF
    import json
    import urllib.parse

    def lambda_handler(event, context):
        # Lấy thông tin từ sự kiện S3 báo về
        bucket = event['Records'][0]['s3']['bucket']['name']
        key = urllib.parse.unquote_plus(event['Records'][0]['s3']['object']['key'], encoding='utf-8')
        
        # In ra log (sau này có thể viết code nén ảnh thumbnail ở đây)
        print(f"OriShop Auto-Bot: Có ảnh sản phẩm mới được upload lên kho {bucket}! Tên file là: {key}")
        
        return {
            'statusCode': 200,
            'body': json.dumps('Da ghi log thanh cong!')
        }
    EOF
  }
}

# 3. Khởi tạo AWS Lambda Function
resource "aws_lambda_function" "s3_trigger_lambda" {
  filename         = data.archive_file.lambda_zip.output_path
  source_code_hash = data.archive_file.lambda_zip.output_base64sha256
  function_name    = "quyenlt-s3-image-processor"
  role             = aws_iam_role.lambda_role.arn
  handler          = "index.lambda_handler"
  runtime          = "python3.12"
}

# 4. Cấp quyền cho cái Bucket S3 được phép "gọi điện" đánh thức Lambda
resource "aws_lambda_permission" "allow_s3" {
  statement_id  = "AllowExecutionFromS3Bucket"
  action        = "lambda:InvokeFunction"
  function_name = aws_lambda_function.s3_trigger_lambda.arn
  principal     = "s3.amazonaws.com"
  source_arn    = aws_s3_bucket.orishop_media.arn
}

# 5. Gắn Cò (Trigger): Khi có ảnh mới (ObjectCreated) -> Kích hoạt Lambda
resource "aws_s3_bucket_notification" "bucket_notification" {
  bucket = aws_s3_bucket.orishop_media.id

  lambda_function {
    lambda_function_arn = aws_lambda_function.s3_trigger_lambda.arn
    events              = ["s3:ObjectCreated:*"]
  }
  
  depends_on = [aws_lambda_permission.allow_s3]
}

terraform init -upgrade
terraform apply -auto-approve

---
# 1. TẠO "THẺ NHÂN VIÊN" (SERVICE ACCOUNT) ĐỂ APP CÓ QUYỀN VÀO S3
apiVersion: v1
kind: ServiceAccount
metadata:
  name: orishop-sa
  annotations:
    eks.amazonaws.com/role-arn: arn:aws:iam::808999395759:role/quyenlt-orishop-s3-role

---
# 2. TRIỂN KHAI ỨNG DỤNG LÊN CLUSTER (DEPLOYMENT)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: orishop-app
spec:
  replicas: 2 # Chạy 2 Pod để đảm bảo không bao giờ sập web
  selector:
    matchLabels:
      app: orishop
  template:
    metadata:
      labels:
        app: orishop
    spec:
      serviceAccountName: orishop-sa # Giao thẻ nhân viên cho Pod
      containers:
      - name: orishop
        image: tobi1008/orishop:latest # Image sẽ được Jenkins đẩy lên
        ports:
        - containerPort: 8091
        env:
        # --- KẾT NỐI DATABASE (RDS MYSQL) ---
        - name: SPRING_DATASOURCE_URL
          value: "jdbc:mysql://orishop-db.ch8mw2wuqs14.ap-southeast-1.rds.amazonaws.com:3306/orishop"
        - name: SPRING_DATASOURCE_USERNAME
          value: "admin"
        - name: SPRING_DATASOURCE_PASSWORD
          value: "OriShop12345!"
        
        # --- KẾT NỐI KHO ẢNH (AWS S3) ---
        - name: AWS_S3_BUCKET_NAME
          value: "com-quyenlt-media-dgecje"
        - name: AWS_REGION
          value: "ap-southeast-1"

---
# 3. MỞ CỬA CHO KHÁCH HÀNG TRUY CẬP (LOAD BALANCER SERVICE)
apiVersion: v1
kind: Service
metadata:
  name: orishop-service
spec:
  type: LoadBalancer # Báo AWS cấp cho 1 cái tên miền (URL) Public
  selector:
    app: orishop
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8091

aws eks update-kubeconfig --region ap-southeast-1 --name quyenlt-eks-cluster

kubectl run tmp-mysql-client --image=mysql:8.0 --command -- sleep 3600

kubectl exec -i tmp-mysql-client -- mysql -h orishop-db.ch8mw2wuqs14.ap-southeast-1.rds.amazonaws.com -u admin -pOriShop12345! orishop < datalast.sql

kubectl delete pod tmp-mysql-client

kubectl get svc orishop-service

<dependency>
    <groupId>com.amazonaws</groupId>
    <artifactId>aws-java-sdk-sts</artifactId>
</dependency>

# Sửa lỗi Maximum upload size exceeded
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=10MB

# Update đúng endpoint của RDS Terraform tạo ra
spring.datasource.url=jdbc:mysql://orishop-db...rds.amazonaws.com:3306/orishop

git add .
git commit -m "Test tự động hóa Webhook"
git push origin main