DEV Community: KenjiGoh

Get started with Claude!

KenjiGoh — Fri, 06 Mar 2026 13:59:05 +0000

Documenting my learning Journey

Free Claude Tutorial can be found here: https://anthropic.skilljar.com/claude-code-in-action

Installation

1. MacOS (Homebrew):

brew install --cask claude-code

2. MacOS, Linux, WSL:

curl -fsSL https://claude.ai/install.sh | bash

3. Windows CMD:

curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

After installation, run claude at your terminal. The first time you run this command you will be prompted to authenticate

Set up instructions can be found here:
https://code.claude.com/docs/en/quickstart

Start by creating a claude.md file

Type /init

claude
/init

Common Commands

Stop Claude - press Esc
Add a memory - press#
Rewind to previous conversation - press Esc 2 times

Adding Context

Example, we can tell claude to always look at prisma/schema.prisma to check structure of data in db:

Next time when you ask about a schema attributes, claude will go straight to the schema instead of searching more files.

Reusing knowledge for similar task

Type /compact

Plan Mode

Press Shift + Tab 2 times to enable Plan mode
In Plan mode, claude will do more research, reads more files and come up with a complete plan for your tasks for your review. It will list down exactly what it wants to do to complete your tasks.

Thinking Mode

Allow claude to reason about more challenging problems.
Think ---> Ultrathink

MCP Playwright Server

F5 Load Balancing

KenjiGoh — Sun, 18 May 2025 09:16:05 +0000

VMs located in different Data Centre

                    ┌──────────────────────────┐
                    │        Client            │
                    └────────────┬─────────────┘
                                 │
                                 ▼
                    DNS Request: pmpcn.com
                                 │
                                 ▼
                      ┌────────────────────┐
                      │   F5 GTM (DNS)     │
                      └───────┬────────────┘
                              │
         ┌────────────────────┴────────────────────┐
         ▼                                         ▼
┌────────────────────┐                   ┌────────────────────┐
│ F5 LTM - DC1       │                   │ F5 LTM - DC2       │
│ VIP: 10.0.0.100:8443│                   │ VIP: 10.0.1.100:8443│
└─────────┬──────────┘                   └─────────┬──────────┘
          │                                        │
   ┌──────┴──────┐                          ┌──────┴──────┐
   ▼             ▼                          ▼             ▼
┌────────┐   ┌────────┐                ┌────────┐     ┌────────┐
│ VM1    │   │ VM2    │                │ VM3    │     │ VM4    │
│ Java   │   │ Java   │                │ Java   │     │ Java   │
│ App    │   │ App    │                │ App    │     │ App    │
│ :8443  │   │ :8443  │                │ :8443  │     │ :8443  │
└────────┘   └────────┘                └────────┘     └────────┘

VMs in same Data Center

                    ┌──────────────────────────┐
                    │        Client            │
                    └────────────┬─────────────┘
                                 │
                      DNS Request: pmpcn.com
                                 │
                                 ▼
                      ┌────────────────────┐
                      │   F5 LTM (VIP)     │
                      │  10.0.0.100:8443   │
                      └─────────┬──────────┘
                                │
                   ┌────────────┴────────────┐
                   ▼                         ▼
            ┌────────────┐           ┌────────────┐
            │   VM1      │           │    VM2     │
            │ Java App   │           │ Java App   │
            │  :8443     │           │  :8443     │
            └────────────┘           └────────────┘

Client
  ↓
DNS request (pmpcn.com)
  ↓
F5 GTM (optional, DNS-level routing)
  ↓
F5 LTM (VIP: 10.0.0.100:8443)
  |
  +--> VM1 (Java App 1:8443)
  |
  +--> VM2 (Java App 2:8443)

Flow from Client to App for VMs in different DCs

User accesses: https://api.pmpcn.com
     ↓
DNS lookup: api.pmpcn.com (CNAME → gtm.pmpcn.com)
     ↓
F5 GTM resolves → dc1-ltm.pmpcn.com or dc2-ltm.pmpcn.com
     ↓
VIP: 10.0.0.100:8443 (DC1) or 10.1.0.100:8443 (DC2)
     ↓
