Forem: Mayowa Adeniyi

Building a Fully Reproducible Kubernetes Platform Using Scaleway, Terraform, and ArgoCD - Part 1

Mayowa Adeniyi — Wed, 18 Mar 2026 16:26:57 +0000

Prerequisites

Docker
Terraform
Scaleway Account
Infisical Account
Terrform Cloud Account
Cloudflare Account
Set up a PostgreSQL database and get the connection string
Familiarity with using Terraform

In this article, you will learn the following:

Provision a Kubernetes cluster using Scaleway Kapsule with Terraform.
Bootstrap ArgoCD using the App-of-Apps pattern with Terraform.
Inject secrets securely at run time into the cluster using Infisical.
Deploying infrastructure components with GitOps.
Automatically configure DNS records using Cloudflare.
Prepare the platform for secure access control using Cloudflare Zero Trust.

What is a Reproducible Kubernetes Platform?

It simply means an infrastructure setup that can be created and re-created from scratch with code, using an Infrastructure as Code (IaC) tool like Terraform for infrastructure provisioning and ArgoCD for application management.

One of the primary advantages of this approach is that if your Kubernetes cluster is totally down, everything can be re-created from Git with a single Terraform command.

Getting Started

Clone this repo https://github.com/Ademayowa/k8s-api-deployment

In the root of the project, run these commands:

docker login

docker build -t your_dockerhub_username/real-estate-backend:v1.0.0 .

Replace your_docker_username with yours in the command above.

Push the image to Docker Hub by running the command:

docker push your_dockerhub_username/real-estate-backend:v1.0.0

Check your Docker Hub; the image should be there.

Creating Secrets with Infisical

Now, you need to create a PostgreSQL database and get the connection string. The database connection string you created will be kept on Infisical. You can create a free PostgreSQL database on Supabase, Render, Neon, etc.

Next, create an account on Infisical: https://app.infisical.com/signup

Note: The aim of the steps below is to get the client_id, client_secret, and project_slug on Infisical. All other parts that involve setting up secrets for the Kubernetes cluster will be done using Terraform.

During sign-up, enter the organization name as Real Estate. On the dashboard, select Add new project.

A modal is displayed on the screen. Follow the steps and click the Create Project button.

You will be redirected to a page to let you add secrets. Select the dev environment and add a secret.

Now, add the database URL connection string from your PostgreSQL database into the value field in the form.

Next, fill in the other text fields and click the Create Secret button.

Now that the secret has been created successfully, you will need to create a Machine Identities by following the steps below:

After selecting the Add Machine Identity to Project button, a modal is displayed. Fill the form fields and click on the create button.

Next, you will need the client id, client secret, and the project slug.

On the Access Control tab, under the Authentication section, click the drop-down arrow icon where there is Universal Auth.

Then scroll down and copy the client id. To add a client secret, click the Add client secret button.

In the modal window, enter text in the text field, then click the Create button. Once that is done, the secret is automatically generated on the screen for you. Ensure to copy it.

To get the project id, click the settings tab and select copy project id as shown below:

Now that you have the client id and client secret from Infisical, note the two values. You will need them in the next section when implementing Terraform.

Implementing Terraform: Setting Up Terraform Cloud

Terraform Cloud will be used to manage the remote state of your infrastructure, making state sharing and locking much easier.

To set up a Terraform Cloud account, go to: https://app.terraform.io/signup/account

Create an organization - name it something like real estate

Select personal. It is suitable for projects like this. Then enter the organization name and click the Create organization button.

Next, select the CLI workflow. This will enable you to run Terraform commands in the terminal.

Add a workspace name and click the Create button at the bottom of the page.

Note your organization name and workspace name - you will need it later.

Set up Kubernetes Kapsule on Scaleway using Terraform

First, sign up for free here: https://www.scaleway.com/en/kubernetes-kapsule/

Select Personal project for the account type, and choose your preferred sign-up method.

You will need to add a valid card during the sign-up process. Note that you won't be debited. On the dashboard, create an organization and add a project.

Enter the project name and description in the modal form displayed on the screen.

Next, get Scaleway API Credentials from your dashboard. Go to https://console.scaleway.com/iam/api-keys

Click on the Generate API key button. A modal is displayed on the screen. Fill the form fields. You can select No for the section Will this API key be used for Object Storage? Then click on the Generate API key button on the modal to generate your API keys.

After clicking the Generate API keys button, scroll down to review all the credential values. Click the drop-down icon, then copy the values for each key.

Next, add those credentials to your Terraform Cloud dashboard as variables. Go to your workspace and select the project on the central page. On the sidebar, select variables.

Click on the Add variable button. Paste your values and use these as the keys: infisical_client_id, infisical_client_secret, scaleway_access_key, scaleway_organization_id, scaleway_project_id, and scaleway_secret_key.

Then click the Save variable button.

Also, make sure the Terraform directory is set on Terraform Cloud. Click on the workspace from the central dashboard. Select the settings, then scroll down to the Terraform Working Directory section.

Click on the Save settings button.

Creating Terraform Modules for Kubernetes Kapsule on Scaleway

In the root of the project, run these commands:

mkdir -p infra/terraform/modules/scaleway/kubernetes

touch infra/terraform/modules/scaleway/kubernetes/main.tf

touch infra/terraform/modules/scaleway/kubernetes/variables.tf

touch infra/terraform/modules/scaleway/kubernetes/outputs.tf

Add this content to infra/terraform/modules/scaleway/kubernetes/main.tf

terraform {
 required_version = ">= 1.0"

 required_providers {
   scaleway = {
     source  = "scaleway/scaleway"
     version = "~> 2.0"
   }
 }
}

resource "scaleway_k8s_cluster" "main" {
 name    = var.cluster_name
 version = var.kubernetes_version
 region  = var.region
 cni     = "cilium"
 tags    = var.tags

 private_network_id = scaleway_vpc_private_network.k8s.id

 # Delete associated resources on cluster deletion
 delete_additional_resources = true

 # Set project id
 project_id = var.project_id
}

resource "scaleway_k8s_pool" "main" {
 cluster_id = scaleway_k8s_cluster.main.id
 name       = "${var.cluster_name}-pool"
 node_type  = var.node_type
 size       = var.node_count

 autoscaling = var.autoscaling
 min_size    = var.autoscaling ? var.min_nodes : null
 max_size    = var.autoscaling ? var.max_nodes : null

 tags = var.tags
}

# Required for stable cluster creation with Cilium on Scaleway
resource "scaleway_vpc_private_network" "k8s" {
 name       = "${var.cluster_name}-pn"
 project_id = var.project_id
 tags       = var.tags
}

The code above sets up a Kubernetes cluster on Scaleway, on a private network.

Next, add the following to infra/terraform/modules/scaleway/kubernetes/variables.tf

variable "cluster_name" {
  description = "Cluster name"
  type        = string
}

