DEV Community: Sojin Samuel

My Journey Deploying a Full-Stack Node.js App to AWS using Pulumi

Sojin Samuel — Sun, 06 Apr 2025 20:22:03 +0000

This is a submission for the Pulumi Deploy and Document Challenge: Fast Static Website Deployment

What I Built

In this tutorial, we'll deploy a dynamic Node.js web application that converts uploaded video files (MP4) into downloadable MP3 audio. The app provides a simple web interface, uses ffmpeg on the server for conversion, and even generates shareable links.

We'll use Pulumi with TypeScript to provision the necessary AWS infrastructure: a VPC, an EC2 instance running Ubuntu to host our app, an Application Load Balancer (ALB) to distribute traffic, and the required Security Groups.

Live Demo Link

You can try the deployed cloud version of Video-to-MP3 converter here

Project Repo

Complete Source code of the deployed project:

sojinsamuel / pulumi-video-converter-deploy

Video to Mp3 converter Project Deployed to AWS via Pulumi

☁️🚀 Deploy Video-to-MP3 Converter to AWS with Pulumi 🎬🎵

This repository contains the Pulumi infrastructure code (IaC) written in TypeScript to deploy the Node.js Video-to-MP3 Converter application to AWS.

The Goal: To automate the provisioning of AWS resources (EC2, Application Load Balancer, Security Groups, VPC configuration) required to host and run the web application, making deployment repeatable and manageable.

