DEV Community: sipsdaoracle

MAKING THE MOST OUT OF MY AWS SUMMIT EXPERIENCE

sipsdaoracle — Mon, 02 Sep 2024 16:49:05 +0000

August was an incredibly eventful month, and a standout moment for me was attending the AWS Summit in Johannesburg at the Sandton Convention Centre. Here’s a look back at my experience and some insights on how to make the most out of such events.

Arrival, Registration, and Breakfast

I arrived at the venue bright and early, around 7:00 am. After registering and receiving some AWS swag, I found myself eagerly asking the event staff when we could start. By 8:00 am, the doors opened, and I enjoyed a hearty breakfast before diving into the exhibition hall.

Early Morning Sessions

This was my first AWS Summit, and I wasn’t entirely sure what to expect, especially attending solo. Fortunately, Chiche, who had encouraged me to attend, provided valuable tips and helped me plan my day. I browsed the agenda on the AWS events app and selected presentations and workshops that piqued my interest. I was excited to see some of my favorite tech companies among the sponsors, seeing this as a prime opportunity to engage with industry leaders and explore new services.

While wandering the exhibition hall, I stumbled upon the AWS Partyrock hub. As someone who has created around 20 apps on AWS, I’ve encountered limitations and issues with the platform’s UI. This was a perfect opportunity to discuss my challenges and explore alternatives. I learned about Amazon Q, which has a more user-friendly interface and addresses the context quota issues I faced, especially with complex use cases.

First Presentation: Women in Tech

My first session was the Women in Tech presentation. As a woman in technology, it was both inspiring and empowering to hear from successful women who have navigated the industry, balanced personal and professional roles, and achieved significant milestones. Their stories of resilience and success were truly uplifting.

Keynote and Main Presentations

The keynote presentation provided deep insights into how AWS partners and organizations are leveraging AWS for innovation and transformation. We explored various use cases, including how the pharmaceutical industry used machine learning during the pandemic to accelerate vaccine development.

We also learned from the Johannesburg Exchange about AWS’s role in enhancing and innovating the trading industry.

Veliswa’s demonstration of Amazon Q and Amazon Bedrock highlighted how these tools are revolutionizing application development through generative AI. This session made me even more eager to transition from AWS Partyrock to Amazon Q.

Breakout sessions | Activities | Networking

One of the highlights of the summit was the chance to meet and learn from industry leaders such as Veliswa Boya. The event was a treasure trove of information, resources, and networking opportunities. I was pleasantly surprised by the number of people who reached out to pitch ideas and opportunities.

It enabled me access to organizations as well the opportunity to engage on a level I would not have been able to. I took this time and asked all the questions I wanted to ask and networked with as many people who shared similar interest and goals

Engaging with brilliant minds like Cinga Nyangintsimbi from Batsamayi, who shared insights into the WoW initiative transforming taxi operations in the Eastern Cape, was particularly enlightening. I gained a deeper understanding of the development process, challenges faced, and the company’s future direction.

I concluded my day at the AWS Community Lounge, which featured sessions on topics ranging from AI to FinOps. Engaging in discussions with panelists such as Thoko Mathenjwa, Kudakwashe Manhodo, Rehan van der Merwe, and Mohammed Bangie provided valuable insights and connections across various AWS groups.

Final Thoughts and Tips

To maximize your experience at such events, plan ahead and strategize. Be open to conversations and make connections with as many people as possible. Arrive early to avoid long lines and ensure your phone is fully charged with enough storage for documenting the day. Don’t be discouraged if you’re attending alone; put yourself out there and engage with others.

A huge thank you to all the AWS partners, customers, sponsors, speakers, and the AWS community for making this event memorable. Special thanks to Chiche for convincing me to attend and helping me plan. It was an invaluable experience, and I’m already looking forward to the next AWS Summit.

What is Infrastructure as Code (IaC) and Why It's Transforming DevOps

sipsdaoracle — Sat, 17 Aug 2024 21:59:50 +0000

Hey there, tech enthusiasts! If you've ever found yourself drowning in a sea of server configurations, network setups, and cloud resources? Well, grab a life jacket because we're about to dive into the world of Infrastructure as Code (IaC) – the superhero of modern DevOps practices.

What exactly is Infrastructure as Code anyway?

Picture this: instead of manually clicking through endless setup screens or running commands till your fingers hurt, you write a few lines of code, hit "run," and voila! Your entire infrastructure springs to life. That's IaC in a nutshell.

Gone are the days of "Bob's the only one who knows how to set up the staging environment" or "Why does production look different from dev?" With IaC, your infrastructure becomes as manageable as your application code. Version control? Check. Reproducibility? You bet. Collaboration? Absolutely!

Why should you care?

- Consistency is king: No more "works on my machine" excuses. Every environment is a carbon copy.
- Speed is your new best friend: Deployment time goes from "grab a coffee" to "blink and you'll miss it."
- Scaling is a breeze: Need 10 more servers? No sweat. How about 100? Coming right up!
- Save those dollars: Efficient resource use means your wallet stays happier.
- Sleep better at night: Standardized setups mean fewer security headaches.

The cool kids of IaC

There are quite a lot of tools out there to help you jump on the IaC bandwagon. AWS CloudFormation, Ansible, Puppet – they're all great. But let's talk about the popular kid in school: Terraform.

Terraform: The Swiss Army knife of IaC
The reason this tool is so popular is because of its flexibility, it works with practically any cloud provider, speaks a language that is easy to understand, and keeps track of your infrastructure. That's Terraform for you.

Here's how it works:

You write code describing your infrastructure.
Terraform says, "Cool, here's what I'm gonna do."
You nod, and Terraform makes it happen.

It's like having a genie, but instead of three wishes, you get infinite infrastructure possibilities!

IaC and DevOps: A match made in tech heaven

Remember the age-old battle between dev and ops? IaC is like couples therapy for your tech teams. Developers can spin up environments faster than you can say "agile," and ops folks can ensure everything's running smoothly without breaking a sweat.

CI/CD pipelines? IaC slides right in there, making sure your infrastructure evolves just as fast as your code.

It's not all rainbows and unicorns

Let's keep it real – adopting IaC isn't always a walk in the park. There's a learning curve, and you might find yourself scratching your head over new concepts. And let's not forget about keeping those API keys and passwords safe in an automated world.

But fear not! Start small, train your team, use version control religiously, and before you know it, you'll be an IaC ninja.

The bottom line

Infrastructure as Code isn't just some fancy tech jargon to throw around at meetups. It's a game-changer that's making life easier for DevOps teams everywhere. It's bringing the agility of software development to the world of infrastructure, and trust me, once you go IaC, you never go back.

So, are you ready to code your infrastructure into existence? Trust me, your future self will thank you.

Happy coding, and may the infrastructure odds be ever in your favor!

Automating Linux User Creation with a Bash Script

sipsdaoracle — Wed, 03 Jul 2024 21:47:31 +0000

A Practical Script for SysOps Engineers

In the SysOps engineer world, automation is key, especially for repetitive tasks that save valuable time and ensure consistency. As a SysOps engineer, knowing how to write robust and efficient scripts along with strong Linux skills, boosts productivity and gives you a better workflow. This article will walk you through a bash script designed to automate the creation of Linux users.

The script creates users and groups as specified, sets up home directories with appropriate permissions and ownership, it generates random passwords for the users, and logs all actions to /var/log/user_management.log. Additionally, it stores the generated passwords securely in /var/secure/user_passwords.txt. and covers error handling for scenarios like existing users.

Prerequisite:

Bash shell environment.
Text editor for editing the script and preparing the input file.

Let's have a look at our script which we will later use to accomplish this task, and break it down by a detailed explanation of each section:

#!/bin/bash

# Check if the script is run as root
if [[ "$(id -u)" -ne 0 ]]; then
    echo "You must run the script as root" >&2
    exit 1
fi

# Check if a filename is provided
if [[ -z "$1" ]]; then
    echo "Usage: $0 <name-of-text-file>" >&2
    exit 1
fi

# File paths
LOG_FILE="/var/log/user_management.log"
PASSWORD_FILE="/var/secure/user_passwords.csv"

# Ensure /var/secure storage for passwords
mkdir -p /var/secure
touch $PASSWORD_FILE
chown root:root /var/secure
chmod 700 /var/secure
chmod 600 $PASSWORD_FILE

# Function to log actions
log_action() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a $LOG_FILE
}

# Function to generate a random password
generate_password() {
    tr -dc 'A-Za-z0-9!@#$%^&*()_+=-[]{}|;:<>,.?/~' </dev/urandom | head -c 16
}

# Function to hash passwords
hash_password() {
    echo "$1" | openssl passwd -6 -stdin
}