variable "region" {
  description = "Scaleway region"
  type        = string
  default     = "fr-par"
}

variable "kubernetes_version" {
  description = "Kubernetes version"
  type        = string
}

variable "node_type" {
  description = "Node instance type"
  type        = string
}

variable "node_count" {
  description = "Number of nodes"
  type        = number
  default     = 1
}

variable "autoscaling" {
  description = "Enable autoscaling"
  type        = bool
  default     = false
}

variable "min_nodes" {
  description = "Min nodes for autoscaling"
  type        = number
  default     = 1
}

variable "max_nodes" {
  description = "Max nodes for autoscaling"
  type        = number
  default     = 3
}

variable "tags" {
  description = "Resource tags"
  type        = list(string)
  default     = []
}

variable "project_id" {
  description = "Scaleway project ID"
  type        = string
}

The code above are variables needed for the cluster creation on Scaleway.

Add this content to infra/terraform/modules/scaleway/kubernetes/outputs.tf

output "cluster_id" {
 description = "Cluster ID"
 value       = scaleway_k8s_cluster.main.id
}

output "cluster_name" {
 description = "Cluster name"
 value       = scaleway_k8s_cluster.main.name
}

output "cluster_endpoint" {
 description = "API endpoint"
 value       = scaleway_k8s_cluster.main.apiserver_url
 sensitive   = true
}

output "cluster_region" {
 description = "Cluster region"
 value       = scaleway_k8s_cluster.main.region
}

output "cluster_version" {
 description = "Kubernetes version"
 value       = scaleway_k8s_cluster.main.version
}

output "kubeconfig_host" {
 value = scaleway_k8s_cluster.main.kubeconfig[0].host
}

output "kubeconfig_token" {
 value     = scaleway_k8s_cluster.main.kubeconfig[0].token
 sensitive = true
}

output "kubeconfig_cluster_ca_certificate" {
 value     = scaleway_k8s_cluster.main.kubeconfig[0].cluster_ca_certificate
 sensitive = true
}

output "kubeconfig" {
 description = "Complete kubeconfig file"
 sensitive   = true
 value       = scaleway_k8s_cluster.main.kubeconfig[0].config_file
}

Next, run:

mkdir -p infra/terraform/envs/dev/scaleway

touch infra/terraform/envs/dev/scaleway/main.tf

touch infra/terraform/envs/dev/scaleway/variables.tf

touch infra/terraform/envs/dev/scaleway/outputs.tf

Add the following content to infra/terraform/envs/dev/scaleway/main.tf

terraform {
  required_version = ">= 1.0"

  required_providers {
    scaleway = {
      source  = "scaleway/scaleway"
      version = "~> 2.0"
    }
  }

  backend "remote" {
    organization = "real-estate"

    workspaces {
      name = "real-estate-app"
    }
  }
}

provider "scaleway" {
  access_key      = var.scaleway_access_key
  secret_key      = var.scaleway_secret_key
  organization_id = var.scaleway_organization_id
  region          = var.region
  zone            = var.zone
}

module "kubernetes" {
  source = "../../../modules/scaleway/kubernetes"

  cluster_name       = var.cluster_name
  region             = var.region
  kubernetes_version = var.kubernetes_version
  node_type          = var.node_type
  node_count         = var.node_count
  autoscaling        = var.autoscaling
  min_nodes          = var.min_nodes
  max_nodes          = var.max_nodes
  tags               = var.tags
  project_id         = var.scaleway_project_id
}

Here is what happens in the code above:

Store the Terraform state remotely using Terraform Cloud real-estate
Authenticates Scaleway by using your API credentials with access_key, secret_key, and organization_id.
Call the reusable modules by importing them.

Next, the follwoing to infra/terraform/envs/dev/scaleway/variables.tf


variable "scaleway_access_key" {
  description = "Scaleway access key"
  type        = string
  sensitive   = true
}

variable "scaleway_secret_key" {
  description = "Scaleway secret key"
  type        = string
  sensitive   = true
}

variable "scaleway_organization_id" {
  description = "Scaleway organization ID"
  type        = string
  sensitive   = true
}

variable "scaleway_project_id" {
  description = "Scaleway project ID"
  type        = string
  sensitive   = true
}

variable "cluster_name" {
  description = "Cluster name"
  type        = string
  default     = "real-estate-dev"
}

variable "region" {
  description = "Scaleway region"
  type        = string
  default     = "fr-par"
}

variable "zone" {
  description = "Scaleway zone"
  type        = string
  default     = "fr-par-1"
}

variable "kubernetes_version" {
  description = "Kubernetes version"
  type        = string
}

variable "node_type" {
  description = "Node type"
  type        = string
  default     = "DEV1-M" # 3 vCPUs & 4 GB RAM
}

variable "node_count" {
  description = "Number of nodes"
  type        = number
  default     = 1
}

variable "autoscaling" {
  description = "Enable autoscaling"
  type        = bool
  default     = false
}

variable "min_nodes" {
  description = "Min nodes"
  type        = number
  default     = 1
}

variable "max_nodes" {
  description = "Max nodes"
  type        = number
  default     = 3
}

variable "tags" {
  description = "Resource tags"
  type        = list(string)
  default     = ["dev", "real-estate", "kubernetes"]
}

variable "repo_url" {
  description = "Git repository URL for ArgoCD to sync from"
  type        = string
}

variable "target_revision" {
  description = "Git branch or tag for ArgoCD to sync from"
  type        = string
  default     = "main"
}

variable "bootstrap_path" {
  description = "Path in the Git repo to the ArgoCD bootstrap folder"
  type        = string
}

variable "infisical_client_id" {
  description = "Infisical universal auth client ID"
  type        = string
  sensitive   = true
}

variable "infisical_client_secret" {
  description = "Infisical universal auth client secret"
  type        = string
  sensitive   = true
}

variable "infisical_env_slug" {
  description = "Infisical environment slug"
  type        = string
}

variable "infisical_project_slug" {
  description = "Infisical project slug"
  type        = string
}

The code above are Terraform variable for the dev environment.

Add this content to infra/terraform/envs/dev/scaleway/outputs.tf

output "cluster_id" {
 description = "Cluster ID"
 value       = module.kubernetes.cluster_id
}

output "cluster_name" {
 description = "Cluster name"
 value       = module.kubernetes.cluster_name
}

output "cluster_endpoint" {
 description = "API endpoint"
 value       = module.kubernetes.cluster_endpoint
 sensitive   = true
}

output "cluster_region" {
 description = "Cluster region"
 value       = module.kubernetes.cluster_region
}

output "cluster_version" {
 description = "Kubernetes version"
 value       = module.kubernetes.cluster_version
}

output "kubeconfig" {
 description = "Kubeconfig for the Scaleway Kubernetes cluster"
 sensitive   = true
 value       = module.kubernetes.kubeconfig
}

Next, run:

touch infra/terraform/envs/dev/scaleway/terraform.tfvars

