DEV Community: Kalsoom ahmed

Secure Packages with CodeArtifact

Kalsoom ahmed — Thu, 05 Jun 2025 12:28:51 +0000

KEY CONCEPTS

AWS CodeArtifact
Amazon EC2
GitHub

Get ready to:

🗂️ Set up CodeArtifact as a repository for your project's dependencies.
🛡️ Use IAM roles and policies to give your web app access to CodeArtifact.
✅ Verify your web app's connection to CodeArtifact!

💎 Become a package uploader - create and add your own packages to your CodeArtifact repository!

Launch your EC2 Instance

Let's kick things off by launching an EC2 instance! This instance will be our virtual server in the cloud where we'll develop our Java web app.

This is important because Amazon EC2 provides the compute resources we need to host our application and build our CI/CD pipeline.

In this step, you're going to:

Launch a new EC2 instance

nstall Maven and Java on EC2 on terminal

copy past following commands into terminal
wget https://archive.apache.org/dist/maven/maven-3/3.5.2/binaries/apache-maven-3.5.2-bin.tar.gz

sudo tar -xzf apache-maven-3.5.2-bin.tar.gz -C /opt

echo "export PATH=/opt/apache-maven-3.5.2/bin:$PATH" >> ~/.bashrc

source ~/.bashrc

Now we're going to install Java 8, or more specifically, Amazon Correto 8:

sudo dnf install -y java-1.8.0-amazon-corretto-devel

export JAVA_HOME=/usr/lib/jvm/java-1.8.0-amazon-corretto.x86_64

export PATH=/usr/lib/jvm/java-1.8.0-amazon-corretto.x86_64/jre/bin/:$PATH

To make it easier to work with our web app files on the EC2 instance, we'll use the VS Code Remote - SSH extension.

Use the extension to SSH connect to your EC2 instance.

Set Up Your Web App

In your EC2 instance terminal, run the following Maven command to generate a basic Java web app structure. Copy and paste the entire command and press Enter:
mvn archetype:generate \
-DgroupId=com.nextwork.app \
-DartifactId=nextwork-web-project \
-DarchetypeArtifactId=maven-archetype-webapp \
-DinteractiveMode=false

After running the command, you should see a BUILD SUCCESS message in your terminal output. This tells us that Maven has successfully generated the web app!

Connect Your Web App to GitHub

Let's connect our local web app to a remote repository on GitHub. This will let us track changes to our code and collaborate with others!
In this step, you'll:

Install Git on your EC2 instance.
Set up a GitHub repository.
Connect your local web app to the GitHub repository.
install Git

To start using Git, we need to install it on your EC2 instance
sudo dnf update -y

sudo dnf install git -y

To check that Git was installed correctly, run the following command in the terminal: git --version

Set Up AWS CodeArtifact Repository

Now, let's set up AWS CodeArtifact, a fully managed artifact repository service. We'll use it to store and manage our project's dependencies, ensuring secure and reliable access to Java packages.

This is important because CodeArtifact provides a centralized, secure, and scalable way to manage dependencies for our Java projects, improving build consistency and security.
In this step, you're going to:

Create a CodeArtifact repository.

Create an IAM Policy for CodeArtifact Access

For Maven to start working with CodeArtifact, we need to create an IAM role that grants our EC2 instance the permission it needs to access CodeArtifact.

Otherwise, Maven can try all it wants to command your EC2 instance to store and retrieve packages from CodeArtifact, but your EC2 instance simple wouldn't be able to do anything! And going another layer deeper, IAM roles are made of policies; so we need to create policies first before setting up the role
In this step, you're going to:

Try connecting Maven with CodeArtifact (error!)
Create a new IAM policy.
Set up the policy to grant an EC2 instance access to CodeArtifact.

Attach IAM Policy and Verify CodeArtifact Connection

Now that we've created the IAM policy for CodeArtifact access, let's attach it to an IAM role and then associate that role with our EC2 instance. This will grant our EC2 instance the permissions it needs to securely access CodeArtifact. Finally, we'll verify the connection to CodeArtifact from our EC2 instance.

This is important because attaching the IAM role to our EC2 instance is what actually grants the instance the permissions defined in the policy, enabling secure access to CodeArtifact.

In this step, you're going to:

Create a new IAM role for EC2 that has your new policy attached.
Attach the IAM role to your EC2 instance.
Re-run the export token command, this time seeing a successful response

Login in to github account:

Set up a new repository called nextwork-web-project.

-Back in your terminal, set up a new local Git repository:
git init

Add remote origin

Now let's connect your local project folder with your Github repo!

Head back to your terminal in VS Code.
Add the remote repository as the origin with the following command, replacing with your repository's URL.
git remote add origin

To verify that the remote origin has been set up correctly, run the command git remote -v

Add, commit, and push your code to GitHub

Now, let's add all the files in your project to the Git repository. To do this, there are three commands you need to run...
git add .
git commit -m "Updated index.jsp with new content"
git push -u origin master

You should now see all your web app files listed in your GitHub repository. SO good!

See Packages in CodeArtifact!

Let's make sure everything is set up correctly by verifying the connection to our CodeArtifact repository from our EC2 instance. We'll configure Maven to use CodeArtifact and then try to compile our web app, which should now download dependencies from CodeArtifact.

In this step, you're going to:

Finish setting up the connection between Maven and CodeArtifact.
Compile your Maven project using the settings.xml file.
See your CodeArtifact repository automatically store your project's dependencies!

Delete your resources

Now that we've successfully verified our CodeArtifact connection, it's time to clean up the AWS resources we created to avoid incurring any unnecessary costs.

Resources to delete:

EC2 instance
IAM role and policy
CodeArtifact repository and domain
Key pair file

Set Up a Web App in the Cloud

Kalsoom ahmed — Wed, 04 Jun 2025 14:35:09 +0000

KEY CONCEPTS

Amazon EC2
VSCode

Get ready to:

Launch an EC2 instance.
Use VS Code to set up a remote SSH connection to your EC2 instance.
Install Maven and Java and generate a basic web app.
Edit code without VS Code - you'll see why IDEs are so well loved after this

Login with your IAM user

Login to AWS
For this project you'll need your IAM user, not your root user

Launch an EC2 Instance

Before we get into the juicy work of building your web app, we need to set up a home for your web app's files.

Since we want your web app to be entirely created and run on the cloud, we'll use a virtual server (EC2 instance) to house our development work.

Let's get an EC2 instance up and running!

In this step, you're going to:

Launch a new EC2 instance.
Set up a key pair for secure access.
Set up network settings for your instance.
Set up an EC2 instance called nextwork-devops-yourname with a key pair called nextwork-keypair
Store the downloaded private key into a new folder on your Desktop. Name that folder DevOps. We'll come back to it late

Install VS Code

Now that your EC2 instance is up and running, how are we going to get inside your instance and set up a web app?

We'll use Visual Studio Code (VS Code) to connect with your instance, so you can create and edit your web app's code.

First things first, let's install VS Code.

In this step, you're going to:

Download and install VS Code.
Set up a terminal within VS Code.
Change the permissions of your .pem file.

Install VS Code through the Visual Studio Code website

Navigate your terminal to the DevOps folder.
Change the permissions of your .pem file to make it readable only by you (the owner) and restrict access for everyone else.

Connect to your EC2 Instance

Your EC2 instance is working and you've just set up VS Code.

You have all the ingredients you need to set up a 🔌 connection 🔌 to your EC2 instance.

Once we're connected, we can work inside your EC2 instance to set up that web app.

In this step, you're going to:

Connect to your EC2 instance.

Use the following command to connect to your EC2 instance: ssh -i [PATH TO YOUR .PEM FILE] ec2-user@[YOUR PUBLIC IPV4 DNS]

Install Apache Maven into your EC2 instance:

wget https://archive.apache.org/dist/maven/maven-3/3.5.2/binaries/apache-maven-3.5.2-bin.tar.gz

sudo tar -xzf apache-maven-3.5.2-bin.tar.gz -C /opt

echo "export PATH=/opt/apache-maven-3.5.2/bin:$PATH" >> ~/.bashrc
source ~/.bashrc

Install Java (Amazon Correto 8) into your EC2 instance:

sudo dnf install -y java-1.8.0-amazon-corretto-devel

export JAVA_HOME=/usr/lib/jvm/java-1.8.0-amazon-corretto.x86_64

export PATH=/usr/lib/jvm/java-1.8.0-amazon-corretto.x86_64/jre/bin/:$PATH