📖 Companion Tutorial: This repository is best understood alongside the detailed tutorial available on dev.to [https://dev.to/sojinsamuel/pulumi-v2-4fai]

🏗️ Architecture Overview

This Pulumi program deploys the following AWS resources:

Networking: Uses your AWS account's Default VPC and associated Subnets.
Security Groups:
- alb-sg: Allows public HTTP traffic (port 80) to the Load Balancer.
- instance-sg: Allows traffic from the ALB to the EC2 instance on the application port (3001) and allows SSH access (port 22) for management (Important: Restrict SSH source IP!). Allows all outbound traffic.
Compute: An EC2…

View on GitHub

Tutorial Starter Repo

For this tutorial, we'll be using this repo as the starter code, which I've already created for you. It doesn't use Pulumi or AWS as a cloud service, which is exactly what we'll be adding today. We'll come back to it later as our application code to follow along with the tutorial.

My Journey

Moving beyond simple static sites, this project tackles deploying a real-world Node.js application. We need a server, file processing, and external API interaction.

This guide walks through cloning the application code, setting up a separate Pulumi project to define our AWS infrastructure, configuring Git, and finally deploying everything using Pulumi's Infrastructure as Code approach.

We'll focus on clarity and explain the "what" and "why" behind each step, especially for those new to Pulumi or AWS cloud deployments.

So, in this article, we'll cover:

Setting up the project structure locally.
Cloning the application code.
Optionally running the app locally.
Initializing a separate Pulumi project for infrastructure.
Writing the Pulumi code (Infrastructure as Code) in TypeScript.
Handling Git repository setup for deployment.
Deploying to AWS using pulumi up.

Why Pulumi? Pulumi lets us define cloud infrastructure using familiar programming languages like TypeScript. This improves productivity, enables version control, and fits naturally into modern development workflows. It supports CI/CD integration, encourages better collaboration, and works across multiple cloud providers; making infrastructure easier to manage, automate, and scale.

Prerequisites:

An AWS account with configured credentials (IAM user or default profile with permissions for EC2, VPC, ALB).
AWS CLI installed
Pulumi CLI installed.
Node.js (v18+ recommended, I used v22.x.x).
Git installed.
A GitHub account to host your code repository.

Step 1: Create Your Main Project Directory

First, let's create a parent directory on your local machine to hold both the application code and the infrastructure code. This keeps everything organized.

mkdir pulumi-video-converter && cd pulumi-video-converter

Why? This top-level folder will be our Git repository root later, containing both the app and pulumi IaC subdirectory.

Step 2: Clone the Application Code

Inside the pulumi-video-converter directory, clone the GitHub repository containing the application code, i created for you.

# Tutorial starter code!
git clone https://github.com/sojinsamuel/video-to-mp3-app-example.git video-to-mp3-app

This creates a subdirectory video-to-mp3-app containing our app:

pulumi-video-converter/
└── video-to-mp3-app/     # <-- Cloned application code
    ├── public/
    ├── .git/             # <-- Will be removed in next step
    ├── .gitignore
    ├── server.js
    ├── package.json
    └── ...

Step 3: Remove Nested `.git` Directory (Important!)

The video-to-mp3-app directory you just cloned contains its own .git history from the original repo. To avoid issues with Git treating this as a submodule or causing conflicts when we initialize Git for our main pulumi-video-converter project, remove the nested .git folder:

rm -rf video-to-mp3-app/.git

Why? This ensures that video-to-mp3-app is treated as just a regular subdirectory within our main project's Git repository, which we'll set up later.

Step 4: Install App Dependencies & Test Locally (Optional)

Before deploying, let's ensure the app runs locally.

Navigate into the application directory (if you're not already):
```
cd video-to-mp3-app
```
Install dependencies:
```
npm install
```
Run the server:
```
node server.js
```
Open your browser to http://localhost:3001. You should see the application interface. Test uploading a small video file if you like.
Stop the local server by pressing Ctrl+C in the terminal.
Navigate back to the parent directory:
```
cd ..
```

Why? This verifies the application code itself is working before we deploy.

Step 5: Initialize Pulumi for Infrastructure

Now, from the root pulumi-video-converter directory, create a new subdirectory for your infrastructure code:

mkdir pulumi-infra && cd pulumi-infra

Inside the pulumi-infra folder, initialize a new Pulumi project using the AWS TypeScript template:

pulumi new aws-typescript --stack dev

Pulumi will:

Ask for basic project details like description and the AWS region where you want to deploy (you can accept the defaults or customize them).
Generate standard Pulumi files inside the pulumi-infra folder, including Pulumi.yaml, Pulumi.dev.yaml, index.ts, and more.
Use the --stack dev flag to create and select a stack named dev. A stack is an isolated instance of your infrastructure (like dev, staging, or production).

Your structure now looks like:

pulumi-video-converter/
├── video-to-mp3-app/   # Application code (no .git folder)
└── pulumi-infra/       # Infrastructure code (Pulumi project)
    ├── node_modules/
    ├── Pulumi.yaml
    ├── Pulumi.dev.yaml
    ├── index.ts
    └── ...

Step 6: Configure AWS Credentials

Ensure the AWS CLI (and therefore Pulumi) can authenticate with your AWS account. If you haven't configured the CLI before:

aws configure

You'll be prompted to enter your AWS Access Key ID, Secret Access Key, and default region (e.g., ap-southeast-2).

Note: This command won't work if the AWS CLI isn't installed. Make sure you’ve installed it first.

Why? Pulumi uses the same credential chain as the AWS CLI to interact with your AWS account.

Step 7: Write the Pulumi Infrastructure Code (`index.ts`)

Navigate into your infrastructure code directory:

cd pulumi-infra

Now, replace the contents of pulumi-infra/index.ts with the code below. This TypeScript code uses the Pulumi AWS SDK to declare the cloud resources needed.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const config = new pulumi.Config();
// Instance type for EC2, defaulting to t2.micro (free tier eligible)
const instanceType = config.get("instanceType") || "t2.micro";
// **Placeholder for Our app's GitHub repo URL - we'll set this later!**
const appRepoUrl = config.require("appRepoUrl");

// --- Networking (Using Default VPC) ---
const vpc = aws.ec2.getVpc({ default: true });
const vpcId = vpc.then(v => v.id);

const subnetIds = vpc.then(v => aws.ec2.getSubnets({
    filters: [{ name: "vpc-id", values: [v.id] }]
})).then(s => s.ids);

// --- Security Groups ---

// ___Security Group for the Application Load Balancer (ALB)___
// Allows public HTTP traffic on port 80
const albSg = new aws.ec2.SecurityGroup("alb-sg", {
    vpcId: vpcId,
    description: "Allow HTTP inbound traffic for ALB",
    ingress: [{ // Allow HTTP from anywhere
        protocol: "tcp", fromPort: 80, toPort: 80, cidrBlocks: ["0.0.0.0/0"],
    }],
    egress: [{ // Allow all outbound traffic
        protocol: "-1", fromPort: 0, toPort: 0, cidrBlocks: ["0.0.0.0/0"],
    }],
    tags: { Name: "video-to-audio-converter-alb-sg" },
});

// ___Security Group for the EC2 Instance___
// Allows traffic from ALB on port 3001 and SSH 
const instanceSg = new aws.ec2.SecurityGroup("webapp-instance-sg", {
    vpcId: vpcId,
    description: "Allow HTTP from ALB and SSH",
    ingress: [
        { // Allow HTTP traffic on port 3001 ONLY from the ALB
            protocol: "tcp", fromPort: 3001, toPort: 3001, securityGroups: [albSg.id],
        },
        { // Allow SSH traffic on port 22 - **IMPORTANT: Restrict this CIDR block!**
            protocol: "tcp", fromPort: 22, toPort: 22, cidrBlocks: ["0.0.0.0/0"], // <-- Change to your IP/32
        },
    ],
    egress: [{ // Allow all outbound traffic (for apt-get, git clone, npm, External APIs)
        // This is a broad rule, consider restricting it further based on your needs
        protocol: "-1", fromPort: 0, toPort: 0, cidrBlocks: ["0.0.0.0/0"],
    }],
    tags: { Name: "video-converter-instance-sg" },
});

// --- EC2 Instance ---

// Find the latest Ubuntu 22.04 LTS AMI (Jammy) for amd64
const ami = aws.ec2.getAmi({
    filters: [
        { name: "name", values: ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*"] },
        { name: "virtualization-type", values: ["hvm"] },
    ],
    mostRecent: true,
    owners: ["099720109477"], // Canonical's AWS account ID
});

// **IMPORTANT**: (Assumes you have an existing key pair created in AWS)
const keyPairName = config.require("keyPairName");

console.log(`---> DEBUG: Pulumi resolved keyPairName as: '${keyPairName}'`);

const userData = pulumi.interpolate`#!/bin/bash
# Exit on first error
set -e
echo ">>>> Starting UserData script..."

# --- Install git ---
echo ">>>> Installing git..."
sudo apt-get update -y && sudo apt-get install -y git
echo ">>>> Git installed."

# --- Clone the repo into /home/ubuntu/app ---
echo ">>>> Cloning repository ${appRepoUrl} into /home/ubuntu/app..."
sudo -u ubuntu git clone ${appRepoUrl} /home/ubuntu/app
echo ">>>> Clone finished."

# --- Install NVM and Node.js as ubuntu user ---
echo ">>>> Installing NVM and Node.js 22 for user ubuntu..."
sudo -i -u ubuntu bash << EOF
echo ">>>> Running as ubuntu user for NVM install..."
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh | bash
\\. "\\$HOME/.nvm/nvm.sh"
nvm install 22
nvm use 22
nvm alias default 22
echo ">>>> Node.js installed. Verifying versions..."
node -v
nvm current
npm -v
EOF
echo ">>>> Finished NVM and Node.js installation."

# --- Install dependencies and setup PM2 in video-to-mp3-app ---
echo ">>>> Setting up application in /home/ubuntu/app/video-to-mp3-app..."
sudo -i -u ubuntu bash << EOF
\\. "\\$HOME/.nvm/nvm.sh"
cd /home/ubuntu/app/video-to-mp3-app
echo ">>>> Running npm install..."
npm install
echo ">>>> npm install finished."
echo ">>>> Installing PM2 globally..."
npm install pm2 -g
echo ">>>> Starting server.js with PM2..."
pm2 start server.js --name video-converter
echo ">>>> PM2 process started."
EOF
echo ">>>> Application setup finished."

echo ">>>> UserData script finished successfully."
`;

// Create the EC2 instance
const instance = new aws.ec2.Instance("webapp-instance", {
    instanceType: instanceType,
    ami: ami.then(a => a.id),
    vpcSecurityGroupIds: [instanceSg.id],
    subnetId: subnetIds.then(ids => ids[0]), // Use the first default subnet
    keyName: keyPairName, // Assign your key pair for SSH access
    userData: userData, // Run the setup script on launch
    tags: { Name: "video-to-audio-converter" },
});

// --- Application Load Balancer (ALB) ---

// Create the ALB, Target Group, and Listener
const alb = new aws.lb.LoadBalancer("webapp-lb", {
    internal: false,
    loadBalancerType: "application",
    securityGroups: [albSg.id],
    subnets: subnetIds, // Assign the ALB to the default subnets
    tags: { Name: "video-to-audio-converter-alb" },
});

const targetGroup = new aws.lb.TargetGroup("webapp-tg", {
    port: 3001, protocol: "HTTP", targetType: "instance", vpcId: vpcId,
    healthCheck: { // Basic health check for the root path
        path: "/", protocol: "HTTP", matcher: "200-399", interval: 30, timeout: 5,
        healthyThreshold: 2, unhealthyThreshold: 2,
    },
    tags: { Name: "video--audio-converter-tg" },
});

const targetGroupAttachment = new aws.lb.TargetGroupAttachment("webapp-tg-attachment", {
    targetGroupArn: targetGroup.arn,
    targetId: instance.id,
    port: 3001,
});

const listener = new aws.lb.Listener("webapp-listener", {
    loadBalancerArn: alb.arn,
    port: 80, protocol: "HTTP",
    defaultActions: [{ type: "forward", targetGroupArn: targetGroup.arn }],
});

// --- Outputs ---
// Public DNS name of the ALB so we can access the app
export const albUrl = alb.dnsName;
// Instance ID for reference
export const instanceId = instance.id;
// Public IP of the instance for SSH access
export const instancePublicIp = instance.publicIp;

Here's what it does:

Configuration (pulumi.Config): Reads appRepoUrl and keyPairName from a config file. Sets t2.micro as the default instance type.
Networking: Uses the default AWS VPC and its subnets for simplicity.
ALB Security Group (alb-sg): Controls traffic to the Load Balancer.
EC2 Security Group (webapp-instance-sg): Secures the EC2 instance, restricting inbound traffic to specific sources.
EC2 Instance (aws.ec2.Instance): Runs on the latest Ubuntu 22.04 LTS AMI with a setup script executed on boot.
UserData Script: Automates app setup by installing tools, cloning the repo, and starting the application.
Application Load Balancer (webapp-lb): Public ALB that receives incoming traffic.
Target Group (webapp-tg): Directs traffic to the EC2 instance with a health check.
Listener (webapp-listener): Connects the ALB to the target group.
Outputs: Provides the ALB DNS name, instance ID, and instance public IP for access.

PS: It's completely okay to have doubts. A helpful tip, you can copy-paste index.ts into Pulumi Copilot to explore it further. It's available as a Pulumi VS Code extension powered by their official REST API, and also on the official Pulumi website.

Step 8: Initialize Git & Push Our Project to GitHub

Our EC2 instance (to be created by pulumi IaC) needs to download the application code. We also want to version control our infrastructure code. So, let's put everything into a single main Git repository.

Navigate to Parent Directory: Ensure you are in the main pulumi-video-converter directory.
```
# If you are inside pulumi-infra:
cd ..
```
Initialize Git:
```
git init
```

Create .gitignore: Create a .gitignore file in the pulumi-video-converter root to exclude unnecessary files:

# Node modules
node_modules/
pulumi-infra/node_modules/
video-to-mp3-app/node_modules/

# Pulumi state and logs
.pulumi/
pulumi-infra/.pulumi/

# Application Uploads (local and server)
video-to-mp3-app/uploads/
uploads/

# OS generated files
.DS_Store
Thumbs.db

# Log files
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
pm2.log
logs/

# Environment files
.env*

Add and Commit: Stage all files and make your first commit.

git add .
git commit -m "Initial commit: Add app code and Pulumi infra code"

Create GitHub Repository: Go to GitHub and create a new public repository (e.g., pulumi-video-converter-deploy). Do not initialize it with a README, license, or .gitignore on GitHub.
Link Remote and Push: Connect your local repository to the GitHub remote and push your code (replace the URL with your new repository's URL):
```
git remote add origin https://github.com/your-username/pulumi-video-converter-deploy.git
git branch -M main
git push -u origin main
```

Why Git? It versions both your app and infrastructure code. The userData script in pulumi-infra/index.ts relies on git clone using the public URL you configure in the next step.

Your current project structure should look like:

pulumi-video-converter/  (Git repository root)
├── .git/
├── .gitignore
├── video-to-mp3-app/    # Application code (no .git folder here)
│   ├── node_modules/    # (Ignored by Git)
│   ├── public/
│   ├── uploads/         # (Ignored by Git, created by app)
│   ├── server.js
│   └── package.json
│   └── ...
└── pulumi-infra/        # Infrastructure code (Pulumi project)
    ├── node_modules/    # (Ignored by Git)
    ├── .pulumi/         # (Ignored by Git)
    ├── index.ts         # Pulumi IaC definition
    ├── package.json
    ├── Pulumi.yaml
    ├── Pulumi.dev.yaml  # Contains your config (repo URL, key name)
    └── tsconfig.json

Step 9: Configure Pulumi Stack (Repo URL & Key Pair)

Now, tell Pulumi the URL of the repository it needs to clone and the name of your EC2 key pair (we'll create it later).

Follow these steps:

Navigate to Infra Directory: Make sure you are inside the pulumi-infra directory.
```
cd pulumi-infra
```

Set GitHub Repository URL: Use the HTTPS URL of the main pulumi-video-converter-deploy repository you created on Step 8.

# Replace with YOUR project repository URL && Execute it in your terminal
pulumi config set appRepoUrl https://github.com/your-username/pulumi-video-converter-deploy.git

How to Create/Find Key Pair:

A) Go to the AWS EC2 Console in your target region (e.g., ap-southeast-2). Navigate to Network & Security -> Key Pairs.

B) Click Create key pair

C) Give it a name (e.g., video-converter-key) and choose RSA type and .pem format for SSH clients. Then click "Create key pair". It will automatically download the .pem file (e.g., video-converter-key.pem).

D) Configure Pulumi: Use the name you gave the key pair in AWS console (without .pem extension).

# Replace 'video-converter-key' with the exact name from Console

pulumi config set keyPairName video-converter-key

Why configure? This securely injects these values into your Pulumi program (index.ts) where config.require("appRepoUrl") and config.get("keyPairName") are used, avoiding hardcoding sensitive or environment-specific details.

Tip: After executing the commands, you can also double check the values you just set, by visting your pulumi-infra/Pulumi.dev.yaml file

config:
  aws:region: ap-southeast-2
  pulumi-infra:appRepoUrl: https://github.com/sojinsamuel/pulumi-video-converter-deploy.git
  pulumi-infra:keyPairName: video-converter-key

This is a snapshot of my Pulumi.dev.yaml file, in your case, you'll have a different value for the appRepoUrl and keyPairName. if you come across any issues or mistyped your property values you can reset it by running the appropriate pulumi config set "<command>"

Step 10: Deploy to AWS!

It's time to bring your infrastructure to life! Run pulumi up from within the pulumi-infra directory:

# Make sure you are in the pulumi-infra directory!
pulumi up

Pulumi will:

Show you a preview of all the AWS resources it will create (VPC, Subnets, SGs, EC2, KeyPair association, ALB, Target Group, Listener, etc.).
Ask for confirmation (yes).

Review the plan carefully. If it looks right, type yes and press Enter. Pulumi will provision the resources in AWS. This can take several minutes.

Once finished, Pulumi will display the outputs, including the albUrl.

Outputs:
    albUrl          : "webapp-lb-xxxxxxxxxxxxxxxxx.ap-southeast-2.elb.amazonaws.com"
    instanceId      : "i-xxxxxxxxxxxxxxxxx"
    instancePublicIp: "xx.xx.xx.xx"

Step 11: Verify Your Deployment

Copy the albUrl value from the Pulumi output and paste it into your web browser. You should see your Video Audio Extractor application!

Test it: Upload a small MP4 file, process it, download the MP3, and try generating the shareable link.

Troubleshooting Tips if your albUrl fails to display the webapp in your browser:

Invalid key pair: If you see an invalid key pair error in your terminal after running pulumi up, it likely means the key pair name in your AWS Console doesn’t match the one you set using pulumi config. Double-check that both names are exactly the same.

One issue I ran into was that I had an old AWS access key and secret saved in my ~/.aws folder, which I had completely forgotten about. So when I ran pulumi up, resources were getting created in my old AWS account. Pulumi then failed to use the key pair name I had created in my new account because that key pair didn’t exist in the old one.

To avoid this, make sure you’ve set your AWS credentials and region correctly as explained in Step 6.

Bad Gateway: If you're getting a 502 Bad Gateway error after visiting the albUrl, it usually means something went wrong during the execution of the userData script in pulumi-infra/index.ts.

To find the root cause, SSH into the EC2 instance and investigate:

# <INSTANCE_PUBLIC_IP> is shown in your `pulumi up` output
# Replace /path/to/your/key/yourkeyname.pem with the actual path to your key file
ssh -i /path/to/your/key/yourkeyname.pem ubuntu@<INSTANCE_PUBLIC_IP>

Once you're in, check the logs for script output:

cat /var/log/cloud-init-output.log

You probably won’t even need to go through these troubleshooting steps, your albUrl should display the application right away. I've already configured pulumi-infra/index.ts after a lot of trial and error on my end.

But if anything comes up, I'm just a message away on LinkedIn.

Wrap Up

And there we have it! 🚀 We've successfully taken a standard Node.js video conversion application from a local setup to a fully deployed service on the AWS cloud, all orchestrated using Pulumi and TypeScript.

We navigated the process of:

Structuring our project with separate directories for application and infrastructure code.
Cloning the starter application code and preparing it for deployment.
Initializing a Pulumi project to define our cloud resources declaratively.
Writing TypeScript code to provision a VPC (default), EC2 instance, Application Load Balancer, Target Group, Listener, and necessary Security Groups.
Tackling the crucial EC2 userData script, leveraging nvm for reliable Node.js installation and pm2 to run our application.
Configuring Git and handling repository details for automated cloning during deployment.
Using pulumi up to bring our infrastructure to life and iterating through troubleshooting steps (like credential issues, key pair mismatches, and userData script errors).

This journey reflects a realistic workflow for deploying dynamic web applications. By defining our infrastructure as code, we've created a repeatable, version-controlled, and manageable deployment process – a huge step up from manual configurations!

💰 Cost Considerations

Deploying resources to AWS incurs costs. While we've used the free-tier eligible t2.micro instance type by default, be aware of the following:

EC2 Instance: t2.micro instances are part of the AWS Free Tier (subject to hourly limits per month for the first 12 months of your AWS account). If you exceed these limits or use a different instance type, you will be charged per hour the instance is running.
Application Load Balancer (ALB): ALBs are not included in the standard Free Tier. You are charged for each hour an ALB is running and for Load Balancer Capacity Units (LCUs) consumed based on traffic metrics. This is likely the main cost driver for this deployment.
Data Transfer: AWS charges for data transferred out from EC2 and the ALB to the internet. Uploading videos incurs negligible ingress costs, but downloading the converted MP3s contributes to egress costs. Significant usage could lead to noticeable charges.
EBS Volume: The EC2 instance uses an EBS General Purpose SSD (gp2/gp3) volume for its root disk. There's a Free Tier allowance (e.g., 30 GB), but usage beyond that incurs costs.

Recommendation:

Monitor Billing: Keep an eye on your AWS Billing Dashboard to understand costs.
Destroy When Done: Most importantly, if you are only running this for the tutorial or testing, destroy the infrastructure when you are finished to stop incurring charges:
```
# Run from the pulumi-infra directory
pulumi destroy
```
Confirm yes when prompted. This will terminate the EC2 instance, delete the ALB, and remove associated resources managed by Pulumi.

🤔 Using Pulumi: Lessons Learned & Copilot Assistance

Deploying this application involved significantly more moving parts than a simple static website. Pulumi proved invaluable in managing this complexity, though the journey highlighted key cloud deployment concepts and debugging strategies.

How Pulumi Benefited This Project:

Managing Interconnected Resources: Defining the ALB, Target Group, Listener, EC2 Instance, and their associated Security Groups in TypeScript made their relationships explicit. Pulumi automatically understood dependencies (e.g., the instance needing the SG, the ALB needing the SG and subnets, the listener needing the ALB and TG) and created them in the correct order, preventing errors that are common with manual setups or less expressive tools. Referencing resource IDs directly in code (like securityGroups: [albSg.id]) is much clearer than manually tracking ARNs or names.
Infrastructure as Code (IaC): Having the entire infrastructure defined in index.ts means:
- Repeatability: Anyone (including future you!) can run pulumi up and get the same setup.
- Version Control: Our infrastructure definition lives in Git alongside the application code (in separate folders), allowing us to track changes, revert if needed, and collaborate.
- Clarity: The TypeScript code serves as documentation for the deployed resources.
Configuration Management: Using pulumi config set for the appRepoUrl and keyPairName was essential. It allowed us to inject environment-specific values into the deployment without hardcoding them in index.ts, keeping the code clean and reusable for different stacks or users.
Iterative Development & Debugging userData: Bootstrapping EC2 instances with userData is notoriously tricky. While Pulumi didn't write the script for us, it made iterating much easier:
- We could define the multi-step installation process (NVM, Node, Git, clone, npm install, pm2) directly within our TypeScript code using pulumi.interpolate.
- If the script failed (causing 502 errors), we could modify the userData string in index.ts and simply run pulumi up. Pulumi would detect the change, replace the EC2 instance, and run the new script, allowing for relatively quick test cycles compared to manually creating/terminating instances and running scripts.
State Management & Recovery: Although i hit issues due to initial credential mix-ups causing state inconsistencies, Pulumi's state management was ultimately helpful. Once the state became invalid (preventing pulumi destroy), the pulumi state delete <URN> command provided a necessary escape hatch to manually remove "ghost" resources from the state file, allowing us to reset and achieve a clean deployment with pulumi up.

Leveraging Pulumi Copilot:

During my troubleshooting phase, especially with userData and configuration, Pulumi Copilot (VS Code Extension / Web) was very valuable to accelerate debugging:

Initial userData Structure: When the first apt-get install nodejs approach failed, a prompt like this helped explore alternatives:

Show me a Pulumi TypeScript example of EC2 userData to install Node.js v20 using nvm on Ubuntu 22.04 and run a simple Node app.

(This provided the basic structure for using sudo -i -u ubuntu bash << EOF and installing/using nvm).
Configuration Issue: The persistent InvalidKeyPair.NotFound error, despite the key existing, led to asking:

Explain how pulumi config set stores values in Pulumi.yaml and how config.require() reads them in TypeScript compared to config.get().

(This clarified the project-name prefixing behavior and why config.require was the correct choice).
Debugging 502 Errors: When the 502 errors occurred, general debugging prompts were useful:

Why would an AWS Application Load Balancer return a 502 Bad Gateway error when the EC2 instance seems to be running?

(Copilot suggested checking target group health, security groups allowing traffic on the app port from the ALB, and application logs on the instance – guiding the SSH troubleshooting steps).
Specific Resource Syntax: For refining the code:

How do I correctly specify filters when using aws.ec2.getSubnets in Pulumi TypeScript?

(This helped fix the vpcId vs filters issue).

While Copilot didn't write the final, perfect script, it provided valuable code snippets, explanations of Pulumi concepts, and common debugging checklists that significantly reduced the time spent resolving issues encountered during this real-world deployment scenario.

What's Next?

Restrict SSH Access: Immediately update the Instance Security Group (instance-sg) in index.ts to allow SSH (port 22) only from your IP address (YOUR_IP/32) instead of 0.0.0.0/0. Run pulumi up to apply.
HTTPS: Secure your site using AWS Certificate Manager (ACM) and configure the ALB Listener for HTTPS (port 443).
Robust PM2 Startup: Re-add and test pm2 startup / pm2 save (within the ubuntu user context in userData) if you need the application to restart automatically on server reboots.
ffmpeg Dependency: If deploying this to a different AMI, you might need to add ffmpeg back to the apt-get install line in userData.
Static Assets: Serve frontend files from S3/CloudFront.
Containerization: Dockerize the app and deploy via ECS/Fargate managed by Pulumi.
CI/CD: Automate deployments with GitHub Actions triggering pulumi up.
Cleanup: When finished, run pulumi destroy from the pulumi-infra directory to remove all AWS resources and avoid costs.

This journey, including the bumps along the way, is typical of real-world cloud deployments. By using Infrastructure as Code with Pulumi, we made the process manageable, repeatable, and ultimately successful!

Feel free to reach out on linkedin if you have questions or feedback!

Happy coding champs 👋

Pulumi is the first ever IaC, i've ever tried + Pulumi Copilot is the perfect cherry on top to make the development much easier. Thanks a lot Team Pulumi

Sojin Samuel — Fri, 04 Apr 2025 22:04:28 +0000

Sojin Samuel

Apr 4 '25

Fast-Track Your Static Site: Deploying Hugo with Pulumi on AWS S3

#devchallenge #pulumichallenge #webdev #cloud

Comments 2

8 min read

Fast-Track Your Static Site: Deploying Hugo with Pulumi on AWS S3

Sojin Samuel — Fri, 04 Apr 2025 21:49:46 +0000

This is a submission for the Pulumi Deploy and Document Challenge: Fast Static Website Deployment

What I Built

In this tutorial, I'll guide you through deploying a static website using Hugo and Pulumi on AWS. Hugo is a fast and flexible static site generator, and Pulumi is an infrastructure-as-code tool that lets you define cloud resources using familiar programming languages like TypeScript. We'll set up a Hugo site, configure Pulumi to deploy it to an AWS S3 bucket, and make the site publicly accessible as a static website.

Live Demo Link

You can access the deployed static hugo website here

Project Repo

The complete code for this project, including a detailed README, is available in my GitHub repository:

sojinsamuel / pulumi-hugo-aws

A fast static website deployment using Hugo and Pulumi on AWS S3, with a step-by-step tutorial for the Pulumi Deploy and Document Challenge.

Hugo and Pulumi Static Website Deployment on AWS S3

This project demonstrates how to deploy a static website using Hugo and Pulumi on AWS S3. Hugo is a fast static site generator, and Pulumi is an infrastructure-as-code tool that allows you to define cloud resources using TypeScript. The site is deployed to an S3 bucket configured as a static website, with public access enabled for viewing.

Live Demo

You can view the deployed site here: http://site-bucket-657f8f1.s3-website-ap-southeast-2.amazonaws.com

Project Overview

This project…

View on GitHub

My Journey

In this section, I’ll walk you through the entire process of setting up the project, configuring Pulumi, and deploying the static website to AWS S3. Along the way, I’ll highlight the challenges I faced and the solutions I found to ensure a smooth deployment.

Before we begin, ensure you have the following installed:

An AWS account with an IAM user that has permissions for S3 operations (s3:PutObject, s3:GetObject, s3:PutBucketPolicy, s3:PutPublicAccessBlock, s3:GetBucketPublicAccessBlock)
Pulumi CLI installed
Node.js (version 16 or higher recommended; I used v20.12.2).
Hugo installed installed (I used v0.128.0).

Step 1: Install Pulumi CLI

Install the Pulumi CLI by running:

curl -fsSL https://get.pulumi.com | sh

This command downloads and installs the Pulumi CLI, which you’ll use to manage your cloud infrastructure.

Verify the installation:

pulumi version

Step 2: Set Up Your Project Directory

Create a new directory for your project and navigate into it:

mkdir pulumi-hugo-aws && cd pulumi-hugo-aws

This directory will hold all the files for your Hugo site and Pulumi project.

Step 3: Create a Hugo Site

Initialize a new Hugo site:

hugo new site mysite && cd mysite

This creates a new Hugo site in the mysite directory with the basic structure for your static site.

Add a Theme:
Hugo sites need a theme to render content. We'll use the Ananke theme for this tutorial:

git init
git submodule add https://github.com/budparr/gohugo-theme-ananke.git themes/ananke
echo 'theme = "ananke"' >> hugo.toml

Create a Sample Post:

Add a sample post to ensure there’s content to display:

hugo new content/posts/my-first-post.md

Edit the post to add some content and ensure it's published:

nano content/posts/my-first-post.md

Update the file to look like this:

+++
title = 'My First Post'
date = 2025-04-04T23:41:34+05:30
draft = false
+++

This is my first post on Hugo

Save and exit (Ctrl+O, Enter, Ctrl+X in nano).

Customize the Homepage:

By default, the Ananke theme's homepage doesn't list posts. Let's customize it to show recent posts:

mkdir -p layouts
nano layouts/index.html

Add the following content:

{{ define "main" }}
  <div class="container">
    <h1>{{ .Site.Title }}</h1>
    <p>Welcome to my Hugo site!</p>
    <h2>Recent Posts</h2>
    <ul>
      {{ range first 5 (where .Site.RegularPages "Section" "posts") }}
        <li>
          <a href="{{ .RelPermalink }}">{{ .Title }}</a>
          <small>{{ .Date.Format "January 2, 2006" }}</small>
        </li>
      {{ end }}
    </ul>
  </div>
{{ end }}

Save and exit (Ctrl+O, Enter, Ctrl+X in nano).

This template displays the site title and a list of up to 5 recent posts from the posts section.

Step 4: Create a Pulumi Project

Initialize a new Pulumi project in the mysite directory:

pulumi new aws-typescript --force

--force is needed because the directory isn’t empty (Hugo already created files).

Follow the prompts to set up your Pulumi project. This command initializes a new Pulumi project using the AWS TypeScript template, which provides a starting point for deploying AWS resources using TypeScript.

P.S: If you want to learn why pulumi new expects us to always start from an empty directory, check out this GitHub discussion.

Step 5: Configure AWS Credentials

Make sure your AWS credentials are configured. You can do this by running:

aws configure

This command sets up your AWS credentials, which are necessary for Pulumi to interact with AWS services. You will be prompted to enter your AWS Access Key ID, Secret Access Key, and default region. Your IAM user must have permissions for S3 operations (see Prerequisites).

Step 6: Install Dependencies

Install the necessary Pulumi packages and mime-types for handling file types:

npm install @pulumi/aws @pulumi/pulumi mime-types @types/mime-types --save-dev

@pulumi/aws and @pulumi/pulumi are required for AWS resource management.
mime-types helps set correct MIME types for uploaded files.

Step 7: Write Pulumi Code

Replace the default index.ts with the following code to set up an S3 bucket, configure it as a website, and upload the Hugo site:

import * as aws from "@pulumi/aws";
import * as pulumi from "@pulumi/pulumi";
import * as fs from "fs";
import * as path from "path";
import * as mime from "mime-types";

// Create an S3 bucket
const siteBucket = new aws.s3.Bucket("site-bucket", {});

// Configure the bucket as a website
const website = new aws.s3.BucketWebsiteConfigurationV2("website", {
    bucket: siteBucket.id,
    indexDocument: {
        suffix: "index.html",
    },
});

// Configure public access block to allow public access
const publicAccessBlock = new aws.s3.BucketPublicAccessBlock("public-access-block", {
    bucket: siteBucket.id,
    blockPublicAcls: false,
    blockPublicPolicy: false,
    ignorePublicAcls: false,
    restrictPublicBuckets: false,
});

// Add a bucket policy to allow public read access
const bucketPolicy = new aws.s3.BucketPolicy("bucketPolicy", {
    bucket: siteBucket.bucket,
    policy: siteBucket.bucket.apply(bucketName => JSON.stringify({
        Version: "2012-10-17",
        Statement: [{
            Effect: "Allow",
            Principal: "*",
            Action: ["s3:GetObject"],
            Resource: [`arn:aws:s3:::${bucketName}/*`],
        }],
    })),
}, { dependsOn: [publicAccessBlock] });

// Function to recursively upload files from a directory
function uploadDirectory(dirPath: string, bucket: aws.s3.Bucket) {
    fs.readdirSync(dirPath, { withFileTypes: true }).forEach((dirent) => {
        const filePath = path.join(dirPath, dirent.name);
        if (dirent.isDirectory()) {
            uploadDirectory(filePath, bucket);
        } else {
            const relativePath = path.relative("./public", filePath);
            new aws.s3.BucketObject(relativePath, {
                bucket: siteBucket,
                source: new pulumi.asset.FileAsset(filePath),
                contentType: mime.lookup(filePath) || "application/octet-stream",
                key: relativePath,
            }, { dependsOn: [publicAccessBlock, website, bucketPolicy] });
        }
    });
}

// Upload all files from the Hugo 'public' directory
uploadDirectory("./public", siteBucket);

// Export the website URL
export const bucketEndpoint = pulumi.interpolate`http://${website.websiteEndpoint}`;

Save and exit (Ctrl+O, Enter, Ctrl+X in nano).

This code:

Creates an S3 bucket and configures it as a website with index.html as the default page.
Disables S3 Block Public Access settings to allow public access.
Applies a bucket policy to make all objects publicly readable.
Recursively uploads all files from the public/ directory, preserving the directory structure and setting correct MIME types.

Step 8: Build Hugo Site

Generate the static files for your Hugo site:

hugo

This creates the public/ directory with your site’s static files, including index.html and the post at posts/my-first-post/.

Step 9: Deploy with Pulumi

Deploy the site to AWS:

pulumi up

Pulumi will preview the changes, showing the resources to be created (S3 bucket, website configuration, bucket policy, and objects).
Select yes to deploy.
Once complete, the output will include bucketEndpoint (e.g., http://site-bucket-9170bd3.s3-website-ap-southeast-2.amazonaws.com).

Step 10: Verify the Deployment

Open the bucketEndpoint URL in a browser. You should see your Hugo site with the Ananke theme, displaying the site title ("My New Hugo Site") and a "Recent Posts" section listing "My First Post" with a link to the full post.

Project Structure (Key Files Only)

pulumi-hugo-aws/
└── mysite/
    ├── archetypes/         # Hugo archetypes for new content
    ├── content/            # Hugo content files (e.g., posts/)
    │   └── posts/
    │       └── my-first-post.md
    ├── layouts/            # Custom Hugo templates
    │   └── index.html
    ├── public/             # Generated static files
    ├── themes/             # Hugo themes (e.g., ananke/)
    ├── hugo.toml           # Hugo configuration
    ├── index.ts            # Pulumi deployment script
    ├── package.json        # Node.js dependencies
    ├── Pulumi.yaml         # Pulumi project configuration
    └── tsconfig.json       # TypeScript configuration

Wrap Up

In this tutorial, we successfully deployed a static website using Hugo and Pulumi on AWS S3. We covered setting up a Hugo site with a theme, customizing the homepage to display posts, configuring Pulumi to deploy to S3, and ensuring the site is publicly accessible.

Using Pulumi

Pulumi made this project much easier to manage. I was able to define and deploy AWS infrastructure using TypeScript, which I already use daily. That let me stay in one workflow without needing to switch between tools or learn a new configuration language. Here's how Pulumi helped me get the Hugo site up and running on S3:

TypeScript for Infrastructure: Writing infrastructure in TypeScript meant fewer surprises. I could catch issues like incorrect resource properties before deployment and stay consistent with the rest of the project. Compared to YAML or JSON-based tools, the development process felt more natural.
AWS Setup with Less Friction: Pulumi’s AWS provider (@pulumi/aws) gave me a direct way to create what I needed in S3. Buckets, static website configs, policies. it all came together in a clear and code-first way. I didn't have to spend extra time wrestling with CloudFormation or the AWS console.
Helpful Copilot Tooling: The Pulumi Copilot helped me troubleshoot faster. When I ran into public access issues, it explained how the BucketPublicAccessBlock resource worked and gave an example I could use. It also clarified some TypeScript syntax issues and pointed me to the right docs for deeper reading on S3 configs.
Smarter State Management: Pulumi's state tracking meant that when I updated the Hugo public/ directory, only the changed files were uploaded. That saved time and made updates feel more reliable.

There were a few moments where I had to figure things out, but the tooling and docs helped me get through them:

Nested Folder Uploads: Hugo’s output includes nested directories and my first attempt didn’t handle those correctly. I ended up writing a recursive function on index.ts to upload all the files while keeping the structure. The assets and archives guide helped with that.
Public Access Errors: At first, S3’s Block Public Access settings blocked my custom bucket policy, which caused AccessDenied errors. Pulumi Copilot helped me fix this by showing how to use BucketPublicAccessBlock. The example policy in the docs also gave me a solid reference.
Homepage Didn't Show Posts: Hugo’s default setup doesn’t display posts on the homepage, so I had to create a custom layouts/index.html. This part was more of a Hugo issue, but once I rebuilt the site, Pulumi picked up the changes and deployed them without extra work on my end.

In the end, Pulumi let me stay close to my code and avoid bouncing between services and dashboards. Hugo handled the content and site structure, and Pulumi made sure it reached the web with minimal overhead.

What's Next?

Now that your Hugo site is live, consider these next steps:

Add More Content: Create additional posts or pages in Hugo to expand your site.
Enable HTTPS: Set up AWS CloudFront with an SSL certificate to serve your site over HTTPS (S3 websites are HTTP-only by default).
CI/CD Integration: Automate deployments with Pulumi's automation API and a CI/CD pipeline (e.g., GitHub Actions).

Notes

Recursive File Uploads: Always account for nested directories when uploading static sites to S3. Use a recursive function to preserve the directory structure.
IAM Permissions: Verify your AWS IAM user has the necessary permissions for S3 operations to avoid AccessDenied errors.

By following this tutorial, you can leverage Pulumi and Hugo to deploy scalable, efficient static websites with ease.

Feel free to reach out on linkedin if you have any questions.

Happy coding champs 👋

Win Up to $1200 in the InfinityAI Halloween Challenge 🎃

Sojin Samuel — Wed, 30 Oct 2024 00:19:23 +0000

If you’re interested in exploring AI video creation or sharing your own Halloween-inspired ideas, the InfinityAI Halloween Challenge is for you. This month-long event invites creators to make Halloween or horror-themed videos using InfinityAI-generated characters, with up to $1200 in prizes available.

What is the InfinityAI Halloween Challenge?

The InfinityAI Halloween Challenge brings together AI video creators to showcase Halloween and horror-themed videos. Each week in October features new themes, and now, in this final week, the theme is “Free for All.” This means any Halloween or horror-inspired video that includes a notable amount of InfinityAI characters is welcome.

October Challenge Details

This is the last chance to enter and compete for prizes in the October Challenge. The best video of the month will win $500, and the second place will receive $100. With the prize pool for this month totaling $1200, there are many opportunities to win!

Why Enter? Prizes and Community

Here’s the complete prize breakdown:

InfinityAI Team Prizes: $50 for 1st place and $25 for 2nd place. The prize pool increases by $100 for every 10 unique participants (up to $500).
Community Choice Prize: $50 goes to the finalist who receives the most votes in a community poll.

Participating connects you with an active community of AI creators, giving you the chance to share your work, learn from others, and see different ways AI can be used in video.

How to Participate

Create a Video: Use InfinityAI to generate characters and scenes for a Halloween or horror concept.
Submit Your Entry: Make sure your video includes a significant amount of InfinityAI-generated content.
Deadline: Entries for the final week are due by Monday, November 4th.

Ready to Join?

Check out all the details and submit your entry here: InfinityAI Halloween Challenge Link

Networking cant be easier than this

Sojin Samuel — Sun, 23 Jun 2024 11:34:20 +0000

This is a submission for the Twilio Challenge

What I Built

An AI agent were you can pass in an email or a linkedin profile url to get candidate details and share it with your partner, cofounder via:

Twilio Call, SMS or Email.

The Agent user can also pass in the phone number of a potential candidate and get his/her details regarding the availability of the phone, which was made with the help of Twilio Phone Lookup service

This Agent also has the power of displaying real time notifications for example when an email is sent and the recipient opens it, the AI Agent dashboard notifies the user, when they have opened the mail.

eg:

Hey sojinsamue2001@gmail.com just opened their mail

And importantly the user data: like the signup, login events, message events back and forth between the user and AI, page visits etc are tracked with the help of Twilio segment.

Demo

Project Link

Demo video:

Twilio and AI

I have used Vercel AI SDK with gpt4o to render react components which then interacts with Twilio SDK to send messages via sms, email and as a call. Combining GPT function calling and executing actions using natural language.

Source code on github

Additional Prize Categories

Qualify for:

Twilio Times Two: utilized Twilio Segment for studying customer data, Twilio Phone lookup endpoint to get candidate phone details, Twilio SMS and Programmable voice for notifying colleagues or candidates, Twilio Sendgrid for sending candidate details in a dynamically generated email template using gpt.
Impactful Innovators: Best for Networking and get details by just submitting an email address to the Agent and if that email is associated with a linkedin account then get their details and send it to your team for further verification or checks before hiring. And the data thats returned from the Reverse Contact lookup can also be passed on to email or programmable voice by mentioning what you want to share in natural language, which helps you to manage more than one channel.
Entertaining Endeavors: Getting realtime information from just an email id and passing that data into others channel with the help of webhooks to notify the recipient without missing important notifications like hiring, interview, etc

TweetGagger Plugin: getLikes, getRetweets, getReplies

Sojin Samuel — Sat, 27 Apr 2024 18:35:01 +0000

This is a submission for the Coze AI Bot Challenge: Trailblazer.

What I Built

TweetGagger needs an id associated with a TWeet URL to get all the details which includes details of the liking users, retweeting users, replies being made to that particular tweet.

I made this plugin for my GiveAway Picker bot, where it needed to check actions mentioned on a giveaway contest hosted on Twitter where Authors asking users to Like, Retweet and Comment something specific, then a random user(s) get shortlisted for winning prices.

But this isn't just a plugin that usefull for my bot, you can use this to get engagement metrics of a tweet, check for Spamming users who are making irrelevant comments etc

Demo

Find the TweetGagger Plugin from Store.

getRetweet function execution response from GiveAwayPicker bot.

Each functions are triggered only when an action associated with it is mentioned in the Tweet.

Journey

Submitted via Coz Studio, at first it did seem a little scary. But finally I did make it work out.

Thanking Coze for hosting such a wonderful hackathon and this is my last submission to this challenge.

Best of luck to all the participants.

Tweet Media Extractor Plugin

Sojin Samuel — Sat, 27 Apr 2024 11:24:46 +0000

This is a submission for the Coze AI Bot Challenge: Trailblazer.

What I Built

There are already amazing Twitter related plugins available on Coze Plugins store that can be used with Tweets.

What I needed was a plugin that could take the Media comprised in a Tweet, could be an image or video (Which I needed in different resolutions)

So I built one to use on my TweetMediaManager bot, which is an integral part for the bots functionality.

When a user submits a tweet or post URL:
https://twitter.com/<username>/status/<id>

It has a unique id associated with it. which is the input parameter being used in TweetMediaExtractor to make a LookUp search via Twitter API v2.

If the tweet does comprise media the JSON response would contain an includes field.



// Assuming the target Tweet contained a video
 {
    "data": {
        ...
    },
    "includes": {
        "media": [
            {
                "media_key": "77777777",
                "type": "video",
                "variants": [
                    {
                        "bit_rate": 632000,
                        "content_type": "video/mp4",
                        "url": "https://video.twimg.com/ext_tw_video/12345678/pu/vid/avc1/320x568/4024rVUaMBVYHT_b.mp4?tag=12"
                    },
                    {
                        "bit_rate": 950000,
                        "content_type": "video/mp4",
                        "url": "https://video.twimg.com/ext_tw_video/12345678/pu/vid/avc1/480x852/5JGUFqyletKVFUuF.mp4?tag=12"
                    },
                    {
                        "bit_rate": 2176000,
                        "content_type": "video/mp4",
                        "url": "https://video.twimg.com/ext_tw_video/12345678/pu/vid/avc1/720x1280/E9zgV0hONDsfOwrq.mp4?tag=12"
                    },
                    {
                        "content_type": "application/x-mpegURL",
                        "url": "https://video.twimg.com/ext_tw_video/12345678/pu/pl/ORE8nOl29XDVW9kz.m3u8?tag=12&container=cmaf"
                    }
                ]
            }
        ],
        "users": [
            ...
        ]
    }
}

Even though we could download an image by going to devtools via inspect on chrome, using the same method for a video will only give you a blob URL. which isn't what we want. Many people do share awesome infographical or gif representation of AWS architectural patterns which is what my motivation behind building this custom plugin.

At the time of building this, I wasn't familiar with the Coze Studio and was honestly confused like what are tools? where do they even come in action. where would I safely store my Twitter API Keys, what does Tool name mean.

Even though there is already options from Coze to bind existing external service APIs. I still needed the Studio option because I needed to implement oauth 1.0 authentication method for the Twitter API.

So my second option was to create a REST API via AWS API gateway and make a resource path /getmedia, which then executes a lambda function and the id needed was passed via query param by registering it as an Existing service (used the API Gateway REST API endpoint).

Demo

You can check out the TweetMediaExtractor plugin from Coze plugin store

This is the JSON response we saw earlier, the plugin usage in action can be tested via my TweetMediaManager bot

Journey

Even though I moved forward with using API Gateway instead of Coze Studio, it was still a great experience to learn about this AWS service and made my development process much easier.

Still, I wasn't gonna let go of using Coze Studio that easily!

It is indeed a learning process, So i created another plugin called TweetGagger (yeah another plugin powered by Twitter API) which I made it work from the Studio itself instead of using API gateway.

Read: TweetGagger Plugin Submission

Randomly Picks a Giveaway Winner on Twitter (Oops X)

Sojin Samuel — Fri, 26 Apr 2024 22:56:15 +0000

This is a submission for the Coze AI Bot Challenge: Bot Innovator.

What I Built

Giving Away Prices is becoming a thing on X nowadays. From books to Crypto coins are just some. But sometimes a lot of people participate in it and the people who are hosting this giveaway might be having a hard time to choose that winner.

They have to make sure they choose a person without making any personal or emotional choices and strictly abide the rules.

The Team behind the contest could hire someone to do the job. But what if the Author has a bot that will choose for him/her randomly.

Demo

Some conversation snapshots:

That is what GiveAwayPicker bot does.

Wait, but what if the Author wants to choose more than one person in ranks. Its not always going to be just a single winner

Already covered 😉

Your Configuration

TweetLinkParser check the URL and verifies if the tweet is actually talking about a GiveAway Contest + What are the actions mentioned in the Tweet for example: Like, Retweet, replies.

Based on the actions provided appropriate function are executed with the help of TweetGagger Plugin.



// Prompt
# Character
You're an efficient Twitter Giveaway Analyzer. You are proficient at checking, verifying and analyzing "Giveaway Tweets" based on the author's instructions. 

## Skills
### Skill 1: Tweet Analysis
- Use getTweet to analyze the content of the provided tweet.
- Determine if it's a giveaway tweet and understand what the author asks the participants to do in order to win the giveaway.

### Skill 2: Function Execution
- Use the getReplies, getRetweet, and getlikes functions as needed, according to the tweet content.
- If additional actions besides liking, retweeting, and replying are required and are impossible to perform; explain the limitations to the user and ask whether the available options are acceptable.

### Skill 3: Determining the Winner
- Identify those who've completed all required actions.
- Select only one user (unless the author has explicitly mentioned he may be selecting more than one) at random and inform the giver of the winner's Twitter handle allowing them to distribute the prize.

## Constraints:
- If the giveaway tweet contains atleast one action that you dont support then let the user know i cant support that particular action and explicitly ask to the user if the user wants you check any or all of the action you support
- Process only tweets that indicate clearly what actions the participants must take to be qualified as potential winners of the giveaway.
- Interpret "repost" in a tweet as a request to "retweet" and use getRetweet accordingly.
- If "comment" or "reply" is mentioned but without specifying what needs to be commented or replied, still activate the getReplies function.
- Reveal only the winner's details, twitter handle link of the winner, no other information or details of the participants should be displayed.
- Remember to use only the necessary functions, based on the giveaway criteria described in the tweet.
- If a tweet's criteria for the giveaway can't be met due to the lack of necessary functions, inform the user about the issue and offer the alternative of executing functions that are available.
- In the output make sure you only include the one single winner (unless the author has explicitly asked he needs more than one winner) Twitter handle along with the link to check their profile and also adding the congratulatory message

Journey

Based on the first bot I built for the contest which downloads media from Tweets, that was hard at the time because I was still learning and in the path of being comfortable to a new development environment. Give-away Picker bot was an idea I already had in mind, but there wasnt any plugins that could check Likes, Retweets, Replies details. So I need to build and deploy TweetGagger from Coze Studio.

This Bot Downloads Media from any Tweet and Set Reminders for Future reference

Sojin Samuel — Wed, 24 Apr 2024 10:14:47 +0000

This is a submission for the Coze AI Bot Challenge: Bot Innovator.

What I Built

I have been using Twitter since 2019 and have seen many valuable resources shared by people, ranging from AWS architectural patterns to SEO tips, web design principles, etc.

The highlight often is the media associated with it, which could be a representation of a diagram or a video explanation.

I often do what we've always done: bookmark it for future reference. The problem is, most of us never come back. In my case, after a couple of months, I may have even forgotten that I saved something like this.

I even wondered if it would have been great if the bookmarking feature also had some kind of reminder mechanism that I could schedule, like 'remind me next month,' etc.

Sadly, Twitter (Now X) hasn't rolled it out yet.

This is where TweetMediaManager comes to the rescue.

You can send a Tweet URL that looks something like this to the bot:
https://twitter.com/<username>/status/<id>

And later, this is what happens:

But that's not just it. You could also schedule a reminder of a particular Tweet for a specific time, whether it be tomorrow, next week, or next month. That's up to you.

For example:

We'll see a live demo of both of these examples in a sec 😉

I'm preparing for the AWS Solutions Architect exam, and this is going to help me a lot because there are some awesome developers on X who are sharing really valuable tips, including diagrams, gif representations of some internal processes, etc., from time to time.

Even if you're not preparing for any exams, you could still use this for many different purposes. The possibilities are endless and unique to each of you.

// Detect dark theme var iframe = document.getElementById('tweet-1782169943540400148-638'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1782169943540400148&theme=dark" }

In my case, I used this bot to download the video where Jack Dorsey presents Twitter back in 2006. This simple video motivates me to work harder and keep going.

Demo

You can check out TweetMediaManager bot from Coze store. It's also available on Discord and Telegram.

Configuration

// prompt
# Character
You're an expert in digital content extraction specializing in obtaining multimedia materials from Twitter. Sharp, meticulous, and excellent in preserving original content quality, you shine at analysing tweets and retrieving embedded media files.

## Skills
### Skill 1: Media Extraction from Tweet URLs
- Analyze the structure and syntax of provided Tweet URLs, focusing on image or video content.
- Extract these files, maintaining their original form and quality.

### Skill 2: Secure Media Delivery 
- Following secured media extraction, use reliable and safe data transmission means to forward the obtained media files to the user.
- Ensure the unaltered, original condition receipt of these files by the user.

## Constraints
- Use the Tweet_Processor tool to extract the id from a valid Twitter URL, obtain media URLs and share these along with URL specifics like resolution based on bitrate, and the text content of the tweet.
- Stick to URLs originating from Twitter exclusively. Other platforms are not within operational limits.
- Implement ‘url_storage' to verify redundancy of the Tweet URL and save novel URLs along with their respective media URL, if any.
- Clean up the shared tweet text; remove hashtags, mentions, promotions, keep it simple, and emphasize it in bold. Also include the original tweet link and any media content.
- Guide the user towards the correct URL format if provided URLs are inconsistent with the examples:

A) https://twitter.com/<username>/status/<id>

B) https://x.com/<username>/status/<id>

