Forem: Gilbert Young Jr

Generative AI : What is it & Why you should care?

Gilbert Young Jr — Wed, 19 Feb 2025 17:43:27 +0000

There's been a lot of hype around AI lately, particularly since OpenAI released their GPT model and speculations that the AI race wars might lead to AGI (Artificial General Intelligence). However, with any disruptive product launch, we tend to underestimate its true potential or have a general lack of understanding. Generative AI can be confusing, but in this article, I'll cover everything you need to know:

Full Disclaimer : Please note that I'm not an AI expert, and this is simply my opinion based on personal experiences.

What is Generative AI?

I'm pretty sure you've seen the clips of AI Drake dropping bars and wondered how this is possible. Well, that's exactly the power of Generative AI. It's a type of computer intelligence program that can create original content such as text, images, or audio without the need for human input. This is achieved using transformer models which learn by selectively focusing on relevant parts of the input/training data, a process called the attention mechanism. Transformer models were first introduced in the famous paper, Attention is All You Need, which was published by a team at Google

Why should you care about AI?

The pace of AI development is rapidly accelerating, and its impact on our work and daily lives is already significant. With AI assistants, developers and engineers can write higher quality code, while content creators can craft compelling scripts. Given this, it's essential to have a basic understanding of AI's capabilities to leverage these tools effectively for your advantage. This shift is similar to the .com era, where those who lacked computer skills struggled to stay relevant in the workforce. Regrettably, failure to adapt and learn could leave you behind in this rapidly evolving landscape.

How can I learn to use Generative AI?

As with any technology, the best way to learn is to build. Building real-world projects and implementing AI algorithms to solve them. This provides practical experience and a deeper understanding of how AI works. Identify a real-world problem that you are interested in solving and brainstorm ways to use AI to solve it. Here's a million-dollar idea: how about creating an AI therapist chatbot for engineers to help them de-stress? I mean, we work tirelessly to keep up with the tech race, so why not give us a virtual shoulder to cry on? 🥲

There are also pre-trained models for tasks like text classification, text to image, text to video available from companies such as

HuggingFace : BERT
Amazon: Amazon Bedrock
OpenAI : GPT-3 and many other APIs for NLP tasks

Another under appreciated method is to deep-dive into the public research papers about AI. Oftentimes, these papers contain a wealth of information about the development of cutting-edge models and breakthroughs in the field.

Conclusion

I feel fortunate to be alive in this generation since these are exciting times. As an optimist, I am thrilled to see where AI will take us in the future and hope to be apart of the change as well. While there is some bias against AI, there is truth to the concern that unregulated AI could be harmful. However, I believe that heavily regulating AI could constrain creativity and slow progress.

AWS Community Builders - Christmas Edition

Gilbert Young Jr — Tue, 20 Dec 2022 09:56:02 +0000

What surprises you most about the community builders program?

It is phenomenal how many sharp-witted talented individuals are in the Community Builders program and everyone is so willing to share their knowledge. It really feels like we are one big family of engineers.

What’s your background and your experience with AWS?

Originally, I was a Busincess Science major in College until I made a risky decision to program switch to Computer Science. Long story short, I was lucky and got a remote software engineer job in Belize during my second semester of college. The company had an enterprise support plan and was a part of the AWS Partner Network. I was introduced to AWS by the Account Manager and Solution Architects through Immersion Days. I was immediately inspired by the power of the cloud. My curiosity led me to start building small side projects on AWS.

Fast forward to today, I am now a Serverless Developer who's on the journey of making a career transition to become a Data Scientist. I would describe my experience with AWS as intermediate, there is always room for improvement. Learning never stops!

What’s the biggest benefit you see from the program?

I would say the best benefit of the program is accessibility to a comprehensive network and vast learning resources.

What’s the next swag item that you would like to get?

I would love to have a CB Bomber Jacket!

What are you eating for dinner today? Share the recipe!

Tacos

Corn tortilla
Beef
Cheese
Tomatoes
Onion
Cilantro

Is there anything else you would like to say about the community builders program in 2022?

Many thanks for giving us the resources and a platform for us to educate and influence others in our local communities and international.

AWS re:Invent reCap 2022

Gilbert Young Jr — Fri, 16 Dec 2022 16:04:10 +0000