Create the Application

We've assembled both Maven and Java into our EC2 instance. Now let's cut straight to generating the web app!

In this step, you're going to:

Run Maven commands in your terminal to generate a Java web app
Use mvn to generate a Java web app mvn archetype:generate \ -DgroupId=com.nextwork.app \ -DartifactId=nextwork-web-project \ -DarchetypeArtifactId=maven-archetype-webapp \ -DinteractiveMode=false

Connect VS Code with your EC2 Instance

You might be thinking... have I really just set up a web app? Where is it, how can I actually see it?

In this step, you'll connect VS Code to your EC2 instance so you can see and edit the web app you've just created.

In this step, you're going to:

Install the Remote - SSH extension in VS Code.
Use the extension to set up a connection between VS Code and your EC2 instance.
Explore and edit your Java web app's files using VS Code.
Set up a Remote SSH connection between VS Code and your EC2 instance.
Using VS Code as an IDE for your web app's files, modify index.jsp by changing the placeholder code:

Hello {YOUR NAME}!

This is my NextWork web application working!

Nice work - you've just learnt how to set up a web app on an EC2 instance AND connect it with VS Code, one of the most popular and practical IDEs out there.
Also you can Edit your web app in the terminal.

Delete Your Resources

You MUST delete the resources you've created today to avoid charges to your AWS account.

Delete your EC2 instance and key pair.

Today you've learnt how to:

💂 Set up an IAM user: You created a new IAM user with admin permissions to provide a safer alternative to using the AWS root account for ongoing projects.

☁️ Set up VS Code: You set up a new IDE environment using VS Code to write, run, and debug code. You also learnt how to connect VS Code to your EC2 instance to use it as an IDE.
⬇️ Install Maven & Java: You installed Apache Maven and Amazon Corretto 8 in your EC2 instance to manage your project's dependencies for building a Java web app.

🏗️ Create the application: Using Maven, you generated a new Java web app from a template, creating a basic project structure and environment for further development.

💎 Edit your code without VS Code: You edited index.jsp again, this time using nano instead of an IDE. It's a completely different experience!

Continuous Integration with CodeBuild

Kalsoom ahmed — Wed, 04 Jun 2025 13:54:33 +0000

KEY CONCEPTS

AWS CodeBuild
AWS CodeArtifact
Amazon S3
GitHub
IAM

Set Up Your Development Instance

Let's get started by launching an EC2 instance! This will be our virtual server in the cloud where we'll set up our CI/CD pipeline.

In this step, you're going to:

Launch an EC2 instance using the AWS Management Console and ssh -i in your terminal.
Understand the benefits of using EC2 for this project.
Troubleshoot common issues during instance launch.
Tools to install on your ec2
Install Maven, Java, and Git on your EC2 instance.
Run these commands on the terminal in your EC2.

wget https://archive.apache.org/dist/maven/maven-3/3.5.2/binaries/apache-maven-3.5.2-bin.tar.gz
sudo tar xzf apache-maven-3.5.2-bin.tar.gz -C /opt
echo 'export PATH=/opt/apache-maven-3.5.2/bin:$PATH' >> ~/.bashrc
source ~/.bashrc
sudo dnf install -y java-1.8.0-amazon-corretto-devel
export JAVA_HOME=/usr/lib/jvm/java-1.8.0-amazon-corretto.x86_64
export PATH=$JAVA_HOME/jre/bin/:$PATH
sudo dnf update -y
sudo dnf install git -y

What is AWS CodeArtifact?

AWS CodeArtifact is like a secure, private locker for all your software packages and dependencies. Instead of having developers download packages from the public internet (which can be risky and unreliable), you store trusted versions in CodeArtifact.

Let's set up AWS CodeArtifact

a fully managed artifact repository service. This will help us securely store and share software packages used in our CI/CD pipeline.

In this step, you're going to:

Set up a CodeArtifact repository to store your web app's packages.
Create an IAM policy and role for CodeArtifact access.
Configure Maven settings to use CodeArtifact.
Build your web app with Maven and verify the connection with CodeArtifact.

Ready to dive in? Let's create our CodeBuild project!

What is AWS CodeBuild?