Load balanced to: VM1 or VM2 in that DC on port 8443

Testing Setup

Test DNS resolving to GTM

# DNS Resolution
dig api.pmpcn.com
OR
# CNAME Resolution
nslookup api.pmpcn.com

api.pmpcn.com should resolve to gtm.pmpcn.com (CNAME)

Test GTM resolving to LTMs

dig gtm.pmpcn.com

Test LTM connectivity

ping <VIP IP>
nc -vz <VIP IP> 8443
curl -vk https://<VIP IP>:8443/actuator/health

Summary of Commands

Purpose	Command Example
DNS Resolution	`dig api.pmpcn.com`
CNAME Resolution	`nslookup api.pmpcn.com`
GTM FQDN Test	`dig gtm.pmpcn.com`
LTM FQDN Test	`dig dc1-ltm.pmpcn.com`
Port Test to VIP	`nc -vz api.pmpcn.com 8443`
SSL Cert Validation	`openssl s_client -connect api.pmpcn.com:8443`
Backend Health API	`curl -vk https://api.pmpcn.com/actuator/health`
Trace Route	`traceroute api.pmpcn.com`
Direct Backend Check	`telnet <VM IP> 8443`

Telnet (for basic port check only)

This tests TCP connectivity to a host and port, it doesn’t understand HTTP or HTTPS:

telnet api.pmpcn.com 8443

Curl (for actual HTTPS request)

This checks the HTTP response from your app, including TLS handshake:

curl -vk https://api.pmpcn.com:8443

-v: verbose (shows headers)
-k: skip SSL certificate validation (useful if self-signed cert)

Summary

Action	Use This Command
Check if port 8443 is open	`telnet api.pmpcn.com 8443`
Send HTTPS request	`curl -vk https://api.pmpcn.com:8443`
Check specific API health	`curl -vk https://api.pmpcn.com:8443/actuator/health`

Configuring SSL Certs

Component	SSL Cert Needed?	Details
GTM	Usually No	GTM mainly handles DNS, not SSL termination.
LTM VIP	Yes	LTM usually terminates SSL for your public-facing service.
Backend VMs	Optional (Yes or No)	Depends if LTM does SSL termination or passes through.
Client URL	Yes (on LTM VIP)	The cert must match the public FQDN clients use (e.g., `api.pmpcn.com`)

What to secure	How to name it	Cert procurement method
LTM VIP SSL certificate	Use FQDN, not IP	Public CA for domain cert
Public service domain	FQDN (e.g., api.pmpcn.com)	Public CA or internal CA
Backend VMs (optional)	Depends on your architecture	Internal CA or self-signed cert

Steps to setup SSL for LTM (VIPs)

Create DNS A records pointing FQDNs to your VIP IPs

Hostname	Type	Value (VIP IP)
`dc1-ltm.pmpcn.com`	A	10.0.0.100
`dc2-ltm.pmpcn.com`	A	10.0.0.101

Get SSL certificates for these FQDNs from a trusted CA.
Configure your LTM VIPs to use these FQDN certs for SSL termination.

Your public service URL (e.g., api.pmpcn.com) should be a CNAME that ultimately resolves to your GTM, which then routes to the LTM VIP FQDNs/IPs.

SSL Termination at LTM (Backend VMs do not need SSL)

LTM VIP has the SSL cert for your public FQDN (api.pmpcn.com).
LTM decrypts SSL, forwards plain HTTP (or HTTPS) to backend VMs.
Backend VMs don’t need certs if traffic is HTTP, or can have self-signed certs if HTTPS is used internally.

SSL Passthrough (Backend VMS must have SSL)

End-to-End Encryption
LTM passes encrypted SSL traffic to backend VMs without decrypting.
Backend VMs must have SSL certs matching the FQDN (usually their own hostname).
GTM still doesn’t handle SSL, just DNS.

Use OpenSSL to inspect a cert

openssl s_client -connect api.pmpcn.com:8443 | openssl x509 -text -noout

Look under Subject: and X509v3 Subject Alternative Name:.

Basic Setup: Run SpringBoot using JBoss (Wildfly)