- Emphasize the importance of non-commercial, personal, and ethical use of retrieved media content.
- When the media type is a video just provide the response as the text, which includes: Download URL with all obtainable resolutions you have for example define the resolution as a label based on the bit rate , Tweet text etc and do not use card data attachment on the media type video.

Journey

Learning something new is never easy for anybody and it did took some time to get the whole Coze workflow for building an AI chatbot.

For this particular bot, none of the currently available plugins were able to bring my idea to life. So i have to build one which in this case i had to use the Twitter API v2 Tweet Lookup endpoint with some extra parameters and expansions to get the media (both image and video) from a tweet.

Unfortunately i was having a hard time to figure out how to create this custom plugin and configure it to make a call to Twitter API v2 since it required Oauth 1.0 authentication setup with Consumer key, Consumer Secret, Access Token and Access token secrets. Bearer token aren't used anymore for most cases

So i had to either drop this idea or move on with another one. which i couldn't. so i created a RestAPI on AWS APIGateway and executed a lambda function containing the programmatic logic to make a call to Twitter with Oauth 1.0 and returned a JSON comprising of the media details when a particular endpoint is accessed.

After a couple of hours of publishing TweetMediaManager i saw the users count increasing, which did made me worry and happy at the same time because to access the Tweet Lookup endpoint (to get media) i needed a Paid API plan from twitter so i choose the $100/mon plan for my use case. But the main problem was the rate limiting issue (429 error). could arise when a specific endpoint is consumed a lot more than it should on a time period (its dfferent for different API plans) of users are having a conversation at the same time or either i could go for a $5K/mon plan which does gives a lot more freedom, which i can't for this hackathon. if Coze could help, I'm definitely gonna make this plugin production ready so you can all utilize it for any number of bots.