# Read the input file line by line
while IFS=";" read -r username groups; do
    # Trim whitespace
    username=$(echo "$username" | xargs)
    groups=$(echo "$groups" | xargs)

    # Skip empty lines
    if [[ -z "$username" ]]; then
        continue
    fi

    # Check if user already exists
    if id "$username" &>/dev/null; then
        log_action "User $username already exists!"
        continue
    fi

    # Create personal group
    if groupadd "$username"; then
        log_action "Group $username created successfully."
    else
        log_action "Failed to create group $username."
        continue
    fi

    # Create user with a home directory and personal group
    if useradd -m -s /bin/bash -g "$username" "$username"; then
        log_action "User $username created successfully."
    else
        log_action "Failed to create user $username."
        continue
    fi

    # Create groups and add user to them
    IFS=',' read -ra group_array <<< "$groups"
    for group in "${group_array[@]}"; do
        group=$(echo "$group" | xargs)
        if ! getent group "$group" >/dev/null 2>&1; then
            if groupadd "$group"; then
                log_action "Group $group created."
            else
                log_action "Failed to create group $group."
                continue
            fi
        fi
        if usermod -aG "$group" "$username"; then
            log_action "User $username added to group $group."
        else
            log_action "Failed to add user $username to group $group."
        fi
    done

    # Generate random password
    password=$(generate_password)
    hashed_password=$(hash_password "$password")
    if usermod --password "$hashed_password" "$username"; then
        echo "$username,$password" >> $PASSWORD_FILE
        log_action "Password set for user $username."
    else
        log_action "Failed to set password for user $username."
    fi

    # Set home directory permissions
    if mkdir -p "/home/$username" && chown -R "$username:$username" "/home/$username" && chmod 755 "/home/$username"; then
        log_action "Home directory permissions set for user $username."
    else
        log_action "Failed to set home directory permissions for user $username."
    fi

done < "$1"

log_action "User creation process completed. Check $LOG_FILE for details."

Breaking Down the Script

1. Check for Root Privileges

if [[ "$(id -u)" -ne 0 ]]; then
    echo "You must run the script as root" >&2
    exit 1
fi

This part checks if the script is run by the root user, this is because only the root user has permission to create and manage other users. If the script is not run as root, it will print an error message and exit.

2. Check for Filename Argument

if [[ -z "$1" ]]; then
    echo "Usage: $0 <name-of-text-file>" >&2
    exit 1
fi

This section will check if the user provided a filename as an argument when running the script. If no filename is found, it will print a usage message and exit.

3. Define File Paths

LOG_FILE="/var/log/user_management.log"
PASSWORD_FILE="/var/secure/user_passwords.csv"

These lines define the file paths for logging actions and storing passwords.

4. Ensure Secure Storage for Passwords

mkdir -p /var/secure
touch $PASSWORD_FILE
chown root:root /var/secure
chmod 700 /var/secure
chmod 600 $PASSWORD_FILE

This part of the script ensures that the /var/secure directory and the password file exist with appropriate permissions for secure storage. mkdir -p creates the directory if it doesn't exist, touch creates the password file, and chmod and chown set the permissions so only the root user can read and write to it.

5. Logging Function

log_action() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a $LOG_FILE
}

The log_action function's job is to log messages with timestamps to the log file. It uses the date command to add a timestamp to each log entry and tee to append the message to the log file.

6. Password Generation Function

generate_password() {
    tr -dc 'A-Za-z0-9!@#$%^&*()_+=-[]{}|;:<>,.?/~' </dev/urandom | head -c 16
}

The generate_password function generates a random password. tr is used to filter characters from /dev/urandom (a random number generator), and head -c 16 ensures the password is 16 characters long.

7. Password Hashing Function

hash_password() {
    echo "$1" | openssl passwd -6 -stdin
}

The hash_password function hashes the generated password using the openssl command with SHA-512 encryption. This makes the password secure before storing it.

8. Read and Process Input File

while IFS=";" read -r username groups; do
    # Trim whitespace
    username=$(echo "$username" | xargs)
    groups=$(echo "$groups" | xargs)

    # Skip empty lines
    if [[ -z "$username" ]]; then
        continue
    fi

This part reads the input file line by line, separating the username and groups by the semicolon (;). It also trims any whitespace around the username and groups and skips any empty lines.

9. Check for Existing User

if id "$username" &>/dev/null; then
    log_action "User $username already exists!"
    continue
fi

This checks if the user already exists. If so, it logs the action and skips to the next user.

10. Create Personal Group

if groupadd "$username"; then
    log_action "Group $username created successfully."
else
    log_action "Failed to create group $username."
    continue
fi

This creates a personal group with the same name as the username.

11. Create User

if useradd -m -s /bin/bash -g "$username" "$username"; then
    log_action "User $username created successfully."
else
    log_action "Failed to create user $username."
    continue
fi

This creates the user with a home directory and assigns the personal group as the primary group.

12. Create and Assign Groups