KenjiGoh — Thu, 20 Feb 2025 05:39:30 +0000

This tutorial assumes you have already set up Java and Maven in your system.

1. Install JBoss (Wildfly)

Go wildfly download page and download the tar file. For example, I downloaded version 35.0.1.Final.

Once downloaded, run this to unzip:

tar -xvzf wildfly-<version>.tar.gz
cd wildfly-<version>/

tar -xvzf wildfly-35.0.1.Final.tar.gz
cd wildfly-35.0.1.Final/

2. Test start the Jboss server

cd wildfly-35.0.1.Final/
./bin/standalone.sh

The default port is 8080, you can change port like this:

./bin/standalone.sh -Djboss.http.port=9090

Open http://localhost:9090 to see this:

3. Download and package a springboot app

Go start spring and select maven.
By default, maven will build jar. We need to use war for JBoss server.
Locate your pom.xml and update your build to war:

<packaging>war</packaging>

Exclude the embedded tomcat:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

Add spring-boot-starter-tomcat as provided:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <scope>provided</scope>
</dependency>

Modify the SpringBootApplication Class to extend from SpringBootServletInitializer:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication
public class MyApplication extends SpringBootServletInitializer {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

Do some minimal changes to your springboot app for easier validation:
Add ThymeLeaf in pom.xl

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

Add a HTML under resources\templates:

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Home Page</title>
</head>
<body>
    <h1 th:text="${message}">Welcome to the Home Page</h1>
</body>
</html>

Add a HomeController

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class HomeController {

    @GetMapping("/home")
    public String home(@RequestParam(name = "message", required = false, defaultValue = "Hello, Thymeleaf!") String message, Model model) {
        model.addAttribute("message", message);
        return "home";
    }
}

4. Start the war package

Build the WAR

mvn clean package

Copy the WAR file to JBoss deployments folder

cp target/demo-0.0.1-SNAPSHOT.war $JBOSS_HOME/standalone/deployments/

5. Finally start your demo springboot app with Jboss server!

http://localhost:9090/demo-0.0.1-SNAPSHOT/home?message=Springboot%20is%20running%20on%20jboss%20now!

Shell script to start up a flask project in a venv

KenjiGoh — Sat, 16 Mar 2024 01:40:10 +0000

Copy & Save it as flask_starter.sh

#!/bin/bash

# Inform the user about the script purpose
echo "This script will set up a Flask project."

# Ask for project directory name
read -p "Enter the name of your Flask project: " project_name

# Inform the user about creating the project directory
echo "Creating project directory: $project_name"
# Create project directory
mkdir "$project_name"
cd "$project_name"

# Inform the user about setting up the virtual environment
echo "Setting up virtual environment..."
# Set up virtual environment
python -m venv venv

# Inform the user about activating the virtual environment
echo "Activating virtual environment..."
# Activate virtual environment
source venv/Scripts/activate

# Inform the user about installing Flask
echo "Installing Flask..."
# Install Flask
pip install Flask

# Inform the user about creating app.py
echo "Creating app.py..."
# Create app.py
cat <<EOF > app.py
from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html')

if __name__ == '__main__':
    app.run(debug=True)
EOF

# Inform the user about creating templates directory
echo "Creating templates directory..."
# Create templates directory
mkdir templates

# Inform the user about creating index.html template
echo "Creating index.html template..."
# Create index.html template
cat <<EOF > templates/index.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Flask App</title>
</head>
<body>
    <h1>Hello, Flask!</h1>
</body>
</html>
EOF

# Inform the user that setup is complete
echo "Setup completed successfully!"

# Open the project in Visual Studio Code
echo "Opening the project in Visual Studio Code..."
code .

# Run the Flask app
echo "Running the Flask app..."
python app.py

Command to run the script

bash flask_starter.sh

Now go to browser to see the app

http://localhost:5000/

Kafka Quickstart

KenjiGoh — Wed, 13 Mar 2024 13:01:05 +0000

Getting Started on Kafka (Windows)

1. Start up zookeeper server

Open a command prompt in C:\kafka and enter this command:

.\bin\windows\zookeeper-server-start.bat .\config\zookeeper.properties

Zookeeper is running on Port 2181

2. Start the Kafka server

Open a new command prompt and start the Kafka server:

.\bin\windows\kafka-server-start.bat .\config\server.properties

3. Create a topic

Open a new command prompt in C:\kafka\bin\windows:

kafka-topics.bat --create --bootstrap-server localhost:9092 --topic mytopic

4. Create a Producer Console

kafka-console-producer.sh --broker-list <BROKER_LIST> --topic <TOPIC_NAME>

Open another new command prompt in C:\kafka\bin\windows:

kafka-console-producer.bat --broker-list localhost:9092 --topic mytopic

You should see a > prompt when the producer is ready.

5. Create a Consumer Console

kafka-console-consumer.sh --bootstrap-server <BROKER_LIST> --topic <TOPIC_NAME>

Open another new command prompt in C:\kafka\bin\windows:

kafka-console-consumer.bat --topic mytopic --bootstrap-server localhost:9092 --from-beginning

6. Paste Data to Producer and Observe Consumer

Sample data for use:

{"Name":"Kenneth","Age":"35","Gender":"Male"}
{"Name":"Gemma","Age":"25","Gender":"Female"}
{"Name":"Amy","Age":"15","Gender":"Male"}

Referencing the image below, once you paste a row of data into the producer terminal (left), the data appears on the consumer terminal (right) almost instantaneously.

In Git Bash/ Linux

Similar commands collated from kafka quickstart

# Download and extract
tar -xzf kafka_2.13-3.7.0.tgz
cd kafka_2.13-3.7.0

# Start the ZooKeeper service
bin/zookeeper-server-start.sh config/zookeeper.properties
# Start and hide logs on terminal
bin/zookeeper-server-start.sh config/zookeeper.properties > /dev/null 2>&1 &
# verify that Zookeeper is indeed running
ps -aef

# Start the Kafka broker service in another terminal
bin/kafka-server-start.sh config/server.properties

# Create a topic in another terminal
bin/kafka-topics.sh --create --topic quickstart-events --bootstrap-server localhost:9092

# Show details of a topic
bin/kafka-topics.sh --describe --topic quickstart-events --bootstrap-server localhost:9092
Topic: quickstart-events        TopicId: z_zqwwkiT6ueXVJxi3EAdA PartitionCount: 1       ReplicationFactor: 1     Configs:
        Topic: quickstart-events        Partition: 0    Leader: 0       Replicas: 0     Isr: 0

# Run Producer Console in another terminal
bin/kafka-console-producer.sh --topic quickstart-events --bootstrap-server localhost:9092

# Run Consumer Console in another terminal
bin/kafka-console-consumer.sh --topic quickstart-events --from-beginning --bootstrap-server localhost:9092

# Write event to topic at Producer console
This is my first message
This is my second message

Demonstrating 3 Brokers Replica

# Create 2 other brokers
cp config/server.properties config/server-1.properties
cp config/server.properties config/server-2.properties
ll config/serv*

Update these 3 areas in server-1 and server-2 file:

# SERVER-1
# id of the broker
broker.id=1
# broker port
listeners=PLAINTEXT://:9093
# log files directories 
log.dirs=/tmp/kafka-logs-1

# SERVER-2
# id of the broker
broker.id=2
# broker port
listeners=PLAINTEXT://:9094
# log files directories 
log.dirs=/tmp/kafka-logs-2

Now start all 3 brokers

bin/kafka-server-start.sh config/server.properties
bin/kafka-server-start.sh config/server-1.properties
bin/kafka-server-start.sh config/server-2.properties

Now Create a topic with 2 partitions and 3 replication factor across 3 brokers

bin/kafka-topics.sh --create --topic TestTopicXYZ --partitions 2 --replication-factor 3 --bootstrap-server localhost:9092, localhost:9093, localhost:9094

Lastly describe the topic to examine:

bin/kafka-topics.sh --describe --topic TestTopicXYZ --bootstrap-server localhost:9092,localhost:9093, localhost:9094

Topic: TestTopicXYZ     TopicId: 65thxHOeTIGSJJ5L_jl-XQ PartitionCount: 2       ReplicationFactor: 3    Configs:
        Topic: TestTopicXYZ     Partition: 0    Leader: 0       Replicas: 0,2,1 Isr: 0,2,1
        Topic: TestTopicXYZ     Partition: 1    Leader: 2       Replicas: 2,1,0 Isr: 2,1,0

What is Kafka?

Publish/Subscribe systems

With Publish/Subscribe systems, each event can be processed by multiple consumers who are listening to the topic. So multiple consumers can all get the same messages from the producer.

Pub/Sub systems introduce the concept of a topic. We can have multiple topics (to categorize your messages) and multiple producers writing to each topic and multiple consumers reading from a topic.

Distributed
Kafka is like a messaging system. Kafka Cluster is made up of more than 1 Kafka servers. Each Kafka server is referred to as a Broker. A Kafka cluster will have multiple brokers, therefore it is distributed application.
Fault-Tolerant
In Kafka cluster, messages are replicated in multiple brokers. A message published in Broker 1 will also be published in Broker 3. Therefore Kafka is fault-tolerant as message is replicated and not lost even if Broker 1 is down.
Language Agnostic
Data transferred (called Messages) are byte arrays so you can use JSON or a data format like Avro. Messages are immutable and have a timestamp, a value and optional key/headers

Kafka Architecture

Every Kafka ecosystem can have multiple producers/publishers.
A Kafka system consists of several components:

Producer - Any service that pushes messages to Kafka is a producer.
Consumer - Any service that consumes (pulls) messages from Kafka is a consumer. There can be multiple Consumer groups in the Kafka ecosystem. Consumers must be associated in a Consumer groups.
Kafka Brokers - the kafka cluster is composed of a network of nodes called brokers. Each machine/instance/container running a Kafka process is called a broker.

In a Kafka cluster, the individual servers are referred to as brokers. Brokers will handle:

Receiving Messages - accepting messages from producers
Storing Messages - storing them on disk organized by topic. Each message has a unique offset identifying it.
Serving Messages - sending messages to consumer services when the consumer requests it

Topics - A Kafka server has multiple topics. Every topics can have multiple partitions. Messages in Kafka are stored in topics, which are the core structure for organizing and storing your messages. You can think of a topic as a log file that stores all the messages and maintains their order. New message are appended to the end of the topic.

Offset Explorer

A UI tool for Kafka to help us visualize kafka clusters, topics and offset etc.

Thank you!

Using AWS-CLI & AWS CloudShell

KenjiGoh — Sun, 04 Feb 2024 01:43:38 +0000

1. AWS-CLI

Installation

Following this official guide: https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html

Example, for windows, we can install via this command on command prompt:

msiexec.exe /i https://awscli.amazonaws.com/AWSCLIV2.msi

Check for success installation:

aws --version
# aws-cli/2.15.17 Python/3.11.6 Windows/10 exe/AMD64 prompt/off

Configure

Example, on VS Code local:

Usage

Check for iam users.

aws iam list-users

2. AWS CloudShell

An alternative to AWS-CLI will be using AWS CloudShell directly.
AWS CloudShell is a browser-based shell that gives you command-line access to your AWS resources in the selected AWS region.
AWS CloudShell comes pre-installed with popular tools for resource management and creation.
You have the same credentials as you used to log in to the console.

Are available only in Supported Regions.

Usage

Create and download a file from CloudShell.

Use pwd to get the path of your created file in the CloudShell.

Cheers!

Spring Boot 3 – package javax.persistence does not exist

KenjiGoh — Wed, 20 Dec 2023 14:57:53 +0000

When migrating from Spring Boot 2 to Spring Boot 3, one might face this error:

The import javax.persistence cannot be resolvedJava(268435846)

This is due to this Transition from Java EE to Jakarta EE

Spring Boot 2.x using Java EE APIs javax.*

java: package javax.persistence does not exist

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

To fix this, we can just update all javax to jakarta.

Spring Boot 3 using Jakarta EE APIs jakarta.*

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

Thanks!

How SAML is used for SSO

KenjiGoh — Sun, 03 Dec 2023 08:59:25 +0000

Identity Management System

example of identity providers (IdP): Okta, ADFS, ForgeRock
in real world, there will usually be a mixture of applications using different authentication mechanism, some using SAML, some using OIDC.

Security Assertion Markup Language (SAML)

a popular authentication mechanism for SSO
other alternative mechanism are OAuth/OIDC and AD directory services

SAML Theory & Terminology

Subject - End User
User Agent - The Browser
Identity Provider (IdP)
Service Provider (SP) - E.g. SaaS Application
Circle of Trust
SAML Metadata
SAML Assertion
Protocol Binding
Subject - User of Application
XML - SAML's Requests & Response data format
HTTP-Redirect
HTTP-POST
Entity ID - Identifier associated with SP & IdP
Relay State
Relying Party (refer to the SP too)
Assertion - the XML within the response that contains user and group attributes
Attributes - sometimes called SAML claims
Assertion Consumer Service (ACS) URL

IdP

is responsible for authenticating end users, managing their account, and issuing SAML assertions about them.

SP

The provider of the service or application that the end user is trying to access.
has a trust relationship with the IdP, which enables the SP to rely on the assertions it receives from the IdP.

Single Sign-On (SSO)

The ability for an end user to authenticate once but gain access to multiple applications, without having to authenticate separately to each one.

Trust Relationship

to be set up between IdP and SP
a quick way to achieve this trust is to exchange the SAML metadata file (an XML formatted) file.

SAML's Protocol Binding

defines what forwarded mechanisms to use
can be HTTP 302 redirect or HTTP Post
either way, a similar request is being sent to the SAML IdP from the browser (user agent)

SAML Authentication Flow

SP Initiated SAML Single Sign On
IdP Initiated SAML Single Sign On

1. SP Initiated SAML SSO

SP initiates the SAML Request Redirect back to the browser after User access the SP from the browser.

Sample SP Initiated SAML SSO Flow

User accessed Application on Browser
Browser (as agent) forwards Request to IdP
IdP displays login screen
IdP authenticates the user against directory
IdP forwards Response to Application

Understanding Entity ID

Both the IdP and SP are entities and both have Entity ID associated with them. With Entity ID, we can identify who is the issuer of a request or who is the recipient of the response.

Understanding Relay State Here

When User first requests (1) a URL (e.g. SaaS Application), this accessed URL is usually passed as Relay State when (2) Browser forwards the request to IdP. And it will be returned in the Response (5) for application to act on.

2. IdP Initiated SAML SSO

IdP initiates the SAML Response. The application gets a SAML Response without it requesting an authentication.

Sample IdP Initiated SAML SSO Flow

User accesses & logs into IdP
IdP authenticates the user against directory
IdP creates a Response XML with the right assertion (XML within the response that contains user and group attributes)
The assertion is digitally sign and encrypted
The Response is being sent to the SP

Understanding Relay State Here

Since it is not SP-initiated, there is no initial URL to store as Relay State. In this case, the IdPs can store a default Relay State to sent back to the Application on Browser. Application gets the response from the IdP and verify the assertion.

Reference

Getting Started with Openshift on Windows

KenjiGoh — Sat, 11 Nov 2023 17:02:21 +0000

Step-by-Step Instructions

1. Register account at Redhat

2. Go Console

3. Download OpenShift local

4. Unzipped the downloaded folder at C:\Users\username\crc

5. Open Powershell and run `crc setup`. Will take awhile to setup.

crc setup

6. After setup is down run `crc start`

crc start
// if face error
crc start --log-level debug

It will eventually prompt you for the pull secret.
Copy from the console and right-click to paste to the terminal.
It will then take awhile to start up the container.

7. Test that Openshift Cli oc is properly installed.

Copy and paste the following command:

oc login -u developer https://api.crc.testing:6443

8. Head over to Sandbox and start a 30-day trial sandbox account.

9. Login to your sandbox once provisioned and download oc CLI

Extract the file and save it to "C:\Users\username\oc-folder" or any preferred location.

10. Add the oc CLI file path to the environment variables

11. Open powershell and run `oc` to verify.

12. Logging into sandbox via cli

Go over to sandbox console and copy login command
This will open a new tab with your API token and login command.

Create Lambda function using AWS CloudShell

KenjiGoh — Sun, 24 Sep 2023 17:17:46 +0000

1. Access CloudShell from Lambda Console

Since npm is already installed in CloudShell, we can use it to create node_modules.

2. Create a lambda folder

mkdir lambda
cd lambda

3. Open Nano text editor

Run nano index.js to open the nano editing GNU.

// if no nano installed then run this first
sudo yum install -y nano
// else just run this
nano index.js

4. Copy the following code into the nano GNU

const AWSXRay = require('aws-xray-sdk-core');
const AWS = AWSXRay.captureAWS(require('aws-sdk'));
const s3 = new AWS.S3();
exports.handler = async function (event) {
  return s3.listBuckets().promise();
};

Then Ctrl-X, Y and Enter to exit nano.
We can run the following to double confirm the code has been pasted into index.js

cat index.js

5. Install the required Dependencies

npm i aws-xray-sdk

Run ll to check that node_modules exist and the dependencies are indeed being installed.

6. Set proper permission for files

chmod a+r *

7. Zip the files

zip -r function.zip .

Run ll again to double check zipped folder is created.

8. Create a IAM role

Since we are using lambda and S3, we need to assign 2 permission policies:

AWSLambdaBasicExecutionRole
AmazonS3ReadOnlyAccess

Name the IAM role as DemoLambdaRole

Copy the role ARN

9. Use cli to upload the zipped folder to create the lambda function

Remember to replace the ARN with yours

aws lambda create-function --zip-file fileb://function_test.zip --function-name lambda-with-dependencies --runtime nodejs14.x --handler index.handler --role arn:aws:iam::023028579192:role/DemoLambdaRole

Refresh the Lambda Functions table and you should see your new lambda being created

10. Enable x-ray Tracing

Lastly, since we are using x-ray, we also need to enable x-ray tracing at the lambda function.

Once you enabled x-ray tracing, go back to the IAM DemoLambdaRole and you will see a new permission policy being assigned.

11. Test the Lambda

You should see all your S3 buckets being returned, as shown below:

12. Clean up!

Finally, as a good habit, delete the Lambda to save resources. You may also delete the create Role too.

Cheers! Reference

Automate CloudFront Cache Invalidation

KenjiGoh — Tue, 15 Aug 2023 13:57:42 +0000

If you are using CloudFront distribution to serve your users, it will be good to be able to automate cache invalidation by using this command:

Replace stackName with the name of your Cloudformation stack.

distributionId=$(aws cloudformation describe-stacks --stack-name stackName --query "Stacks[0].Outputs[?OutputKey=='DistributionId'].OutputValue" --output text)

echo distributionId

aws cloudfront create-invalidation --distribution-id $distributionId --paths "/*"

2 ways to create Lambda with Cloudformation

KenjiGoh — Mon, 17 Jul 2023 14:32:49 +0000

1. Inline Code

Cloudformation:

AWSTemplateFormatVersion: "2010-09-09"
Description: Lambda inline code
Resources:
  MyInlineLambda:
    Type: AWS::Lambda::Function
    Properties: 
      Runtime: python3.x
      Role: arn:aws:iam::123456789012:role/lambda-role
      Handler: index.handler
      Code:
        ZipFile: |
          import os

          DB_URL = os.getenv("DB_URL")
          db_client = db.connect(DB_URL)
          def handler(event, context):
            user = db_client.get(user_id = event["user_id"])
            return user

2. Through Zip File on S3

Cloudformation:

AWSTemplateFormatVersion: "2010-09-09"
Description: Lambda from S3
Resources:
  MyLambdaFromS3:
    Type: AWS::Lambda::Function
    Properties: 
      Runtime: nodejs18.x
      Role: arn:aws:iam::123456789012:role/lambda-role
      Handler: index.handler
      Code:
        S3Bucket: some-bucket
        S3Key: function.zip
        S3ObjectVersion: String

Serverless Framework:

service: my-service

package:
  individually: true

functions:
  hello:
    handler: com.serverless.Handler
    package:
      artifact: s3://some-bucket/path/to/function.zip