The videos on CozeHQ official Youtube channel was very helpful for starters for building, utilizing different skills, publishing it to various channels like Telegram etc.

Most importantly the Live Stream on April 22 was really awesome, @joshalphonse and @zarazhangrui helped me to clear lot of my doubts in that available time frame. We all built a Travel Assistant bot together that day and it was such a great experience for me.

Lastly, best of luck to all contenders of Coze AI hackathon, feel free to share your projects on X with a mention to @SamuelSojin.

I'm psyched to test all of your amazing hackathon submissions.

Peace ✌️

How To Create a WhatsApp Chatbot in 2025 With a Custom Knowledge Base

Sojin Samuel — Thu, 25 Jan 2024 22:10:51 +0000

Introduction

In this post, we assume that you have already installed Node v18 on your machine and has some experience with Supabase, and PostgreSQL. Additionally, make sure you have a free Twilio account set up (if you don't have one yet). We will be developing a WhatsApp chatbot using the OpenAI Chat Completions API endpoint.

Users can ask questions, and the chatbot will generate responses based on the information provided through a vector database. It will also ensure to refrain from answering questions when they are asked out of context from its knowledge base, opting instead to reply with a polite sorry message.

Setting up your Local Environment

First, set up your Node.js application. Make sure you understand how to create an Express server before you proceed.

Install dependencies: In your project terminal start by executing the following command to install the necessary packages:

npm init -y && npm i @supabase/supabase-js twilio express dotenv openai langchain

After executing this command, you'll find a node project dependency tree in the root of your project, complete with a package.json file containing the specified dependencies.

Add Environment variables

Create a .env file with the following contents. which will be used to authenticate REST API requests.

TWILIO_ACCOUNT_SID= <your twilio account sid>
TWILIO_AUTH_TOKEN= <your twilio auth token>

OPENAI_API_KEY= <your open ai key>

SUPABASE_URL= <your supabase url>
SUPABASE_API_KEY= <your supabase api key>

Here is a breakdown on how to get these credentials:

Obtaining Twilio Credentials:

Log in to your Twilio account.
Navigate to the Twilio Auth Token page.
Copy and paste the credentials into the .env file.

Obtaining OpenAI API Key:

Log in to your OpenAI account.
Head to the OpenAI dashboard.
Copy and paste the OpenAI API key into the .env file.

Obtaining Supabase Credentials:

Create a Supabase project.
Go to the API settings page.
Copy and paste the Supabase API URL and API key into the .env file.

Configuring OpenAI and Supabase

In the root of your project, create a file called utils.js. This is where we'll configure our OpenAI and Supabase client.

require('dotenv').config(); // loads .env variables

const OpenAI = require('openai');
const { createClient } = require('@supabase/supabase-js');

const supabase = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_API_KEY);

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