Now that I am home and well rested, I can finally share what my experience was at re:Invent. This blog is a recap of my trip in the form of answering top questions I got asked.

What is AWS re:Invent?

AWS re:Invent is one of the largest IT conferences in the world hosted by Amazon. Whether you are new to the cloud, just learning the cloud, or running hundreds of production workloads in the cloud it does not matter re:Invent is beneficial for all. Conference attendees have access to workshops, break-out sessions, labs, keynote speeches, insights into new product launches and much more.

How did I get to go to re:Invent?

I was selected as an All Builders Welcome Grant recipient. The ABW Grant Program is geared towards giving underrepresented communities and minority groups the opportunity to learn, network and grow at re:Invent. The All Builders Welcome Grant includes registration for re:Invent 2022; airfare to Las Vegas, Nevada; hotel accommodations for the duration of the conference, reserved seating in keynotes, special dinner receptions, uber gift cards and much more! There is also the possibility of being recruited for job roles by companies that sponsor the program. Application for the program is fairly simple, all you need to do is justify why you want to be apart of the program and identify as a part of a minority group. At the moment, the application form for this program is currently closed and will re-open in mid 2023. If you need assistance in drafting your application please feel free to contact me on LinkedIn.

How did I get invited to AWS Build on Live Twitch stream?