Copy code
IFS=',' read -ra group_array <<< "$groups"
for group in "${group_array[@]}"; do
    group=$(echo

How to use the script?

Save the script as create_users.sh in your preferred directory.
Prepare a text file (users_and_groups.txt) with one username per line, followed by groups separated by commas. For example: light;sudo,dev,www-data idimma;sudo mayowa;dev,www-data
Make the script executable with chmod +x create_users.sh.
Run the script with the path to your text file as an argument: ./create_users.sh users_and_groups.txt.

Conclusion

By following the structured steps outlined above, SysOps engineers can efficiently manage large numbers of user accounts and their associated groups, providing a robust solution for onboarding new developers.

Acknowledgment

This script was developed as part of the HNG Internship DevOps track. For more details on the program, visit the HNG Internship Website.

You can learn more about the HNG Internship program here and here.

Thank you for reading.

Setting up VPC, Public and Private Subnets, NAT, Internet Gateway, and Route Tables on AWS

sipsdaoracle — Tue, 05 Mar 2024 19:15:43 +0000

If you're new to Amazon Web Services (AWS) and looking to set up your Virtual Private Cloud (VPC) along with subnets, NAT, Internet Gateway, and route tables? In this guide, we'll take a look at some use cases and walk you through the process of setting up these services step by step, making it easy for you to understand and implement.

In today's digital landscape, businesses and individuals alike are embracing the power and flexibility of cloud computing to drive innovation, streamline operations, and scale their applications. As the leading cloud services provider, Amazon Web Services (AWS) offers a comprehensive suite of tools and services to meet the diverse needs of cloud users worldwide. Whether you're a seasoned IT professional or a newcomer to the world of cloud computing, understanding the foundational elements of AWS is essential for success.

Before we begin, have a look at the architecture diagram that illustrates how the VPC will be structured. These diagrams are crucial for visualizing our setup and guiding us towards our objectives. They also serve as a useful tool for testing whether the implemented configuration aligns with our desired outcomes. We'll also have a look at some use cases to help with better understanding.

Use Cases:

To understand how these services all come together we'll break down how each component (subnets, internet gateway, route tables, and NAT gateway) into the following use cases:

Web Application Hosting:
-Internet Gateway: Allows resources in public subnets to communicate with the internet, enabling access to web servers.
-Subnets: You'll have public subnets for hosting web servers accessible to users on the internet. Backend application servers and databases will be placed in private subnets for enhanced security.
-Route Tables: Routes traffic from public subnets to the internet gateway for outbound internet access.
-NAT Gateway: Not typically used in this scenario unless backend servers need to initiate outbound connections.

Big Data Processing:
-Internet Gateway: Used for data ingestion tools in public subnets to access external data sources or services.
-Subnets: Public subnets host data ingestion and analysis tools, while private subnets contain databases and processing clusters.
-Route Tables: Routes traffic between public and private subnets, allowing communication between data processing tools and databases.
-NAT Gateway: May be used in private subnets for outbound internet access if necessary.

Multi-tier Architecture:
-Internet Gateway: Allows communication between front-end servers and the internet.
-Subnets: Front-end tier hosted in public subnet, middle-tier application servers in another public subnet, and back-end database tier in private subnet.
-Route Tables: Directs traffic between different tiers of the application, ensuring proper communication and security.
-NAT Gateway: Used for outbound internet access from the private subnet, if required for backend processes.

Hybrid Cloud Deployment:
-Internet Gateway: Facilitates connectivity between on-premises infrastructure and AWS resources.
-Subnets: Used to segment resources between on-premises infrastructure and AWS resources.
-Route Tables: Routes traffic between on-premises network and AWS VPC, ensuring proper communication.
-NAT Gateway: May be used for outbound internet access from private subnets within the VPC.

VPN Connectivity:
-Internet Gateway: Enables secure connection between corporate network and VPC.
-Subnets: Provide connectivity between a corporate network and VPC resources.
-Route Tables: Directs VPN traffic between a corporate network and VPC, ensuring secure communication.
-NAT Gateway: This may be used for outbound internet access from private subnets, depending on the VPN setup.

Containerized Workloads:
-Internet Gateway: Allows containers in public subnets to communicate with external services if needed.
-Subnets: Used to deploy containerized applications, with public or private subnets based on access requirements.
-Route Tables: Directs traffic between containers and other resources within the VPC, ensuring proper communication.
-NAT Gateway: May be used for outbound internet access from private subnets containing containers.

Each component plays a crucial role in facilitating communication, security, and connectivity within the VPC environment, tailored to specific use cases and networking requirements.

Why do we use a VPC?

Think of a VPC as your own virtual data center in the AWS cloud. By creating a VPC, you're essentially defining the boundaries of your network environment. Just like in a physical data center, where you set up walls to separate different areas, creating a VPC allows you to isolate your resources logically. This step establishes the foundation of your network infrastructure in AWS. With a VPC, you can securely separate and manage your resources in the AWS cloud, much like you would with a network in a traditional on-premises environment.

Step 1: Create a VPC

Sign in to the AWS Management Console.
Navigate to the VPC dashboard.
Click on "Create VPC."
Specify the CIDR block for your VPC. This defines the range of IP addresses for your VPC.
Configure any additional settings as needed, such as DHCP options.
Click on "Create VPC" to create your VPC.

What you should see after creating:

What is an Internet Gateway used for?

An Internet Gateway is like a bridge that connects your VPC to the internet. It allows resources within your public subnets to communicate with the outside world. Without an Internet Gateway, your public-facing resources wouldn't be reachable from the internet, much like a house without a driveway can't be accessed from the street.

Step 2: Configuring Internet Gateway (IGW)

Navigate to the "Internet Gateways" section in the VPC dashboard.

Click on "Create internet gateway."
Attach the newly created internet gateway to your VPC by selecting the VPC and clicking on "Attach internet gateway."

Why do we use Subnets?

Think of your VPC like a piece of land, and subnets as different parts of that land. Public subnets are like streets in a city where everyone can go, such as sidewalks where people walk freely. This is where you'd put things like web servers that need to be reached from the internet. Meanwhile, private subnets are more like gated communities, where only residents can enter. It's similar to neighborhoods where houses are private. Here, you'd deploy things like databases and application servers that don't need to be accessed directly from the internet, making them more secure by keeping them away from public access.

Step 3: Setting up Public and Private Subnets

After creating the VPC, navigate to the "Subnets" section in the VPC dashboard.

Click on "Create subnet."
Choose the VPC that you created earlier.
Specify the CIDR block for the subnet.
Choose the availability zone for the subnet.

Repeat the process to create both public and private subnets, ensuring that each subnet is associated with the correct route table.

Why do we need route tables?

Route tables act as maps for directing traffic within your VPC. Just as you need road signs to navigate through a city, route tables determine where network traffic should go based on its destination. By configuring route tables, you're essentially telling AWS how to route traffic between different subnets and out to the internet. For example, you'll set up routes to direct traffic destined for the Internet to the Internet Gateway and routes to direct internal traffic between subnets.

Step 4: Configure Route Tables

Go to the "Route Tables" section in the VPC dashboard.
Create a route table associated with your VPC.

Add a route to the internet gateway (0.0.0.0/0) to enable outbound internet access for resources in the public subnet.

Go to the Subnet Association tab and click on Edit Subnet Association

Select the route table associated with your subnet

This is how it should look like

Select the route table associated with your private subnet.
Add routes for any services or resources that your private subnet needs to access, such as NAT Gateway or Virtual Private Gateway.

What is a NAT Gateway used for?

Setting up a NAT Gateway for your private subnet is like having a translator. It lets devices in your private area talk to the internet without revealing their private details. Picture it as a receptionist at a gated community. They take requests from residents who want to send packages (network requests) outside, but they don't share where those residents live (private IP addresses) to keep things safe.

Step 5: Set Up NAT Gateway (for Private Subnet)

Navigate to the "NAT Gateways" section in the VPC dashboard.
Click on "Create NAT Gateway."
Choose the subnet for the NAT Gateway (typically the public subnet).
Allocate an Elastic IP address for the NAT Gateway.
Create the NAT Gateway.

Step 6: Update Route Tables for Private Subnet

After creating the NAT Gateway, update the route table associated with the private subnet.
Add a route to the NAT Gateway (0.0.0.0/0) to enable outbound internet access for resources in the private subnet.

After setting up the NAT Gateway, you need to update the route tables associated with your private subnets to ensure that outbound traffic is directed through the NAT Gateway. This ensures that resources in your private subnets can access the internet securely via the NAT Gateway.

Conclusion

Congratulations! You've successfully set up your VPC infrastructure on AWS, laying the foundation for your cloud projects. With a secure and scalable network environment in place, you're ready to deploy and manage your applications with confidence. Whether you're hosting web applications, processing big data, or extending your on-premises infrastructure to the cloud, a well-designed VPC ensures optimal performance, security, and connectivity. As you continue your journey in the cloud, remember to adhere to AWS best practices and explore additional services to unlock the full potential of the AWS platform. Happy cloud computing!

P.S. Don't forget to delete all the resource instances we've created when you're done.

Creating a Continuous Delivery Pipeline in AWS (Hands-On)

sipsdaoracle — Tue, 20 Feb 2024 17:09:25 +0000

This week, I decided to dive deeper into the world of DevOps and SRE. As I was exploring various resources, I stumbled upon a hands-on AWS module focusing on Creating Continuous Delivery Pipelines. Recognizing the importance of this topic and its relevance in modern software development, I felt compelled to delve into it as a starting point for my journey.

For those unfamiliar with the concept, continuous deployment is a method that enables automatic deployment of code revisions to a production environment, eliminating the need for manual approval from developers. This automation streamlines the software release process and enhances efficiency.

Throughout this tutorial, I gained valuable insights into the creation of a continuous delivery pipeline. I learned how to set up a system that automatically deploys a sample web application whenever changes are made to the source code. This hands-on experience provided a practical understanding of the mechanisms behind continuous delivery and its significance in modern software development practices.

Everything done in this tutorial is Free Tier eligible.

Prerequisite

An AWS account
A GitHub account
Git installed on your computer

What I learned from this:

Set up a GitHub repository for the application
code
Create an AWS Elastic Beanstalk environment
to deploy the application
Configure AWS CodeBuild to build the source
code from GitHub
Use AWS CodePipeline to set up the continuous
delivery pipeline with source, build, and deploy
stages

Visual representation of End Architecture:

Task 1: Set Up Git Repo

Step 1: Fork a GitHub repository to create a new one

navigate to GitHub
open the aws-elastic-beanstalk-express-js-sample repo
Choose the white Fork button on the top right corner of the screen and choose Create a fork

Step 2: Store code and metadata in GitHub Repository(Push Code)

Go to the repository, click on the green Code button and copy the url of the repo to clone it.
Open the terminal or Bash platform of your choice and enter the following command and paste the URL

git clone https://github.com/YOUR-USERNAME/aws-elastic-beanstalk-express-js-sample

In the new folder there is a file named app.js. Open app.js Change the message in line 5 to say something other than "Hello World!" and save the file.
Go to the folder created with the name aws-elastic-beanstalk-express-js-sample/ and Commit the change with the following commands:

git add app.js git commit -m "change message"

Push the changes by entering the following command:

git push

Step 3: Test the changes

On Github under Repositories, select the one named aws-elastic-beanstalk-express-js-sample
Choose the app.js file. The contents of the file, including your change, should be displayed

Task 2: Deploy a Web App

Step 1: Configure and create an AWS Elastic Beanstalk environment

open the AWS Elastic Beanstalk console and click on Create Application button

under the heading Application name, enter DevOpsGettingStarted

Select Node.js from the Platform dropdown menu.

Ensure that sample application is selected.

Click create application button

Once you see the green checkmark, you have successfully created an AWS Elastic Beanstalk application and deployed it to an environment.

Step 2: Test the web app

To test your sample web app, select the link under the name of your environment.

Once the test has completed, a new browser tab should open with a webpage congratulating you!

We will use this environment and our continuous delivery pipeline to deploy the Hello World! web app we created in the previous module.

Task 3:Create Build Project

Step 1: Create a build project with AWS CodeBuild

Open the AWS CodeBuild console and choose the create project button.

In the Project name field, enter Build-DevOpsGettingStarted.

Select GitHub from the Source provider dropdown menu, Connect using OAuth and Choose the white Connect to GitHub button.
Choose the green Authorize aws-codesuite button and Enter your GitHub password.
Choose the Confirm button and Select Repository in my GitHub account.
Enter aws-elastic-beanstalk-express-js-sample in the search field.
Select the repo you forked

Confirm that Managed Image is selected.
Select Amazon Linux 2 from the Operating system dropdown menu.
Select Standard from the Runtime(s) dropdown menu.
Select aws/codebuild/amazonlinux2-x86_64-standard:3.0 from the Image dropdown menu.
Confirm that Always use the latest image for this runtime version is selected for Image version.
Confirm that Linux is selected for Environment type.
Confirm that New service role is selected.

Step 2: Create a Buildspec file for the project

Select Insert build commands.
Choose Switch to editor.
Replace the Buildspec in the editor with the code below: version: 0.2 phases: build: commands: - npm i --save artifacts: files: - '**/*'

Create build project button. You should now see a dashboard for your project.

Step 3: Test the CodeBuild Project

Choose the Start build button to configure the build process

Wait for the build to complete. After a couple minutes, a green checkmark and a Succeeded message confirming the build worked.

We have created a build project on AWS CodeBuild to run the build process of the Hello World! web app from our GitHub repository. We will be using this build project as the build step in our continuous delivery pipeline.

Task 4: Create Continuous Delivery Pipeline

Step 1: Create a new Pipeline

Open the AWS CodePipeline console and click the Create pipeline button

In the Pipeline name field, enter Pipeline-DevOpsGettingStarted.
Confirm that New service role is selected.
Choose the Next button.

Step 2: Configure a source stage using your GitHub repo

Select GitHub version 1 from the Source provider dropdown menu.
Choose Connect to GitHub button.
Choose Authorize aws-codesuite button.
From the Repository dropdown, select the repo you created.

Select main from the branch dropdown menu.
Confirm that GitHub webhooks is selected.
Choose the Next button.

Step 3: Configure the build stage

From the Build provider dropdown menu, select AWS
CodeBuild.
Under Region confirm that the US West (Oregon)
Region is selected.
Select Build-DevOpsGettingStarted under Project
name.

Choose the Next button.

Step 4: Configure Deploy stage

Select AWS Elastic Beanstalk from the Deploy
provider dropdown menu.
Under Region, confirm that the US West (Oregon)
Region is selected.
Select the field under Application name and
confirm you can see the app DevOpsGettingStarted
Select DevOpsGettingStarted-env from the
Environment name textbox.
Choose the Next button.

You will now see a page where you can review the pipeline configuration.

Choose the Create pipeline button.

Step 5: Watch the pipeline execution

Once the Deploy stage has switched to green and it says Succeeded, choose AWS Elastic Beanstalk.
A new tab listing your AWS Elastic Beanstalk environments will open.
Select the URL in the Devopsgettingstarted-env row.

You should see a webpage with a white background and the text you included in your GitHub commit

We have created a continuous delivery pipeline on AWS CodePipeline with three stages: source, build, and deploy.
The source code from the GitHub repo is part of the source stage. That source code is then built by AWS CodeBuild in the build stage.
Finally, the built code is deployed to the AWS Elastic Beanstalk environment.

Task 5:Finalize Pipeline and Test

Step 1: Create Review Stage in Pipeline

Open the AWS CodePipeline console
Select Pipeline-DevOpsGettingStarted
Choose the Edit button and click the Add stage button between the Build and Deploy stages.

In the Stage name field, enter Review.
Choose the Add stage button.
In the Review stage, choose the Add action group button.

Under Action name, enter Manual_Review.
From the Action provider dropdown, select Manual approval.
Confirm that the optional fields have been left blank. Choose the Done button. Choose the Save button at the top of the page. Choose the orange Save button to confirm the changes. You will now see your pipeline with four stages: Source, Build, Review, and Deploy.

Conclusion:

In summary, this tutorial has equipped you with the knowledge to set up a continuous delivery pipeline on AWS using services like CodePipeline, Elastic Beanstalk, and CodeBuild. By automating the deployment process for a sample web application, you've learned the benefits of continuous delivery, including faster release cycles and improved efficiency.

As you delve deeper into DevOps and SRE practices, remember to regularly review and optimize your pipelines to meet evolving organizational needs. By embracing automation and continuous improvement, you'll be better positioned to respond to customer feedback and market demands effectively.

I hope this tutorial has empowered you to embark on your continuous delivery journey with confidence. Happy coding and deploying!

Understanding Apache Spark and Hadoop Jobs

sipsdaoracle — Tue, 20 Feb 2024 14:16:48 +0000

In the fast-changing world of technology, where new tools and concepts pop up constantly, understanding terms like Spark and Hadoop can feel overwhelming. Even after trying to research them online, it's easy to feel lost in the details. That's why I decided to dive into the world of Apache Spark and Hadoop jobs. I created this blog to help beginners like myself grasp what they're all about and how they're used in real-world scenarios.

Introduction:

Apache Spark and Hadoop stand out as two powerhouse tools for efficiently managing massive datasets. Both Apache Spark and Hadoop are open-source frameworks meticulously engineered to distribute and process data across clusters of computers, providing scalable solutions to address the complexities associated with big data.

Apache Spark excels in in-memory processing and real-time analytics, while Hadoop, with its distributed file system (HDFS) and MapReduce processing paradigm, specializes in batch processing and storage. In this blog, we will explore the concepts of Apache Spark and Hadoop jobs, exploring their functionalities and use cases.

Understanding Apache Spark:

Apache Spark is highly regarded for its impressive speed, flexibility, and ability to handle large amounts of data. At the core of Spark are its jobs, which serve as the fundamental components for processing data. These jobs are crucial for helping organizations gain valuable insights and drive innovation.
With its rapid processing speed and ability to handle complex analytical tasks, Spark jobs have become indispensable tools for data professionals like engineers, analysts, and scientists.

Here is an architecture diagram to illustrate Apache Spark:

Use Case 1: Real-Time Analytics

Apache Spark is good at quickly analyzing data as it comes in, which makes it perfect for doing things in real time, like giving personalized recommendations to customers on e-commerce websites. Imagine a company wanting to do this to make their website more enjoyable for users.

Apache Spark can help by taking in all the data about what users are doing on the site as it happens, like clicks and views. Then, it can use that information to figure out what each user might like and suggest things they might want to buy. This helps make the website more fun for users and keeps them happy. Apache Spark is great at doing this fast, so businesses can keep up with all the action happening online and make sure their customers are happy.

Use Case 2: Machine Learning at Scale

Spark's machine learning library, MLlib, enables scalable and distributed machine learning. Imagine a scenario where healthcare providers are faced with the daunting task of analyzing enormous volumes of patient data to foresee medical outcomes. In this scenario, Spark's machine learning library, MLlib, emerges as a lifesaver. MLlib enables healthcare professionals to tackle this challenge by employing scalable and distributed machine learning techniques.

With Spark's assistance, they can efficiently process and analyze vast datasets, training sophisticated machine learning models to predict patient outcomes with precision. This transformative capability empowers healthcare providers to make informed decisions, guiding their medical strategies based on comprehensive insights gleaned from thorough data analysis. Thus, Spark's machine learning capabilities offer beginners an accessible and powerful tool to delve into the world of data-driven decision-making in healthcare and beyond.

Understanding Hadoop Jobs

Imagine you have a gigantic pile of data, like all the information stored on the internet or every transaction made by a company over many years. It's so much data that a regular computer can't handle it all at once. That's where Hadoop comes in. Hadoop is like a super-powered tool that can manage and process this massive amount of information efficiently.

Inside Hadoop, different kinds of jobs do specific tasks like bringing in data, sorting it out, and doing analysis or machine learning on it. These jobs are what makes Hadoop so useful for working with big data.

Hadoop's MapReduce

Hadoop's MapReduce is a key component of the Apache Hadoop ecosystem, designed to handle batch processing tasks efficiently. It comprises two main phases: the Map phase, where data is divided into smaller chunks and processed in parallel across multiple nodes, and the Reduce phase, where the results from the Map phase are aggregated to produce the final output. This distributed computing paradigm enables Hadoop to tackle large-scale data processing tasks with ease.

Use Case 1: Batch Processing

In the realm of big data, batch processing stands as a cornerstone for handling vast amounts of information efficiently. One of the most prominent tools in this domain is Hadoop's MapReduce, a framework renowned for its capability to process extensive datasets in a parallel and distributed manner.

To demonstrate how Hadoop's MapReduce is applied in real-world scenarios, imagine a situation where a financial organization must analyze extensive transaction data to detect fraud and ensure compliance. Utilizing Hadoop's MapReduce, this data can be processed in parallel and distributed fashion overnight, facilitating thorough analysis and identification of potentially fraudulent activities. Through the scalability and fault tolerance capabilities of Hadoop, businesses can extract valuable insights from their data while meeting regulatory standards.

Use Case 2: Data Warehousing

In scenarios where businesses need to store and analyze structured and unstructured data for reporting and analysis, Hadoop provides a cost-effective solution. Retailers, for example, can use Hadoop to store and analyze sales data, customer interactions, and social media sentiments to gain a holistic view of customer behavior and preferences.

Integration of Apache Spark and Hadoop:

Apache Spark and Hadoop are two powerful tools often used separately, but they can also work well together. Spark can take advantage of Hadoop's ability to store data across many computers, called distributed storage. This means Spark can read data from and write data to Hadoop's storage system, known as HDFS. By combining Spark's fast and easy-to-use features with Hadoop's strong storage and ability to handle big batches of data at once, organizations get the best of both worlds.

Conclusion:

In the world of big data, Apache Spark and Hadoop are like superheroes for organizations. They help companies handle and understand huge amounts of data. Whether a company needs to analyze data in real time, use machine learning to learn from lots of data, process data in big batches, or store data for later use, these frameworks have tools to do it all. By learning about what Apache Spark and Hadoop can do, businesses can unlock the potential of big data to come up with new ideas and make smart choices.

Build a JavaScript single-page application (SPA) (Microsoft Graph)

sipsdaoracle — Thu, 25 May 2023 12:50:47 +0000

Today, I'll be building a JavaScript Single Page Application that signs in users and calls Microsoft Graph, it does this by using authorization code flow with PKCE

Here is what we will be covering throughout:

Perform the OAuth 2.0 authorization code flow with PKCE
Sign in personal Microsoft accounts as well as work and school accounts
Acquire an access token
Call Microsoft Graph or your own API that requires access tokens obtained from the Microsoft identity platform

Prerequisites

Node.js for running a local webserver
Visual Studio Code or another code editor
Microsoft Authentication Library for JavaScript v2.0

How the app works:

The application you create in this tutorial enables a JavaScript SPA to query the Microsoft Graph API by acquiring security tokens from the the Microsoft identity platform. In this scenario, after a user signs in, an access token is requested and added to HTTP requests in the authorization header. Token acquisition and renewal are handled by the Microsoft Authentication Library for JavaScript (MSAL.js).

What is Microsoft Graph App

Microsoft Graph App enables developers to create applications that integrate with Microsoft services, enabling seamless collaboration, data access, and functionality across various Microsoft platforms and services.

Task 1: Create your project

Step 1: Change to your project directory in your terminal and then run the following npm commands:

npm init -y
npm install @azure/msal-browser
npm install express
npm install morgan
npm install yargs

Step 2: Create file named server.js and add the following code:

const express = require('express');
const morgan = require('morgan');
const path = require('path');

const DEFAULT_PORT = process.env.PORT || 3000;

// initialize express.
const app = express();

// Initialize variables.
let port = DEFAULT_PORT;

// Configure morgan module to log all requests.
app.use(morgan('dev'));

// Setup app folders.
app.use(express.static('app'));

// Set up a route for index.html
app.get('*', (req, res) => {
    res.sendFile(path.join(__dirname + '/index.html'));
});

// Start the server.
app.listen(port);
console.log(`Listening on port ${port}...`);

Task 2: Create the SPA UI

Step 1:Create an app folder and in it create an index.html

In the index.html file, add the following code:

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0, shrink-to-fit=no">
  <title>Microsoft identity platform</title>
  <link rel="SHORTCUT ICON" href="./favicon.svg" type="image/x-icon">

   <!-- msal.min.js can be used in the place of msal.js; included msal.js to make debug easy -->
  <script src="https://alcdn.msauth.net/browser/2.30.0/js/msal-browser.js"
    integrity="sha384-o4ufwq3oKqc7IoCcR08YtZXmgOljhTggRwxP2CLbSqeXGtitAxwYaUln/05nJjit"
    crossorigin="anonymous"></script>

  <!-- adding Bootstrap 4 for UI components  -->
  <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css"
    integrity="sha384-Vkoo8x4CGsO3+Hhxv8T/Q5PaXtkKtu6ug5TOeNV6gBiFeWPGFN9MuhOf23Q9Ifjh" crossorigin="anonymous">
  <link rel="SHORTCUT ICON" href="https://c.s-microsoft.com/favicon.ico?v2" type="image/x-icon">
</head>

<body>
  <nav class="navbar navbar-expand-lg navbar-dark bg-primary">
    <a class="navbar-brand" href="/">Microsoft identity platform</a>
    <div class="btn-group ml-auto dropleft">
      <button type="button" id="SignIn" class="btn btn-secondary" onclick="signIn()">
        Sign In
      </button>
    </div>
  </nav>
  <br>
  <h5 class="card-header text-center">Vanilla JavaScript SPA calling MS Graph API with MSAL.js</h5>
  <br>
  <div class="row" style="margin:auto">
    <div id="card-div" class="col-md-3" style="display:none">
      <div class="card text-center">
        <div class="card-body">
          <h5 class="card-title" id="WelcomeMessage">Please sign-in to see your profile and read your mails</h5>
          <div id="profile-div"></div>
          <br>
          <br>
          <button class="btn btn-primary" id="seeProfile" onclick="seeProfile()">See Profile</button>
          <br>
          <br>
          <button class="btn btn-primary" id="readMail" onclick="readMail()">Read Mails</button>
        </div>
      </div>
    </div>
    <br>
    <br>
    <div class="col-md-4">
      <div class="list-group" id="list-tab" role="tablist">
      </div>
    </div>
    <div class="col-md-5">
      <div class="tab-content" id="nav-tabContent">
      </div>
    </div>
  </div>
  <br>
  <br>

  <!-- importing bootstrap.js and supporting js libraries -->
  <script src="https://code.jquery.com/jquery-3.4.1.slim.min.js"
    integrity="sha384-J6qa4849blE2+poT4WnyKhv5vZF5SrPo0iEjwBvKU7imGFAV0wwj1yYfoRSJoZ+n"
    crossorigin="anonymous"></script>
  <script src="https://cdn.jsdelivr.net/npm/popper.js@1.16.0/dist/umd/popper.min.js"
    integrity="sha384-Q6E9RHvbIyZFJoft+2mJbHaEWldlvI9IOYy5n3zV9zzTtmI3UksdQRVvoxMfooAo"
    crossorigin="anonymous"></script>
  <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/js/bootstrap.min.js"
    integrity="sha384-wfSDF2E50Y2D1uUdj0O3uMBJnjuUD4Ih7YwaYd1iqfktj0Uod8GCExl3Og8ifwB6"
    crossorigin="anonymous"></script>

  <!-- importing app scripts (load order is important) -->
  <script type="text/javascript" src="./authConfig.js"></script>
  <script type="text/javascript" src="./graphConfig.js"></script>
  <script type="text/javascript" src="./ui.js"></script>

  <!-- <script type="text/javascript" src="./authRedirect.js"></script>   -->
  <!-- uncomment the above line and comment the line below if you would like to use the redirect flow -->
  <script type="text/javascript" src="./authPopup.js"></script>
  <script type="text/javascript" src="./graph.js"></script>
</body>

</html>

Step 2: Create a file named ui.js in the app folder

Add the following code:

// Select DOM elements to work with
const welcomeDiv = document.getElementById("WelcomeMessage");
const signInButton = document.getElementById("SignIn");
const cardDiv = document.getElementById("card-div");
const mailButton = document.getElementById("readMail");
const profileButton = document.getElementById("seeProfile");
const profileDiv = document.getElementById("profile-div");

function showWelcomeMessage(username) {
    // Reconfiguring DOM elements
    cardDiv.style.display = 'initial';
    welcomeDiv.innerHTML = `Welcome ${username}`;
    signInButton.setAttribute("onclick", "signOut();");
    signInButton.setAttribute('class', "btn btn-success")
    signInButton.innerHTML = "Sign Out";
}

function updateUI(data, endpoint) {
    console.log('Graph API responded at: ' + new Date().toString());

    if (endpoint === graphConfig.graphMeEndpoint) {
        profileDiv.innerHTML = ''
        const title = document.createElement('p');
        title.innerHTML = "<strong>Title: </strong>" + data.jobTitle;
        const email = document.createElement('p');
        email.innerHTML = "<strong>Mail: </strong>" + data.mail;
        const phone = document.createElement('p');
        phone.innerHTML = "<strong>Phone: </strong>" + data.businessPhones[0];
        const address = document.createElement('p');
        address.innerHTML = "<strong>Location: </strong>" + data.officeLocation;
        profileDiv.appendChild(title);
        profileDiv.appendChild(email);
        profileDiv.appendChild(phone);
        profileDiv.appendChild(address);

    } else if (endpoint === graphConfig.graphMailEndpoint) {
        if (!data.value) {
            alert("You do not have a mailbox!")
        } else if (data.value.length < 1) {
            alert("Your mailbox is empty!")
        } else {
            const tabContent = document.getElementById("nav-tabContent");
            const tabList = document.getElementById("list-tab");
            tabList.innerHTML = ''; // clear tabList at each readMail call

            data.value.map((d, i) => {
                // Keeping it simple
                if (i < 10) {
                    const listItem = document.createElement("a");
                    listItem.setAttribute("class", "list-group-item list-group-item-action")
                    listItem.setAttribute("id", "list" + i + "list")
                    listItem.setAttribute("data-toggle", "list")
                    listItem.setAttribute("href", "#list" + i)
                    listItem.setAttribute("role", "tab")
                    listItem.setAttribute("aria-controls", i)
                    listItem.innerHTML = d.subject;
                    tabList.appendChild(listItem)

                    const contentItem = document.createElement("div");
                    contentItem.setAttribute("class", "tab-pane fade")
                    contentItem.setAttribute("id", "list" + i)
                    contentItem.setAttribute("role", "tabpanel")
                    contentItem.setAttribute("aria-labelledby", "list" + i + "list")
                    contentItem.innerHTML = "<strong> from: " + d.from.emailAddress.address + "</strong><br><br>" + d.bodyPreview + "...";
                    tabContent.appendChild(contentItem);
                }
            });
        }
    }
}

What is the DOM?
The DOM is a World Wide Web Consortium standard.

The DOM defines a standard for accessing documents:

"The Document Object Model (DOM) is a platform and language-neutral interface that allows programs and scripts to dynamically access and update the content, structure, and style of a document."

The DOM standard is separated into 3 different parts:

Core DOM - standard model for all document types
XML DOM - standard model for XML documents
HTML DOM - standard model for HTML documents

Task 3: Register your application

Step 1: Sign in to the Azure portal.

Search for and select Azure Active Directory.

Under Manage, select App registrations > New registration.

Step 2: Enter a Name for your application.
Users of your app might see this name, and you can change it later.

Choose the Supported account types for the application.

Select Register to create the app registration.

Step 3: Under Management>Authentication enable the Implicit grant and hybrid flows

Select ID tokens.
Select Access tokens.

_Select save.

You've now completed the registration of your single-page application (SPA) and configured a redirect URI to which the client will be redirected and any security tokens will be sent. By selecting one or both of ID tokens and Access tokens, you've enabled the implicit grant flow._

Next Configure the app's code to use the app registration created.

Task 4: Configure your JavaScript SPA

Step 1: Create a file named authConfig.js in the app folder

Add the following code:


/**
 * Configuration object to be passed to MSAL instance on creation. 
 * For a full list of MSAL.js configuration parameters, visit:
 * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-browser/docs/configuration.md 
 */
const msalConfig = {
    auth: {
        // 'Application (client) ID' of app registration in Azure portal - this value is a GUID
        clientId: "Enter_the_Application_Id_Here",
        // Full directory URL, in the form of https://login.microsoftonline.com/<tenant-id>
        authority: "Enter_the_Cloud_Instance_Id_HereEnter_the_Tenant_Info_Here",
        // Full redirect URL, in form of http://localhost:3000
        redirectUri: "Enter_the_Redirect_Uri_Here",
    },
    cache: {
        cacheLocation: "sessionStorage", // This configures where your cache will be stored
        storeAuthStateInCookie: false, // Set this to "true" if you are having issues on IE11 or Edge
    },
    system: {   
        loggerOptions: {    
            loggerCallback: (level, message, containsPii) => {  
                if (containsPii) {      
                    return;     
                }       
                switch (level) {        
                    case msal.LogLevel.Error:       
                        console.error(message);     
                        return;     
                    case msal.LogLevel.Info:        
                        console.info(message);      
                        return;     
                    case msal.LogLevel.Verbose:     
                        console.debug(message);     
                        return;     
                    case msal.LogLevel.Warning:     
                        console.warn(message);      
                        return;     
                }   
            }   
        }   
    }
};

/**
 * Scopes you add here will be prompted for user consent during sign-in.
 * By default, MSAL.js will add OIDC scopes (openid, profile, email) to any login request.
 * For more information about OIDC scopes, visit: 
 * https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-permissions-and-consent#openid-connect-scopes
 */
const loginRequest = {
    scopes: ["User.Read"]
};


/**
 * Add here the scopes to request when obtaining an access token for MS Graph API. For more information, see:
 * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-browser/docs/resources-and-scopes.md
 */
const tokenRequest = {
    scopes: ["User.Read", "Mail.Read"],
    forceRefresh: false // Set this to "true" to skip a cached token and go to the server to get a new token
};

Step 2: create a file named graphConfig.js. in the app folder

Add the following code to provide your application the configuration parameters for calling the Microsoft Graph API:

Add the following code:

graphMeEndpoint: "https://graph.microsoft.com/v1.0/me",
graphMailEndpoint: "https://graph.microsoft.com/v1.0/me/messages"

Task 5: Use (MSAL) to sign in user

Step 1: Create a file named *authPopup.js *

Add the following code:

// Create the main myMSALObj instance
// configuration parameters are located at authConfig.js
const myMSALObj = new msal.PublicClientApplication(msalConfig);

let username = "";

function selectAccount() {

    /**
     * See here for more info on account retrieval: 
     * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-common/docs/Accounts.md
     */

    const currentAccounts = myMSALObj.getAllAccounts();
    if (currentAccounts.length === 0) {
        return;
    } else if (currentAccounts.length > 1) {
        // Add choose account code here
        console.warn("Multiple accounts detected.");
    } else if (currentAccounts.length === 1) {
        username = currentAccounts[0].username;
        showWelcomeMessage(username);
    }
}

function handleResponse(response) {

    /**
     * To see the full list of response object properties, visit:
     * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-browser/docs/request-response-object.md#response
     */

    if (response !== null) {
        username = response.account.username;
        showWelcomeMessage(username);
    } else {
        selectAccount();
    }
}

function signIn() {

    /**
     * You can pass a custom request object below. This will override the initial configuration. For more information, visit:
     * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-browser/docs/request-response-object.md#request
     */

    myMSALObj.loginPopup(loginRequest)
        .then(handleResponse)
        .catch(error => {
            console.error(error);
        });
}

function signOut() {

    /**
     * You can pass a custom request object below. This will override the initial configuration. For more information, visit:
     * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-browser/docs/request-response-object.md#request
     */

    const logoutRequest = {
        account: myMSALObj.getAccountByUsername(username),
        postLogoutRedirectUri: msalConfig.auth.redirectUri,
        mainWindowRedirectUri: msalConfig.auth.redirectUri
    };

    myMSALObj.logoutPopup(logoutRequest);
}

function getTokenPopup(request) {

    /**
     * See here for more info on account retrieval: 
     * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-common/docs/Accounts.md
     */
    request.account = myMSALObj.getAccountByUsername(username);

    return myMSALObj.acquireTokenSilent(request)
        .catch(error => {
            console.warn("silent token acquisition fails. acquiring token using popup");
            if (error instanceof msal.InteractionRequiredAuthError) {
                // fallback to interaction when silent call fails
                return myMSALObj.acquireTokenPopup(request)
                    .then(tokenResponse => {
                        console.log(tokenResponse);
                        return tokenResponse;
                    }).catch(error => {
                        console.error(error);
                    });
            } else {
                console.warn(error);   
            }
    });
}

function seeProfile() {
    getTokenPopup(loginRequest)
        .then(response => {
            callMSGraph(graphConfig.graphMeEndpoint, response.accessToken, updateUI);
        }).catch(error => {
            console.error(error);
        });
}

function readMail() {
    getTokenPopup(tokenRequest)
        .then(response => {
            callMSGraph(graphConfig.graphMailEndpoint, response.accessToken, updateUI);
        }).catch(error => {
            console.error(error);
        });
}

selectAccount();

Task 6: Redirect

Step 1: Create a file named authRedirect.js in the app folder

Add the following authentication and token acquisition code for login redirect:

// Create the main myMSALObj instance
// configuration parameters are located at authConfig.js
const myMSALObj = new msal.PublicClientApplication(msalConfig);

let username = "";

/**
 * A promise handler needs to be registered for handling the
 * response returned from redirect flow. For more information, visit:
 * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-browser/docs/acquire-token.md
 */
myMSALObj.handleRedirectPromise()
    .then(handleResponse)
    .catch((error) => {
        console.error(error);
    });

function selectAccount () {

    /**
     * See here for more info on account retrieval: 
     * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-common/docs/Accounts.md
     */

    const currentAccounts = myMSALObj.getAllAccounts();

    if (currentAccounts.length === 0) {
        return;
    } else if (currentAccounts.length > 1) {
        // Add your account choosing logic here
        console.warn("Multiple accounts detected.");
    } else if (currentAccounts.length === 1) {
        username = currentAccounts[0].username;
        showWelcomeMessage(username);
    }
}

function handleResponse(response) {
    if (response !== null) {
        username = response.account.username;
        showWelcomeMessage(username);
    } else {
        selectAccount();
    }
}

function signIn() {

    /**
     * You can pass a custom request object below. This will override the initial configuration. For more information, visit:
     * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-browser/docs/request-response-object.md#request
     */

    myMSALObj.loginRedirect(loginRequest);
}

function signOut() {

    /**
     * You can pass a custom request object below. This will override the initial configuration. For more information, visit:
     * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-browser/docs/request-response-object.md#request
     */

    const logoutRequest = {
        account: myMSALObj.getAccountByUsername(username),
        postLogoutRedirectUri: msalConfig.auth.redirectUri,
    };

    myMSALObj.logoutRedirect(logoutRequest);
}

function getTokenRedirect(request) {
    /**
     * See here for more info on account retrieval: 
     * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-common/docs/Accounts.md
     */
    request.account = myMSALObj.getAccountByUsername(username);

    return myMSALObj.acquireTokenSilent(request)
        .catch(error => {
            console.warn("silent token acquisition fails. acquiring token using redirect");
            if (error instanceof msal.InteractionRequiredAuthError) {
                // fallback to interaction when silent call fails
                return myMSALObj.acquireTokenRedirect(request);
            } else {
                console.warn(error);   
            }
        });
}

function seeProfile() {
    getTokenRedirect(loginRequest)
        .then(response => {
            callMSGraph(graphConfig.graphMeEndpoint, response.accessToken, updateUI);
        }).catch(error => {
            console.error(error);
        });
}

function readMail() {
    getTokenRedirect(tokenRequest)
        .then(response => {
            callMSGraph(graphConfig.graphMailEndpoint, response.accessToken, updateUI);
        }).catch(error => {
            console.error(error);
        });
}

Task 6: Call the Microsoft Graph API

Step 1: Create file named graph.js in the app folder.

Add the following code for making REST calls to the Microsoft Graph API:

/** 
 * Helper function to call MS Graph API endpoint
 * using the authorization bearer token scheme
*/
function callMSGraph(endpoint, token, callback) {
    const headers = new Headers();
    const bearer = `Bearer ${token}`;

    headers.append("Authorization", bearer);

    const options = {
        method: "GET",
        headers: headers
    };

    console.log('request made to Graph API at: ' + new Date().toString());

    fetch(endpoint, options)
        .then(response => response.json())
        .then(response => callback(response, endpoint))
        .catch(error => console.log(error));
}

In the sample application created in this tutorial, the callMSGraph() method is used to make an HTTP GET request against a protected resource that requires a token.

The request then returns the content to the caller. This method adds the acquired token in the HTTP Authorization header.

In the sample application created in this tutorial, the protected resource is the Microsoft Graph API me endpoint which displays the signed-in user's profile information.
_

Test your application

On Visual Studio Code, once you have completed following all the steps, run and debug. The Application should load

There you go!!

I have also provided the code on GitHub.

https://github.com/sipsdaoracle/JavaScript-SPA

Remember to delete your resources once done.

How to create a JSON ARM template with Visual Studio Code

sipsdaoracle — Fri, 19 May 2023 07:25:14 +0000

In this exercise, we will use the extension to create an ARM template from scratch. While doing so you experience the extensions capabilities such as ARM template snippets , validation , completions, and parameter file support.

What is JSON ARM and what is it useful for?

JSON, or JavaScript Object Notation, is a data interchange format that is commonly used for configuration and data exchange in modern applications.

In Azure Resource Manager, JSON templates are used to define and deploy resources in a declarative way.

This means that instead of writing imperative scripts to specify the steps required to create and configure resources, you can define the desired state of your resources using JSON templates.

Prerequisite:

Visual Studio Code
Azure Resource Manager Tools extension
Azure CLI or Azure Powershell
Azure subscription

Task 1: Create an ARM template

Step 1: Create and open with VSCode new file azuredeploy.json

Enter arminto the code editor, which initiates Azure Resource Manager snippets for scaffolding out an ARM template.

Select arm! to create a template scoped for an Azure resource group deployment

The result should be the template below:

Task 2: Add an Azure resource

Step 1: Scroll down to line 7 and place the cursor in the template resources block and then select arm-storage

You should see the following storage template below:

Task 3: Add template parameters

Parameters will be used to specify the storage account name.

Step 1: On line 4 place the cursor in the parameters block, type " and select the new-parameter snippet.

This should add a parameter to your template.

Step 2: Set the name of the parameter to storageAccountName and the description to Storage Account Name.

Step 3: Add min and max storage account name

length

Step 4: Update name property to use it

Navigate to line 14 on the resource storage
Remove current name
Enter a double quote " and an opening square bracket[, select parameters

Step 5: Enter round brackets and a single quote ' inside the brackets

A list of defined parameters will be listed, select the parameter

Task 4: Create a parameter file

A parameter file allows you to store environment-specific parameter values and pass these values in as a group during deployment.

Step 1: Right-click on the template (code editor) and select Select/Create Parameter File

Step 2: Select New > All Parameters
Enter a name and choose a location for the parameter file

The extension between the parameter file and the template validates both the files together.

Task 5 Deploy the template

Step 1:
Open Visual studio code terminal or Azure Powershell

N.B: Make sure that on your Visual Studio Code you have singed in to your Microsoft account. To do this you need select the accounts icon and Turn On Cloud

Now...Deploy by pasting the following code on the CLI/Powershell:

az group create --name arm-vscode --location eastus

az deployment group create --resource-group arm-vscode --template-file azuredeploy.json --parameters azuredeploy.parameters.json

The first code was executed successfully now it will deploy and create an ARM resource group

Now we can head on to our Azure portal and check if indeed it has been created.

So far so good!

There you go you have successfully deployed.

If you prefer you can push your code to your Github repository as I have done:

Clean up Resources

Now that you have successfully deployed ensure you clean by deleting all the resources to avoid unnecessary incurred cost.

Log back to your Azure portal and search for resources that have just been created and ensure that you have deleted them.

Congratulations, on completing this tutorial.

Create a Virtual Machine Instance(EC2) in AWS & Connect Via SSH(Cloudshell)

sipsdaoracle — Sun, 07 May 2023 01:06:35 +0000

What is an EC2?

An EC2 (Elastic Compute Cloud) is a virtual computing environment provided by Amazon Web Services (AWS). It allows you to create and manage virtual machines (instances) in the cloud.

How can you use an EC2?

You can use an EC2 to run your applications, services, or workloads in the cloud. You can choose the hardware specifications (CPU, memory, storage) and the operating system of your instances, and you only pay for the resources you use.

By the end of this tutorial you should be able to accomplish the following:

Create EC2 instance
SSH into EC2 Virtual Instance Machine using Cloudshell

What you'll need to get started:

An AWS account
SSH Client(Cloudshell)

Now let's get started and create an EC2 instance:

Step 1:

Sign into the [AWS Management Console](https://aws.amazon.com/console/)

Step 2:

Navigate to the EC2 Dashboard ( search for EC2 )

Step 3:

Click on Instance

Step 4:

Click on the "Launch Instance" button.

Step 5:

Name your EC2 Instance:

Step 6:

Choose an Amazon Machine Image (AMI)
An AMI is a pre-configured image that contains the software and operating system you want to use on your instance.

We'll use AWS Linux in this tutorial

Step 7:

Select an Instance Type
An Instance Type determines the hardware specifications of your virtual machine, such as CPU, memory, and storage.

Step 8:

Create a key pair
A key pair is a set of public and private keys that allows you to securely connect to your instance over SSH.

Step 9:

Configure the Network Instance Details, such as the VPC settings, the subnet.

Configure Security Group settings to allow inbound traffic to your instance.

You can add rules to your security group to allow access over specific ports or protocols, such as SSH or HTTP.

Step 10:

Add Storage to your instance
You can choose the storage type (such as SSD or HDD), size, and number of volumes. You can add up 30GB on the free tier account

Review Summary
A summary of your configurations will be displaced you can also select the number of instances you'd like, if you're happy with everything you can click on launch

Step 11:

Launch your instance and connect

After a few minutes, your virtual machine will be launched and ready to use.

You've successfully created a virtual machine (EC2) in AWS.

You can now connect to your instance by following the steps below:
1. Click on the check box **
**2. Click on connect

Connect using SSH client

Open an SSH client
In the AWS Management Console, at the top of the screen, choose the AWS CloudShell icon

Locate your private key file.
The key used to launch this instance is sips.pem

Run this command
To ensure your key is not publicly viewable.
chmod 400 sips.pem

Connect to your instance
using its Public DNS:
ec2-3-90-208-38.compute-1.amazonaws.com

Run command:

ssh -i "sips.pem" ec2-user@ec2-3-90-208-38.compute-1.amazonaws.com

Voila! You've successfully created a virtual machine (EC2) in AWS and used AWS cloudshell to SSH into it.

Exploring AWS CloudShell and the AWS Cloud9 IDE

sipsdaoracle — Fri, 05 May 2023 14:39:12 +0000

As a graduate trainee in the AWS re/Start program I've decided to write about my experiences by documenting and creating tutorials and so this will be my first article covering one of the lab practicals.

This article is based on the AWS lab practical - AWS Cloud9 IDE which is available on the AWS re/start Canvas platform.

Let's get started.

What is Cloudshell and AWS Cloud9?

AWS CloudShell and AWS Cloud9 IDE are both tools provided by Amazon Web Services (AWS) to help developers build, test, and deploy applications on the AWS platform.

What can you do with AWS Cloud9?

With AWS Cloud9, you can code, build, run, test, debug, and release software in many exciting scenarios and variations.

How does AWS Cloud9 work?

The following diagram shows a high-level overview of how AWS Cloud9 works.

From the diagram (starting at the bottom), you use the AWS Cloud9 IDE, running in a web browser on your local computer, to interact with your AWS Cloud9 environment. A computing resource (for example, an Amazon EC2 instance or your own server) connects to that environment. Finally, your work is stored in an AWS CodeCommit repository or other type of remote repository.

What we'll do and what you should learn by the end of this.

Connect to AWS CloudShell
Run AWS CLI commands
Run AWS software development kit (SDK) code
Create an AWS Cloud9 development environment
Connect to the browser-based IDE
Copy files to and from (Amazon S3), CloudShell, and AWS Cloud9
_Install AWS SDK for Python _(Boto3) on an AWS Cloud9 instance
Use AWS Cloud9 to create files and run code files
Connect to an AWS CloudShell environment and explore its capabilities

Duration: It should take approximately 60 minutes

SCENARIO:

This lab is based on a scenario from small café business that sells desserts and coffee.

The owner's daughter Sofía is eager to start developing a web presence for the café.

She thinks that before she starts coding, it would be a good idea to decide on a development environment for developing and running her code.

She decides to explore at least two options available on Amazon Web Services (AWS).

Prerequisite:

An empty S3 bucket bucket

Here is a visual demonstration of how the start of the architecture and and the end of the architecture should look like.

Start Architecture:

End Architecture:

Task 1: Connect to CloudShell and explore.

Step 1: In the AWS Management Console, at the top of the screen, choose the AWS CloudShell icon

A new browser tab opens with the AWS CloudShell interface.

Step 2: Verify that the AWS CLI is installed

Run the following command: aws --version

Step 3: Test the ability to run an AWS CLI command

Run the following simple AWS CLI command: aws s3 ls

A list of the S3 buckets that exist in the account is returned

Step 4: From the Actions menu, choose Tabs layout > Split into columns.

A second terminal window opens.

Step 5: Test the ability to run SDK for Python code.

Download this file to your local computer

Step 6: From the Actions menu, choose Files > Upload file, and then choose Select file. Browse to where the file is and click on Upload

Step 7: In the terminal on the right side, run the following command: cat list-buckets.py

You should see the contents of the file that you uploaded

Step 8: Run the SDK for Python code by issuing the following command: python3 list-buckets.py

The name of the S3 bucket is returned.

You have now used two different programmatic ways to retrieve a list of the S3 buckets that exist in the AWS account.

Step 9: Copy a file from CloudShell to an S3 bucket.

Copy the name of the bucket that includes -sample bucket- in the name.
Copy the list-buckets.py file to the bucket, go to the terminal on the left and run this command (replace with your actual bucket name):

aws s3 cp list-buckets.py s3://<bucket-name>

Update from the café

Sophia would like to build a website, she would like to use a fully featured integrated development environment (IDE) where she can visually write, edit, run, and debug her code.

CloudShell provides the vi and vim terminal-based text editors, but it doesn't provide many of the additional features that Sofía is looking for.

Sofía is eager to explore AWS Cloud9, which is what you will do next!

Task 2: Creating an AWS Cloud9 instance

Step 1: Return to the AWS Management Console browser window.

Step 2: In the search bar at the top of the AWS Management Console, enter Cloud9, and select it.

Choose Create environment.

Step 3: In the Name box, enter MyCloud9.

Step 4: In the Network settings section under Connection,
choose Secure Shell (SSH)

Choose Create .

Step 5: Select the Open link to open your AWS Cloud9 IDE

Task 3: Exploring the AWS Cloud9 IDE

In this task, you will explore some features of the AWS Cloud9 IDE and learn how to use them.

You will also interact with Amazon S3 from the AWS Cloud9 environment.

Finally, you will publish a Hello World webpage in AWS Cloud9 and host the webpage in Amazon S3

This AWS Cloud9 environment runs on an Amazon Elastic Compute Cloud (Amazon EC2) instance that is now running in your AWS account. Notice that the root directory is named MyCloud9, which is the name that you used for your AWS Cloud9 environment.

Step 1: Copy a file from Amazon S3 to your local storage in AWS Cloud9

In the Bash terminal return the name of your bucket by running the following command aws s3 ls

Step 2: Download the list-buckets.py file from Amazon S3 to the local storage on AWS Cloud9

aws s3 cp s3://<bucket-name>/list-buckets.py

The list-buckets.py file should now be listed in the navigation pane.

Step 3: Open a code file that uses the SDK for Python and run it.

Double-click the list-buckets.py file so it opens in the file editor window.

The code displays

The command does not run successfully. Instead, a new tab opens in the bottom panel and you see an error message: ModuleNotFoundError: No module named 'boto3'

Step 4: Return to the Bash terminal and install the SDK for Python libraries by running this command:
sudo pip3 install boto3

Try running the Python code again sudo pip3 install boto3

_ You can also invoke the same code from the Bash terminal directly by running the python3 list-buckets.py command. The Run button is a convenience._

Step 5: Create a new file and upload it to Amazon S3

Choose File > New From Template > HTML File.
Between the
tags, add the following text: Hello World

Step 6: Choose File > Save and save the file as index.html.

Step 7: On the left side of the AWS Cloud9 editor, choose the AWS icon.

Expand the Region—for example, US East (N. Virginia)—expand S3, and then expand your bucket.

The contents of the bucket are listed.

Step 8: Right-click the bucket name and choose Upload File.

In the dialog box that appears, select index.html and choose Upload.

The file is uploaded from the AWS Cloud9 instance to the S3 bucket

Step 9: Access the webpage that's hosted on Amazon S3 from the internet.

Make the index.html file that you uploaded to Amazon S3 publicly accessible by running the following AWS CLI command:

aws s3api put-object-acl --bucket <bucket-name> --key index.html --acl public-read

Step 10: Back in the AWS Management Console, browse to the Amazon S3 console.

Tip: Alternatively, choose the Cloud9 icon in the top left of the Cloud9 IDE and choose Go To Your Dashboard to open the AWS Management Console in a new browser tab.

Step 11: Choose your bucket, choose the index.html file, and choose the Object URL.

The webpage, with your Hello World message, should open.

Update from the café

Sofía is pleased that she identified an IDE that has the features she will need to develop the café website. She likes that AWS Cloud9 offers a graphical text editor, a file browser, a terminal for running AWS CLI commands, and code that uses the AWS SDKs. She's also glad that she knows about the features of CloudShell because it's easy to open from the AWS Management Console. CloudShell also provides some features that are similar to AWS Cloud9, but without the need to run an EC2 instance.

In the next lab, Sofia will use AWS Cloud9 to accomplish her development objectives

How to Deploy and configure servers and database for Azure SQL

sipsdaoracle — Mon, 01 May 2023 18:31:02 +0000

If you have ever wondered and would like to know how to Deploy and configure servers and database for Azure SQL and query some sample data then this article is just the cup of tea you need to get you going.

Before you get started make sure you have the following:

Prerequisites

Azure subscription account (you can create a free trial)
Azure Data Studio
SQL Server Management Studio-SSMS

Firstly in order for you to deploy and configure anything you need to be on the Azure portal and create the server and database for Azure SQL. These two go hand in hand as the database would require a database server in order to run.

STEP 1: Sign in to the Azure portal (https://portal.azure.com).

STEP 2: Create a new resource group for your Azure SQL deployment.

STEP 3: Create a new Azure SQL Server instance.

You will need to specify a server name, choose the subscription, resource group, location, and administrator login and password.

STEP 4: Create a new Azure SQL database.
Search for database and click on SQL Database and click create

Click the + symbol or click on create

Under the Basic Tab:

Select the subscription account and and choose the resource group you previously created.

Fill in the Database name , make sure that the Server you have created is selected, if you have any issues you can always click on the Create new link and add a new server.

Next up is the Service Tier, Compute + storage , the default compute and storage is a bit costly and not really what we need so we'll configure the preferred service tier and go for the basic tier .

Next up you have to configure backups and disaster recovery settings for your Azure SQL database.
By default, Azure SQL Database stores backups in geo-redundant storage blobs that are replicated to a paired region. Geo-redundancy helps protect against outages that affect backup storage in the primary region.

Under the Networking tab:

Configure firewall settings for the server. By default, Azure SQL will block all connections that originate outside of Azure.

Set the connectivity method to Public Endpoint . Adjust the firewall settings to *Yes * to Allow access to the server, and to add the current client IP address

Under the Additional Settings tabs:

You can choose to create an empty database, import an existing database, or create a database from a template. For this exercise you can select use sample data .

Now you can create and deploy your database.
Once it has completed deploying you can click on the Go to resource button to navigate your database resources and settings.

Now you need to configure you firewall.

Add a client IP address. You can use the Azure portal to specify which IP addresses or ranges can access your Azure SQL server.

STEP 5: Test your connection

Test the connection to the Azure SQL database to ensure that everything is working as expected.

Click on Open with and choose Azure Data Studio

Click Launch it now link

Click Open Azure Data Studio

Connect by entering the details of your database and sql server

Well done you have connected and here is your database

If you have downloaded Microsoft SQL Server Management Studio
You can simply open the app and connect to the database.

Congratulations! Here is your database

STEP 6: Query data
You can go a step further and query some data as indicated below and execute to run the query.

SELECT * FROM SalesLT.Product
WHERE color = 'red';

Summary
What we have done and learned in summary is the process of setting up infrastructure to host and manage data in a scalable and secure manner on Microsoft's cloud platform, Azure.

We went a step further and connected the database to SQL Server Management Studio-SSMS.

Lastly we queried some sample data that is provided by Microsoft.

How to Build your first Static Web App on Azure

sipsdaoracle — Sun, 30 Apr 2023 19:03:52 +0000

Building a Static Web App might sound a bit intimidating especially if you're a beginner to using cloud platforms such as Azure. You might wonder why do you even need to build one? And with your busy schedule, you might ask how long will it take you to complete.

Well, here's a []minute read that takes you step by step, answering those questions, putting your doubts and worries to rest so you can get to building your very first Static Web App using Azure.

Alright now let's get started.

Prerequisite

Create an Azure subscription free trial account.
GitHub account

Firstly, you need to decide on which hosting platform you are going to use to host your static web app, you can choose between Github or Azure DevOps in this tutorial we are going to choose Github .

Step 1: Create A Repository

In this instance we are going to navigate to the following
location to create a new repository:
https://github.com/staticwebdev/react-basic/generate
Name your repository my-first-static-web-app
Select Create repository from template.

Here is the repository...

Step 2: Create a static web app

Now that we have created our repository we are going to have to create the static web app from Azure Portal

After logging in to the portal:
1.Select Create a Resource.
2.Search for Static Web Apps.
3.Select Static Web Apps.

4.Select Create.
Enter the static web app details as below, enter in the name , choose the region . Under the Deployment details Sign in with Github and then click on Review and Create

Choose the organization and repository and then choose main ** for the branch.
Select **React as your build preset, leave everything as default and click on Review + Create

Deploying...

Step 3: Visit the website

Once deployment is complete click on Go to Resource

Under the Overview pane look for the *URL * and click to open

Congratulations here is your first static web app!

Step 4: Clean up resources

Once you have completed creating and visiting the static web app, you clean up by deleting the static web app to avoid incurring costs.