module.exports = { openai, supabase };

The above code consists of 2 core steps:

Supabase Initialization: Sets up a connection to Supabase.This initialized supabase client allows interaction with the Supabase database in the application.
OpenAI Instance: Initializes the OpenAI API client., which is crucial for making requests to the OpenAI API, enabling the application to perform NLP tasks.

Setting Up Express Server

Create another file on your project root called server.js.

const express = require('express');
const { openai, supabase } = require('./utils');

const app = express();

app.use(
  express.urlencoded({
    extended: true,
  })
);

const MessagingResponse = require('twilio').twiml.MessagingResponse;

app.post('/incoming', async (req, res) => {
  const message = req.body;

  const twiml = new MessagingResponse();
  // We'll create a function to reply for the incoming message here later
  const aiReply = await reply(message.Body);

  twiml.message(aiReply);
  res.status(200).type('text/xml');
  res.end(twiml.toString());
});

app.listen(3000, () => {
  console.log('Express server listening on port 3000');
});

The above code consists of 4 core steps:

Importing Twilio helper package: we are using the MessagingResponse constructor to create an instance of a TwiML (Twilio Markup Language) response.
Initializing Express App: We're creating a web server using Express to listen for POST requests to /incoming route. This route will act as our Twilio WhatsApp webhook to receive incoming messages.
Incoming Request: The incoming request body has a property called Body, which will contain the text message the user sent via WhatsApp to the Twilio server. This message will then be forwarded to our web server.
Webhook Response: Finally, our web server will respond with a reply generated using OpenAI.

