Forem: Oluwatobiloba Akinbobola

Getting Started with Cloud Marketplace

Oluwatobiloba Akinbobola — Fri, 14 Mar 2025 10:07:15 +0000

INTRODUCTION

In this article, you use Google Cloud Marketplace to quickly and easily deploy a LAMP stack on a Compute Engine instance. The Bitnami LAMP Stack provides a complete web development environment for Linux that can be launched in one click.

Use Cloud Marketplace to deploy a LAMP stack

In the Google Cloud Console, on the Navigation menu, click Marketplace.
In the search bar, type LAMP and then press ENTER.
In the search results, click Bitnami package for LAMP. If you choose another LAMP stack, such as the Google Click to Deploy offering, the lab instructions will not work as expected.
On the LAMP page, click GET STARTED.
On the Agreements page, check the box for Terms and agreements, and click AGREE.
On the Successfully agreed to terms pop up, click DEPLOY. If prompted, click on Enable for the Compute Engine API and the Infrastructure Manager API.
For Zone, select the deployment zone to ZONE
For Machine Type, select E2 as the Series and e2-medium as the Machine Type.
Leave the remaining settings as their defaults.
Click Deploy. If a Welcome to Deployment Manager message appears, click Close to dismiss it. Note: Warnings may appear as the deployment is happening. You can disregard these for this lab. The status of the deployment appears in the console window: lampstack-1 is being deployed. When the deployment of the infrastructure is complete, the status changes to lampstack-1 has been deployed.

Azure Exercise

Oluwatobiloba Akinbobola — Sat, 22 Feb 2025 21:14:16 +0000

Try your hand at this Azure lab exercise and verify your output right here.

Task 1:

Create a virtual network with the following details:
Address Space: 10.0.0.0/16
Subnets:
Subnet 1: 10.0.1.0/24 (Front-end)
Subnet 2: 10.0.2.0/24 (Back-end)
Name the virtual network "VNet-Assessment" and assign appropriate names for subnets.

Presentation 01

Task 2:

Create and associate a Network Security Group (NSG) to the back-end subnet with the following rules:
Allow inbound SSH traffic on port 22 from any source
Deny all inbound HTTP traffic on port 80
Allow all outbound traffic
Assessment Criteria:
NSG configuration and correct association to the subnet
Proper definition of a security rule

Presentation 02

Task 3:

Peering Two Virtual Networks
Create another virtual network called "VNet-Secondary" with the following address space: 10.1.0.0/16.
Peer "VNet-Assessment" and "VNet-Secondary" ensure they can communicate.

Presentation 03

Task 4:

Deploying a Virtual Machine in a VNet
Deploy a Virtual Machine (VM) in the front-end subnet of "VNet-Assessment" using a Linux image. Ensure the VM has a private IP and is accessible only within the virtual network.

Assessment Criteria:
Correct deployment of VM in the right subnet
Proper network settings ensure private IP usage

Presentation 04

Push a Docker Image to Docker Hub

Oluwatobiloba Akinbobola — Mon, 17 Feb 2025 15:04:22 +0000

INTRODUCTION

Pushing a Docker image to Docker Hub is a straightforward process that allows you to share and deploy your containerized applications. Follow these steps:

1.Log in to Docker Hub:
Use the command docker login and enter your Docker Hub credentials when prompted.

docker login

2.Tag Your Image:
Tag your local image with your Docker Hub username and repository name.

docker tag <local-image-name> <docker-hub-username>/<repository-name>:<tag>

Example:

docker tag fastfood brookeycutie/profusion:v1

3.Push the Image:
Push the tagged image to Docker Hub using the docker push command.

docker push <docker-hub-username>/<repository-name>:<tag>

Example:

docker push brookeycutie/profusion:v1

4.Verify on Docker Hub:
Log in to your Docker Hub account and check the repository to confirm the image has been uploaded.

By following these steps, you can easily share your Docker images with others or deploy them across different environments.

Master Docker in Minutes: Your Ultimate Hands-On Guide to Containerization

Oluwatobiloba Akinbobola — Mon, 17 Feb 2025 13:23:31 +0000

INTRODUCTION

Containerization has transformed software development, deployment, and management. Docker, a leading containerization platform, stands out for its simplicity and efficiency. This hands-on lab will guide you through the basics of Docker, empowering you to leverage containerized applications with confidence.

Lab 1: Installing Docker

Install Docker:
- Download Docker Desktop from the official website.
- Follow the installation instructions for your operating system.
Verify Installation:
- Open a terminal or command prompt and run:

docker --version
docker-compose --version

This confirms Docker is installed and ready to use.

Lab 2: Running Your First Container

Step 1: Get the Sample Application

Clone the sample application repository:

git clone https://github.com/docker/welcome-to-docker

Alternatively, download the repository manually.

Step 2: Explore the Dockerfile
A Dockerfile defines the contents of a container. Open the Dockerfile in your project folder to understand its structure.

Step 3: Build Your First Image

Build the Docker image:

docker build -t welcome-to-docker .

The -t flag tags the image with a name (welcome-to-docker).
The . specifies the location of the Dockerfile.

Step 4: Run Your Container
1.Use Docker Desktop to run the container:

Go to the Images tab, select your image, and click Run. 2.Set the Host Port to 8080.

Step 5: View the Frontend

Access the running container via Docker Desktop or navigate to https://docs.docker.com/get-started/introduction/ in your browser.

Step 6: Stop Your Container
Stop the container in Docker Desktop by selecting the Stop icon in the Containers tab.

Summary
This article walked you through building and running your first Docker container. You also learned how to use Docker Desktop to manage containers and images.

Reference
For more advanced use cases, explore images on Docker Hub and refer to the official Docker documentation.

Automate Email Alerts with Azure Logic Apps for New OneDrive Files

Oluwatobiloba Akinbobola — Sat, 15 Feb 2025 18:37:11 +0000

INTRODUCTION

Azure Logic Apps is a powerful cloud service that enables you to automate workflows and integrate services without writing extensive code. In this guide, we will create a Logic App that monitors a specific OneDrive folder and sends an email whenever a new file is added.

Prerequisites

Before proceeding, ensure you have the following:

An Azure subscription (you can sign up for a free trial if needed).
A OneDrive account.
An email account (such as Outlook, Gmail, or Office 365 Mail) to send notifications.

Steps to Create the Logic App

Step 1: Create an Azure Logic App
1.Sign in to Azure Portal: Go to Azure Portal and log in.
2.Create a new Logic App:

In the Azure Portal, search for “Logic Apps” and select it.
Click Create and provide the following details:
Click Review + Create and then Create.

Step 2: Configure the Trigger

Open the Logic App Designer:
- In the Azure Portal, navigate to your newly created Logic App.
- Click Logic App Designer > Blank Logic App.
Add a OneDrive Trigger:
- Click on "When a file is created" (OneDrive trigger).
- Sign in with your OneDrive account to grant permissions.
- Configure the trigger settings:
  - Folder: Select the OneDrive folder to monitor.
  - Interval: Choose how often Azure checks for new files (e.g., every 1 minute).

Step 3: Add an Email Action

Click + New Step and search for "Send an email".
Select an email provider (Outlook, Gmail, or Office 365 Outlook).
Sign in and grant necessary permissions.
Configure the email action:
- To: Enter the recipient’s email address.
- Subject: Example - “New File Added: @{triggerOutputs()?['body/name']}”
- Body: Example - "A new file named @{triggerOutputs()?['body/name']} has been added to OneDrive."

Step 4: Save and Enable the Logic App

Click Save.
Click Run Trigger to test the setup.
Upload a new file to the specified OneDrive folder.
Check your email to confirm the notification.

CONCLUSION

By following these steps, you have successfully created an Azure Logic App that sends an email when a new file is added to a OneDrive folder. This automation can be useful for monitoring file uploads, document management, and real-time notifications.

Building an Event-Driven Azure Function with Node.js and Event Grid

Oluwatobiloba Akinbobola — Fri, 07 Feb 2025 00:17:44 +0000

INTRODUCTION

Azure Functions, combined with Azure Event Grid, provide a powerful serverless solution for building event-driven applications. This guide will create an Azure Function in JavaScript (Node.js) that listens to Event Grid events and logs the event data. This is a great starting point for integrating event-driven architectures into your Azure solutions.

Prerequisites

Before starting, ensure you have the following:

An active Azure account.
Node.js installed on your local machine.
Visual Studio Code (VS Code) with the Azure Functions extension.
Azure Functions Core Tools installed (follow the installation guide.

Step 1: Create a Resource Group

Log in to the Azure Portal.
Search for Resource groups in the top search bar and select it.
Click + Create.
Fill in the required fields:
- Subscription: Select your subscription.
- Resource group: Enter a name like EventGridLabRG.
- Region: Choose a region (e.g., East US).
Click Review + Create, then Create.

Step 2: Create a Storage Account

In the Azure Portal, search for Storage accounts and select it.
Click + Create.
Fill in the details:
- Resource group: Select EventGridLabRG.
- Storage account name: Enter a globally unique name (e.g., eventgridlabstorage).
- Region: Choose the same region (e.g., East US).
- Performance: Standard.
- Replication: Locally-redundant storage (LRS).
Click Review + Create, then Create.

Step 3: Create an Azure Function App

In the Azure Portal, search for Function App and select it.
Click + Create.
Fill in the basis details required
Click Next: Hosting, then select the storage account created earlier (eventgridlabstorage).
Click Review + Create, then Create.

Step 4: Create the Azure Function (Event Grid Trigger)

Open VS Code and install the Azure Functions extension if not already installed.
Press F1 or type > in the search bar, then select Azure Functions: Create New Project.
Select a working folder and choose JavaScript as the runtime.
Select Event Grid Trigger as the function template.
Name the function (e.g., EventGridTrigger).
Deploy the function to Azure using the command:

func azure functionapp publish eventgridfunctionapp

Step 5: Write the Function Code

In the Azure Portal, go to your Function App.
Select the EventGridTrigger function from the Functions list.
Navigate to Code + Test.
Replace the default index.js code with the following:

module.exports = async function (context, eventGridEvent) {
    context.log("Event Grid Event received:");
    context.log(JSON.stringify(eventGridEvent, null, 2));

    // Extract and log details
    const { subject, eventType, data } = eventGridEvent;
    context.log(`Subject: ${subject}`);
    context.log(`Event Type: ${eventType}`);
    context.log(`Data: ${JSON.stringify(data)}`);
};

5.Click Save.

Step 6: Create an Event Grid Topic

In the Azure Portal, search for Event Grid Topics and select it.
Click + Create.
Fill the required basis
Click Review + Create, then Create.

Step 7: Link the Event Grid Topic to the Function

Go to the Event Grid Topic (eventgridlabtopic) in the Azure Portal.
In the left-hand menu, select Event Subscriptions, then click + Event Subscription.
Fill the required basis.
- Name: Enter a name (e.g., EventGridFunctionSubscription).
- Event Schema: Leave as default (Event Grid Schema).
- Endpoint Type: Select Azure Function.
- Endpoint: Select your Function App and the EventGridTrigger function.
Click Create.

Step 8: Test the Function

Go to your Function App in the Azure Portal.
Navigate to Code + Test and click Test/Run.
Enter sample JSON data:

{
  "id": "test-event-id",
  "eventType": "TestEvent",
  "subject": "/example/test",
  "data": {
    "property1": "hello",
    "property2": "world"
  },
  "eventTime": "2025-01-25T12:00:00.000Z",
  "dataVersion": "1.0"
}

4.Click Run.

Step 9: Verify the Function Execution

Go to your Function App in the Azure Portal.
Check the Invocation logs to confirm the function processed the event and logged the data.

Step 10: Clean Up Resources
To avoid unnecessary charges, delete the resource group:

In the Azure Portal, search for Resource groups and select it.
Select EventGridLabRG.
Click Delete resource group, confirm the name, and click Delete.

CONCLUSION

By following this guide, you have successfully created an Event Grid-triggered Azure Function using Node.js. This setup allows you to process and log Event Grid events, enabling seamless integration of event-driven solutions in Azure. This approach is scalable, cost-effective, and ideal for modern cloud applications.

Analyzing billing information using BigQuery

Oluwatobiloba Akinbobola — Fri, 31 Jan 2025 19:07:43 +0000

INTRODUCTION

Google BigQuery is a powerful tool for studying big datasets effectively. In this tutorial, we'll go over how to import billing data into BigQuery, analyze the dataset, and perform SQL queries to glean insightful information.

PROCEDURE

Task 1: Import Data into BigQuery

Sign in to BigQuery and Create a Dataset
- Navigate to the Cloud Console and select BigQuery from the Navigation menu.
- Click the View actions icon next to your project ID (e.g., qwiklabs-gcp) and select Create dataset.
- Specify the basic details
- Click Create Dataset. 2.Create a Table and Import Data
- Click the View actions icon next to billing_dataset and select Create Table.
- For the source and destination, specify:
- Click Create Table. Once the job completes, the table will appear under the dataset in the left pane.

Task 2: Examine the Table

Click on sampleinfotable to view its schema. BigQuery automatically generates this schema based on the imported data, which includes strings, integers, timestamps, and floating values. 2.Navigate to the Details tab to check the number of rows. In this case, the table contains 415,602 rows.
Use the Preview tab to explore a sample of the data.

Task 3: Compose a Simple Query
To analyze the data, construct a query to filter rows where the Cost field is greater than 0:

SELECT * FROM `billing_dataset.sampleinfotable`
WHERE Cost > 0

Run the query to find that 70765 rows have a cost greater than 0.

Task 4: Analyze the Billing Dataset with SQL
1.Retrieve All Billing Data
Run the following query to extract key billing details:

SELECT
  billing_account_id,
  project.id,
  project.name,
  service.description,
  currency,
  currency_conversion_rate,
  cost,
  usage.amount,
  usage.pricing_unit
FROM
  `billing_dataset.sampleinfotable`

This query returns 415,602 rows of billing data.

2.Find the Latest 100 Records with Charges
To identify the most recent charges, use:

SELECT
  service.description,
  sku.description,
  location.country,
  cost,
  project.id,
  project.name,
  currency,
  currency_conversion_rate,
  usage.amount,
  usage.unit
FROM
  `billing_dataset.sampleinfotable`
WHERE
  Cost > 0
ORDER BY usage_end_time DESC
LIMIT 100

3.To find all charges that were more than 10 dollars, for Compose New Query, paste the following in Query Editor:

SELECT
  service.description,
  sku.description,
  location.country,
  cost,
  project.id,
  project.name,
  currency,
  currency_conversion_rate,
  usage.amount,
  usage.unit
FROM
  `billing_dataset.sampleinfotable`
WHERE
  cost > 10

4.Determine the Product with the Most Billing Records
To find the product with the highest number of records, use:

SELECT
  service.description,
  COUNT(*) AS billing_records
FROM
  `billing_dataset.sampleinfotable`
GROUP BY
  service.description
ORDER BY billing_records DESC

The result shows that Compute Engine has the most billing records (281,136).

5.To find the most frequently used product costing more than 1 dollar, for New Query, paste the following in Query Editor:

SELECT
  service.description,
  COUNT(*) AS billing_records
FROM
  `billing_dataset.sampleinfotable`
WHERE
  cost > 1
GROUP BY
  service.description
ORDER BY
  billing_records DESC

The query reveals that Cloud SQL has the most billing records (15) costing over $1.
6.Identify the Most Commonly Charged Unit of Measure
To determine the most frequently charged unit, use:

SELECT
  usage.unit,
  COUNT(*) AS billing_records
FROM
  `billing_dataset.sampleinfotable`
WHERE cost > 0
GROUP BY
  usage.unit
ORDER BY
  billing_records DESC

The result shows that Byte-seconds is the most commonly charged unit.

7.Find the Product with the Highest Aggregate Cost
To calculate the total cost per product, run:

SELECT
  service.description,
  ROUND(SUM(cost),2) AS total_cost
FROM
  `billing_dataset.sampleinfotable`
GROUP BY
  service.description
ORDER BY
  total_cost DESC

This query identifies the product with the highest total cost.

CONCLUSION

BigQuery may be used to import, analyze, and effectively extract insights from massive datasets. Whether you are looking through billing records or running intricate SQL queries, BigQuery gives you the resources you need to make informed decisions.

Implementing Cloud SQL

Oluwatobiloba Akinbobola — Thu, 30 Jan 2025 17:02:29 +0000

INTRODUCTION

In this article, you set up a Cloud SQL server and discover how to use a proxy to connect an application to it over an external connection. You can also set up a connection using a private IP link, improving security and performance. Although we used WordPress as the example application in this lab, the knowledge and best practices may be applied to any application that requires SQL Server.

By the end of this experiment, you will have two functional Wordpress frontend instances connected to their SQL instance backend using two distinct connection types, as illustrated in this diagram:

ARCHITECTURAL DIAGRAM

PROCEDURE

Task 1. Create a Cloud SQL database
Configure a SQL server according to Google Cloud best practices and create a Private IP connection.
1.On the Navigation menu, click SQL.
2.Click Create instance.

3.Click Choose MySQL.

4.Specify and leave the remaining settings as their defaults
Note: Note the root password; it will be used in a later step and referred to as [ROOT_PASSWORD].
5.Expand Show configuration options.
6.Expand the Machine configuartion section.
7.Provision the right amount of vCPU and memory. To choose a Machine configuration, click the dropdown menu, and then explore your options.
8.For this lab, select Dedicated core from the dropdown menu, and then select 1 vCPU, 3.75 GB.
9.Next, expand the Storage section and then choose Storage type and Storage capacity.
10.Click each of the capacity options to see how it affects the throughput. Reset the option to 10GB.
11.Expand the Connections section.
12.Select Private IP.
13.In the Network dropdown, select default.
14.Click the Set up Connection button that appears.

15.In the panel to the right, click Enable API, click Use an automatically allocated IP range, click Continue, and then click Create Connection.
16.Click Create Instance at the bottom of the page to create the database instance.

Task 2. Configure a proxy on a virtual machine
1.On the Navigation menu click Compute Engine.
2.Click SSH next to wordpress-proxy.

3.Download the Cloud SQL Proxy and make it executable:

wget https://dl.google.com/cloudsql/cloud_sql_proxy.linux.amd64 -O cloud_sql_proxy && chmod +x cloud_sql_proxy

In order to start the proxy, you need the connection name of the Cloud SQL instance. Keep your SSH window open and return to the Cloud Console.
4.On the Navigation menu, click SQL.

5.Click on the wordpress-db instance and wait for a green checkmark next to its name, which indicates that it is operational (this could take a couple of minutes).

6.Note the connection name it will be used later and referred to as [SQL_CONNECTION_NAME].
7.In addition, for the application to work, you need to create a table. Click Databases.
8.Click Create database, type wordpress, which is the name the application expects, and then click Create.

9.Return to the SSH window and save the connection name in an environment variable, replacing [SQL_CONNECTION_NAME] with the unique name you copied in a previous step:

export SQL_CONNECTION=[SQL_CONNECTION_NAME]

10.To verify that the environment variable is set, run:

echo $SQL_CONNECTION

The connection name should be printed out.
11.To activate the proxy connection to your Cloud SQL database and send the process to the background, run the following command:

./cloud_sql_proxy -instances=$SQL_CONNECTION=tcp:3306 &

The expected output is:

Listening on 127.0.0.1:3306 for [SQL_CONNECTION_NAME]
Ready for new connections

12.Press ENTER.

Task 3. Connect an application to the Cloud SQL instance
Connect a sample application to the Cloud SQL instance.
1.Configure the Wordpress application. To find the external IP address of your virtual machine, query its metadata:

curl -H "Metadata-Flavor: Google" http://169.254.169.254/computeMetadata/v1/instance/network-interfaces/0/access-configs/0/external-ip && echo

2.Go to the wordpress-proxy external IP address in your browser and configure the Wordpress application.
3.Click Let's Go.

4.Specify and replacing [ROOT_PASSWORD] with the password you configured upon machine creation, and leave the remaining settings as their defaults

5.Click Submit.
6.When a connection has been made, click Run the installation to instantiate Wordpress and its database in your Cloud SQL. This might take a few moments to complete.

7.Populate your demo site's information with random information and click Install Wordpress. You won't have to remember or use these details.

8.When a 'Success!' window appears, remove the text after the IP address in your web browser's address bar and press ENTER.
You'll be presented with a working Wordpress Blog!

Task 4. Connect to Cloud SQL via internal IP
1.In the Cloud Console, on the Navigation menu, click SQL.
2.Click wordpress-db.
3.Note the Private IP address of the Cloud SQL server; it will be referred to as [SQL_PRIVATE_IP].

4.On the Navigation menu, click Compute Engine.
5.Copy the external IP address of wordpress-private-ip, paste it in a browser window, and press ENTER.

6.Click Let's Go.

7.Specify and leave the remaining settings as their defaults

8.Click Submit.
9.Click Run the installation.
An 'Already Installed!' window is displayed, which means that your application is connected to the Cloud SQL server over private IP.

10.In your web browser's address bar, remove the text after the IP address and press ENTER.
You'll be presented with a working Wordpress Blog!

CONCLUSION

We have successfully created a Cloud SQL database and configured it with a secure proxy and Private IP for better security and performance. Private IP works only if the application and Cloud SQL server share the same region and VPC. For different regions, VPCs, or projects, use a proxy for a secure external connection.

Mastering Azure SQL Database: A Practical Guide to SSMS Integration

Oluwatobiloba Akinbobola — Wed, 29 Jan 2025 15:28:00 +0000

INTRODUCTION

A completely managed relational database service, Azure SQL Database enables smooth interaction with SQL Server Management Studio (SSMS). This tutorial explains setting up security settings, creating an Azure SQL database, and running SQL queries.

PROCEDURE

Part 1: Creating an Azure SQL Database

Sign in to Azure Portal
- Navigate to Azure Portal and log in.
Create a New SQL Database
- Click Create a resource > Search for SQL Database > Select Create.
Configure Database Settings
- Choose a subscription and resource group.
- Provide a Database Name
- Click Create new server, set authentication to SQL auth only, define an admin login and password, and select a region.
- Choose Basic pricing for this lab.
- Click Review + create > Create.
Configure Firewall Rules
- Navigate to SQL Server > Networking.
- Click Add Client IP > Save.

Part 2: Connecting to Azure SQL Database with SSMS

Launch SSMS on your computer.
Connect to the Server
- Server type: Database Engine.
- Server name: Copy from Azure Portal.
- Authentication: SQL Server Authentication.
- Login: Use the admin username and password.
- Click Connect.
Expand Databases in Object Explorer to view.

Part 3: Running SQL Queries in SSMS
1.Create a Table

CREATE TABLE Employees (
    EmployeeID INT PRIMARY KEY,
    FirstName NVARCHAR(50),
    LastName NVARCHAR(50),
    Email NVARCHAR(100)
);

Click Execute.

2.Insert Data

INSERT INTO Employees (EmployeeID, FirstName, LastName, Email)
VALUES (1, 'John', 'Doe', 'john.doe@example.com'),
       (2, 'Jane', 'Smith', 'jane.smith@example.com');

Click Execute.

3.Query the Data

SELECT * FROM Employees;

Click Execute.

4.Update and Delete Data

UPDATE Employees SET Email = 'johndoe@newmail.com' WHERE EmployeeID = 1;
DELETE FROM Employees WHERE EmployeeID = 2;

Click Execute.

Part 4: Additional Features

Query Performance Insight
- Navigate to your database in the Azure Portal.
- Under Intelligent Performance, open Query Performance Insight to monitor slow queries.
Enable Automatic Tuning
- Go to Automatic tuning > Enable options like Force Last Good Plan.
Backup and Restore
- Azure SQL Database provides automatic backups.
- To restore, go to Backups > Point-in-time restore.

Writing SQL Queries in Azure Portal
1.Open Query Editor in Azure Portal under SQL Database > Query Editor (preview).
2.Log in using SQL Authentication.
3.Run Queries Directly in the Portal

CREATE TABLE Customers (
    CustomerID INT PRIMARY KEY,
    FirstName NVARCHAR(50),
    LastName NVARCHAR(50),
    PhoneNumber NVARCHAR(15)
);

Click Run.

CONCLUSION

This guide covered creating and configuring an Azure SQL Database, connecting to SSMS, executing SQL queries, and exploring advanced features like performance insights and backups. These foundational skills are essential for managing databases in a cloud environment.

Optimizing Cloud Storage Operations: Access, Encryption, and Data Management.

Oluwatobiloba Akinbobola — Mon, 27 Jan 2025 02:22:57 +0000

INTRODUCTION

Cloud Storage is a core service in Google Cloud, offering a wide range of advanced features essential for modern cloud solutions. This article provides hands-on experience with key Cloud Storage functionalities, enabling you to leverage its capabilities effectively in your designs. Through both the Google Cloud Console and the gsutil command-line tool, you will learn to create and manage buckets, configure access control lists for security, utilize custom encryption keys, implement version control, enable directory synchronization, and share buckets across projects using IAM. These skills are critical for optimizing storage management and ensuring secure, scalable, and collaborative cloud environments.

PROCEDURE

Task 1. Preparation

Open Google Console.
Create a Cloud Storage bucket
1.On the Navigation menu, click Cloud Storage > Buckets.
2.Click Create.
3.Specify the following, and leave the remaining settings as their defaults:
4.Make a note of the bucket name. It will be used later in this lab and referred to as [BUCKET_NAME_1].
5.Click Create.

Download a sample file using CURL and make two copies
1.In the Cloud Console, click Activate Cloud Shell.
2.If prompted, click Continue.
3.Store [BUCKET_NAME_1] in an environment variable:

export BUCKET_NAME_1=<enter bucket name 1 here>

4.Verify it with echo:

echo $BUCKET_NAME_1

5.Run the following command to download a sample file (this sample file is a publicly available Hadoop documentation HTML file):

curl \
https://hadoop.apache.org/docs/current/\
hadoop-project-dist/hadoop-common/\
ClusterSetup.html > setup.html

6.To make copies of the file, run the following commands:

cp setup.html setup2.html
cp setup.html setup3.html

Task 2. Access control lists (ACLs)

Copy the file to the bucket and configure the access control list
1.Run the following command to copy the first file to the bucket:

gcloud storage cp setup.html gs://$BUCKET_NAME_1/

2.To get the default access list that's been assigned to setup.html, run the following command:

gsutil acl get gs://$BUCKET_NAME_1/setup.html  > acl.txt
cat acl.txt

3.To set the access list to private and verify the results, run the following commands:

gsutil acl set private gs://$BUCKET_NAME_1/setup.html
gsutil acl get gs://$BUCKET_NAME_1/setup.html  > acl2.txt
cat acl2.txt

4.To update the access list to make the file publicly readable, run the following commands:

gsutil acl ch -u AllUsers:R gs://$BUCKET_NAME_1/setup.html
gsutil acl get gs://$BUCKET_NAME_1/setup.html  > acl3.txt
cat acl3.txt

Examine the file in the Cloud Console
1.In the Cloud Console, on the Navigation menu, click Cloud Storage > Buckets.
2.Click [BUCKET_NAME_1].
3.Verify that for file setup.html, Public access has a Public link available.

Delete the local file and copy back from Cloud Storage
1.Return to Cloud Shell. If necessary, click Activate Cloud Shell.
2.Run the following command to delete the setup file:

rm setup.html

3.To verify that the file has been deleted, run the following command:

ls

4.To copy the file from the bucket again, run the following command:

gcloud storage cp gs://$BUCKET_NAME_1/setup.html setup.html

Task 3. Customer-supplied encryption keys (CSEK)

Generate a CSEK key
For the next step, you need an AES-256 base-64 key.
1.Run the following command to create a key:

python3 -c 'import base64; import os; print(base64.encodebytes(os.urandom(32)))'

Result (this is example output):

b'tmxElCaabWvJqR7uXEWQF39DhWTcDvChzuCmpHe6sb0=\n'

2.Copy the value of the generated key excluding b' and \n' from the command output. Key should be in form of tmxElCaabWvJqR7uXEWQF39DhWTcDvChzuCmpHe6sb0=.

Modify the boto file
The encryption controls are contained in a gsutil configuration file named .boto.
1.To view and open the boto file, run the following commands:

ls -al

nano .boto

Note: If the .boto file is empty, close the nano editor with Ctrl+X and generate a new .boto file using the gsutil config -n command. Then, try opening the file again with the above commands.

If the .boto file is still empty, you might have to locate it using the gsutil version -l command.

2.Locate the line with "#encryption_key="
Note: The bottom of the nano editor provides you with shortcuts to quickly navigate files. Use the Where Is shortcut to quickly locate the line with the #encryption_key=.
3.Uncomment the line by removing the # character, and paste the key you generated earlier at the end.
Example (this is an example):

Before:
# encryption_key=

After:
encryption_key=tmxElCaabWvJqR7uXEWQF39DhWTcDvChzuCmpHe6sb0=

4.Press Ctrl+O, ENTER to save the boto file, and then press Ctrl+X to exit nano.

Upload the remaining setup files (encrypted) and verify in the Cloud Console
1.To upload the remaining setup.html files, run the following commands:

gsutil cp setup2.html gs://$BUCKET_NAME_1/
gsutil cp setup3.html gs://$BUCKET_NAME_1/

2.Return to the Cloud Console.
3.Click [BUCKET_NAME_1]. Both setup2.html and setup3.html files show that they are customer-encrypted.

Delete local files, copy new files, and verify encryption
1.To delete your local files, run the following command in Cloud Shell:

rm setup*

2.To copy the files from the bucket again, run the following command:

gsutil cp gs://$BUCKET_NAME_1/setup* ./

3.To cat the encrypted files to see whether they made it back, run the following commands:

cat setup.html
cat setup2.html
cat setup3.html

Task 4. Rotate CSEK keys

Move the current CSEK encrypt key to decrypt key
1.Run the following command to open the .boto file:

nano .boto

2.Comment out the current encryption_key line by adding the # character to the beginning of the line.

Note: The bottom of the nano editor provides you with shortcuts to quickly navigate files. Use the Where Is shortcut to quickly locate the line with the encryption_key=.

3.Uncomment decryption_key1 by removing the # character, and copy the current key from the encryption_key line to the decryption_key1 line.
Result (this is example output):

Before:
encryption_key=2dFWQGnKhjOcz4h0CudPdVHLG2g+OoxP8FQOIKKTzsg=

# decryption_key1=

After:
# encryption_key=2dFWQGnKhjOcz4h0CudPdVHLG2g+OoxP8FQOIKKTzsg=

decryption_key1=2dFWQGnKhjOcz4h0CudPdVHLG2g+OoxP8FQOIKKTzsg=

4.Press Ctrl+O, ENTER to save the boto file, and then press Ctrl+X to exit nano.
Note: In practice, you would delete the old CSEK key from the encryption_key line.

Generate another CSEK key and add to the boto file
1.Run the following command to generate a new key:

python3 -c 'import base64; import os; print(base64.encodebytes(os.urandom(32)))'

2.Copy the value of the generated key excluding b' and \n' from the command output. Key should be in form of tmxElCaabWvJqR7uXEWQF39DhWTcDvChzuCmpHe6sb0=.
3.To open the boto file, run the following command:

nano .boto

4.Uncomment encryption and paste the new key value for encryption_key=.
Result (this is example output):

Before:
# encryption_key=2dFWQGnKhjOcz4h0CudPdVHLG2g+OoxP8FQOIKKTzsg=

After:
encryption_key=HbFK4I8CaStcvKKIx6aNpdTse0kTsfZNUjFpM+YUEjY=

5.Press Ctrl+O, ENTER to save the boto file, and then press Ctrl+X to exit nano.

Rewrite the key for file 1 and comment out the old decrypt key
1.Run the following command:

gsutil rewrite -k gs://$BUCKET_NAME_1/setup2.html

2.To open the boto file, run the following command:

nano .boto

3.Comment out the current decryption_key1 line by adding the # character back in.

Result (this is example output):

Before:
decryption_key1=2dFWQGnKhjOcz4h0CudPdVHLG2g+OoxP8FQOIKKTzsg=

After:
# decryption_key1=2dFWQGnKhjOcz4h0CudPdVHLG2g+OoxP8FQOIKKTzsg=

4.Press Ctrl+O, ENTER to save the boto file, and then press Ctrl+X to exit nano.
Note: In practice, you would delete the old CSEK key from the decryption_key1 line.

Download setup 2 and setup3
1.To download setup2.html, run the following command:

gsutil cp gs://$BUCKET_NAME_1/setup2.html recover2.html

2.To download setup3.html, run the following command:

gsutil cp gs://$BUCKET_NAME_1/setup3.html recover3.html

Note: What happened? setup3.html was not rewritten with the new key, so it can no longer be decrypted, and the copy will fail.
You have successfully rotated the CSEK keys.

Task 5. Enable lifecycle management

View the current lifecycle policy for the bucket

Run the following command to view the current lifecycle policy:

gsutil lifecycle get gs://$BUCKET_NAME_1

Note: There is no lifecycle configuration. You create one in the next steps.

Create a JSON lifecycle policy file
1.To create a file named life.json, run the following command:

nano life.json

2.Paste the following value into the life.json file:

{
  "rule":
  [
    {
      "action": {"type": "Delete"},
      "condition": {"age": 31}
    }
  ]
}

Note: These instructions tell Cloud Storage to delete the object after 31 days.
3.Press Ctrl+O, ENTER to save the file, and then press Ctrl+X to exit nano.

Set the policy and verify
1.To set the policy, run the following command:

gsutil lifecycle set life.json gs://$BUCKET_NAME_1

2.To verify the policy, run the following command:

gsutil lifecycle get gs://$BUCKET_NAME_1

Task 6. Enable versioning

View the versioning status for the bucket and enable versioning
1.Run the following command to view the current versioning status for the bucket:

gsutil versioning get gs://$BUCKET_NAME_1

Note: The Suspended policy means that it is not enabled.
2.To enable versioning, run the following command:

gsutil versioning set on gs://$BUCKET_NAME_1

3.To verify that versioning was enabled, run the following command:

gsutil versioning get gs://$BUCKET_NAME_1

Create several versions of the sample file in the bucket
1.Check the size of the sample file:

ls -al setup.html

2.Open the setup.html file:

nano setup.html

3.Delete any 5 lines from setup.html to change the size of the file.
4.Press Ctrl+O, ENTER to save the file, and then press Ctrl+X to exit nano.
5.Copy the file to the bucket with the -v versioning option:

gcloud storage cp -v setup.html gs://$BUCKET_NAME_1

6.Open the setup.html file:

nano setup.html

7.Delete another 5 lines from setup.html to change the size of the file.
8.Press Ctrl+O, ENTER to save the file, and then press Ctrl+X to exit nano.
9.Copy the file to the bucket with the -v versioning option:

gcloud storage cp -v setup.html gs://$BUCKET_NAME_1

List all versions of the file
1.To list all versions of the file, run the following command:

gcloud storage ls -a gs://$BUCKET_NAME_1/setup.html

2.Highlight and copy the name of the oldest version of the file (the first listed), referred to as [VERSION_NAME] in the next step.
Note: Make sure to copy the full path of the file, starting with gs://
3.Store the version value in the environment variable [VERSION_NAME].

export VERSION_NAME=<Enter VERSION name here>

4.Verify it with echo:

echo $VERSION_NAME

Result (this is example output):

gs://BUCKET_NAME_1/setup.html#1584457872853517

Download the oldest, original version of the file and verify recovery
1.Download the original version of the file:

gcloud storage cp $VERSION_NAME recovered.txt

2.To verify recovery, run the following commands:

ls -al setup.html

ls -al recovered.txt

Task 7. Synchronize a directory to a bucket

Make a nested directory and sync with a bucket
1.Run the following commands:

mkdir firstlevel
mkdir ./firstlevel/secondlevel
cp setup.html firstlevel
cp setup.html firstlevel/secondlevel

2.To sync the firstlevel directory on the VM with your bucket, run the following command:

gsutil rsync -r ./firstlevel gs://$BUCKET_NAME_1/firstlevel

Examine the results
1.In the Cloud Console, on the Navigation menu, click Cloud Storage > Buckets.
2.Click [BUCKET_NAME_1]. Notice the subfolders in the bucket.
3.Click on /firstlevel and then on /secondlevel.

4.Compare what you see in the Cloud Console with the results of the following command:

gcloud storage ls -r gs://$BUCKET_NAME_1/firstlevel

5.Exit Cloud Shell:

exit

Task 8. Cross-project sharing

Switch to the second project
1.Open a new incognito tab.
2.Navigate to console.cloud.google.com to open a Cloud Console.
3.Click the project selector dropdown in the title bar.
4.Click All, and then click the second project provided for you in the Qwiklabs Connection Details dialog. Remember that the Project ID is a unique name across all Google Cloud projects. The second project ID will be referred to as [PROJECT_ID_2].
Prepare the bucket
1.In the Cloud Console, on the Navigation menu, click Cloud Storage > Buckets.
2.Click Create.
3.Specify and leave the remaining settings as their defaults
4.Note the bucket name. It will be referred to as [BUCKET_NAME_2] in the following steps.
5.Click Create.
Upload a text file to the bucket
1.Upload a file to [BUCKET_NAME_2]. Any small example file or text file will do.
2.Note the file name (referred to as [FILE_NAME]); you will use it later.
Create an IAM Service Account
1.In the Cloud Console, on the Navigation menu, click IAM & admin > Service accounts.
2.Click Create service account.
3.On Service account details page, specify the Service account name as cross-project-storage.

4.Click Create and Continue.
5.On the Service account permissions page, specify the role as Cloud Storage > Storage Object Viewer.
6.Click Continue and then Done.
7.Click the cross-project-storage service account to add the JSON key.

8.In Keys tab, click Add Key dropdown and select Create new key.

9.Select JSON as the key type and click Create. A JSON key file will be downloaded. You will need to find this key file and upload it in into the VM in a later step.

10.Click Close.
11.On your hard drive, rename the JSON key file to credentials.json.
12.In the upper pane, switch back to [PROJECT_ID_1].

Create a VM
1.On the Navigation menu, click Compute Engine > VM instances.
2.Click Create Instance.
3,On the Machine configuration page, specify and leave the remaining settings as their defaults

4.Click OS and storage.
5.If the Image shown is not Debian GNU/Linux 12 (bookworm), click Change and select Debian GNU/Linux 12 (bookworm), and then click Select.
6.Click Create.

SSH to the VM
1.For crossproject, click SSH to launch a terminal and connect.

Note: If the message appears like Connection via Cloud Identity-Aware Proxy Failed then click Connect without Identity-Aware Proxy.
2.Store [BUCKET_NAME_2] in an environment variable:

export BUCKET_NAME_2=<enter bucket name 2 here>

3.Verify it with echo:

echo $BUCKET_NAME_2

4.Store [FILE_NAME] in an environment variable:

export FILE_NAME=<enter FILE_NAME here>

5.Verify it with echo:

echo $FILE_NAME

6.List the files in [PROJECT_ID_2]:

gcloud storage ls gs://$BUCKET_NAME_2/

Result (this is example output):

AccessDeniedException: 403 404513585876-compute@developer.gserviceaccount.com does not have storage.objects.list access to the Google Cloud Storage bucket.

Authorize the VM
1.To upload credentials.json through the SSH VM terminal, click on the up arrow icon (upload icon) in the upper-right corner, and then click Upload file.
2.Select credentials.json and upload it.
3.Click Close in the File Transfer window.
Verify that the JSON file has been uploaded to the VM:

ls

Result (this is example output):

credentials.json

5.Enter the following command in the terminal to authorize the VM to use the Google Cloud API:

gcloud auth activate-service-account --key-file credentials.json

Verify access
1.Retry this command:

gcloud storage ls gs://$BUCKET_NAME_2/

2.Retry this command:

gcloud storage cat gs://$BUCKET_NAME_2/$FILE_NAME

3.Try to copy the credentials file to the bucket:

gcloud storage cp credentials.json gs://$BUCKET_NAME_2/

Result (this is example output):

Copying file://credentials.json [Content-Type=application/json]...
AccessDeniedException: 403 cross-project-storage@qwiklabs-gcp-02-c638e3daa975.iam.gserviceaccount.com does not have storage.objects.create access to the Google Cloud Storage object.

Modify role
1.In the upper pane, switch back to [PROJECT_ID_2].
2.In the Cloud Console, on the Navigation menu, click IAM & admin > IAM.
3.Click the pencil icon for the cross-project-storage service account (You might have to scroll to the right to see this icon).
4.Click on the Storage Object Viewer role, and then click Cloud Storage > Storage Object Admin.
5.Click Save. If you don't click Save, the change will not be made.

Verify changed access
1.Return to the SSH terminal for crossproject.
2.Copy the credentials file to the bucket:

gcloud storage cp credentials.json gs://$BUCKET_NAME_2/

Result (this is example output):

Copying file://credentials.json [Content-Type=application/json]...
- [1 files][  2.3 KiB/  2.3 KiB]
Operation completed over 1 objects/2.3 KiB.

CONCLUSION

You learned how to create and manage buckets and objects while investigating key Cloud Storage features in this lab. You discovered how to rotate encryption keys, use customer-supplied encryption keys (CSEK) for increased security, and set up access control lists (ACLs) to govern permissions, switching between private and public access as necessary. You also synchronized folders between a virtual machine and a bucket, enabled versioning to restore earlier versions of data, and put lifecycle management policies in place to automatically destroy items after 31 days. Lastly, you used IAM to conduct cross-project resource sharing, which allowed resources to be accessed easily across projects. You can create scalable, effective, and safe cloud storage solutions with these abilities.

Getting Started with Azure Cosmos DB and Node.js: A Step-by-Step Guide

Oluwatobiloba Akinbobola — Sun, 26 Jan 2025 16:57:14 +0000

INTRODUCTION

Microsoft Azure's fully managed NoSQL database solution, Azure Cosmos DB, gives you low latency, scalable, and highly available access to your data. We'll go over how to install the required tools, set up Azure Cosmos DB, and build a basic Node.js application to communicate with the database in this tutorial.

PROCEDURE

Step 1: Set Up Azure Cosmos DB
Before diving into coding, you must set up an Azure Cosmos DB account and create a database and container.
1.Create an Azure Cosmos DB Account:

Log in to the Azure Portal.
Search for "Azure Cosmos DB" and click Create.
Choose the Core (SQL) API and fill in the required details, such as the resource group, account name, and region.
- Click Review + Create, then Create to provision your account.

2.Create a Database and Container:

Navigate to Data Explorer in the Azure Portal once the account is ready.
Create a new database (e.g., ToDoListDB).
Inside the database, create a new container (e.g., Items) and set the partition key (e.g., /id).

Step 2: Install Required Software on Your Local Machine
To build and run the Node.js application, you’ll need to install the following tools:

Install Node.js:
- Visit the Node.js official website and download the latest LTS version.
- Install Node.js, which includes npm (Node Package Manager).
Set Up Your Project:
- Create a new directory for your project:

mkdir cosmosTest && cd cosmosTest

Initialize a new Node.js project:

npm init -y

Install the Azure Cosmos DB SDK:

npm install @azure/cosmos

Step 3: Write a Simple Application to Connect to Cosmos DB
Now, let’s create a basic Node.js application to connect to your Cosmos DB instance.
1.Create a New File:

Open your project in VS Code and create a new file named app.js.

2.Write the Connection Code:

Add the following code to app.js:

const { CosmosClient } = require("@azure/cosmos");

const endpoint = "<your-cosmosdb-endpoint>";
const key = "<your-cosmosdb-key>";
const client = new CosmosClient({ endpoint, key });

const databaseId = "ToDoListDB";
const containerId = "Items";

async function run() {
    const database = client.database(databaseId);
    const container = database.container(containerId);

    // Test insertion
    const { resource: item } = await container.items.create({
        id: "1",
        description: "This is a test item",
        isCompleted: false,
    });
    console.log("Item created successfully: ", item.id);

    // Test retrieval
    const { resource: fetchedItem } = await container.item(item.id).read();
    console.log("Item fetched successfully: ", fetchedItem);
}

run().catch((error) => {
    console.error("Error occurred:", error);
});

Replace <your-cosmosdb-endpoint> and <your-cosmosdb-key> with your actual Cosmos DB endpoint and key. These can be found in the Keys section of your Cosmos DB account in the Azure Portal. Step 4: Run and Test the Application With the code in place, it’s time to run and test your application. 1.Run the Application:
In the terminal, navigate to your project directory and run:

node app.js

2.Check the Output:

If everything is set up correctly, you should see output similar to:

Item created successfully: 1
Item fetched successfully: { id: 'Wakefield.7', description: 'This is a test item', isCompleted: false }

3.Verify in Azure Portal:

Go to your Azure Cosmos DB account in the Azure Portal.
Navigate to Data Explorer > ToDoListDB > Items.
You should see the document created by your script.

CONCLUSION

Well done! You have successfully installed the required tools, configured Azure Cosmos DB, and developed a basic Node.js application to communicate with your database.

Deploy a Web App using Azure CLI and ARM Template

Oluwatobiloba Akinbobola — Mon, 20 Jan 2025 16:13:22 +0000

INTRODUCTION

Azure CLI and ARM (Azure Resource Manager) templates help make the process of deploying a web application on Azure more efficient. By defining your infrastructure as code using ARM templates, deployments become consistent and repeatable. This is a detailed tutorial on how to use an ARM template and the Azure CLI to launch a PHP web application.

PROCEDURE

Step 1: Create the ARM Template
1.Create a new folder e.g. web-app using this code.

cd web-app

2.The ARM template (template.json) defines the resources needed for your web app, such as the App Service Plan and the Web App itself. Here’s the template:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [
    {
      "type": "Microsoft.Web/serverfarms",
      "apiVersion": "2021-01-15",
      "name": "[parameters('appServicePlanName')]",
      "location": "[resourceGroup().location]",
      "sku": {
        "name": "F1",
        "tier": "Free",
        "size": "F1",
        "family": "F",
        "capacity": 1
      }
    },
    {
      "type": "Microsoft.Web/sites",
      "apiVersion": "2021-01-15",
      "name": "[parameters('webAppName')]",
      "location": "[resourceGroup().location]",
      "properties": {
        "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', parameters('appServicePlanName'))]",
        "siteConfig": {
          "appSettings": [
            {
              "name": "SCM_DO_BUILD_DURING_DEPLOYMENT",
              "value": "true"
            }
          ]
        }
      }
    }
  ],
  "parameters": {
    "appServicePlanName": {
      "type": "string"
    },
    "webAppName": {
      "type": "string"
    }
  }
}