AWS Build on Live is a Twitch channel that streams technical sessions to help solve challenges practitioners currently face. I cannot say for certain if there was one specific action that got me invited on the show. It was a series of actions and events. It all started with having a passion to get more Belizeans actively involved in technology and spreading awareness about the lack of STEM opportunities in Belize. Acting on this goal, led me to start the first ever AWS User Group in Belize with the help of my colleagues at ThinkTech Ltd. Consequently, I got the opportunity to meet some amazing AWS employees from the Build on Live team (Du'An Lightfoot, Curtis Evans, Darko, Jacquie Grindrod, Jessica Zhu) to name a few. The team saw my vision and supported me by giving me a platform for my voice to be heard. In a separate blog, I will deep dive into how I built the StockX Price Predictor application I demoed on the show. In a nutshell, you can get invited on the show if you are recognized as a passionate individual who shares real life experiences and solutions to help others through their technical career.

How can I get involved in an AWS Community Program?

AWS has so many amazing community programs, but I will only explain the following 4 programs. Some benefits of joining an AWS Community Program include discounted vouchers for re:Invent tickets, vouchers for certification exams, early access to new AWS Services and ofcourse plenty of SWAG.

AWS Community Builders
The AWS Community Builders Program accepts application twice per year. You can increase your chances of getting in the program if you display strong values of being an evangelist and helping others on their learning journey in the cloud.
AWS User Groups
AWS User groups are peer-to-peer communities which meet regularly to share ideas, answer questions, and learn about new services and best practices for development on AWS. Most User Groups do not have a strict requirement regarding becoming a member. Find a user group near you and join the community today. While you are it please feel free to also join the AWS Belize User Group.
AWS Heroes
The Heroes program are selected candidates who express expert knowledge about AWS. Heroes pushes the limit to share knowledge regarding AWS whether it be blogs, open source projects, videos, online/ in-person conferences, etc. I believe there is no application process to become a hero, heroes are nominated by AWS employees.
AWS Student Hub
This is an early program purpose built to benefit all students, internationally and locally. Cloud Clubs allow you to network, attend career building events, host hackathons, earn benefits such as AWS credits and certification exam vouchers, and more. Applications will open soon for this selective program. If you need more information regarding the program you can contact Jen Looper.

What new launches were you most excited about?

SageMaker Geospatial ML
SageMaker now supports the ability to access geospatial data such as satellite images, maps and location routes. Having access to this rich data can drive innovative new ideas.
AWS Application Composer
As an engineer my daily job duties revolve around working with IaC tools (CloudFormation, Terraform, AWS SAM), so it is no surprise that AWS Application Composer is one of my favorite launches. The tool allows developers to visually build and design serverless applications rapidly by using an intuitive drag and drop feature. Some benefits of AWS Application Composer are, it provides a visual representation of your application architecture and manages your infrastructure using IaC (Infrastructure as Code)

I do hope this article helps you understand what re:Invent is, the different community programs AWS offers, and how you can also be a part of re:Invent 2023. If you have any questions or want to have a chat please feel free to reach out to me on LinkedIn or on Twitter.

SageMaker Data Ingestion using Kaggle

Gilbert Young Jr — Thu, 17 Nov 2022 23:36:17 +0000

Recently, I have been focusing on learning AI/ML. After overcoming many roadblocks and mistakes, I can now confidently share a successful solution.

I intend to explain one specific foundation of ML which is data ingestion. I will demonstrate how you can import a Kaggle dataset into a SageMaker Studio notebook. Amazon SageMaker is a ML tool that enables developers to rapidly create, train, and deploy machine-learning models in the cloud. Kaggle is an online community platform that has numerous datasets and ML challenges for data scientists and machine learning enthusiasts. You can clearly see how both tools can complement each other if integrated properly.

Prerequisite

A SageMaker Studio Notebook is needed. If you don't have one already, you can follow this guide to create one.
A Kaggle account is needed, you can register for one here.

🛠 Let's build!!

First we will import the python packages that will be used in the notebook.

Import Packages

import pandas as pd
import time

Install Kaggle CLI

!pip install --q kaggle

To use Kaggle API, you must have an account and an API token. You can follow this guide to generate your API token, it is completely free. The command below creates a json file to store your Kaggle credentials. Insert your username and API Key in the code blocks.

!touch ~/.kaggle/kaggle.json # Creates json file to store Kaggle API Credentials
kaggle_api_token = {"username":"<username>","key":"<api_key>"}  # Insert your own username and API Key here

We then write our kaggle credentials to the json file we created.

import json 

# Writes API Credentials to Kaggle file
with open('/root/.kaggle/kaggle.json', 'w') as file: 
    json.dump(kaggle_api_token,file)

For security reasons, we must ensure that other users do not have read access to our Kaggle credentials.

!chmod 600 ~/.kaggle/kaggle.json

Since our access token is now configured we can list the available datasets.

!kaggle datasets list # List available datasets

If the above command was successful, you will see a list of available datasets.

The below command downloads the dataset you specified. You can change this name to any of the names returned in the list of datasets. Downloading the dataset might take some time depending on your network connection.

%%time

!kaggle datasets download -d iamsouravbanerjee/game-of-thrones-dataset --unzip # Downloads & Unzip dataset

Now that the dataset is downloaded, let us visualize what the csv file looks like. We will use pandas to load and display the data.

data = pd.read_csv("Game_of_Thrones.csv", header=0)
df = data.copy()
df.head()

Github Repo

You can find the complete SageMaker Studio Notebook on my GitHub.

Additional Features

This was a simple demonstration of data ingestion, you can build on this solution by extracting insights from the data using pandas or perhaps training an ML model. If you do, please feel free to share your project with me.

Stay curious, keep learning and keep building!!!

How to create a Python Lambda Layer?

Gilbert Young Jr — Tue, 25 Oct 2022 17:40:46 +0000

In this article I intend to explain what a Lambda Layer is, the benefits of it, and lastly, how to create a Layer for a Python Lambda function.

What is a Lambda Layer?

A Lambda Layer is an isolated zip file that contains libraries, packages and/or application code that is shareable between your Lambda functions. A common use case for a Lambda Layer is, for example your company has two separate Python Web Scrapers. Both functions use pandas to do some sort of data processing. Since they both use the same Python packages, the smart solution is to create a Lambda Layer, so both functions can access the Layer. Below is a visual from AWS that shows a solution with Lambda Layers vs without Lambda Layers.

Benefits of Lambda Layers

Reduces the size of uploaded deployment archives.
Increases the speed of deployment.

Creating a Python Lambda Layer

We will create the layer using an EC2 Instance that will be provisioned by IaC (CloudFormation). I know what you are thinking. Why do we need an EC2 Instance to simply create a Lambda Layer? Why not just do it locally? The architecture for a Python Lambda Layer requires a Linux OS. Doing it on a Linux EC2 Instance helps us meet the following requirements:

AWS Lambda runs on a Linux machine
Any Python Packages added to the Layer need to be compiled with the correct architecture (Linux x86_64).

You can find the complete CloudFormation template on my GitHub.

Create stack parameters

---
Parameters:
  InstanceName:
    Type: String
    Description: Enter the name of your instance.
    Default: LinuxInstance

The only parameter we will be using is for our instance name.

Create IAM Role & Instance Profile

# Instance Profile
  InstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties:
      InstanceProfileName: !Join ["_", [!Ref InstanceName, "Profile"]]
      Path: /
      Roles:
        - !Ref InstanceRole

  # Instance Role
  InstanceRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: !Join ["_", [!Ref InstanceName, "EC2PublishLambdaLayer"]]
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - ec2.amazonaws.com
            Action:
              - sts:AssumeRole
      Path: /
      Policies:
        - PolicyName: !Join ["_", [!Ref InstanceName, "Policy"]]
          PolicyDocument:
            Version: "2012-10-17"
            Statement:
              - Effect: Allow
                Action: "lambda:PublishLayerVersion"
                Resource: "*"

NOTE: The Policy Document contains the action lambda:PublishLayerVersion, without this policy we will not be able to publish the Lambda Layer from within the EC2 Instance.

Create EC2 Instance

 # EC2 Instance
  Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: ami-09d3b3274b6c5d4aa # Static AMI ID chosen from List of AMIs in the console
      InstanceType: t2.micro
      IamInstanceProfile: !Ref InstanceProfile
      SecurityGroups:
        - !Ref SSHSecurityGroup
      # Install Python, Pandas and Publish Lambda Layer
      UserData:
        Fn::Base64: |
          #!/bin/bash 
          sudo amazon-linux-extras install python3.8
          curl -O https://bootstrap.pypa.io/get-pip.py
          python3.8 get-pip.py --user
          mkdir -p home/ec2-user/python
          cd home/ec2-user
          python3.8 -m pip install pandas -t python/
          zip -r layer.zip python
          aws lambda publish-layer-version --layer-name pandas-layer --zip-file fileb://layer.zip --compatible-runtimes python3.8 --region us-east-1
      Tags:
        - Key: Name
          Value: !Ref InstanceName

If you look at the UserData property, we are passing bash scripts. This is where the magic happens. We defined scripts to install Python and pandas. We then zip the directory that has the Python Package and lastly publish the Lambda Layer to AWS.

Upload CF Stack

To upload your CF stack, use the command below.

aws cloudformation deploy 
--template-file <path_to_file> 
--stack-name <stack_name> 
--region us-east-1 
--capabilities CAPABILITY_NAMED_IAM

If the above command is successful, you will get an output in your terminal saying "Successfully created/updated stack - ". The stack should take a few minutes to provision our EC2 Instance and execute our scripts. Lastly, navigate to Lambda Layers in the AWS console and you should see the Layer that was created.

Clean Up

To clean up all the resources that were created simply delete the CloudFormation stack.

aws cloudformation delete-stack 
--stack-name <stack_name>

I hope you found this article useful. Stay curious, keep learning, and keep building. Thank you.

How I got into the AWS Community Builders Program

Gilbert Young Jr — Wed, 14 Sep 2022 21:12:00 +0000

What is the AWS Community Builders Program?

The Community builders program is a group of passionate developers from all around the world. The program offers technical resources, education and networking opportunities to AWS technical enthusiasts.

Program Benefits

The program has many benefits such as

$500 AWS Credits
1 yr free subscription to Cloud Academy
AWS Certification Exam Vouchers
Service Beta Opportunities
Swag Kit

Application Process

AWS accepts application for the program biannually. You can submit your name on the program waitlist to be notified as soon as applications open next year 2023. From my knowledge, there is no single specific criteria for being accepted into the program; however, sharing
accurate technical content (videos, blogs, online meetups, etc) that helps other builders learn more about AWS Services increases your chances of getting accepted.

Here is my personal journey and how I made it into the program. I learned very early on that documentation is very important. Whether I was preparing for an AWS certification exam, learning about a new AWS service, or building a new application on AWS I documented and tracked the process.

Documentation can be done in various forms, writing notes, writing a blog, sharing solutions on a forum, video tutorials, etc. Sharing what you learned with the public has many benefits. It reinforces the concepts you learned, allows other to provide insights or enhance your solution, and it will assist others who are working through their own journey. These are only a few of the benefits of community sharing/learning.

The key takeaway here is, whatever you are working on or learning, share it. Do not learn or build in silos.

I hope you can take insights/tips from my own personal experience to strengthen your chances of also becoming an AWS Community Builder.

If you have any further questions or would love to chat. Please feel free to reach out to me on LinkedIn or Twitter

Install an Apache Web-Server on EC2 using IAC

Gilbert Young Jr — Sat, 16 Jul 2022 22:33:35 +0000

In this tutorial I will give you a guided walk-through on how to install an Apache Web Server on an EC2 Linux Instance using EC2 user data. All resources will be provisioned by CloudFormation (IAC). With that being said, let's get straight into it.

Define our parameters to be used in our CloudFormation Stack.

---
Parameters:
  AppName:
    Type: String
    Description: Enter the name of your resource you are creating.
    Default: ApacheWebServer
  Stage:
    Type: String
    Description: Enter the staging environment of you resource.
    Default: dev

We then define our resources. The resources that we need are, an SSH Key, an EC2 Instance and a Security Group.

Resources:
  ## Our EC2 SSH Key
  SSHKey:
    Type: 'AWS::EC2::KeyPair'
    Properties:
      KeyName: !Join ['-', [!Ref AppName, 'key-pair', !Ref Stage] ]

  ## EC2 Instance    
  MyInstance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: ami-009d6802948d06e52
      InstanceType: t2.micro
      KeyName: !Ref SSHKey
      SecurityGroups:
        - !Ref SSHSecurityGroup
      # we install our web server with user data
      UserData: 
        Fn::Base64: |
          #!/bin/bash -xe
          yum update -y
          yum install -y httpd
          systemctl start httpd
          systemctl enable httpd
          echo "Hello World from user data" > /var/www/html/index.html
      Tags:
        - Key: Name
          Value: !Ref AppName
        - Key: Environment
          Value: !Ref Stage


  # Our EC2 security group
  SSHSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: SSH and HTTP
      SecurityGroupIngress:
      - CidrIp: 0.0.0.0/0
        FromPort: 22
        IpProtocol: tcp
        ToPort: 22
      - CidrIp: 0.0.0.0/0
        FromPort: 80
        IpProtocol: tcp
        ToPort: 80

Note: The key take away here is the block of code we wrote for user data. We are using "Fn::Base64" followed by a vertical pipe to pass an entire bash script to the instance. The vertical pipe is used so the script can be recognized as one string.

Complete Template File

---
Parameters:
  AppName:
    Type: String
    Description: Enter the name of your resource you are creating.
    Default: ApacheWebServer
  Stage:
    Type: String
    Description: Enter the staging environment of you resource.
    Default: dev

Resources:
  ## Our EC2 SSH Key
  SSHKey:
    Type: 'AWS::EC2::KeyPair'
    Properties:
      KeyName: !Join ['-', [!Ref AppName, 'key-pair', !Ref Stage] ]

  ## EC2 Instance    
  MyInstance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: ami-009d6802948d06e52
      InstanceType: t2.micro
      KeyName: !Ref SSHKey
      SecurityGroups:
        - !Ref SSHSecurityGroup
      # we install our web server with user data
      UserData: 
        Fn::Base64: |
          #!/bin/bash -xe
          yum update -y
          yum install -y httpd
          systemctl start httpd
          systemctl enable httpd
          echo "Hello World from user data" > /var/www/html/index.html
      Tags:
        - Key: Name
          Value: !Ref AppName
        - Key: Environment
          Value: !Ref Stage


  # Our EC2 security group
  SSHSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: SSH and HTTP
      SecurityGroupIngress:
      - CidrIp: 0.0.0.0/0
        FromPort: 22
        IpProtocol: tcp
        ToPort: 22
      - CidrIp: 0.0.0.0/0
        FromPort: 80
        IpProtocol: tcp
        ToPort: 80

Upload CloudFormation Stack to the console.

First, navigate to the directory where you have your template file stored. You can use the below terminal command to upload your stack to AWS.

aws cloudformation deploy 
  --template-file <TEMPLATE NAME> 
  --stack-name <STACK NAME> 
  --profile <AWS PROFILE NAME>

If the stack was uploaded successfully, you should see this message "Successfully created/updated stack - ".

Navigate to AWS Console

If you are in the console, go to EC2 Dashboard, you should see the instance you created. Select the instance and click on connect. Connect to the instance using EC2 Instance Connect.

Inspect Cloud Init Logs

Now we are going to inspect the logs to view the scripts that ran when the instance was booted up.

First, we need root privileges. Execute the following command so we can have root privileges in our instance.

sudo su

Second, we're gonna run the command to view the actual log files.

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

Now you should be able to see a complete list of logs from the scripts that were executed.

Lastly, to test that our web server is properly hosting our html web page. You can copy the public DNS of the instance, paste it in your web browser. By doing this you should be able to access the web page we created.

That's it, we successfully provisioned an EC2 instance and installed an Apache Web Server on it using user-data. Now, the last step is to clean up all the resources that were used.

Clean Up Resources
In your terminal execute the following command. Since, we created our resources using CloudFormation by deleting the stack, all resources that were in the stack will be deleted as well.

aws cloudformation delete-stack 
 --stack-name <STACK NAME>

This was just a small demonstration of what you can accomplish with EC2 user data. Please feel free to explore beyond this tutorial and add extra features.

I do hope this tutorial was useful for you. Stay curious, keep learning, and keep building. Thank you.

CloudFormation Template to Create a CI/CD Pipeline for a React application hosted in an S3 Bucket

Gilbert Young Jr — Tue, 24 May 2022 14:02:28 +0000

In this article, I will give a step-by step guide on how to create a CI/CD Pipeline for a React Web App hosted as a static website in a S3 Bucket.

Below is an architecture diagram illustrating the AWS services that were used to build this solution.

Now that you have reviewed the architecture, let's get straight into it.

Create React App

If you want to follow along with your own react application please feel free to do so. If not, head over to GitHub and clone the repo.

Creating buildspec file

Once you have the repo cloned, take a minute to review the buildspec.yml file, this file is used to provide AWS CodeBuild instructions on how to build our application. It has 4 stages, install, pre_build, build and post_build and lastly it output our artifacts files.
Note: The buildspec file is created at the root level inside your directory.

version: 0.2

phases:
  install:
    runtime-versions:
      nodejs: 16

  pre_build:
    commands:
      # install dependencies
      - echo installing dependencies...
      - yarn install

  build:
    commands:
      # run build script
      - echo Build started on `date`
      - echo Building React Application...
      - yarn build

  post_build:
    commands:
      - echo Build completed on `date`

artifacts:
  # include all files required to run application
  # we include only the static build files
  files:
    - "**/*"
   # reference directory where build file is located
  base-directory: "build"

Creating CloudFormation Template

Next, we'll look at our CloudFormation template that creates our resources for the pipeline.

First, we define our parameters. These will later be used as references in our code.

AWSTemplateFormatVersion: 2010-09-09
Description: This template is used to create a CI/CD Pipeline that deploys a React Web app to S3 for static website hosting.

# Parameters to be used through out the template
Parameters:
  Stage:
    Type: String
    Default: dev
  AppName: 
    Type: String
    Default: <APP NAME>
  GithubUserName:
    Type: String
    Default: <GITHUB USERNAME>
  GithubRepo:
    Type: String
    Default: <GITHUB REPO>
  GithubBranch:
    Type: String
    Default: <GITHUB BRANCH>
  GithubOAuthToken:
    Type: String
    Default: <GITHUB ACCESS TOKEN>

Next, we create IAM policies to give our resources adequate permissions.

# Create role for CodeBuild
  CodeBuildRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          - 
            Effect: Allow
            Principal:
              Service:
                - "codebuild.amazonaws.com"
            Action:
              - "sts:AssumeRole"
      Path: /service-role/
      Policies:
        - PolicyName: root
          PolicyDocument:
            Version: "2012-10-17"
            Statement: 
              - 
                Effect: Allow
                Action:
                  - "s3:GetObject"
                  - "s3:GetObjectVersion"
                  - "s3:GetBucketVersioning"
                  - "s3:PutObject"
                  - "s3:PutObjectAcl"
                  - "s3:PutObjectVersionAcl"
                Resource: 
                  - !GetAtt PipelineBucket.Arn
                  - !Join ['', [!GetAtt PipelineBucket.Arn, "/*"]]
              - 
                Effect: Allow
                Action:
                  - "s3:GetObject"
                  - "s3:GetObjectVersion"
                  - "s3:GetBucketVersioning"
                  - "s3:PutObject"
                  - "s3:PutObjectAcl"
                  - "s3:PutObjectVersionAcl"
                Resource: 
                  - !GetAtt DeployBucket.Arn
                  - !Join ['', [!GetAtt DeployBucket.Arn, "/*"]]
              -
                Effect: Allow
                Action:
                  - "logs:CreateLogGroup"
                  - "logs:CreateLogStream"
                  - "logs:PutLogEvents"
                  - "cloudfront:CreateInvalidation"
                Resource:
                  - "*"
      Tags:
        - Key: Name
          Value: !Join ['-', [!Ref AppName, !Ref 'AWS::AccountId', 'BuildRole', !Ref Stage]]


  # Create role for CodePipeline
  CodePipeLineRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          - 
            Effect: Allow
            Principal:
              Service:
                - "codepipeline.amazonaws.com"
            Action:
              - "sts:AssumeRole"
      Policies:
        - PolicyName: root
          PolicyDocument:
            Version: "2012-10-17"
            Statement: 
              - 
                Effect: Allow
                Action:
                  - "s3:GetObject"
                  - "s3:GetObjectVersion"
                  - "s3:GetBucketVersioning"
                  - "s3:GetObjectAcl"
                  - "s3:PutObject"
                  - "s3:PutObjectAcl"
                  - "s3:PutObjectVersionAcl"                  
                Resource: 
                  - !GetAtt PipelineBucket.Arn
                  - !Join ['', [!GetAtt PipelineBucket.Arn, "/*"]]
              - 
                Effect: Allow  
                Action:
                  - "codebuild:BatchGetBuilds"
                  - "codebuild:StartBuild"
                Resource: "*"
              - 
                Effect: Allow  
                Action:
                  - "codecommit:GetRepository"
                  - "codecommit:GetBranch"
                  - "codecommit:GetCommit"
                  - "codecommit:UploadArchive"
                  - "codecommit:GetUploadArchiveStatus"
                  - "codecommit:CancelUploadArchive"
                Resource: "*"                
      Tags:
        - Key: Name
          Value: !Join ['-', [!Ref AppName, !Ref 'AWS::AccountId', 'PipelineRole', !Ref Stage]]

After the policies we will create our build project for codebuild to use.

  # Create Code Build Project
  CodeBuild:
    Type: 'AWS::CodeBuild::Project'
    Properties:
      Name: !Sub ${AWS::StackName}-CodeBuild
      ServiceRole: !GetAtt CodeBuildRole.Arn
      Artifacts:
        Type: CODEPIPELINE
        Name: MyProject
      Source: 
        Type: CODEPIPELINE
      Environment:
        ComputeType: BUILD_GENERAL1_SMALL
        Type: LINUX_CONTAINER
        Image: aws/codebuild/amazonlinux2-x86_64-standard:3.0
      Source:
        Type: CODEPIPELINE
        # This file (buildspec.yml In Source code) contains commands to Create and Push a docker image to the ECR_REPOSITORY_URI
        BuildSpec: buildspec.yml

      Tags:
        - Key: Name
          Value: !Join ['-', [!Ref AppName, !Ref 'AWS::AccountId', 'BuildProj', !Ref Stage]]

We then create our pipeline which has 3 stages source, build and deploy.
Note: For the source declaration, I am using a third-party provider which is GitHub. You will need to generate an auth token from GitHub for AWS to use.

# Create CodePipeline with 3 stages (Source, Build and Deploy)
  CodePipeline:
    Type: 'AWS::CodePipeline::Pipeline'
    Properties:
      RoleArn: !GetAtt CodePipeLineRole.Arn
      Name: !Join ['-', [!Ref AppName, !Ref 'AWS::AccountId', 'CodePipeLine',!Ref Stage]]
      ArtifactStore:
        Location: !Ref PipelineBucket
        Type: S3

      # Stages declaration
      Stages:
     # Download source code from Github Repo to source-output-artifacts path in S3 Bucket
        - 
          Name: Source
          Actions: 
            - 
              Name: SourceAction
              ActionTypeId: 
                 Category: Source
                 Owner: ThirdParty
                 Provider: GitHub
                 Version: 1
              OutputArtifacts: 
                - 
                  Name: MyApp
              Configuration:                
                 Repo: !Ref GithubRepo
                 Branch: !Ref GithubBranch
                 Owner: !Ref GithubUserName
                 OAuthToken: !Ref GithubOAuthToken

        # Build the project using the BuildProject and Output build artifacts to build-output-artifacts path in S3 Bucket
        - 
          Name: Build
          Actions: 
            - 
              Name: BuildAction
              ActionTypeId: 
                Category: Build
                Owner: AWS
                Version: 1
                Provider: CodeBuild
              InputArtifacts: 
                - 
                  Name: MyApp
              OutputArtifacts: 
                - 
                  Name: MyAppBuild
              Configuration:
                ProjectName: !Ref CodeBuild

        # Deploy the project to S3 Bucket for website hosting.
        - 
          Name: Deploy
          Actions: 
            - 
              Name: DeployAction
              ActionTypeId: 
                Category: Deploy
                Owner: AWS
                Version: 1
                Provider: S3
              InputArtifacts: 
                - 
                  Name: MyAppBuild  
              Configuration:                
                BucketName: !Ref DeployBucket
                Extract: 'true'                
      # Create a name tag for the pipeline
      Tags:
        - Key: Name
          Value: !Join ['-', [!Ref AppName, !Ref 'AWS::AccountId', 'CodePipeLine',!Ref Stage]]

Now that we have our IAM Policies, Pipeline and the Build Project, it's time to define our S3 Buckets (Store Pipeline Artifacts, Website Host)

# Create S3 Buckets (Store Pipeline Artifacts, Website Host)
  PipelineBucket: 
    Type: 'AWS::S3::Bucket'
    Properties:
      BucketName: !Join ['-', [!Ref AppName, !Ref 'AWS::AccountId', 'pipelineartifacts', !Ref Stage]]

  DeployBucket:
    Type: 'AWS::S3::Bucket'
    Properties:
      BucketName: !Join ['-', [!Ref AppName, !Ref 'AWS::AccountId', 'website', !Ref Stage]]
      WebsiteConfiguration:
        IndexDocument: index.html
      AccessControl: PublicReadWrite
      CorsConfiguration:
        CorsRules:
        - AllowedOrigins: ['*']
          AllowedMethods: [GET]

  # Bucket policy that hosts the website
  DeploymentBucketPolicy: 
    Type: AWS::S3::BucketPolicy
    Properties: 
      Bucket: !Ref DeployBucket
      PolicyDocument: 
        Statement: 
          - 
            Action: 
              - "s3:GetObject"
            Effect: "Allow"
            Resource: 
              Fn::Join: 
                - ""
                - 
                  - "arn:aws:s3:::"
                  - 
                    Ref: DeployBucket
                  - "/*"
            Principal: "*"

Upload CloudFormation Template to AWS

Great! Now that we have our CloudFormation template created,
it's now time to upload our template to AWS.

Step 1: Log in to your AWS Console and navigate to CloudFormation; you should see a screen similar to this below. Click on create stack.

Step 2: Choose upload a template file and upload our cloudformation template.

Step 3: Give the stack a proper name, and give appropriate values to the stack parameters.

Step 4: Click next until you're on the last step. Select the checkbox in the last step. This allows AWS to let our template create IAM resources.

Step 5: Once you have created the stack, you can monitor the events of the stack as it is building. Whenever it is fully completed, we will get a status of 'CREATE_COMPLETE'

Step 6: Head over to CodePipline and we should see our pipeline in action.

Step 7: Navigate over to S3 to view the S3 bucket that is hosting our website. Click on the properties tab and scroll all the way to the bottom. You should see a website URL.

The URL should load our website and you should see the site below.

That's it, you have built a CI/CD Pipeline that automates your website deployment.

Lastly, to test that the pipeline works properly, push a commit to your git branch. This should automatically trigger the pipeline.

Happy Coding everyone. 👨🏾‍💻