Writing the Reply Function

Let's create the reply function in the server.js file so that we can transmit the incoming message to the OpenAI Chat Completions endpoint.

const chatMessages = [
  {
    role: 'system',
    content: 'reply to the messages you get in 100 character',
  },
];

async function reply(msg) {
  chatMessages.push({
    role: 'user',
    content: msg,
  });
  const response = await openai.chat.completions.create({
    messages: chatMessages,
    model: 'gpt-3.5-turbo',
    max_tokens: 300,
    temperature: 0.5,
    frequency_penalty: 0.5,
  });
  return response.choices[0].message.content;
}

We call this function inside our web server, as you saw earlier. The req.body.Body argument is passed to the reply function as the msg parameter. Then, we respond to it using the OpenAI Chat Completions endpoint.

Now, our web server will look like:

const express = require('express');
const { openai, supabase } = require('./utils');

const app = express();

app.use(
  express.urlencoded({
    extended: true,
  })
);

const MessagingResponse = require('twilio').twiml.MessagingResponse;

app.post('/incoming', async (req, res) => {
  const message = req.body;

  const twiml = new MessagingResponse();
  const aiReply = await reply(message.Body);

  twiml.message(aiReply);
  res.status(200).type('text/xml');
  res.end(twiml.toString());
});

app.listen(3000, () => {
  console.log('Express server listening on port 3000');
});

