# evidence-capture / gcp / t0 "Quick start"
#
# Add the label incident=<id> to a Compute Engine VM, and a function:
#   1. turns on deletion protection and takes the VM out of its managed
#      instance group, so autoscaling cannot remove it
#   2. snapshots every disk
#   3. adds a network tag that two deny-all firewall rules match, cutting it off
#
# The label is the trigger because anyone on the incident can add one from the
# console or the command line, and the audit log records who did.
#
# Google Cloud has no managed way to capture memory. Snapshot first, then use
# the manual route described on the template page.
#
# Change the three values below, then:
#   gcloud auth application-default login
#   terraform init && terraform apply
#
# Verify, on a test VM you do not mind isolating:
#   terraform output verify

locals {
  project_id = "your-project-id" # change me
  region     = "us-central1"     # change me: where your VMs run
  network    = "default"         # change me: the VPC network your VMs use
}

terraform {
  required_version = ">= 1.6"
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = "~> 8.0"
    }
    archive = {
      source  = "hashicorp/archive"
      version = "~> 2.7"
    }
    random = {
      source  = "hashicorp/random"
      version = "~> 3.6"
    }
  }
}

provider "google" {
  project = local.project_id
  region  = local.region
}

resource "google_project_service" "needed" {
  for_each = toset([
    "cloudfunctions.googleapis.com", "run.googleapis.com", "eventarc.googleapis.com",
    "cloudbuild.googleapis.com", "artifactregistry.googleapis.com", "pubsub.googleapis.com",
    "compute.googleapis.com",
  ])
  service            = each.value
  disable_on_destroy = false
}

# Deny wins over allow at the same priority, and 0 is the highest priority, so
# no other rule can let traffic past these.
resource "google_compute_firewall" "quarantine_in" {
  name        = "incident-quarantine-deny-in"
  network     = local.network
  direction   = "INGRESS"
  priority    = 0
  target_tags = ["incident-quarantine"]
  deny {
    protocol = "all"
  }
  source_ranges = ["0.0.0.0/0"]
}

resource "google_compute_firewall" "quarantine_out" {
  name        = "incident-quarantine-deny-out"
  network     = local.network
  direction   = "EGRESS"
  priority    = 0
  target_tags = ["incident-quarantine"]
  deny {
    protocol = "all"
  }
  destination_ranges = ["0.0.0.0/0"]
}

resource "google_service_account" "responder" {
  account_id   = "incident-responder"
  display_name = "Preserves and isolates VMs labelled incident=<id>"
}

resource "google_project_iam_member" "responder" {
  for_each = toset([
    "roles/compute.instanceAdmin.v1", # deletion protection, tags, labels, instance groups
    "roles/compute.storageAdmin",     # snapshots
    "roles/eventarc.eventReceiver",
    "roles/run.invoker",
  ])
  project = local.project_id
  role    = each.value
  member  = "serviceAccount:${google_service_account.responder.email}"
}