Step 2: Define Parameters
The parameters.json file provides values for the parameters defined in the ARM template:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "appServicePlanName": {
      "value": "myAppServicePlan"
    },
    "webAppName": {
      "value": "akinWebApp987"
    }
  }
}

Step 3: Create a Resource Group
Before deploying, create a resource group to hold your resources:

az group create --name web-rg --location eastus

Step 4: Create the App Service Plan (if it doesn’t exist)
If the App Service Plan does not exist, you can create it manually using the Azure CLI:

az appservice plan create --name myAppServicePlan --resource-group web-rg --sku F1 --location eastus

This creates a new App Service Plan named myAppServicePlan with the Free tier (F1).

Step 5: Deploy the ARM Template
Use the Azure CLI to deploy the ARM template and parameters file:

az deployment group create --resource-group web-rg --template-file template.json --parameters parameters.json

This command will:

Create an App Service Plan (Free tier).
Deploy a Web App linked to the App Service Plan.

Step 6: Deploy Code from GitHub
To deploy your PHP application code from a GitHub repository, use the following command:

az webapp deployment source config --name akinWebApp987 --resource-group web-rg --repo-url https://github.com/yourtechie/fruitables --branch master --manual-integration

This command connects your web app to the GitHub repository and deploys the code.

CONCLUSION

Create an ARM template, deploy Azure CLI, and connect the web app to GitHub for continuous deployment, ensuring a consistent, automated process for managing and scaling the web app on Azure.