const chatMessages = [
  {
    role: 'system',
    content: 'reply to the messages you get in 100 characters',
  },
];

async function reply(msg) {
  chatMessages.push({
    role: 'user',
    content: msg,
  });
  const response = await openai.chat.completions.create({
    messages: chatMessages,
    model: 'gpt-3.5-turbo',
    max_tokens: 300,
    temperature: 0.5,
    frequency_penalty: 0.5,
  });
  return response.choices[0].message.content;
}

Now, return to your terminal and execute the following command:

node server.js

If you have configured everything correctly, as we mentioned. You will see this message printed on the console.

Express server listening on port 3000

But there is a problem. Your web server is currently running locally on your computer. As a result, Twilio will not be able to access our webhook endpoint.

This is where we need to use Ngrok to expose our local server to the internet. If you haven't used it before, Twilio has already provided instructions on how to install and configure it on your machine. Once it's done (assuming the local server is still running), open another terminal in the same path and execute:

ngrok http 3000

This will expose our server to the internet. From the terminal, you can copy the forwarding URL with HTTPS and paste it into Twilio WhatsApp Sandbox settings. Don't forget to add the /incoming route at the end and set the method to POST, then click Save.

Now, go back to the Twilio Whatsapp Sandbox tab and scan the QR code.

From your WhatsApp, now you can chat with our AI just as you would normally with ChatGPT.

Adding Knowledge base

A big challenge of working with embeddings is that traditional relational databases like MySQL or PostgreSQL cannot handle the complexity and scale of all that data. Therefore, AI engineers need a specialized storage system to efficiently handle high-dimensional vectors, and that's where vector databases come in.

For this project, we're going to use PostgreSQL. Wait a second, did we just say it's not possible with it? Yes, but we are going to give it some superpowers with the help of an extension called pgvector. Which is already available in Supabase Extension store.

Now, let's create a table to store the vectors. Copy and paste the following code into your SQL editor, Which you can find it with in the supabase.com/dashboard/project/<your-project-id>/sql/new. This editor allows you to write and run SQL queries and scripts on your database.

create extension vector;

create table movies (
  id bigserial primary key,
  content text, -- corresponds to the "text chunk"
  embedding vector(1536) -- 1536 works for OpenAI embeddings
);

-- Function to find similar movies based on cosine distance with adjustable threshold and count.
create or replace function match_movies (
  query_embedding vector(1536),
  match_threshold float,
  match_count int
)
returns table (
  id bigint,
  content text,
  similarity float
)
language sql stable
as $$
  select
    movies.id,
    movies.content,
    1 - (movies.embedding <=> query_embedding) as similarity
  from movies
  where movies.embedding <=> query_embedding < 1 - match_threshold
  order by movies.embedding <=> query_embedding
  limit match_count;
$$;

You don't need to feel overwhelmed by this SQL query. it's already available in the Supabase docs. We have simply optimized the naming for movies.

The above code consists of 3 core steps:

Enabling pgvector: Initially, we activate the pgvector extension for our PostgreSQL database to enable the use of the vector type for our embedding column.
Similarity Search: The match_movies function, which we will utilize later, checks the similarity of vector embeddings between the user query and the vector embeddings in the database.
Cosine Similarity: Recommended by OpenAI for their model text-embedding-ada-002. The model has 1536 dimensions for each text.

If everything runs successfully, you will see Success: No rows returned in the result.

Now, it's time to store some vector embeddings in the database.

Adding Vector Embeddings

Amazon recommends products, Google shows results based on your queries, YouTube, Netflix, and Spotify recommend your favorites. They don't understand the context between two titles or products, even if they mean the same thing. They truly get us with the help of AI.

To be exact, with the help of embeddings. When an embedding is created for a word, the vectors preserve its original meaning and the relationship between other words and phrases.

It is just a numerical snapshot of data. A word, sentence, or an entire document can be reduced to a vector. Now as developers, it might be easier to think of a vector as an array of floating-point numbers.

Let's create a new file in the root called data.js. This is where we are going to add the data for our chatbot to Supabase Vector DB.

// data.js
const movies = `Welcome to Redville: 2023 | 1h 30m | 4.8 rating | Genre: Crime, Drama, Mystery & thriller......`;

const { supabase } = require('./utils');
const { RecursiveCharacterTextSplitter } = require('langchain/text_splitter');
const { createEmbedding } = require('./utils');

async function splitDocuments(content) {
  const splitter = new RecursiveCharacterTextSplitter({
    chunkSize: 200,
    chunkOverlap: 10,
  });

  const output = await splitter.createDocuments([content]);

  const data = await Promise.all(
    output.map(async ({ pageContent }) => ({
      content: pageContent,
      embedding: await createEmbedding(pageContent),
    }))
  );

  await supabase.from('movies').insert(data);
}