Add this content to the file:

cluster_name       = "real-estate-dev"
region             = "fr-par"
zone               = "fr-par-1"
kubernetes_version = "1.34.5"

node_type  = "DEV1-M" # 3 vCPUs & 4 GB RAM
node_count = 1

autoscaling = false
min_nodes   = 1
max_nodes   = 3

tags = ["dev", "real-estate", "kubernetes"]

repo_url               = "https://github.com/Ademayowa/k8s-api-deployment" # Add your repo URL
target_revision        = "main"
bootstrap_path         = "infra/k8s/argocd/bootstrap/dev"
infisical_project_slug = "real-estate-db-sc" # Add your Infisical project slug
infisical_env_slug     = "dev"

Replace with your repo_url and infisical_project_slug. This file should be added to .gitignore.
Next, add the following to the Terraform root directory as a .gitignore file:

# Terraform directories
**/.terraform/*

# State files
*.tfstate
*.tfstate.*

# Crash logs
crash.log
crash.*.log

# Sensitive files
*.tfvars
*.tfvars.json

# Override files
override.tf
override.tf.json
*_override.tf
*_override.tf.json

# CLI config
.terraformrc
terraform.rc

# Certificates and keys
*.pem
*.key
*.crt

# Kubeconfig
kubeconfig
*.kubeconfig

# Lock file 
.terraform.lock.hcl

Creating ArgoCD Modules in Terraform

Here, you need to create ArgoCD modules to bootstrap the entire platform, both the infrastructure and the application layer.

In this case, the infrastructure layer consists of cert-manager, which handles TLS/SSL certificates, Traefik for Ingress routing, and Cloudflare for DNS management. The application layer consists of the Golang backend APIs.

Now, run the commands below:

mkdir -p infra/terraform/modules/argocd-bootstrap

touch infra/terraform/modules/argocd-bootstrap/main.tf

touch infra/terraform/modules/argocd-bootstrap/variables.tf

touch infra/terraform/modules/argocd-bootstrap/outputs.tf

Add this content to infra/terraform/modules/argocd-bootstrap/main.tf

terraform {
  required_providers {
    kubectl = {
      source  = "gavinbunney/kubectl"
      version = "~> 1.14"
    }
    kubernetes = {
      source  = "hashicorp/kubernetes"
      version = "~> 2.0"
    }
    helm = {
      source  = "hashicorp/helm"
      version = "~> 2.11"
    }
  }
}

# Install ArgoCD via Helm
resource "helm_release" "argocd" {
  name       = "argocd"
  repository = "https://argoproj.github.io/argo-helm"
  chart      = "argo-cd"
  namespace  = "argocd"
  version    = var.chart_version

  create_namespace = true
  wait             = true
  timeout          = 600
}

# Create ArgoCD root application (App of Apps)
resource "kubectl_manifest" "argocd_root_app" {
  wait = true

  yaml_body = <<-YAML
   apiVersion: argoproj.io/v1alpha1
   kind: Application
   metadata:
     name: root
     namespace: argocd
     finalizers:
       - resources-finalizer.argocd.argoproj.io
   spec:
     project: default
     source:
       repoURL: ${var.repo_url}
       targetRevision: ${var.target_revision}
       path: ${var.bootstrap_path}
     destination:
       server: https://kubernetes.default.svc
       namespace: argocd
     syncPolicy:
       automated:
         prune: true
         selfHeal: true
       syncOptions:
         - CreateNamespace=true
 YAML

  depends_on = [helm_release.argocd]
}

# Terraform owns the dev-real-estate namespace - ArgoCD does not create it
resource "kubernetes_namespace_v1" "dev-real-estate" {
  metadata {
    name = "dev-real-estate"
  }

  depends_on = [kubectl_manifest.argocd_root_app]
}

# Creates the Infisical auth secret so the operator can authenticate with Infisical
resource "kubernetes_secret_v1" "infisical_auth" {
  metadata {
    name      = "infisical-auth-real-estate"
    namespace = "dev-real-estate"
  }

  data = {
    clientId     = var.infisical_client_id
    clientSecret = var.infisical_client_secret
  }

  depends_on = [kubernetes_namespace_v1.dev-real-estate]
}

The code above is the core for bootstrapping a reproducible Kubernetes platform. Here is what happens.

When the terraform apply command is run, ArgoCD creates an application named root. This root is the parent application that automatically creates two child applications: infrastructure and applications. Note that Terraform only creates the dev-real-estate namespace; all other workloads in this namespace will be created by ArgoCD.

Next, add this to infra/terraform/modules/argocd-bootstrap/variables.tf

Next, add this content to infra/terraform/modules/argocd-bootstrap/variables.tf

variable "chart_version" {
  description = "ArgoCD Helm chart version"
  type        = string
  default     = "9.4.0"
}

variable "repo_url" {
  description = "Git repository URL for ArgoCD to sync from"
  type        = string
}

variable "target_revision" {
  description = "Git branch or tag for ArgoCD to sync from"
  type        = string
  default     = "main"
}

variable "bootstrap_path" {
  description = "Path in the Git repo to the bootstrap folder for the environment"
  type        = string
}

variable "infisical_client_id" {
  description = "Infisical universal auth client ID"
  type        = string
  sensitive   = true
}

variable "infisical_client_secret" {
  description = "Infisical universal auth client secret"
  type        = string
  sensitive   = true
}

variable "infisical_env_slug" {
  description = "Infisical environment slug"
  type        = string
}
variable "infisical_project_slug" {
  description = "Infisical project slug"
  type        = string
}

The code above defines variables for the argocd-bootstrap module.

Next, add this content to infra/terraform/modules/argocd-bootstrap/outputs.tf

output "namespace" {
  description = "Namespace where ArgoCD is installed"
  value       = helm_release.argocd.namespace
}

output "chart_version" {
  description = "Installed ArgoCD chart version"
  value       = helm_release.argocd.version
}

Adding the Infisical Operator Modules in Terraform

The Infisical operator handles the management of secrets in the Kubernetes cluster. Now, run the commands below:

mkdir -p infra/terraform/modules/infisical-operator

touch infra/terraform/modules/infisical-operator/main.tf

touch infra/terraform/modules/infisical-operator/variables.tf

touch infra/terraform/modules/infisical-operator/outputs.tf

Add this content to infra/terraform/modules/infisical-operator/main.tf

resource "helm_release" "infisical_operator" {
  name       = "infisical-operator"
  repository = "https://dl.cloudsmith.io/public/infisical/helm-charts/helm/charts/"
  chart      = "secrets-operator"
  namespace  = "infisical-operator-system"
  version    = var.chart_version

  create_namespace = true
}

The code above installs the Infisical operator into the Kubernetes cluster via a Helm chart.

Next, add this content to infra/terraform/modules/infisical-operator/variables.tf

variable "chart_version" {
 description = "Infisical Helm chart version"
 type        = string
 default     = "0.10.5"
}

Add the follwoing to infra/terraform/modules/infisical-operator/outputs.tf

output "namespace" {
 description = "Namespace where Infisical operator is installed"
 value       = helm_release.infisical_operator.namespace
}

output "chart_version" {
 description = "Installed Infisical chart version"
 value       = helm_release.infisical_operator.version
}

Update the infra/terraform/envs/dev/scaleway/main.tf to have the Helm provider, Kubernetes provider, and the modules get updated:

terraform {
  required_version = ">= 1.0"

  required_providers {
    scaleway = {
      source  = "scaleway/scaleway"
      version = "~> 2.0"
    }
    helm = {
      source  = "hashicorp/helm"
      version = "~> 2.11"
    }
    kubernetes = {
      source  = "hashicorp/kubernetes"
      version = "~> 2.0"
    }
    kubectl = {
      source  = "gavinbunney/kubectl"
      version = "~> 1.14"
    }
  }

  backend "remote" {
    organization = "real-estate"

    workspaces {
      name = "real-estate-app"
    }
  }
}

provider "scaleway" {
  access_key      = var.scaleway_access_key
  secret_key      = var.scaleway_secret_key
  organization_id = var.scaleway_organization_id
  region          = var.region
  zone            = var.zone
}

provider "helm" {
  kubernetes {
    host  = module.kubernetes.kubeconfig_host
    token = module.kubernetes.kubeconfig_token
    cluster_ca_certificate = base64decode(
      module.kubernetes.kubeconfig_cluster_ca_certificate
    )
  }
}

provider "kubernetes" {
  host  = module.kubernetes.kubeconfig_host
  token = module.kubernetes.kubeconfig_token
  cluster_ca_certificate = base64decode(
    module.kubernetes.kubeconfig_cluster_ca_certificate
  )
}

provider "kubectl" {
  host  = module.kubernetes.kubeconfig_host
  token = module.kubernetes.kubeconfig_token
  cluster_ca_certificate = base64decode(
    module.kubernetes.kubeconfig_cluster_ca_certificate
  )
  load_config_file = false
}

module "kubernetes" {
  source = "../../../modules/scaleway/kubernetes"

  cluster_name       = var.cluster_name
  region             = var.region
  kubernetes_version = var.kubernetes_version
  node_type          = var.node_type
  node_count         = var.node_count
  autoscaling        = var.autoscaling
  min_nodes          = var.min_nodes
  max_nodes          = var.max_nodes
  tags               = var.tags
  project_id         = var.scaleway_project_id
}

module "infisical_operator" {
  source = "../../../modules/infisical-operator"

  depends_on = [module.kubernetes]
}

module "argocd" {
  source = "../../../modules/argocd-bootstrap"

  repo_url                = var.repo_url
  target_revision         = var.target_revision
  bootstrap_path          = var.bootstrap_path
  infisical_client_id     = var.infisical_client_id
  infisical_client_secret = var.infisical_client_secret
  infisical_project_slug  = var.infisical_project_slug
  infisical_env_slug      = var.infisical_env_slug

  depends_on = [module.kubernetes]
}

To verify that the updated files work as expected, run:

cd infra/terraform/envs/dev/scaleway

terraform init
terraform plan

Implementing ArgoCD App of Apps Pattern

Note: Change repo_URL to your own GitHub repository in the files below.

Now, in the root of the project, run the commands below:

mkdir -p infra/k8s/argocd/bootstrap/dev

touch infra/k8s/argocd/bootstrap/dev/infrastructure.yaml

touch infra/k8s/argocd/bootstrap/dev/applications.yaml

Add this content to infra/k8s/argocd/bootstrap/dev/infrastructure.yaml

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
 name: infrastructure
 namespace: argocd
 finalizers:
   - resources-finalizer.argocd.argoproj.io
spec:
 project: default

 source:
   repoURL: https://github.com/Ademayowa/k8s-api-deployment
   targetRevision: main
   path: infra/k8s/argocd/infrastructure
   directory:
     recurse: true
     include: "*/application.yaml"

 destination:
   server: https://kubernetes.default.svc
   namespace: argocd

 syncPolicy:
   automated:
     prune: true
     selfHeal: true