locals {
  code = <<-PY
    import datetime, re
    import functions_framework
    from google.cloud import compute_v1

    TAG = "incident-quarantine"
    DONE = "preserved-and-isolated"


    def name_for(*parts):
        n = re.sub(r"[^a-z0-9-]", "-", "-".join(parts).lower())[:62].strip("-")
        return n if n[:1].isalpha() else "ir-" + n[:59]


    @functions_framework.cloud_event
    def handler(event):
        parts = event.data.get("protoPayload", {}).get("resourceName", "").split("/")
        if len(parts) < 6 or parts[4] != "instances":
            return
        project, zone, name = parts[1], parts[3], parts[5]
        vms = compute_v1.InstancesClient()
        vm = vms.get(project=project, zone=zone, instance=name)
        incident = vm.labels.get("incident")
        # The function's own label change fires this again. Stop there.
        if not incident or vm.labels.get("incident-status") == DONE:
            return

        # 1. Keep it alive.
        vms.set_deletion_protection(project=project, zone=zone, resource=name, deletion_protection=True).result()
        for item in vm.metadata.items:
            if item.key == "created-by" and "/instanceGroupManagers/" in item.value:
                mig = item.value.split("/")[-1]
                if "/regions/" in item.value:
                    region = item.value.split("/regions/")[1].split("/")[0]
                    compute_v1.RegionInstanceGroupManagersClient().abandon_instances(
                        project=project, region=region, instance_group_manager=mig,
                        region_instance_group_managers_abandon_instances_request_resource=
                        compute_v1.RegionInstanceGroupManagersAbandonInstancesRequest(instances=[vm.self_link])).result()
                else:
                    compute_v1.InstanceGroupManagersClient().abandon_instances(
                        project=project, zone=zone, instance_group_manager=mig,
                        instance_group_managers_abandon_instances_request_resource=
                        compute_v1.InstanceGroupManagersAbandonInstancesRequest(instances=[vm.self_link])).result()

        # 2. Snapshot every disk.
        stamp = datetime.datetime.now(datetime.timezone.utc).strftime("%Y%m%d%H%M")
        disks = compute_v1.DisksClient()
        for d in vm.disks:
            disk = d.source.split("/")[-1]
            disks.create_snapshot(project=project, zone=zone, disk=disk, snapshot_resource=compute_v1.Snapshot(
                name=name_for("ir", incident, disk, stamp),
                labels={"incident": incident, "source-instance": name})).result()

        # 3. Cut it off: the quarantine tag brings in the deny-all rules.
        tags = sorted(set(list(vm.tags.items) + [TAG]))
        vms.set_tags(project=project, zone=zone, instance=name,
                     tags_resource=compute_v1.Tags(items=tags, fingerprint=vm.tags.fingerprint)).result()

        labels = dict(vm.labels)
        labels["incident-status"] = DONE
        vms.set_labels(project=project, zone=zone, instance=name,
                       instances_set_labels_request_resource=compute_v1.InstancesSetLabelsRequest(
                           labels=labels, label_fingerprint=vm.label_fingerprint)).result()
  PY
}

data "archive_file" "responder" {
  type        = "zip"
  output_path = "${path.module}/.build/responder.zip"
  source {
    content  = local.code
    filename = "main.py"
  }
  source {
    content  = "functions-framework==3.*\ngoogle-cloud-compute==1.*\n"
    filename = "requirements.txt"
  }
}

resource "random_id" "bucket" {
  byte_length = 4
}

resource "google_storage_bucket" "source" {
  name                        = "incident-responder-src-${random_id.bucket.hex}"
  location                    = local.region
  uniform_bucket_level_access = true
  public_access_prevention    = "enforced"
  force_destroy               = true
}

resource "google_storage_bucket_object" "source" {
  name   = "responder-${data.archive_file.responder.output_md5}.zip"
  bucket = google_storage_bucket.source.name
  source = data.archive_file.responder.output_path
}

# Eventarc delivers audit log events from the trigger's location. Deploy one
# of these per region you run VMs in.
resource "google_cloudfunctions2_function" "responder" {
  name     = "incident-responder"
  location = local.region

  build_config {
    runtime     = "python312"
    entry_point = "handler"
    source {
      storage_source {
        bucket = google_storage_bucket.source.name
        object = google_storage_bucket_object.source.name
      }
    }
  }

  service_config {
    max_instance_count    = 5
    timeout_seconds       = 300
    available_memory      = "512M"
    service_account_email = google_service_account.responder.email
    # Eventarc's delivery counts as internal traffic, and nothing else ever
    # needs to call this function.
    ingress_settings = "ALLOW_INTERNAL_ONLY"
  }

  event_trigger {
    trigger_region        = local.region
    event_type            = "google.cloud.audit.log.v1.written"
    retry_policy          = "RETRY_POLICY_DO_NOT_RETRY"
    service_account_email = google_service_account.responder.email
    event_filters {
      attribute = "serviceName"
      value     = "compute.googleapis.com"
    }
    event_filters {
      attribute = "methodName"
      value     = "v1.compute.instances.setLabels"
    }
  }

  depends_on = [google_project_service.needed, google_project_iam_member.responder]
}

output "verify" {
  description = "Label a test VM, then confirm the snapshots, the quarantine tag, and that it cannot be deleted."
  value       = <<-EOT
    gcloud compute instances add-labels <test-vm> --zone <zone> --labels incident=drill-1
    gcloud compute snapshots list --filter="labels.incident=drill-1"
    gcloud compute instances describe <test-vm> --zone <zone> --format="value(tags.items,deletionProtection)"
    gcloud compute instances delete <test-vm> --zone <zone>      # must be refused: deletion protection is on
  EOT
}
