← Back to blog
11 min readEN

Cloud Infrastructure in Morocco:
GCP, Terraform and Kubernetes in Production

A practical guide based on real projects in Morocco. How to go from physical servers or unmanaged VMs to a cloud-native stack on Google Cloud Platform, with Terraform for Infrastructure as Code and Kubernetes for orchestration.

GCPTerraformKubernetesCloud NativeIaCMorocco

Why GCP for Moroccan projects?

When people think of cloud in Morocco, AWS and Azure naturally come to mind — and for good reason. Yet Google Cloud Platform has specific advantages that make it an excellent choice for certain kinds of Moroccan projects, especially those needing advanced AI/ML capabilities, large-scale data analysis, or a first-class managed Kubernetes.

GCP is the birthplace of Kubernetes — Google created the Borg project (the ancestor of K8s), and Google Kubernetes Engine (GKE) remains the most mature and feature-rich implementation available. For organizations that are serious about Kubernetes, GKE offers features (autopilot mode, release channels, Workload Identity) that considerably simplify operations.

I personally obtained $100,000 in GCP credits through the GCP Cloud Program to fund an innovative cloud infrastructure project. This program — often overlooked — is open to Moroccan startups and SMEs building cloud-native or AI solutions. It is a significant financial opportunity that I recommend any organization starting its cloud migration look into.

Terraform: the Infrastructure as Code that changes everything

Before adopting Terraform, most teams manage their infrastructure through web consoles, fragile shell scripts, or worse — "manual" documentation that nobody really follows. The result: drifted environments, differences between dev and production, and incidents caused by untracked changes.

Terraform solves this by treating infrastructure as code: versioned, reviewed, tested, and deployed reproducibly. Here is what a Terraform configuration for a basic GKE cluster looks like:

main.tf — GKE Cluster
resource "google_container_cluster" "primary" {
  name     = "production-cluster"
  location = "europe-west1"

  # Use a separate node pool
  remove_default_node_pool = true
  initial_node_count       = 1

  workload_identity_config {
    workload_pool = "${var.project_id}.svc.id.goog"
  }
}

resource "google_container_node_pool" "primary_nodes" {
  name       = "primary-node-pool"
  cluster    = google_container_cluster.primary.name
  location   = "europe-west1"
  node_count = var.node_count

  node_config {
    machine_type = "n2-standard-4"
    disk_size_gb = 100
    oauth_scopes = [
      "https://www.googleapis.com/auth/cloud-platform"
    ]
    workload_metadata_config {
      mode = "GKE_METADATA"
    }
  }

  autoscaling {
    min_node_count = 1
    max_node_count = 10
  }
}

This code is versioned in Git, reviewed like any application code, and run through a CI/CD pipeline. Every infrastructure change goes through a pull request with a Terraform plan displayed automatically. No more surprise changes in production.

The monitoring stack you can't do without

A cloud infrastructure without observability is a blind infrastructure. The kube-prometheus-stack (Prometheus + Grafana + Alertmanager) has become the de facto standard for Kubernetes clusters. It installs through a single Helm chart and automatically instruments the entire cluster: system metrics, Kubernetes metrics, application metrics.

Metrics
Prometheus
Collects and stores metrics. ServiceMonitors scrape applications automatically.
Logs
Loki + Promtail
Aggregates the logs of every pod. LogQL queries for correlation with metrics.
Traces
Tempo + OpenTelemetry
Distributed tracing to understand requests that cross several microservices.
Dashboards
Grafana
Unified visualization of metrics, logs and traces. Built-in Slack/PagerDuty alerts.

Security: don't leave it for later

One of the most common mistakes in cloud projects in Morocco is treating security as a final step rather than a cross-cutting concern. In a DevSecOps approach, security is built into every stage:

CodeSAST with SonarQube — detecting vulnerabilities in the source code
BuildDocker image scanning with Trivy — CVEs in OS and application packages
DeployOPA Gatekeeper — Kubernetes policies (no root, resource limits, approved registries)
RuntimeFalco — detecting behavioral anomalies in running containers
SecretsHashiCorp Vault — no hardcoded secrets in configs or CI/CD

A roadmap for migrating to cloud-native in Morocco

For an organization starting its migration, here is the sequence I recommend over 6 months:

Months 1-2Foundations
  • GCP account + organization structure
  • Terraform state backend (GCS)
  • VPC, subnets, NAT Gateway
  • Basic CI/CD pipeline (GitLab CI)
Months 2-3Containerization
  • Dockerizing the first 2-3 applications
  • Artifact Registry for the images
  • GKE cluster (non-production)
  • Base Helm charts
Months 3-4Production
  • Production GKE with autopilot
  • kube-prometheus-stack monitoring
  • ArgoCD for GitOps
  • Vault for secrets
Months 4-6Optimization
  • Full DevSecOps pipeline
  • Cost optimization + budget alerts
  • SLOs and error budgets
  • Documentation and team training

Conclusion

Migrating to a cloud-native infrastructure with GCP, Terraform and Kubernetes is not a trivial project — but it is an investment with a very high return for Moroccan organizations that commit to it seriously. Reliability goes up, deployments speed up, infrastructure costs become predictable, and the technical team builds skills in technologies that carry international value.

The GCP Cloud Program is an under-exploited financial opportunity in Morocco. If you are building an innovative project, I strongly encourage you to apply — the $100K I obtained funded an infrastructure that we could not otherwise have afforded at the start.