Here is what happens in the code above: any application.yaml file created under the infra/k8s/argocd/infrastructure directory automatically becomes an ArgoCD application that gets deployed.

Next, add this content to infra/k8s/argocd/bootstrap/dev/applications.yaml

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
 name: applications
 namespace: argocd
 finalizers:
   - resources-finalizer.argocd.argoproj.io
spec:
 project: default

 source:
   repoURL: https://github.com/Ademayowa/k8s-api-deployment
   targetRevision: main
   path: infra/k8s/argocd/applications/dev
   directory:
     recurse: true

 destination:
   server: https://kubernetes.default.svc
   namespace: argocd

 syncPolicy:
   automated:
     prune: true
     selfHeal: true

In the code above, any YAML file that has infra/k8s/argocd/applications/dev directory automatically gets deployed.

Next, run these commands below:

mkdir -p infra/k8s/argocd/applications/dev

touch infra/k8s/argocd/applications/dev/real-estate.yaml

touch infra/k8s/argocd/applications/dev/real-estate-infisical-secret.yaml

touch infra/k8s/argocd/applications/dev/namespace.yaml

Add the following content to infra/k8s/argocd/applications/dev/real-estate.yaml

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
 name: real-estate-backend-dev
 namespace: argocd
spec:
 project: default

 source:
   repoURL: https://github.com/Ademayowa/k8s-api-deployment
   targetRevision: main
   path: infra/helm/real-estate-chart
   helm:
     valueFiles:
       - values-dev.yaml

 destination:
   server: https://kubernetes.default.svc
   namespace: dev-real-estate

 syncPolicy:
   # Enable automatic sync
   automated:
     prune: true
     selfHeal: true
     allowEmpty: false # Prevent deleting all resources

The code above is an ArgoCD application that deploys the Golang backend APIs via a Helm chart.

Next, add the following content to infra/k8s/argocd/applications/dev/real-estate-infisical-secret.yaml

apiVersion: secrets.infisical.com/v1alpha1
kind: InfisicalSecret
metadata:
 name: real-estate-infisical-secret
 namespace: dev-real-estate
 labels:
   app: real-estate
spec:
 hostAPI: https://app.infisical.com/api

 # Authenticate with Infisical
 authentication:
   universalAuth:
     secretsScope:
       envSlug: "dev"
       secretsPath: "/"
       projectSlug: "real-estate-db-sc" # Your project slug
     credentialsRef:
       secretName: infisical-auth-real-estate
       secretNamespace: dev-real-estate

 # Store the synced secrets in Kubernetes
 managedSecretReference:
   secretName: real-estate-secret
   secretNamespace: dev-real-estate
   secretType: Opaque
   creationPolicy: "Owner"

 resyncInterval: 300

