Kubernetes Projects 2026 is a multi-branch Kubernetes platform engineering repository focused on GitOps, security policy enforcement, Kubernetes ingress, and infrastructure automation.
The repository is organized into dedicated project branches. Each branch represents a standalone Kubernetes lab with its own Terraform, manifests, scripts, screenshots, and documentation.
It brings together seven major deliverables:
- Project 2: Argo CD GitOps Security Lab with Splunk multi-environment deployment
- Project 3: OPA Gatekeeper + Argo CD Kubernetes policy enforcement
- Project 4: Flux GitOps + Splunk deployment on Google Kubernetes Engine
- Project 5: Kong Ingress Controller with a basic Hello App on Elastic Kubernetes Service (EKS)
- Project 6: Kong Ingress Controller with API key authentication and rate limiting on EKS
- Project 7: Kong Rate Limiting on GKE with key authentication, KongConsumer, Kubernetes Secrets, k6 testing, and Terraform-managed GCP infrastructure
- Project 8: Two Kingdoms, One Gate — dual-tenant Kong key-auth + ACL authorization with OPA Gatekeeper namespace port constraints on a private GKE cluster
Together, these branches demonstrate repeatable infrastructure provisioning, declarative Kubernetes operations, GitOps deployment, RBAC security, policy-as-code, ingress control, API gateway patterns, and operational validation.
-
Project 2 — Argo CD GitOps Security Lab
Based on: Argo CD, AppProjects, RBAC policies, Splunk workloads, Kubernetes namespaces, Terraform-managed AWS EKS infrastructure, and Bash automation. -
Project 3 — OPA Gatekeeper + Argo CD Policy Enforcement
Based on: OPA Gatekeeper, Rego, Kubernetes admission control, Argo CD, environment namespace locking, service port enforcement, Splunk deployments, and automated validation scripts. -
Project 4 — Flux GitOps + Splunk on GKE
Based on: Google Kubernetes Engine, Terraform, Flux CD, GitRepository, Kustomization reconciliation, Kustomize overlays, cert-manager, NGINX Ingress, TLS, Splunk StatefulSet, and evidence artifacts. -
Project 5 — Kong Ingress Hello App on EKS
Based on: AWS EKS, Terraform, Helm, Kong Ingress Controller, Kubernetes Service, Ingress routing, LoadBalancer exposure, and Hello App validation. -
Project 6 — Kong Security Plugins on EKS
Based on: AWS EKS, Terraform, Helm, Kong Gateway, KongPlugin resources, KongConsumer, Kubernetes Secrets, API key authentication, rate limiting, NGINX test workload, and deploy/teardown automation. -
Project 7 — Kong Rate Limiting on GKE
Based on: Google Kubernetes Engine, Terraform, Helm, Kong Gateway, Kong Ingress Controller, KongPlugin resources, KongConsumer, Kubernetes Secrets, key-auth, rate limiting, ConfigMap-hosted HTML content, k6 load testing, curl validation, and automated evidence collection. -
Project 8 — Two Kingdoms, One Gate: Falcon & Lindworm on GKE
Based on: private VPC-native Google Kubernetes Engine, Terraform, Kong Ingress Controller, Kong key-auth and ACL plugins, KongConsumer, Kubernetes Secrets, OPA Gatekeeper admission-time port constraints, a FastAPIpython-gatepolicy enforcement point, and curl-based multi-tenant validation.
- Kubernetes Concepts — Kubernetes Docs
- Terraform Documentation — Terraform Docs
- Helm Charts — Helm Docs
- AWS EKS — Amazon EKS User Guide
- Google Kubernetes Engine — GKE Documentation
- GKE Private Clusters — GKE Private Clusters Guide
- GKE Authorized Networks — GKE Authorized Networks Guide
- Argo CD — Argo CD Docs
- Flux CD — Flux Docs
- OPA Gatekeeper — Gatekeeper Docs
- Rego Policy Language — OPA Rego Docs
- Kong Ingress Controller — Kong Kubernetes Ingress Controller Docs
- Kong Gateway — Kong Gateway Docs
- cert-manager — cert-manager Docs
- NGINX Ingress Controller — Ingress-NGINX Docs
- Splunk — Splunk Documentation
Deliver a secure, automated, GitOps-driven Kubernetes portfolio repository capable of:
- Provisioning Kubernetes infrastructure using Terraform
- Deploying workloads to AWS EKS and Google Kubernetes Engine
- Managing applications through Argo CD and Flux CD
- Enforcing RBAC and environment isolation across Kubernetes namespaces
- Applying policy-as-code controls through OPA Gatekeeper and Rego
- Exposing services through Kong Ingress Controller and AWS LoadBalancer services
- Demonstrating API gateway controls such as authentication and rate limiting
- Generating screenshots, logs, test outputs, and artifacts for proof-of-work submissions
- Practicing clean teardown workflows to avoid orphaned cloud resources and unnecessary cost
- Demonstrating GKE-based Kong API gateway controls with key authentication, request throttling, external LoadBalancer exposure, and repeatable evidence generation
- Enforcing dual-tenant API gateway authorization on a private GKE cluster using Kong key-auth and ACL plugins, backed by a redundant FastAPI policy enforcement point and OPA Gatekeeper namespace port constraints
| Branch | Project | Platform | Main Tools | Focus |
|---|---|---|---|---|
project-2 |
Argo CD GitOps Security Lab | AWS EKS | Terraform, Argo CD, Kubernetes, Bash | RBAC, AppProjects, environment isolation |
project-3 |
OPA Gatekeeper + Argo CD | AWS EKS | Terraform, Argo CD, Gatekeeper, Rego | Admission control and policy enforcement |
project-4 |
Flux GitOps + Splunk on GKE | GCP GKE | Terraform, Flux CD, Kustomize, cert-manager | GitOps reconciliation and TLS ingress |
project-5 |
Kong Ingress Hello App | AWS EKS | Terraform, Helm, Kong, Kubernetes | Basic ingress gateway routing |
project-6 |
Kong Auth + Rate Limiting | AWS EKS | Terraform, Helm, KongPlugin, KongConsumer | API key authentication and rate limiting |
project-7 |
Kong Rate Limiting on GKE | GCP GKE | Terraform, Helm, KongPlugin, k6 | Kong API gateway controls with load testing |
project-8 |
Two Kingdoms, One Gate (Falcon & Lindworm) | GCP GKE (private) | Terraform, Kong, OPA Gatekeeper, FastAPI | Dual-tenant key-auth + ACL authorization with namespace port constraints |
Goal: Deploy a secure multi-environment Splunk GitOps platform using Argo CD, RBAC, and AWS EKS.
Highlights:
- Terraform provisions the AWS EKS cluster and supporting infrastructure
- Argo CD manages Splunk applications across
splunk-dev,splunk-test, andsplunk-prod - AppProjects isolate each environment
- RBAC policies restrict user access by role
- Automation scripts deploy, configure RBAC, create users, validate, and tear down the lab
- Evidence screenshots document Terraform, Argo CD, user access, application trees, and validation checks
Primary skills demonstrated:
- GitOps deployment lifecycle
- Kubernetes namespace isolation
- Argo CD AppProjects
- Argo CD RBAC
- Terraform EKS provisioning
- Bash-driven operational automation
Goal: Integrate OPA Gatekeeper with Argo CD to enforce Kubernetes security and deployment governance policies at admission time.
Highlights:
- Gatekeeper enforces Argo CD namespace placement rules
- Rego policies validate Splunk service ports by environment
- ConstraintTemplates and Constraints define policy-as-code controls
- Negative test manifests prove that invalid configurations are denied
- Argo CD deploys Splunk applications into controlled namespaces
- Validation artifacts include resource inventory and command outputs
Primary skills demonstrated:
- Kubernetes admission control
- OPA Gatekeeper
- Rego policy development
- DevSecOps governance
- GitOps security controls
- Runtime policy enforcement
Goal: Deploy Splunk to Google Kubernetes Engine using Flux CD, Kustomize, Terraform, and GitOps reconciliation.
Highlights:
- Terraform provisions GKE infrastructure
- Flux GitRepository acts as the source of truth
- Flux Kustomization continuously reconciles the desired cluster state
- Splunk runs as a StatefulSet with persistent storage
- NGINX Ingress and cert-manager provide TLS-enabled external access
- Artifact collection captures logs, snapshots, reports, and validation outputs
- Teardown scripts support deterministic cleanup
Primary skills demonstrated:
- Flux CD GitOps workflow
- GKE infrastructure provisioning
- Kustomize-based application layout
- Stateful Kubernetes workloads
- TLS ingress with cert-manager
- Drift correction and reconciliation
Goal: Deploy a simple Kubernetes Hello App and expose it externally through Kong Ingress Controller on AWS EKS.
Highlights:
- Terraform provisions EKS, networking, IAM, storage, and Kubernetes providers
- Helm installs Kong Ingress Controller
- Kubernetes manifests deploy the Hello App, Service, and Ingress
- Kong Gateway provides centralized HTTP routing
- Validation includes successful
/hellorouting and failure testing for invalid paths - Cost-awareness notes identify EKS, LoadBalancer, NAT Gateway, EBS, and CloudWatch cost areas
Primary skills demonstrated:
- Kong Ingress Controller deployment
- Gateway-based service exposure
- Kubernetes Service and Ingress design
- AWS LoadBalancer integration
- Terraform + Helm platform automation
- Operational troubleshooting and cleanup
Goal: Extend Kong Ingress on EKS with API gateway security controls using key-auth, KongConsumer, Kubernetes Secrets, and rate limiting.
Highlights:
- Terraform provisions AWS VPC, EKS, node groups, IAM/OIDC, EBS CSI, and Kong platform resources
- Helm installs Kong Ingress Controller
deploy.shapplies KongPlugin resources, API key Secret, KongConsumer, and Ingress routes/hellois protected with API key authentication/hello-ratelimitvalidates Kong rate limiting behavior- Testing confirms expected
401,200, and429responses teardown.shremoves Kubernetes resources before manual Terraform destroy
Primary skills demonstrated:
- Kong Gateway plugin configuration
- API key authentication
- Rate limiting
- Kubernetes Secret + KongConsumer pattern
- Ingress-based API security
- Repeatable deployment and teardown automation
Goal: Deploy a custom Hello App on Google Kubernetes Engine (GKE) and protect it with Kong Gateway using API key authentication and rate limiting.
Highlights:
- Terraform provisions Google Cloud infrastructure, including VPC, subnets, firewall rules, Cloud NAT, Artifact Registry, GKE cluster, node pool, IAM/OIDC, and outputs
- Helm installs Kong Gateway and Kong Ingress Controller into the
kongnamespace - Kubernetes manifests deploy the Hello App, Service, ConfigMap-hosted HTML page, and Kong-managed Ingress
key-authKongPlugin enforces API key authenticationrate-limitingKongPlugin enforces request throttling at the gateway layer- KongConsumer and Kubernetes Secret define the authorized API client and credential
- curl tests prove
401 Unauthorized,200 OK, and429 Too Many Requestsbehavior - k6 tests generate load-test evidence for authenticated and unauthenticated request paths
- Python artifact collection script gathers YAML exports, command outputs, screenshots, and project proof files
- Teardown script removes Kubernetes resources, Kong components, and supports Terraform cleanup to avoid unnecessary GCP cost
Primary skills demonstrated:
- GKE infrastructure provisioning
- Kong Gateway deployment on Kubernetes
- KongPlugin configuration
- API key authentication
- Rate limiting and abuse control
- Kubernetes Ingress routing
- Kubernetes Secrets and KongConsumer mapping
- ConfigMap-based static HTML delivery
- k6 load testing
- curl-based API validation
- Automated evidence collection
- Terraform teardown and cloud cost control
Goal: Deploy two isolated tenant applications, Falcon and Lindworm, on a private GKE cluster and enforce per-tenant access through Kong key-auth + ACL, backed by a redundant OPA Gatekeeper namespace port constraint.
Highlights:
- Terraform provisions a private, VPC-native GKE cluster, subnets, firewall rules, Cloud NAT, and Artifact Registry
- Kong Ingress Controller authenticates requests via
key-authand routes traffic to thefalconandlindwormnamespaces - Kong's ACL plugin and a redundant
python-gateFastAPI service both enforce a one-user, one-tenant authorization rule - OPA Gatekeeper enforces admission-time Service port constraints (
falcon=12000,lindworm=3653), independent of live traffic - curl tests validate
200 OK,401 Unauthorized, and403 Forbiddenresponses across both tenants - Teardown removes Kong, namespaces, and Gatekeeper before Terraform destroy to avoid orphaned GCP resources
Primary skills demonstrated:
- Private, VPC-native GKE provisioning
- Kong key-auth and ACL plugin configuration
- Multi-tenant API gateway authorization
- OPA Gatekeeper admission control
- Kubernetes namespace isolation
- FastAPI-based policy enforcement points
- Separation of authentication vs. authorization concerns
kubernetes-projects-2026/
├── project-2
│ ├── Terraform-managed AWS EKS foundation
│ ├── Argo CD GitOps applications
│ ├── RBAC policies
│ ├── Splunk dev/test/prod workloads
│ └── deployment, RBAC, validation, and teardown scripts
│
├── project-3
│ ├── Terraform-managed AWS EKS foundation
│ ├── Argo CD applications
│ ├── OPA Gatekeeper ConstraintTemplates
│ ├── Rego policy constraints
│ ├── Splunk policy validation workloads
│ └── automated policy test and artifact scripts
│
├── project-4
│ ├── Terraform-managed GKE infrastructure
│ ├── Flux GitOps source and Kustomization resources
│ ├── Splunk StatefulSet workload
│ ├── cert-manager and NGINX Ingress resources
│ └── artifact collection and teardown automation
│
├── project-5
│ ├── Terraform-managed AWS EKS foundation
│ ├── Helm-managed Kong Ingress Controller
│ ├── Hello App Deployment and Service
│ ├── Kong Ingress route
│ └── Kong teardown and validation workflow
│
├── project-6
│ ├── Terraform-managed AWS EKS foundation
│ ├── Helm-managed Kong Ingress Controller
│ ├── KongPlugin key-auth and rate-limiting resources
│ ├── KongConsumer and API key Secret
│ ├── secured /hello and /hello-ratelimit routes
│ └── deploy and teardown scripts
│
├── project-7
│ ├── Terraform-managed GCP and GKE foundation
│ ├── Helm-managed Kong Gateway and Kong Ingress Controller
│ ├── Hello App Deployment, Service, and ConfigMap-hosted HTML content
│ ├── KongPlugin key-auth and rate-limiting resources
│ ├── KongConsumer and API key Secret
│ ├── Kong-managed Ingress route
│ ├── curl and k6 validation tests for 401, 200, and 429 responses
│ ├── screenshot, video, YAML, and command-output evidence
│ └── deploy, verify, artifact collection, and teardown automation
│
└── project-8
├── Terraform-managed private, VPC-native GKE foundation
├── Helm-managed Kong Ingress Controller
├── falcon and lindworm namespaces, Deployments, ConfigMap-hosted HTML content
├── Kong key-auth and ACL KongPlugin resources
├── KongConsumer credentials and ACL group Secrets
├── OPA Gatekeeper ConstraintTemplate and port Constraint (falcon=12000, lindworm=3653)
├── python-gate FastAPI policy enforcement point (ops namespace)
├── curl validation tests for 200, 401, and 403 responses
└── screenshot, diagram, and RUNBOOK-driven evidence collection
# Confirm Kubernetes access
kubectl cluster-info
kubectl get nodes
# Confirm namespaces
kubectl get ns
# Confirm workloads across all namespaces
kubectl get pods -A
kubectl get svc -A
kubectl get ingress -A
# Confirm Argo CD resources when applicable
kubectl get pods -n argocd
kubectl get applications -n argocd
kubectl get appprojects -n argocd
# Confirm Flux resources when applicable
kubectl get pods -n flux-system
flux get sources git
flux get kustomizations
# Confirm Gatekeeper resources when applicable
kubectl get pods -n gatekeeper-system
kubectl get constrainttemplates
kubectl get constraints
# Confirm Kong resources when applicable
kubectl get pods -n kong
kubectl get svc -n kong
kubectl get kongplugins -A
kubectl get kongconsumers -A
# Confirm Kong resources for Project 7
kubectl get pods -n kong
kubectl get svc -n kong
kubectl get ingress -n kong
kubectl get kongplugin -n kong
kubectl get kongconsumer -n kong
kubectl describe ingress hello-ingress -n kong
# Confirm Kong LoadBalancer endpoint
kubectl get svc -n kong kong-gateway-proxy
kubectl get svc -n kong kong-gateway-proxy -o jsonpath='{.status.loadBalancer.ingress[0].ip}'
# Test API key authentication and rate limiting
curl -i http://<KONG_PROXY_ENDPOINT>/
curl -i -H "apikey: <REDACTED_API_KEY>" http://<KONG_PROXY_ENDPOINT>/
# Run k6 load tests
k6 run python/rate-test.js
k6 run python/key-rate-test.js
# Collect Project 7 deliverables
python python/collect-deliverables.py
# Confirm Kong resources for Project 8
kubectl get pods -n kong
kubectl get svc -n kong
kubectl get kongconsumers -A
kubectl get kongplugins -A
# Confirm Gatekeeper port constraints for Project 8
kubectl get constrainttemplates
kubectl get constraints
# Confirm Kong external IP for Project 8
kubectl get svc kong-gateway-proxy -n kong -o jsonpath='{.status.loadBalancer.ingress[0].ip}'
# Test Project 8 dual-tenant authentication and authorization
curl -i http://<KONG_IP>/falcon -H "apikey: <REDACTED_API_KEY>" # 200
curl -i http://<KONG_IP>/lindworm -H "apikey: <REDACTED_API_KEY>" # 200
curl -i http://<KONG_IP>/lindworm -H "apikey: <WRONG_TENANT_KEY>" # 403
curl -i http://<KONG_IP>/falcon # 401| Issue | Common Cause | Resolution |
|---|---|---|
LoadBalancer pending |
AWS or GKE load balancer still provisioning | Wait several minutes, then run kubectl get svc -A |
ImagePullBackOff |
Invalid image name, missing registry auth, or image pull failure | Run kubectl describe pod <pod> -n <namespace> and verify image path |
CrashLoopBackOff |
Application startup failure or bad configuration | Run kubectl logs <pod> -n <namespace> and inspect events |
Argo CD app stuck OutOfSync |
Manifest drift or missing dependency | Sync the app, inspect kubectl describe application, and validate manifests |
| Argo CD RBAC not applying | ConfigMap not reloaded or policy syntax issue | Restart Argo CD server and validate argocd-rbac-cm |
| Gatekeeper policy not denying invalid resource | ConstraintTemplate or Constraint not installed correctly | Check kubectl get constrainttemplates and kubectl describe constraint <name> |
| Flux reconciliation failing | GitRepository or Kustomization path error | Run flux get sources git, flux get kustomizations, and flux reconcile |
| TLS certificate not ready | cert-manager issuer, DNS, or ingress mismatch | Run kubectl describe certificate -A and inspect cert-manager logs |
Kong route returns 404 |
Ingress rule path or service name mismatch | Check kubectl get ingress -A and verify service backend names |
Kong route returns 401 |
Missing or incorrect API key | Send the correct API key header expected by the KongPlugin configuration |
Kong route returns 429 |
Rate limit triggered successfully | Wait for the rate-limit window to reset or adjust plugin limits |
Namespace stuck Terminating |
Finalizers blocking deletion | Inspect finalizers and remove only after confirming cleanup safety |
| Terraform destroy blocked | Kubernetes resources or cloud load balancers still exist | Run branch-specific teardown script before terraform destroy |
| Orphaned cloud resources | LoadBalancer, NAT Gateway, or EBS volume left behind | Check AWS/GCP console and CLI for leftover resources before closing the lab |
Kong route returns 401 on Project 7 |
Missing API key, wrong header name, bad Secret, or KongConsumer not mapped correctly | Verify key-auth plugin, KongConsumer, Secret, and send the correct apikey header |
Kong route returns 429 on Project 7 |
Rate limit was triggered successfully | Wait for the rate-limit window to reset or adjust the rate-limit-plugin settings |
| Project 7 ConfigMap YAML fails to apply | HTML block indentation or unescaped multiline content inside index.html: | |
Validate YAML spacing and keep embedded HTML indented under the ConfigMap block |
| k6 test does not show expected failures | Test duration, virtual users, or request rate may be too low to exceed the limit | Increase k6 request pressure or confirm the configured rate limit is 5 req/min |
| Kong LoadBalancer has no external IP on GKE | GCP load balancer still provisioning or service pending | Wait several minutes and check kubectl get svc -n kong kong-gateway-proxy |
| GKE cluster unreachable during teardown | Local kubeconfig context may be stale or the cluster was already destroyed | Re-run gcloud container clusters get-credentials or continue Terraform cleanup if cluster is gone |
Kong rejects KongCredential objects on Project 8 |
CRD not installed by the current Kong Ingress Controller | Use Secret-based credentials instead of KongCredential |
| Kong admission webhook denies consumer creation on Project 8 | Referenced credential Secret not created yet due to file apply order |
Apply credential and ACL group Secrets before KongConsumer manifests |
Correct API key returns 403 instead of 200 on Project 8 |
ACL group membership doesn't match the requested tenant route | Verify Kong ACL group assignment and consumer-to-group mapping |
terraform plan fails on data.http.my_ip on Project 8 |
External IP-echo service unreachable or blocked by local network/VPN | Add a detect_runner_ip toggle and supply the runner IP manually instead |
# Clone the repository
git clone https://github.com/tiqsclass6/kubernetes-projects-2026.git
cd kubernetes-projects-2026
# List remote branches
git branch -r
# Check out a specific project branch
git checkout project-2
git checkout project-3
git checkout project-4
git checkout project-5
git checkout project-6
git checkout project-7
git checkout project-8Each branch contains its own README, project structure, scripts, manifests, and validation evidence. Follow the branch-specific documentation before running Terraform or Kubernetes commands.
These labs create real cloud infrastructure. Always tear down Kubernetes resources before destroying Terraform-managed infrastructure.
Recommended cleanup pattern:
# Run the branch-specific teardown script first
./scripts/teardown.sh
# or use the exact script name documented in the branch README
# Then destroy infrastructure
terraform destroyFor AWS-based branches, also check for leftover resources:
aws elb describe-load-balancers --region us-east-1
aws ec2 describe-nat-gateways --region us-east-1
aws ec2 describe-volumes --filters Name=status,Values=available --region us-east-1For GKE-based branches, verify cluster and load balancer cleanup:
gcloud container clusters list
gcloud compute forwarding-rules list
gcloud compute addresses list
gcloud compute disks listFor Project 7, remove Kong and application resources before destroying the GKE infrastructure:
./scripts/3-teardown.sh
terraform destroyProject 7 creates GCP resources that may continue billing if left running, including:
GKE cluster and node pool External LoadBalancer forwarding rule Cloud NAT Artifact Registry Persistent disks if any were created Static or ephemeral external IP resources
For Project 8, remove Kong, the tenant namespaces, and Gatekeeper before destroying the GKE infrastructure:
helm uninstall kong -n kong
kubectl delete namespace kong falcon lindworm ops
kubectl delete -f https://raw.githubusercontent.com/open-policy-agent/gatekeeper/v3.22.2/deploy/gatekeeper.yaml
cd terraform
terraform destroyProject 8 creates GCP resources that may continue billing if left running, including:
GKE cluster and node pool (private, VPC-native) External LoadBalancer forwarding rule (Kong proxy) Cloud NAT Artifact Registry
Destroying the cluster does not delete the GCS Terraform state bucket or the Artifact Registry repo — those persist across projects by design.
| Category | Skills |
|---|---|
| Infrastructure as Code | Terraform, modular cloud provisioning, remote-state-ready structure |
| Kubernetes | Deployments, Services, Ingress, StatefulSets, namespaces, secrets, ConfigMaps |
| GitOps | Argo CD, Flux CD, GitRepository, Kustomization, AppProjects |
| Security | RBAC, OPA Gatekeeper, Rego, admission control, Kong key-auth, Kong ACL, Kubernetes Secrets |
| API Gateway Security | Kong Gateway, Kong Ingress Controller, KongPlugin, KongConsumer, key-auth, ACL, rate limiting, multi-tenant authorization, API abuse control |
| Networking | Ingress routing, LoadBalancer services, TLS ingress, gateway patterns, GCP VPC, subnets, firewall rules, NAT, private/VPC-native clusters |
| Testing / Validation | curl, k6, bash loops, HTTP status validation, 401/200/403/429 proof collection |
| Platform Engineering | Repeatable build scripts, validation scripts, teardown automation, artifact collection |
| Observability / Evidence | Screenshots, logs, resource snapshots, validation outputs, project demos, k6 reports |
| Cloud Platforms | AWS EKS, Google Kubernetes Engine (public and private), IAM, VPC networking, managed node groups, Cloud NAT, Artifact Registry |
| Application Development | FastAPI policy enforcement point (python-gate) for redundant authorization checks |
| Field | Value |
|---|---|
| Author | T.I.Q.S. |
| Group Leader | John Sweeney |
| Group Name | The Brotherhood of jerMutants - Wolfpack |
| Version | v2.0 |
| Date | July 2026 |
| GitHub | tiqsclass6 |
| Repository | kubernetes-projects-2026 |
“Declare it in Git. Reconcile it in Kubernetes. Secure it before it ships.” ☸️