Skip to main content

Create an EKS cluster and deploy a Node.js app

In this guide, we are going to use self-service actions to demonstrate a workflow that does the following:

  • Creates an EKS Cluster.
  • Scaffolds a Node.js app that's automatically ingested as an entity by Port.
  • Deploys the app to the cluster.

🎬 If you would like to follow along to a video that implements this guide, check out this one by @TeKanAid 🎬



Prerequisites

  1. Install Port's GitHub app by clicking here.
  2. This guide assumes the presence of a blueprint representing your repositories. If you haven't done so yet, initiate the setup of your GitHub data model by referring to this guide first.
  3. A repository to contain your action resources i.e. the github workflow file.
  4. In your GitHub repository, go to Settings > Secrets and add the following secrets:
    • AWS Credentials. Follow this guide to create them.
      • AWS_ACCESS_KEY_ID: Your AWS access key.
      • AWS_SECRET_ACCESS_KEY: Your AWS secret access key.
    • CREATOR_TOKEN: A GitHub personal access token (fine-grained) that has Read and Write permissions on the following scopes: Administration, Contents.
  5. Your AWS account has access to an Elastic Container Registry.
Starter Repository

Clone the repository here to follow along with the guide. The repository contains the following folders:

  • app-templates: contains the cookiecutter templates for scaffolding apps.
  • terraform: contains the terraform configuration for creating an EKS cluster.

Creating the EKS Cluster

  1. Create the following blueprints:
Region blueprint
{
"identifier": "region",
"description": "",
"title": "Region",
"icon": "AWS",
"schema": {
"properties": {
"link": {
"type": "string",
"title": "Link",
"format": "url"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {}
}
EKS Cluster blueprint
{
"identifier": "eks",
"description": "",
"title": "EKS Cluster",
"icon": "Service",
"schema": {
"properties": {
"name": {
"type": "string",
"title": "Name"
},
"roleArn": {
"type": "string",
"title": "Role ARN"
},
"tags": {
"type": "array",
"title": "Tags"
},
"version": {
"type": "string",
"title": "Version"
},
"endpoint": {
"title": "Endpoint",
"description": "The cluster endpoint",
"type": "string",
"format": "url"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"region": {
"title": "Region",
"target": "region",
"required": false,
"many": false
}
}
}

  1. Create the file manage-eks-cluster.yml in the .github/workflows folder of your repository.
GitHub Workflow
manage-eks-cluster.yml
name: Manage EKS Cluster

on:
workflow_dispatch:
inputs:
cluster_name:
description: "Name of the EKS cluster"
required: true
region:
description: "AWS Region for the cluster"
required: true
action:
description: "Action to perform (apply/destroy)"
required: true
default: "apply"
port_context:
required: true
description: "Port's payload (who triggered, port_context, etc...)"
type: string

jobs:
manage_cluster: # Combine into a single job
runs-on: ubuntu-latest
defaults:
run:
shell: bash
working-directory: ./terraform

if: ${{ github.event.inputs.action == 'apply' || github.event.inputs.action == 'destroy' }}

env:
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
PORT_CLIENT_ID: ${{ secrets.PORT_CLIENT_ID }}
PORT_CLIENT_SECRET: ${{ secrets.PORT_CLIENT_SECRET }}
CLUSTER_NAME: ${{ github.event.inputs.cluster_name }}
REGION: ${{ github.event.inputs.region }}
ACTION: ${{ github.event.inputs.action }}
PORT_RUN_ID: ${{ fromJson(inputs.port_context).runId }}

steps:
- name: Checkout code
uses: actions/checkout@v4

- name: Create a log message (apply)
if: ${{ github.event.inputs.action == 'apply' }}
uses: port-labs/port-github-action@v1
with:
clientId: ${{ secrets.PORT_CLIENT_ID }}
clientSecret: ${{ secrets.PORT_CLIENT_SECRET }}
baseUrl: https://api.getport.io
operation: PATCH_RUN
runId: ${{ env.PORT_RUN_ID }}
logMessage: "Initiating creation of EKS cluster: ${{ env.CLUSTER_NAME }}."

- name: Setup Terraform
uses: hashicorp/setup-terraform@v1

- name: Terraform Init
run: terraform init

- name: Terraform Format
run: terraform fmt

- name: Terraform Validate
run: terraform validate

- name: Terraform Apply
id: terraform_apply
if: ${{ github.event.inputs.action == 'apply' }}
run: terraform apply -auto-approve
env:
TF_VAR_cluster_name: ${{ env.CLUSTER_NAME }}
TF_VAR_region: ${{ env.REGION }}
TF_VAR_port_run_id: ${{ env.PORT_RUN_ID }}

- name: Terraform Destroy
if: ${{ github.event.inputs.action == 'destroy' }}
run: terraform destroy -auto-approve
env:
TF_VAR_cluster_name: ${{ env.CLUSTER_NAME }}
TF_VAR_region: ${{ env.REGION }}
TF_VAR_port_run_id: ${{ env.PORT_RUN_ID }}

- name: Inform Port about the status of the EKS cluster creation
if: ${{ github.event.inputs.action == 'apply' }}
uses: port-labs/port-github-action@v1
with:
clientId: ${{ secrets.PORT_CLIENT_ID }}
clientSecret: ${{ secrets.PORT_CLIENT_SECRET }}
baseUrl: https://api.getport.io
operation: PATCH_RUN
status: "SUCCESS"
runId: ${{ env.PORT_RUN_ID }}
logMessage: "EKS cluster creation has been completed: ${{ env.CLUSTER_NAME }}"

- name: Inform Port about the status of the EKS cluster destruction
if: ${{ github.event.inputs.action == 'destroy' }}
uses: port-labs/port-github-action@v1
with:
clientId: ${{ secrets.PORT_CLIENT_ID }}
clientSecret: ${{ secrets.PORT_CLIENT_SECRET }}
baseUrl: https://api.getport.io
operation: PATCH_RUN
status: "SUCCESS"
runId: ${{ env.PORT_RUN_ID }}
logMessage: "EKS cluster destruction has been completed: ${{ env.CLUSTER_NAME }}"

  1. Create a Port action against the EKS Cluster blueprint:
    • Go to the self-service page.
    • Click on the + New Action button.
    • Click on the {...} Edit JSON button in the top right corner.
    • Copy and paste the following JSON configuration into the editor.
    • Click Save
Port Action: Create EKS Cluster
Replace the placeholders
  • <GITHUB-ORG> - your GitHub organization or user name.
  • <GITHUB-REPO-NAME> - your GitHub repository name.
{
"identifier": "eks_create_eks_cluster",
"title": "Create an EKS cluster",
"icon": "AmazonEKS",
"description": "An action that creates an eks cluster",
"trigger": {
"type": "self-service",
"operation": "CREATE",
"userInputs": {
"properties": {
"cluster_name": {
"title": "Cluster Name",
"description": "The name of the EKS Cluster",
"icon": "AmazonEKS",
"type": "string"
},
"region": {
"type": "string",
"blueprint": "region",
"title": "Region",
"format": "entity"
}
},
"required": [
"cluster_name"
],
"order": [
"cluster_name"
]
},
"blueprintIdentifier": "eks"
},
"invocationMethod": {
"type": "GITHUB",
"org": "<GITHUB_ORG>",
"repo": "<GITHUB_REPO>",
"workflow": "manage-eks-cluster.yml",
"workflowInputs": {
"cluster_name": "{{ .inputs.\"cluster_name\" }}",
"region": "{{ .inputs.\"region\" }}",
"port_context": {
"entity": "{{ .entity }}",
"blueprint": "{{ .action.blueprint }}",
"runId": "{{ .run.id }}",
"trigger": "{{ .trigger }}"
}
},
"reportWorkflowStatus": true
},
"requiredApproval": false,
"publish": true
}

  1. Create the following Terraform configuration in a terraform folder at the root of your GitHub repository:

    1. main.tf - This file will contain the resource blocks which define the EKS Cluster to be created in AWS and the entity to be created in Port.
    2. variables.tf – This file will contain the variable declarations that will be used in the resource blocks e.g. the Port credentials and Port run id.
    3. output.tf – This file will contain outputs from the cluster creation like the endpoint.
    4. terraform.tf - This file contains the definitions of all the providers we will use.
main.tf
main.tf
provider "aws" {
region = var.region
}

# Filter out local zones, which are not currently supported
# with managed node groups
data "aws_availability_zones" "available" {
filter {
name = "opt-in-status"
values = ["opt-in-not-required"]
}
}

locals {
cluster_name = var.cluster_name == "" ? "education-eks-${random_string.suffix.result}" : var.cluster_name
}

resource "random_string" "suffix" {
length = 8
special = false
}

module "vpc" {
source = "terraform-aws-modules/vpc/aws"
version = "5.0.0"

name = "education-vpc"

cidr = "10.0.0.0/16"
azs = slice(data.aws_availability_zones.available.names, 0, 3)

private_subnets = ["10.0.1.0/24", "10.0.2.0/24", "10.0.3.0/24"]
public_subnets = ["10.0.4.0/24", "10.0.5.0/24", "10.0.6.0/24"]

enable_nat_gateway = true
single_nat_gateway = true
enable_dns_hostnames = true

public_subnet_tags = {
"kubernetes.io/cluster/${local.cluster_name}" = "shared"
"kubernetes.io/role/elb" = 1
}

private_subnet_tags = {
"kubernetes.io/cluster/${local.cluster_name}" = "shared"
"kubernetes.io/role/internal-elb" = 1
}
}

module "eks" {
source = "terraform-aws-modules/eks/aws"
version = "19.15.3"

cluster_name = local.cluster_name
cluster_version = var.cluster_version

vpc_id = module.vpc.vpc_id
subnet_ids = module.vpc.private_subnets
cluster_endpoint_public_access = true

eks_managed_node_group_defaults = {
ami_type = "AL2_x86_64"

}

eks_managed_node_groups = {
one = {
name = "node-group-1"

instance_types = ["t3.small"]

min_size = 1
max_size = 3
desired_size = 2
}

two = {
name = "node-group-2"

instance_types = ["t3.small"]

min_size = 1
max_size = 2
desired_size = 1
}
}
}


# https://aws.amazon.com/blogs/containers/amazon-ebs-csi-driver-is-now-generally-available-in-amazon-eks-add-ons/
data "aws_iam_policy" "ebs_csi_policy" {
arn = "arn:aws:iam::aws:policy/service-role/AmazonEBSCSIDriverPolicy"
}

module "irsa-ebs-csi" {
source = "terraform-aws-modules/iam/aws//modules/iam-assumable-role-with-oidc"
version = "4.7.0"

create_role = true
role_name = "AmazonEKSTFEBSCSIRole-${module.eks.cluster_name}"
provider_url = module.eks.oidc_provider
role_policy_arns = [data.aws_iam_policy.ebs_csi_policy.arn]
oidc_fully_qualified_subjects = ["system:serviceaccount:kube-system:ebs-csi-controller-sa"]
}

resource "aws_eks_addon" "ebs-csi" {
cluster_name = module.eks.cluster_name
addon_name = "aws-ebs-csi-driver"
addon_version = "v1.20.0-eksbuild.1"
service_account_role_arn = module.irsa-ebs-csi.iam_role_arn
tags = {
"eks_addon" = "ebs-csi"
"terraform" = "true"
}
}


# Port resources
resource "port_entity" "eks_cluster" {
identifier = module.eks.cluster_arn
title = module.eks.cluster_name
blueprint = "eks"
run_id = var.port_run_id
properties = {
string_props = {
"version" = module.eks.cluster_version,
"name" = module.eks.cluster_name,
"endpoint" = module.eks.cluster_endpoint,
"roleArn" = module.eks.cluster_iam_role_arn
}
}
relations = {
single_relations = {
"region" = var.region
}
}

depends_on = [module.eks.cluster_name]
}
variables.tf
note

Replace the default region with your own preferred region.

variables.tf
variable "region" {
description = "AWS region"
type = string
default = "eu-west-1"
}

variable "cluster_name" {
description = "Name of the EKS cluster"
type = string
}

variable "cluster_version" {
description = "Version of the EKS cluster"
type = string
default = "1.29"

}

variable "port_run_id" {
type = string
description = "The runID of the action run that created the entity"
default = ""
}
output.tf
output.tf
output "cluster_endpoint" {
description = "Endpoint for EKS control plane"
value = module.eks.cluster_endpoint
}

output "cluster_security_group_id" {
description = "Security group ids attached to the cluster control plane"
value = module.eks.cluster_security_group_id
}

output "region" {
description = "AWS region"
value = var.region
}

output "cluster_name" {
description = "Kubernetes Cluster Name"
value = module.eks.cluster_name
}
terraform.tf
terraform.tf
terraform {

# uncomment for terraform cloud
# cloud {
# workspaces {
# name = "test"
# }
# }

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

random = {
source = "hashicorp/random"
version = "~> 3.5.1"
}

tls = {
source = "hashicorp/tls"
version = "~> 4.0.4"
}

cloudinit = {
source = "hashicorp/cloudinit"
version = "~> 2.3.2"
}

port = {
source = "port-labs/port-labs"
version = "2.0.3"
}
}

required_version = "~> 1.3"
}

  1. Now, create a cluster using the action.

Scaffolding a Node.js app

  1. On the self-service page, create the Port action against the Repository blueprint. This will trigger the GitHub workflow.
    • Click on the + New Action button.
    • Click on the {...} Edit JSON button in the top right corner.
    • Copy and paste the following JSON configuration into the editor.
    • Click Save
Port Action: Scaffold Node App
Replace the placeholders
  • <GITHUB-ORG> - your GitHub organization or user name.
  • <GITHUB-REPO-NAME> - your GitHub repository name.
{
"identifier": "repository_scaffold_node_app",
"title": "Scaffold Node App",
"description": "Scaffold a node.js app",
"trigger": {
"type": "self-service",
"operation": "CREATE",
"userInputs": {
"properties": {
"project_name": {
"title": "Project Name",
"description": "The name of the project",
"type": "string"
},
"description": {
"title": "Description",
"type": "string"
},
"repo_name": {
"icon": "DefaultProperty",
"title": "Repository Name",
"type": "string"
}
},
"required": [
"project_name",
"repo_name"
],
"order": [
"project_name",
"repo_name",
"description"
]
},
"blueprintIdentifier": "repository"
},
"invocationMethod": {
"type": "GITHUB",
"org": "phalbert",
"repo": "azure-resources-terraform",
"workflow": "scaffold-app.yml",
"workflowInputs": {
"project_name": "{{.inputs.\"project_name\"}}",
"repo_name": "{{.inputs.\"repo_name\"}}",
"template": "{{.inputs.\"template\"}}",
"description": "{{.inputs.\"description\"}}",
"port_context": {
"entity": "{{ .entity }}",
"blueprint": "{{ .action.blueprint }}",
"runId": "{{ .run.id }}",
"trigger": "{{ .trigger }}"
}
},
"reportWorkflowStatus": true
},
"requiredApproval": false,
"publish": true
}

  1. Create the file scaffold-app.yml in the .github/workflows folder of your repository.
GitHub workflow to scaffold a Node.js app
Cookiecutter Template

To implement this workflow, you'll need a cookiecutter template for scaffolding the application. You can either create one or utilize our starter repository.

name: Scaffold Node.js App

on:
workflow_dispatch:
inputs:
project_name:
description: "Name of the app"
required: true
repo_name:
description: "Slug of the app"
required: true
template:
description: "Template to use for the app"
required: false
default: "nodejs"
description:
description: "Description of the app"
required: true
default: "A simple app"
port_context:
required: true
description: "Port's payload (who triggered, port_context, etc...)"
type: string

jobs:
scaffold_app:
runs-on: ubuntu-latest

env:
PORT_RUN_ID: ${{ fromJson(github.event.inputs.port_context).runId }}


steps:
- name: Create a log message (post-action)
uses: port-labs/port-github-action@v1
with:
clientId: ${{ secrets.PORT_CLIENT_ID }}
clientSecret: ${{ secrets.PORT_CLIENT_SECRET }}
baseUrl: https://api.getport.io
operation: PATCH_RUN
runId: ${{ env.PORT_RUN_ID }}
logMessage: "Starting scaffolding of app: ${{ github.event.inputs.project_name }}"

- name: Checkout code
uses: actions/checkout@v4

- name: Check if Repository Exists
id: check_repo
run: |
REPO_EXISTS=$(curl -s -o /dev/null -w "%{http_code}" \
-X GET \
-H "Authorization: Bearer ${{ secrets.GH_TOKEN }}" \
"https://api.github.com/repos/${{ github.repository_owner }}/${{ github.event.inputs.repo_name }}")

echo "HTTP Status: $REPO_EXISTS"

if [ $REPO_EXISTS -eq 200 ]; then
echo "Repository already exists."
echo "repo_exists=true" >> $GITHUB_ENV
else
echo "Repository does not exist."
echo "repo_exists=false" >> $GITHUB_ENV
fi

- name: Create a log message (post-action)
uses: port-labs/port-github-action@v1
with:
clientId: ${{ secrets.PORT_CLIENT_ID }}
clientSecret: ${{ secrets.PORT_CLIENT_SECRET }}
baseUrl: https://api.getport.io
operation: PATCH_RUN
runId: ${{ env.PORT_RUN_ID }}
logMessage: "Creating ECR repository: ${{ github.event.inputs.repo_name }}"

- name: Configure AWS credentials
uses: aws-actions/configure-aws-credentials@v4
with:
aws-region: ${{ secrets.AWS_REGION }}
aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}

- name: Login to AWS ECR
id: login-ecr
uses: aws-actions/amazon-ecr-login@v1

- name: Create ECR Repository
id: create-ecr-repo
run: |
repositoryUri=$(aws ecr create-repository --repository-name "${{ github.event.inputs.repo_name }}" --output json | jq -r '.repository.repositoryUri')
echo "ECR_REPOSITORY_URI=$repositoryUri" >> $GITHUB_ENV

- name: Run Cookiecutter
id: cookiecutter
uses: andrewthetechie/gha-cookiecutter@main
with:
# path to what you checked out
template: ./app-templates/${{ github.event.inputs.template }}
outputDir: ./tmp
cookiecutterValues: '{
"project_name": "${{ github.event.inputs.project_name }}",
"directory_name": "${{ github.event.inputs.repo_name }}",
"description": "${{ github.event.inputs.description }}",
"author_name": "Port",
"github_username": "${{ github.repository_owner }}",
"image_repository": "${{ env.ECR_REPOSITORY_URI }}"
}'

- name: Create a log message (post-action)
uses: port-labs/port-github-action@v1
with:
clientId: ${{ secrets.PORT_CLIENT_ID }}
clientSecret: ${{ secrets.PORT_CLIENT_SECRET }}
baseUrl: https://api.getport.io
operation: PATCH_RUN
runId: ${{ env.PORT_RUN_ID }}
logMessage: "Creating repository for app: ${{ github.event.inputs.project_name }}"

- name: Create GitHub Repository
id: create-repo
if: ${{ env.repo_exists == 'false' }}
run: |
HTTP_STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
-X POST \
-H "Accept: application/vnd.github+json" \
-H "Authorization: Bearer ${{ secrets.GH_TOKEN }}" \
-d '{"name": "${{ github.event.inputs.repo_name }}", "private": true, "description": "${{ github.event.inputs.description }}"}' \
"https://api.github.com/user/repos")

echo "HTTP Status: $HTTP_STATUS"

if [ $HTTP_STATUS -eq 201 ]; then
echo "Repository created successfully."
else
echo "Failed to create repository. HTTP Status: $HTTP_STATUS"
exit 1
fi

- name: Create a log message (post-action)
uses: port-labs/port-github-action@v1
with:
clientId: ${{ secrets.PORT_CLIENT_ID }}
clientSecret: ${{ secrets.PORT_CLIENT_SECRET }}
baseUrl: https://api.getport.io
operation: PATCH_RUN
runId: ${{ env.PORT_RUN_ID }}
logMessage: "Commiting new app files: ${{ github.event.inputs.project_name }}"

- name: Commit files
working-directory: ./tmp/${{ github.event.inputs.repo_name }}
run: |
sudo chmod -R 777 .
git init
git config user.name "GitHub Actions Bot"
git config user.email "<>"
git add .
git commit -m "Initial commit"
git branch -M main
git remote add origin https://${{ github.repository_owner }}:${{ secrets.GH_TOKEN }}@github.com/${{ github.repository_owner }}/${{ github.event.inputs.repo_name }}.git
git push -u origin main

- name: Create a log message (post-action)
uses: port-labs/port-github-action@v1
with:
clientId: ${{ secrets.PORT_CLIENT_ID }}
clientSecret: ${{ secrets.PORT_CLIENT_SECRET }}
baseUrl: https://api.getport.io
operation: PATCH_RUN
status: "SUCCESS"
runId: ${{ env.PORT_RUN_ID }}
logMessage: "Finished scaffolding of app: ${{ github.event.inputs.project_name }}"

  1. Scaffold an application using the nodejs template.


This action will create the following:

  • A GitHub repository containing a starter Node.js app.
  • Since the repository is created with a port.yml file, the Port GitHub app will create the repository entity automatically.
  • An ECR repository for the app.

Deploy the app

  1. On the self-service page, create a Port action against the Repository blueprint called Deploy to EKS.
Port Action: Deploy to EKS
Replace the placeholders
  • <GITHUB-ORG> - your GitHub organization or user name.
  • <GITHUB-REPO-NAME> - your GitHub repository name.
{
"identifier": "deploy_to_eks",
"title": "Deploy to EKS",
"description": "Build and deploy an image to EKS",
"trigger": {
"type": "self-service",
"operation": "DAY-2",
"userInputs": {
"properties": {
"cluster": {
"type": "string",
"blueprint": "eks",
"title": "Cluster",
"format": "entity"
}
},
"required": [],
"order": []
},
"blueprintIdentifier": "eks"
},
"invocationMethod": {
"type": "GITHUB",
"org": "<GITHUB_ORG>",
"repo": "<GITHUB_REPO>",
"workflow": "build-and-deploy.yml",
"workflowInputs": {
"cluster": "{{.inputs.\"cluster\"}}",
"port_context": {
"entity": "{{ .entity }}",
"blueprint": "{{ .action.blueprint }}",
"runId": "{{ .run.id }}",
"trigger": "{{ .trigger }}"
}
},
"reportWorkflowStatus": true
},
"requiredApproval": false,
"publish": true
}

  1. Create the file build-and-deploy.yml in the .github/workflows folder of your repository. (This is the same repository you've been using for the other workflows.)
GitHub workflow to deploy a Node.js app
name: Build and Deploy Image to EKS

on:
workflow_dispatch:
inputs:
cluster:
description: 'Deployment cluster'
required: true
port_context:
required: true
description: "Action and general port_context (blueprint, run id, etc...)"
type: string

jobs:
build:
runs-on: ubuntu-latest

env:
REPO_URL: ${{ fromJson(inputs.port_context).entity.properties.url }}
TRIGGERED_BY: ${{ fromJson(inputs.port_context).trigger.by.user.email || github.actor }}

steps:
- name: Extract repository owner and name
run: |
repo_owner=$(echo "${REPO_URL}" | awk -F/ '{print $4}')
repo_name=$(echo "${REPO_URL}" | awk -F/ '{print $5}')

echo "REPO_OWNER=$repo_owner" >> $GITHUB_ENV
echo "REPO_NAME=$repo_name" >> $GITHUB_ENV
shell: bash

- name: Checkout repository
uses: actions/checkout@v4
with:
repository: ${{ env.REPO_OWNER }}/${{ env.REPO_NAME }}
token: ${{ secrets.CREATOR_TOKEN }}

- name: Get short commit ID
id: get-commit-id
run: |
echo "COMMIT_SHORT=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
echo "COMMIT_SHA=$(git rev-parse HEAD)" >> $GITHUB_ENV
shell: bash

- name: Configure AWS credentials
uses: aws-actions/configure-aws-credentials@v4
with:
aws-region: ${{ secrets.AWS_REGION }}
aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}

- name: Login to AWS ECR
id: login-ecr
uses: aws-actions/amazon-ecr-login@v1

- name: Build and push Docker image
env:
ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
ECR_REPOSITORY: ${{ env.REPO_NAME }}
run: |
# Build and push image with short commit ID and triggered by as tags
docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$COMMIT_SHORT .
docker push $ECR_REGISTRY/$ECR_REPOSITORY:$COMMIT_SHORT

# Tag image with commit ID and push
docker tag $ECR_REGISTRY/$ECR_REPOSITORY:$COMMIT_SHORT $ECR_REGISTRY/$ECR_REPOSITORY:$COMMIT_SHA
docker push $ECR_REGISTRY/$ECR_REPOSITORY:$COMMIT_SHA

# Tag image with triggered by and push
docker tag $ECR_REGISTRY/$ECR_REPOSITORY:$COMMIT_SHORT $ECR_REGISTRY/$ECR_REPOSITORY:actor-${TRIGGERED_BY//[^a-zA-Z0-9]/-}
docker push $ECR_REGISTRY/$ECR_REPOSITORY:actor-${TRIGGERED_BY//[^a-zA-Z0-9]/-}

# Tag image with PR ID and push
if [ "${{ github.event_name }}" == "pull_request" ]; then
PR_ID=$(echo "${{ github.event.pull_request.number }}" | tr -d '/')
docker tag $ECR_REGISTRY/$ECR_REPOSITORY:$COMMIT_SHORT $ECR_REGISTRY/$ECR_REPOSITORY:pr-$PR_ID
docker push $ECR_REGISTRY/$ECR_REPOSITORY:pr-$PR_ID
fi

# Tag image with workflow ID and push
docker tag $ECR_REGISTRY/$ECR_REPOSITORY:$COMMIT_SHORT $ECR_REGISTRY/$ECR_REPOSITORY:build-${{ github.run_id }}
docker push $ECR_REGISTRY/$ECR_REPOSITORY:build-${{ github.run_id }}

# Tag image with latest and push
docker tag $ECR_REGISTRY/$ECR_REPOSITORY:$COMMIT_SHORT $ECR_REGISTRY/$ECR_REPOSITORY:latest
docker push $ECR_REGISTRY/$ECR_REPOSITORY:latest

- name: Notify Port
uses: port-labs/port-github-action@v1
with:
clientId: ${{ secrets.PORT_CLIENT_ID }}
clientSecret: ${{ secrets.PORT_CLIENT_SECRET }}
operation: PATCH_RUN
baseUrl: https://api.getport.io
runId: ${{ fromJson(inputs.port_context).runId }}
logMessage: |
Built and pushed image to ECR

- name: Extract cluster name and region from arn
run: |
cluster_arn=$(echo "${{ github.event.inputs.cluster }}" | awk -F/ '{print $NF}')
cluster_name=$(echo "${cluster_arn}" | awk -F: '{print $NF}')
cluster_region=$(echo "${{ github.event.inputs.cluster }}" | awk -F: '{print $4}')

echo "CLUSTER_NAME=$cluster_name" >> $GITHUB_ENV
echo "CLUSTER_REGION=$cluster_region" >> $GITHUB_ENV


- name: Deploy to EKS
run: |
aws eks update-kubeconfig --name ${{ env.CLUSTER_NAME }} --region ${{ env.CLUSTER_REGION }}
kubectl apply -f manifests/deployment.yml
kubectl apply -f manifests/service.yml

- name: Notify Port
uses: port-labs/port-github-action@v1
with:
clientId: ${{ secrets.PORT_CLIENT_ID }}
clientSecret: ${{ secrets.PORT_CLIENT_SECRET }}
operation: PATCH_RUN
status: "SUCCESS"
baseUrl: https://api.getport.io
runId: ${{ fromJson(inputs.port_context).runId }}
logMessage: |
Deployed to EKS



The deploy action will:

  1. Build the docker image.
  2. Push it to the ECR repository.
  3. Deploy it to the cluster.

Done! 🎉

Augment It!

Here are a few additional enhancements you can make to the actions in this guide:

  • Add more templates to the Scaffolding action.
  • Extend the scaffold action by including a step that calls the Port API to trigger the deploy action on the newly created repository.

These enhancements will provide more flexibility and automation to your workflow.