AWS CodeBuild is a fully build tool for your code. It takes your source code, compiles it, runs tests, and packages it up. Engineers love continuous integration tools like CodeBuild because you don't have to manually set up and manage any build servers yourself, and you only pay for the compute time you use for building your projects (instead of entire servers that are idle most of the time). Think of it as a super-efficient, scalable, and managed service that handles all the heavy lifting of building and testing your applications

In this step, you're going to:

Create a new CodeBuild project

Connect CodeBuild to your GitHub Repository

To allow CodeBuild to access your private GitHub repository, we need to establish a connection using AWS CodeConnections.

In this step, you are going to:

Set up a connection between your AWS account and GitHub using AWS CodeConnections

Finish Setting Up Your CodeBuild Project

Next, we need to define the environment where our builds will run. This includes the operating system, runtime, and compute resources.

In this step, you are going to:

Configure CodeBuild's environment settings.
Configure Amazon S3 to store build artifacts.
Enable CloudWatch logs for monitoring build processes.

Run the Build and Troubleshoot Failures

Now that our CodeBuild project is fully configured, let's initiate our first build and see our CI pipeline in action!

In this step, you are going to:

Start your first build in CodeBuild.
Troubleshoot a build failure by adding a buildspec.yml file to your web app repository.
Verify Successful Build and Artifacts
Now that we've fixed our CodeBuild setup, let's re-run the build process. We'll also check our S3 bucket to see if it's storing the build artifact correctly.
In this step, you are going to
Re-run the build process in CodeBuild.
Troubleshoot a second build failure, this time by giving CodeBuild the permission to access CodeArtifact.
Run and verify a successful build!

Delete your resources

Now that we've configured our CI pipeline, it's time to clean up the resources we created. This is important to avoid getting charged for unused resources.

Resources to delete:
Delete the CodeBuild project.
Delete the S3 bucket.
Delete the EC2 instance.
Delete the IAM roles and policies.
Delete the CodeArtifact domain and repository.
Delete the CodeConnection connection
Delete your local file

Visualize Netflix data with QuickSight

Kalsoom ahmed — Fri, 13 Sep 2024 20:33:31 +0000

What is Amazon QuickSight?
Amazon QuickSight is a cloud-based business intelligence (BI)
service offered by Amazon Web Services (AWS) that enables
organizations to visualize their data and gain insights from it through interactive dashboards and reports.

Why it’s useful:
Connect to Data Sources:QuickSight connects to avariety of data sources, including AWS services(Amazon S3, Redshift,RDS),on premises databases,and third-party sources like Salesforce, MySQL,PostgreSQL, and more.
Upload your dataset and a manifest.json file into S3

S3 is used in this project to host the files that will be analysed byAmazonQuicksight.
I edited the manifest.json file by changing the URL in the manifest file.

Create yourAmazonQuicksight account

Go on search bar and type Quicksort and click on that.
It doesn’t cost to create a quicksight account.
It took about 10 minutes to create the account considering the few errors I ran into.
I also had to enable QuickSight’s access to S3 because my dataset was saved in an S3 instance hence needed to interface it with Quicksight.

Connect S3 + QuickSight

I connected the S3 bucket to QuickSight by copying the
manifest.json URI.
The manifest.json file was important in this step because it
helps Quicksight find our dataset in our bucket and understand
our data so it can represent i in charts and graphs.

Let’s make visualisations!

To create visualisation on QuickSight, you’ll have to drag a category to the AutoGraph dashboard

-The chart/graph shown here is a breakdown of the number of
movies released each year by their categories(movies/tv show)

I created this graph by having the release year on the y-axis and having the Type on group to show different colors for each category.

Filters are useful for specifying the variables and exact values
you want to compare while excluding what you don’t want.
Here I added a filter by excluding movies and TV shows
released before 2015.This helped me create a visualization on
the three genres released from 2015.

Set up your dashboard!

As a finishing touch, I arranged my visuals in a good looking format

-Did you know you could export your dashboard as PDFs too? I
did this by clicking ‘Export’ and ‘Generate PDF’ then waiting for
it to prepare download.

My key learnings

An S3 bucket was used in this project to store the dataset
and manifest.json file.
To connect the data stored in S3 with QuickSight, I had to
link the manifest.json file URI to Quicksight.
It is easy to create visualizations in Quicksight and it is easy to navigate different toggles.
One thing I didn’t expect was the ease in creating
visualizations and how it recommends if you put a graph in
the Autograph.