The code above automatically syncs the secrets from Infisical (using infisical-auth-real-estate) into the Kubernetes cluster as a secret real-estate-secret every five minutes. That way, there's no sensitive value hanging around in the YAML files or Git repository, which keeps the cluster more secure.

Now, add this content to infra/k8s/argocd/applications/dev/namespace.yaml

apiVersion: v1
kind: Namespace
metadata:
 name: dev-real-estate

Create the Infrastructure Directory

Next, run the commands below:

mkdir -p infra/k8s/argocd/infrastructure/cert-manager

touch infra/k8s/argocd/infrastructure/cert-manager/applications.yaml

touch infra/k8s/argocd/infrastructure/cert-manager/letsencrypt-staging.yaml

Add the following content to infra/k8s/argocd/infrastructure/cert-manager/applications.yaml

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: cert-manager
  namespace: argocd
spec:
  project: default

  source:
    repoURL: https://charts.jetstack.io
    chart: cert-manager
    targetRevision: v1.17.2
    helm:
      values: |
        crds:
          enabled: true

  destination:
    server: https://kubernetes.default.svc
    namespace: cert-manager

  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true

Add this content to infra/k8s/argocd/infrastructure/cert-manager/letsencrypt-staging.yaml

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-staging
spec:
  acme:
    server: https://acme-staging-v02.api.letsencrypt.org/directory
    email: # Add your emaill address here
    privateKeySecretRef:
      name: letsencrypt-staging
    solvers:
      - http01:
          ingress:
            class: traefik

Run these commands below:

mkdir -p infra/k8s/argocd/infrastructure/traefik

touch infra/k8s/argocd/infrastructure/traefik/application.yaml

Next, add this content to infra/k8s/argocd/infrastructure/traefik/application.yaml

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
 name: traefik
 namespace: argocd
spec:
 project: default

 source:
   repoURL: https://traefik.github.io/charts
   chart: traefik
   targetRevision: 26.0.0
   helm:
     values: |
       service:
         type: LoadBalancer
       ports:
         websecure:
           tls:
             enabled: true

 destination:
   server: https://kubernetes.default.svc
   namespace: traefik

 syncPolicy:
   automated:
     prune: true
     selfHeal: true
   syncOptions:
     - CreateNamespace=true

Bootstrap the Kubernetes Platform

Run the command below:

terraform login

Copy the token displayed in the browser, paste it directly into your terminal, and press Enter. Your terminal output should look like this:

Next, run the commands below:

cd infra/terraform/envs/dev/scaleway

terraform plan
terraform apply

Now, to connect and interact with the Kubernetes cluster on Scaleway, run the commands below and export the kubeconfig file:

terraform output -raw kubeconfig > ~/.kube/config-scaleway

# Secure the file (very important) 
chmod 600 ~/.kube/config-scaleway

export KUBECONFIG=~/.kube/config-scaleway

To ensure the ArgoCD applications work well, from the root of the project run:

kubectl get applications -n argocd

Now, you can get all pods running in the cluster. With this approach of bootstrapping the entire platform with a single terraform apply command, every other workload is reproducible from Git.

In the next part of this series, we will look at how to secure the platform and make the cluster production-ready.

For now, destroy the cluster by running:

terraform destroy

Conclusion

This tutorial showed how to bootstrap a reproducible Kubernetes platform using Scaleway Kapsule, Terraform, ArgoCD, and Infisical for handling secret management.

Here is the GitHub repository for the boilerplate: https://github.com/Ademayowa/k8s-api-deployment

Resources

Scaleway Terraform Providers Official Documentation

Scaleway Kubernetes Kapsule

ArgoCD App of Apps Official Documentation

Infisical Secret CRD Official Documentation

Deploy a Golang App to EC2 with Docker and AWS ECR

Mayowa Adeniyi — Tue, 16 Dec 2025 10:48:17 +0000

Amazon Elastic Compute (EC2) is a cloud service by AWS that allows the creation of virtual machines in the cloud.
Amazon Elastic Container Registry (ECR) is also a cloud service by AWS that allows the storage of Docker images.

If most of our cloud services run on AWS, one of the primary advantages of using ECR is that it ensures faster pulls of Docker images.

In this tutorial, we will learn how to deploy a Golang application to EC2 with Docker and AWS ECR.

Prerequisites

Go 1.25+
Gin
Docker
AWS Account
You already have a running EC2 instance on AWS. Note that on the EC2 instance, the Amazon Machine Image (AMI) selected should be Ubuntu.

Getting Started

Let us ensure we are logged in to AWS via the terminal. If not logged in, run

aws configure

and enter the credentials as prompted.

Clone the Go repository

Before cloning the repository, we need to have two separate terminal windows. One for the clone repository and the other one for the EC2 instance.

Clone the repository by running:

git clone https://github.com/Ademayowa/learn-d-compose.git

In the clone repository terminal window run:

cd learn-d-compose
go mod tidy
cp .env.example .env && echo "POSTGRES_PASSWORD=mysecurepassword123" >> .env

An .env file is created. To get the value of the AWS_ACCOUNT_ID in the .env file, run:

aws sts get-caller-identity --query Account --output text