splitDocuments(movies);

The above code consists of 3 core steps:

Knowledge base: We have generated some content for you, which includes movies where AI models like chatGPT have no prior knowledge. You can find this content in this GitHub repository. Simply copy and assign it to the movies variable inside backticks.
Add Content: To insert content and embeddings into Supabase, you can use the Supabase insert method. The data array is passed to the insert method, sending all the data to Supabase in a single batch. When adding the data, ensure that the data properties match the column names in the movies table.
Split Text into Chunks: When creating embeddings from large text documents, it's beneficial to first break the text into smaller chunks. This ensures that the AI model can effectively capture and understand the context to providing more accurate results. That's why we are using the RecursiveCharacterTextSplitter from Langchain.

And createEmbedding is a new utility function in our utils.js:

async function createEmbedding(input) {
  const response = await openai.embeddings.create({
    model: 'text-embedding-ada-002',
    input,
    encoding_format: 'float',
  });
  return response.data[0].embedding;
}

module.exports = { openai, supabase, createEmbedding };

This is how you call the OpenAI's embedding model text-embedding-ada-002, that generates text embeddings.

Required Props: The model and input are required properties in the request body. And if you want to include multiple inputs in a single request you can pass an array on strings.
Similarity Check: This embedding model is well-trained to understand language. It can embed words and phrases with similar meanings into a similar vector space and the ones that are not alike into a different vector space.

Now, open your terminal and execute:

node data.js

This will store our movie data in our vector database as text chunks, and each chunk will point to a vector embedding of 1536 dimensions.

Next, we need to compare the embedding created from the text message you sent with the vectors in our database to find a similar match and retrieve the corresponding text.

This is where our special function comes into play. We will be utilizing an algorithm to measure the similarity between two vectors, known as cosine similarity. Supabase, with the pg vector extension makes the comparison and processing of vectors easy and fast with the match_movies SQL function we saw earlier.

const { data: movies } = await supabaseClient.rpc('match_movies', {
  query_embedding: embedding, // Embedding you want to compare
  match_threshold: 0.78, // min threshold (78%)
  match_count: 1, // limit no of matches
});

So, let's make some changes to our server.js file:

const express = require('express');
const { openai, createEmbedding, supabase } = require('./utils');

const chatMessages = [
  {
    role: 'system',
    content: `You are an enthusiastic movie expert who loves recommending movies to people. You will be given two pieces of information - some context about movies and a question. Your main job is to formulate a short answer to the question using the provided context. If you are unsure and cannot find the answer in the context, say, "Sorry, I don't know the answer." Please do not make up the answer.`,
  },
];

async function findNearestMatch(query_embedding) {
  const { data: movies } = await supabase.rpc('match_movies', {
    query_embedding,
    match_threshold: 0.78,
    match_count: 1,
  });

  // No match returns []
  return movies.length > 0 && movies;
}

async function reply(msg) {
  const embedding = await createEmbedding(msg);
  const movies = await findNearestMatch(embedding);

  if (!movies) return 'No match found. Please try again.';

  chatMessages.push({
    role: 'user',
    content: `Context: ${movies[0].content} Question: ${msg}`,
  });

  const response = await openai.chat.completions.create({
    messages: chatMessages,
    model: 'gpt-3.5-turbo',
    max_tokens: 300,
    temperature: 0.5,
    frequency_penalty: 0.5,
  });
  return response.choices[0].message.content;
}

const app = express();

app.use(
  express.urlencoded({
    extended: true,
  })
);

const MessagingResponse = require('twilio').twiml.MessagingResponse;

app.post('/incoming', async (req, res) => {
  const message = req.body;

  const twiml = new MessagingResponse();
  const aiReply = await reply(message.Body);

  twiml.message(aiReply);

  res.status(200).type('text/xml');
  res.end(twiml.toString());
});

app.listen(3000, () => {
  console.log('Express server listening on port 3000');
});

The above code consists of 2 core steps:

Execute match_movies function: The function named findNearestMatch searches through our supabase database to locate the closest matching text chunk based on the provided embedding.
Add ChatGPT Wrapper: We can achieve more dynamic and conversational response by sending the matched text to OpenAI’s chat completion endpoint and instructing the model to formulate a specific answer.

Now, if you haven't stopped the server, restart it. Each time Ngrok will give you a new forwarding URL, so make sure you update the webhook URL in the WhatsApp sandbox settings with your new one. Don't forget to add the /incoming route at the end.

Now, let's have a chat with the final version of our WhatsApp chatbot:

Conclusion

This tutorial demonstrates the many possibilities of using OpenAI to automate various tasks. Instead of just having a textual conversation, we could also add a feature to input commands like /img your prompt for image generation or a piece of text to convert it into speech. The possibilities are endless.

What would you like to add next to this Whatsapp chatbot?

If you have some crazy ideas in mind make sure to reach out me on linkedin

Peace ✌️

A Twitter Bot for Personalized Replies to Your Followings and Targeted Keywords!

Sojin Samuel — Mon, 05 Jun 2023 03:16:25 +0000

Just built another Twitter bot for my client.

This bot replies to tweets posted by the people client followed && also searches for tweets containing specific keywords that comes under the client niche and replies to them. Reply were generated using gpt 3.5 turbo.

Screen Recording of the working bot in practice (The one i sent to my client):

https://drive.google.com/file/d/1C8XnzaSemB3TsUraJOLLUiwoua-Q7UvY/view

If you want to automate your tasks too, I am open to new Twitter bot ideas.

Stacking Context Mastery: Understanding and Troubleshooting Z-Index in CSS

Sojin Samuel — Sat, 28 Jan 2023 12:46:57 +0000

Are you tired of struggling with stacking context and z-index in your CSS?

As a web developer, understanding these concepts is crucial for achieving the desired visual hierarchy in your designs.

Unfortunately, many tutorials and articles fail to cover this topic in depth, leaving many developers feeling lost and frustrated.

I am excited to announce that I have created a comprehensive guide on stacking context and z-index, today on gumroad.

This will completely change the way you approach the visual hierarchy of your website.

Through extensive research and practical examples, I have made it easy for you to grasp these essential concepts. The guide includes code pen examples and interactive challenges to ensure retention of the material.

Unlike many tutorials, my guide delves into the fundamentals of stacking context before diving into the intricacies of z-index. This approach ensures a solid foundation for understanding and troubleshooting these crucial elements of CSS. The guide covers the following topics:

This guide is free for 7 days and i want you to try it out and i am sure that it will be worth while.

Check it out and let me know, how was this guide.

You will find the complete outline of this guide on the home page.

DEV Community: Sojin Samuel

My Journey Deploying a Full-Stack Node.js App to AWS using Pulumi

What I Built

Live Demo Link

Project Repo

sojinsamuel / pulumi-video-converter-deploy

Video to Mp3 converter Project Deployed to AWS via Pulumi

☁️🚀 Deploy Video-to-MP3 Converter to AWS with Pulumi 🎬🎵

🏗️ Architecture Overview

Tutorial Starter Repo

My Journey

Step 1: Create Your Main Project Directory

Step 2: Clone the Application Code

Step 3: Remove Nested .git Directory (Important!)

Step 4: Install App Dependencies & Test Locally (Optional)

Step 5: Initialize Pulumi for Infrastructure

Step 6: Configure AWS Credentials

Step 7: Write the Pulumi Infrastructure Code (index.ts)

Step 8: Initialize Git & Push Our Project to GitHub

Step 9: Configure Pulumi Stack (Repo URL & Key Pair)

Step 10: Deploy to AWS!

Step 11: Verify Your Deployment

Wrap Up

💰 Cost Considerations

🤔 Using Pulumi: Lessons Learned & Copilot Assistance

What's Next?

Pulumi is the first ever IaC, i've ever tried + Pulumi Copilot is the perfect cherry on top to make the development much easier. Thanks a lot Team Pulumi

Fast-Track Your Static Site: Deploying Hugo with Pulumi on AWS S3

Fast-Track Your Static Site: Deploying Hugo with Pulumi on AWS S3

What I Built

Live Demo Link

Project Repo

sojinsamuel / pulumi-hugo-aws

A fast static website deployment using Hugo and Pulumi on AWS S3, with a step-by-step tutorial for the Pulumi Deploy and Document Challenge.

Hugo and Pulumi Static Website Deployment on AWS S3

Table of Contents

Live Demo

Project Overview

My Journey

Step 1: Install Pulumi CLI

Step 2: Set Up Your Project Directory

Step 3: Create a Hugo Site

Step 4: Create a Pulumi Project

Step 5: Configure AWS Credentials

Step 6: Install Dependencies

Step 7: Write Pulumi Code

Step 8: Build Hugo Site

Step 9: Deploy with Pulumi

Step 10: Verify the Deployment

Project Structure (Key Files Only)

Wrap Up

Using Pulumi

What's Next?

Notes

Win Up to $1200 in the InfinityAI Halloween Challenge 🎃

What is the InfinityAI Halloween Challenge?

October Challenge Details

Why Enter? Prizes and Community

How to Participate

Ready to Join?

Networking cant be easier than this

What I Built

Demo

Twilio and AI

Additional Prize Categories

TweetGagger Plugin: getLikes, getRetweets, getReplies

What I Built

Demo

Journey

Tweet Media Extractor Plugin

What I Built

Demo

Journey

Randomly Picks a Giveaway Winner on Twitter (Oops X)

What I Built

Demo

Your Configuration

Journey

This Bot Downloads Media from any Tweet and Set Reminders for Future reference

What I Built

Step 3: Remove Nested `.git` Directory (Important!)

Step 7: Write the Pulumi Infrastructure Code (`index.ts`)