Copy the value output in the terminal (that's the AWS account ID) and paste it into the .env file.

Load the .env file into the current terminal session

export $(cat .env | xargs)

aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin ${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com

A "Login Succeeded" message is displayed in the terminal window.

Next, create an ECR repository by running the command below:

aws ecr create-repository --repository-name learn-d-compose --region us-east-1

Once we run the command above, a private repository registry called learn-d-compose is created on AWS ECR.

Build the Docker image locally

docker build -t learn-d-compose:latest .

Tag the Docker image and push to ECR by running:

docker tag learn-d-compose:latest ${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/learn-d-compose:latest

docker push ${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/learn-d-compose:latest

Once we have pushed the Docker image to ECR, check the ECR repository on AWS and select learn-d-compose

Now that we have the Docker image, let us copy some files from our local machine to the EC2 instance.

Copy files from the local machine

Before copying files from the local machine, let us ensure the EC2 instance is running.

On the terminal window for the cloned repository, copy the docker-compose.yml file from the local machine to the EC2 instance by running:

scp -i ~/path_to_your_ssh_key.pem docker-compose.yml ubuntu@EC2_IP:~/

Next, copy the .env file by running:

scp -i ~/path_to_your_ssh_key.pem .env ubuntu@EC2_IP:~/

Now, let us check if the two files were successfully copied from our local machine to the EC2 instance.

Switch to the EC2 instance terminal window

SSH into the instance by running:

ssh -i ~/path_to_your_ssh_key.pem ubuntu@EC2_IP
ls -la

We should have the two files as shown below

Next, update the system by running the command below:

sudo apt update -y && sudo apt upgrade -y

Installing Docker

Install Docker on EC2 by running:

sudo apt install docker.io -y

Start Docker services by running:

sudo systemctl start docker

sudo systemctl enable docker

Add Ubuntu user to Docker group on EC2 by running:

 sudo usermod -aG docker $USER

Log out of the EC2 instance using exit in the terminal so the Docker group can take effect.
Then SSH back into the instance using:

ssh -i ~/path_to_your_ssh_key.pem ubuntu@EC2_IP

Install Docker compose with the following command:

sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Next, run:

sudo chmod +x /usr/local/bin/docker-compose

Verify Docker has been successfully installed on the EC2 instance by running:

docker --version

docker-compose --version

Installing AWS CLI on EC2

Download the AWS CLI and run the command below:

curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"

Install unzip if it is not installed, and unzip the installer.

sudo apt install unzip -y

unzip awscliv2.zip

Run the installer and verify the installation

sudo ./aws/install

aws --version

Clean up the zip file by running:

rm -rf aws awscliv2.zip

Next, let us configure the AWS CLI with our credentials by running:

aws configure

Get the AWS_ACCOUNT_ID automatically in the terminal window and log in to ECR on the EC2 instance:

AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)

aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin ${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com

Deploying to EC2 with Docker Compose

Pull the Docker image from AWS ECR registry by running:

docker-compose pull

Start the services by running:

docker-compose up -d

Check if the containers are running with:

docker-compose ps

Test the API endpoints to check if they are working fine:

    curl -X POST http://localhost:8080/jobs \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Golang Backend Engineer",
    "description": "API Integrations"
  }'

Conclusion

This tutorial demonstrated how to deploy a Golang application to EC2 with Docker and AWS ECR.

Resources

Official AWS Documentation

Sending React Emails using Next.js and the Resend SDK

Mayowa Adeniyi — Wed, 20 Sep 2023 16:25:56 +0000

Resend is a platform for efficient email sending that guarantees direct delivery to your inbox instead of the spam folder. Resend has different SDKs for various programming languages, including PHP, Ruby, JavaScript, Go, Python, and Elixir. Resend also supports serverless and SMTP for sending emails.

React Email is an open-source component library created by the same team behind Resend. This library can be used to create different kinds of modern, responsive email templates.

Features of Resend

With Resend, you can send emails using various programming languages such as Python, Ruby, Go, Elixir, PHP, and JavaScript.
Sending emails from verified DNS (Domain Name System) records.
User-friendly dashboard that shows the status of your emails whether they have been delivered, sent, or bounced.
View email messages directly inside the dashboard.

In this tutorial, you will learn how to send emails from a verified domain using React-Email, Next.js, and Resend.

Prerequisites

Here are what you need to follow along in this tutorial:

Node.js installed on your machine.
A free Resend account (sign up with Resend for free).
A GitHub account.

Getting started with Resend

To get started with Resend, create an account by visiting resend.com. You can sign up with your email address or a GitHub account.

Make sure you confirm your account by clicking the Confirm Account button in the email you received after signing up with an email. After that, you be will redirected to your Resend dashboard.

The next step is to create an API key by following the steps below:

Navigate to the API Keys section on the left side of your dashboard.
Click on the Create API Key button on the right-hand side of the page.
A modal window containing a form appears. Choose a name for the API Key Name and click on the Add button.

The API key will be generated for you once you click the Add button. You will be using this API key later on, so make a note of it.

Verifying the domain for sending emails

The domain that will be used for sending emails must be verified.
On the left-hand side of your dashboard, select Domains and click on the Add Domain button:

A new page appears. Add a domain by entering it in the input field. Then click on the Add button.

Now that you have added a domain, the next step is to add a Domain Name System (DNS) record.

Adding DNS records
To add DNS records, place your mouse over the DNS Records below the alert notification. You will observe a clipboard icon enabling you to copy the values for each listed item. You can then click on the DNS Provider on your dashboard.
💡 The DNS provider can be Namecheap, GoDaddy, Hostinger, etc.

You will be redirected to the DNS provider page where you’ll add DNS records. Add all DNS records you copied from your Resend dashboard. Then click on the Add button.

Next, navigate back to your Resend dashboard and click the Verify DNS Records button.

After that, your dashboard status will change from “Not Started” to “Pending”. This indicates the DNS records verification is in progress. You will get an email notification once the verification is completed.

Upon successful verification, your dashboard status will change to “Verified”. Now you can send emails from your verified domain.

Setting up Resend in a Next.js project

To set up Resend in a Next.js project, click here to generate the starter files based on an existing template repo. Run the command below to clone this project:

git clone <repo-git-url-provided-above>

Navigate into the project directory by running:

cd react-email-demo

Next, install dependencies by running the following command in your project’s terminal:

yarn install

On completion, run yarn run dev in your terminal and navigate to localhost:3000 in your web browser. You should see the starter UI:

Now that you have a Next.js project running successfully, create the .env.local file in the root of your project. Add the Resend API key that was generated for you into this file.

RESEND_API_KEY=YOUR_RESEND_API_KEY

Form component
In the components directory, update the ContactUsForm.tsx file by adding the following code:

// components/ContactUsForm.tsx

'use client';

import { useForm } from 'react-hook-form';
import { toast } from 'react-hot-toast'; // updated code

type FormInput = {
  name: string;
  email: string;
  message: string;
};

export default function ContactUsForm() {
  const {
    register,
    handleSubmit,
    formState: { isSubmitting },
    reset,
  } = useForm<FormInput>();

   /**
   * The function sends a POST request to a server with form data and displays a success notification.
   * @param {FormInput} formData - The formData parameter is an object that contains the input values
   * from the form.
   */
  async function onSubmit(formData: FormInput) { 
    await fetch('/api/send', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },

      body: JSON.stringify({
        name: formData.name,
        email: formData.email,
        message: formData.message,
      }),
    }).then(() => {
      // Toast notification
      toast.success('Your email message has been sent successfully');
    });

    reset();
  }

  return (
    <div className='w-10/12 md:w-6/12'>
      <form
        onSubmit={handleSubmit(onSubmit)} // updated code
        className='mb-10 mt-5 flex w-full flex-col rounded-md bg-white p-5 py-14 shadow-lg md:max-w-3xl md:px-10 mx-auto'
      >
        <input
          className='mt-4 mb-3 h-14 block w-full rounded-md border px-3 text-gray-600 outline-none focus:border-stone-500 focus:outline-none md:mb-0'
          type='text'
          placeholder='Name'
          required
          {...register('name')}
        />
        <input
          className='mt-4 mb-3 h-14 block w-full rounded-md border px-3 text-gray-600 outline-none focus:border-stone-500 focus:outline-none md:mb-0'
          type='email'
          placeholder='Email'
          required
          {...register('email')}
        />
        <textarea
          className='mt-4 mb-5 block w-full rounded-md border px-3 text-gray-600 outline-none focus:border-stone-500 focus:outline-none md:mb-0'
          placeholder='Message Us'
          rows={6}
          required
          {...register('message')}
        />

        <button
          disabled={isSubmitting}
          type='submit'
          className='bg-blue-700 px-6 py-3 disabled:bg-gray-500 block-primary rounded-md cursor-pointer text-white mt-4 font-bold'
        >
          Book Appointment
        </button>
      </form>
    </div>
  );
}

Here, you did the following:

Imported useForm hook from the react-hook-form library to handle form state and submission.
Imported toast from the react-hot-toast library that displays a notification after an email message has been sent successfully.
An async function named onSubmit is defined to handle form submission when the user submits the form. Inside this function, an API request is made using the fetch method that sends a POST request to the /api/send endpoint with the form data as JSON in the request body.
The reset function provided by useForm is used to reset the form fields after submission.

Implementing a dynamic email template

With React Email, creating a modern email template becomes very easy. According to the React Email website, there is a set of standard components to help you build amazing emails without having to deal with the mess of creating table-based layouts and maintaining archaic markup.

To use this set of standard components for building an email template, navigate to the components directory and create the EmailMessage.tsx file. Add the following code to this file:


// components/EmailMessage.tsx

import {
  Body,
  Container,
  Head,
  Heading,
  Hr,
  Html,
  Preview,
  Tailwind,
  Text,
} from '@react-email/components';
import * as React from 'react';

type MessageUsEmailProps = {
  name: string;
  email: string;
  message: string;
};

const MessageUsEmail = ({ name, email, message }: MessageUsEmailProps) => {
  const previewText = `Weekly Updates 🚀${name} sent you a message.`;

  return (
    <Html>
      <Head />
      <Preview>{previewText}</Preview>
      <Tailwind>
        <Body className='bg-white my-auto mx-auto font-sans'>
          <Container className='my-[20px] mx-auto p-[20px] max-w-4xl'>
            <Heading className='text-black text-[20px] font-normal text-left'>
              <strong>Hello {name},</strong>
            </Heading>
            <Text className='text-black text-[14px] leading-[24px]'>
              {message}
            </Text>

            <Hr className='my-[16px] mx-0 w-full' />
            <Text className='text-[#666666] text-[12px]'>
             In a world where every email matters, Resend empowers you to send emails that captivate, engage, and convert. It's more than just an email platform; it's a catalyst for modernizing your email communication.
Don't settle for outdated email practices. Embrace the future of email communication with Resend and watch your messages soar to new heights.
            </Text>
            <Text className='text-[#666666] text-[12px]'>
              This email is delivered to you through the Resend SDK
              integrations.✨
            </Text>
          </Container>
        </Body>
      </Tailwind>
    </Html>
  );
};

export default MessageUsEmail;

Here, you did the following:

Imported from @react-email/components to structure the email template with specific elements for email rendering.
The component receives name, email, and message as props of type MessageUsEmailProps.
The Head component is used for including meta information within the email's <head> section.
The Preview component is used to define the text that appears in the email client's preview pane.
The Tailwind component is used to apply Tailwind CSS classes to style the email template.

Sending emails using the Resend SDK

So far, you have verified a domain, set up Resend in a Next.js project, and implemented a dynamic email template. It’s time to send emails using Resend.

In the app directory, create the api/send/route.ts file and add the following code snippet to this file:

// app/api/send/route.ts

import { Resend } from 'resend';
import { NextRequest, NextResponse } from 'next/server';
import MessageUsEmail from '@/components/EmailMessage';

const resend = new Resend(process.env.RESEND_API_KEY);

export async function POST(req: NextRequest) {
  const { name, email, message } = await req.json();

  try {
    const data = await resend.emails.send({
      from: 'Hello <rayden@sonya.dev>', // your verified domain
        to: `${email}`, // the email address you want to send a message
      subject: `${name} has a message!`,
      react: MessageUsEmail({ name, email, message }),
    });

    return NextResponse.json(data);
  } catch (error) {
    return NextResponse.json({ error });
  }
}

From the code snippet above, you did the following:

Imported Resend from 'resend'.
Imported NextRequest and NextResponse from 'next/server' which are Next.js server-side functions.
Imported the MessageUsEmail component that is used for generating the content of the email you intend to send.
The RESEND_API_KEY is used to create an instance of Resend.
The POST function is an asynchronous function that handles incoming POST requests.
The name, email, and message variables are extracted from the parsed request body.

Now, navigate to the homepage of your project and input some data into the form fields. Click the “Book Appointment” button. Messages sent to your email should appear in your inbox.

Conclusion

This tutorial showed how to send emails from a verified domain using React-Email, Next.js, and Resend.

Resources

Official Resend Documentation
Official React Email Documentation

Build a documentation site with Next.js using Nextra

Mayowa Adeniyi — Fri, 16 Jun 2023 22:41:23 +0000

A documentation website contains information, guides, and instructions about a particular topic. Information on a documentation website should be easy to find, well-organized, and straightforward.

When creating a documentation website, you should closely examine its navigation, design, content organization, and search functionality. This will enable your users to find their desired information quickly and easily.

Do you know there is a framework on top of Next.js that does all this for you out of the box? It’s Nextra!

What is Nextra?

According to Nextra.site, Nextra is a framework on top of Next.js that lets you build content-focused websites. It has all the great features from Next.js, plus extra power to create Markdown-based content with ease.
You can read about Nextra here: More about Nextra.

With Nextra, you can create a full-blown documentation site with search functionality, syntax highlighting, embedding React components into MDX files, and more.

Some companies that use Nextra for their documentation sites include Next.js, React, Tailwind, Node.js, CodeSandbox and more.

Features of Nextra

Light and dark mode theme.
Advanced syntax highlighting for code snippets.
Ability to use React components in markdown files.
Full-text search functionality.

💡 This article assumes you have a basic knowledge of Git.

Getting Started With Nextra

A ready-made template for a documentation site is available on Nextra’s git repository. So you have to clone the repository on your machine.

Now, in your terminal, run:

git clone https://github.com/shuding/nextra-docs-template

Once you've cloned the git repository on your machine, you should have a folder structure like this:

Now that you've cloned the repository navigate into the project directory and install the dependencies:

cd nextra-docs-template
pnpm i

When the installation is complete, start the local development server by running the following:

pnpm dev

Next, visit localhost:3000 in the web browser to check if the documentation template is installed correctly. Your page should look this:

The Nextra documentation template is installed successfully.🎉
Now you can customize any page to your liking.

If you do want to create a new .mdx file in the pages folder, always ensure to use the name of the .mdx file as a key in your _meta.json file:

Conclusion

That's how you create a documentation site with Next.js using Nextra. I hope you find this helpful.

Deploying Next.js 13 apps to Netlify: replace an existing React app

Mayowa Adeniyi — Tue, 13 Jun 2023 16:11:51 +0000

Deploying a Next.js 13 application to Netlify is easy. Moreover, it is possible to easily replace an existing React app or website on Netlify (provided it's on a custom domain) with a Next.js 13 application.

In this article, you will learn how to:

Deploy a Next.js 13 project to Netlify.
Change or replace a React application or website hosted on Netlify with a custom domain.

Prerequisites

The following is necessary to understand this article:

You have an existing React app or website deployed to Netlify and running on a custom domain.
You have Node.js installed on your machine.
You must have an account on Netlify.
You have a Git provider account, E.g., Github, Gitlab, Bitbucket.
Yarn package manager to install and run the scripts.

Getting started with Next.js

To get started with Next.js, run the following command in your terminal:

npx create-next-app@latest

The command above will create a Next.js project. Next, follow the series of prompts that are displayed.

In your terminal, run the following:

yarn dev

The command above will start the local development server for your project. Now open your browser and visit http://localhost:3000. Your Next.js project should be running on port 3000.

Now that you have a Next.js project installed successfully on your machine create a file called netlify.toml in the root of your project. Copy and paste the code snippet below into the netlify.toml file.

[build]
  command = "npm run build"
  publish = ".next"

[[plugins]]
  package = "@netlify/plugin-nextjs"

Here is a breakdown of the code above:

[build]

This specifies the build settings.

command
This specifies the command to run during the build process. In
other words,
this command is set to npm run build.

publish
Specifies the directory that contains the static files to be published and served by Netlify. In this case, it is set to .next, indicating that the .next directory will be published.

[[plugins]]
This specifies the plugins used during the build process.

package
Specifies the package name of the plugin. In this case, it is set to @netlify/plugin-nextjs, indicating that the Netlify plugin for Next.js will be used during the build process.

Now that you have some code snippets inside the netlify.toml file, install the Netlify plugin by running the following command:

yarn add @netlify/plugin-nextjs

Commit and push your code to a Git provider of your choice. In the next section, you'll see how to deploy a Next.js project to Netlify.

Deploying Next.js project to Netlify

Before deploying your Next.js project to Netlify, you must log in to your Netlify account. If you don’t have an account, sign up here: Register for free.

Once you have selected a Git provider, you will be redirected to the Netlify dashboard. Click on Add new site.
Select Import an existing project from the drop-down.

Import your existing Next.js project using a Git provider of your choice.

You can now search and select the repository name of your Next.js project.

It's now time to deploy your Next.js project to Netlify. On Netlify's platform, Next.js apps or websites are automatically detected. Once you have selected the repository, click the Deploy Site button.

When the deployment process is complete, Netlify gives you a link (always ends with .netlify.app) to check your deployed project on your dashboard.

Your Next.js project has been successfully deployed to Netlify.🎉

Now that you have a Next.js project deployed to Netlify, you should replace the existing React app or website.

Replace the existing React app

It’s time to replace the old React app or website on Netlify with the Next.js project (deployed in the previous step).

You can find the old React app or website on your Netlify dashboard.
Select Deploys on the left-hand side of your Netlify dashboard.
Click on Deploy Settings.

Click on Manage Repository. A drop-down option is displayed.
Select Link to a different repository.

Import the deployed Next.js project using a Git provider of your choice.
You can find and select the repository name of the deployed Next.js project.
Click on the Deploy Site button.

From your Netlify dashboard, click on the old React app or website URL when the deployment is complete. In the next few seconds, you will notice that the old React app or website has been replaced with the Next.js version, and you have a Next.js project running on that same custom domain.

Conclusion

This article showed how to deploy a Next.js 13 project to Netlify and replace an existing React app or website on a custom domain.

Resources

Next.js on Netlify
Official Next.js Documentation

Setup Sanity CMS Within A Next.js 13 Project

Mayowa Adeniyi — Sun, 14 May 2023 21:14:18 +0000

Introduction

According to Sanity.io website, Sanity is a headless content management system (CMS) that gives you total composability. A fully decoupled, real-time content back end.

Why use Sanity?

Real-time collaboration: Multiple team members can collaborate on content in real-time.
Rich content editing experience: Sanity offers an intuitive and visually appealing content editing interface to simplify content creation and editing for you.
Content customization: You can design your content schemas and structures to meet your needs.
Extensive integrations: Sanity integrates with various tools and services, e-commerce platforms, analytics solutions, and marketing automation.

Next.js (a React framework for building web applications) will be used as the front-end framework with Sanity Studio. More about Sanity Studio in the later part of this article.

This article will show how to embed a new Sanity project within a Next.js 13 application.

Prerequisites

Before you get started with this article, you will need the following:

Node.js installed on your machine.
Yarn package manager to run the script.

Next.js project setup and installation

To create a new Next.js project in your terminal, run the following command to scaffold a new project.

npx create-next-app@latest

The command above will create a new Next.js project. A series of prompts are displayed. Select No to the src/ directory prompt and choose Yes to all other displayed prompts.

This will set up a new Next.js project. Navigate into the project directory and start the local development server.

cd <project name> 
yarn run dev

Next, open the web browser and visit localhost:3000. The default Next.js project will be running on port 3000.

This shows that Next.js has been installed successfully. Now that you have a Next.js project up and running, it's time to set up a Sanity project.

Sanity project setup and installation

Before creating a new Sanity project, you must create an account with Sanity. If you don't have an account, you can sign up here.

Once you have created an account, run the following command in your terminal to create a new Sanity project.

npm create sanity@latest

Use the arrow keys and select Create new project:

A new prompt is displayed. Give your Sanity project a desired name of your choice:

A series of prompts are displayed. Select Yes to all the prompts and choose the blog schema as a project template.

The blog schema is a predefined editor template. In other words, some schemas were already generated for you automatically, and this blog schema can be edited within the Sanity Studio. There is also an option to select a clean template, but we will use the blog schema template.

This creates a new Sanity project. You will see some configuration files at the root of the project. Notice there is a new folder called sanity. The schemas and some other utility files are kept there.

Sanity Studio is an application user interface that manages all your content. This is where you add, edit, and publish content. In this article, Sanity Studio is embedded within the Next.js 13 application, and you can access your content from there.

Next, open the web browser and visit localhost:3000/studio. This is the base path where Sanity Studio can be found.
With Sanity Studio, you can access all your content locally at localhost:3000/studio.

But before you can access your content from Sanity Studio, you must add localhost:3000 as CORS (Cross-Origin Resource Sharing) to your Sanity project. To add CORS Origin, click the Continue button.

A new screen will be displayed once you have clicked the Continue button. Then click on the Add CORS Origin button.

You can select the provider you signed up with previously to access your Sanity account.

You will be automatically redirected to localhost:3000/studio/desk.

This page shows the blog schema, which means that Sanity Studio is embedded and running successfully within your Next.js 13 application.

By embedding Sanity Studio into a Next.js project, this is how to set up a Sanity project within a Next.js 13 application.

Conclusion

This article shows how to embed a new Sanity project within a Next.js 13 application.