<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by ifeanyi marvelous akpati on Medium]]></title>
        <description><![CDATA[Stories by ifeanyi marvelous akpati on Medium]]></description>
        <link>https://medium.com/@akpatiifeany?source=rss-cf8cd6654d2e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*kCjzarzpozHC3UJUKtz5wg.jpeg</url>
            <title>Stories by ifeanyi marvelous akpati on Medium</title>
            <link>https://medium.com/@akpatiifeany?source=rss-cf8cd6654d2e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 09:37:21 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@akpatiifeany/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[-]]></title>
            <link>https://medium.com/@akpatiifeany/charitize-fe597598e782?source=rss-cf8cd6654d2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/fe597598e782</guid>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[jenkins-pipeline]]></category>
            <category><![CDATA[configuration]]></category>
            <category><![CDATA[acr]]></category>
            <dc:creator><![CDATA[ifeanyi marvelous akpati]]></dc:creator>
            <pubDate>Sat, 14 Nov 2026 08:59:20 GMT</pubDate>
            <atom:updated>2026-11-14T12:32:00.835Z</atom:updated>
            <content:encoded><![CDATA[<h3>AUTOMATED CI/CD AND SECURE CLOUD DEPLOYMENT ON MICROSOFT AZURE USING JENKINS, DOCKER, AZURE CONTAINER REGISTRY (ACR), TERRAFORM &amp; HTTPs</h3><h3>INTRODUCTION</h3><p>This project focuses on deploying the Charitize PHP web application to Microsoft Azure using Jenkins, Docker, Terraform, Azure Container Registry (ACR) and HTTPs.</p><p>I used Docker to containerize the application, GitHub for source code management, Terraform to provision Azure infrastructure, and Jenkins to automate the CI/CD pipeline. ACR was used to store the Docker image, while SSH provided secure access to the production server.</p><p>The project gave me practical experience in automating application deployment, managing cloud infrastructure and applying DevOps practices in a real-world environment.</p><h3>Project Objectives</h3><p>· Prepare and containerize the Charitize PHP application with Docker.</p><p>· Maintain application and infrastructure code in GitHub.</p><p>· Provision Azure resources using Terraform.</p><p>· Create and configure an Ubuntu-based Jenkins server.</p><p>· Configure Jenkins pipeline integration with GitHub and SSH deployment credentials.</p><p>· Build the Docker image, publish it to Azure Container Registry and deploy the application.</p><p>· Verify the deployed application and configure its domain DNS record.</p><h3>Tools and Technologies</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QUq4TMqTTnCHZ1ksUEaF4A.png" /></figure><h3>Practical Setup Guide: Create the Project Folder and Open It in VS Code</h3><p>Follow these steps on Windows using PowerShell. The commands are shown in separate shaded boxes so they are easy to select and copy into the correct terminal or command prompt.</p><h3>Open PowerShell</h3><p>Open the Start menu, search for Windows PowerShell or Terminal, and open it. Make sure Git, Visual Studio Code, Docker Desktop and the Azure CLI are installed before continuing.</p><h3>Create the project folder you used</h3><pre>cd &quot;$HOME\Desktop&quot;\nmkdir &quot;Php-CICD Pro&quot;\ncd &quot;Php-CICD Pro&quot;</pre><p>These commands create the folder named “Php-CICD Pro” on your Desktop and move PowerShell into it. This matches your recorded working folder: C:\Users\Dell\Desktop\Php-CICD Pro.</p><h3>Open the project folder in Visual Studio Code</h3><pre>code .</pre><p>Run this command while PowerShell is inside Php-CICD Pro. It opens the folder in VS Code, where you can work with the PHP application, Dockerfile, Jenkinsfile and infra folder.</p><h3>Open the integrated terminal in VS Code</h3><pre>Ctrl + `</pre><p>In VS Code, press Ctrl and the backtick key to open the integrated terminal. Check that the terminal is at the Php-CICD Pro project root before running Git or Docker commands.</p><h3>Check the project files</h3><pre>git status\ngit remote -v\ndir</pre><p>Run these commands in the VS Code terminal while the terminal is at the project root. They show the Git working-tree status, the configured remote repository and the files in the folder.</p><h3>Build and run the Docker application locally</h3><pre>docker - version\ndocker ps\ndocker build -t charitize:v1 .\ndocker run -d - name charitize-app -p 8080:80 charitize:v1\ndocker ps</pre><p>Run these commands from the project root, where the Dockerfile is located. The final command checks that the container is running; open <a href="http://localhost:8080/">http://localhost:8080</a> in your browser to test the site.</p><p>If the container name is already in use, stop and remove the old container before running it again:</p><pre>docker stop charitize-app\ndocker rm charitize-app</pre><h3>Configure Git identity (one-time setup)</h3><pre>docker stop charitize-app\ndocker rm charitize-app<br>git config - global user.name &quot;Your GitHub Name&quot;\ngit config - global user.email &quot;your-email@example.com&quot;</pre><p>Replace the example name and email with the identity you use for Git commits. This is a one-time configuration on the computer.</p><h3>Initialize and validate Terraform</h3><p>In the VS Code Explorer, open the infra folder. Open a terminal in that folder, or run the following commands from the project root as shown:</p><pre>cd infra\nterraform init\nterraform fmt -recursive\nterraform validate\nterraform plan</pre><p>Terraform init downloads the required provider, fmt formats the configuration, validate checks it, and plan previews the infrastructure changes. Review the plan before applying it.</p><h3>Provision the Azure infrastructure</h3><pre>terraform apply</pre><p>Run this from the infra folder after reviewing the plan. Terraform asks for confirmation; type yes only after checking the resources and estimated costs. Use the outputs printed after a successful apply to identify the server IP addresses and ACR login server.</p><h3>Connect to the Jenkins Linux virtual machine</h3><pre>ssh -i &quot;C:\path\to\your-private-key.pem&quot; azureuser@&lt;JENKINS_PUBLIC_IP&gt;</pre><p>Replace the key path with the actual private-key file location and replace &lt;JENKINS_PUBLIC_IP&gt; with the Jenkins public IP from Terraform outputs. Keep the private key secure and never upload it to GitHub.</p><pre>sudo cat /var/lib/jenkins/secrets/initialAdminPassword</pre><p>Run this after connecting to the Jenkins VM to display the initial administrator password for the first-time Jenkins setup page.</p><h3>Useful commands after making code changes</h3><pre>git add .\ngit commit -m &quot;Update Charitize application&quot;\ngit push origin main</pre><p>Run these commands from the project root after saving your changes. A push to the configured GitHub branch can trigger the Jenkins pipeline when the repository webhook or SCM polling is configured.</p><h3>Important safety reminders</h3><p>· Do not commit private SSH keys, passwords, Terraform state files or secret values to GitHub.</p><p>· Check the Azure subscription, region, resource names and costs before running terraform apply.</p><p>· Use the actual public IP addresses shown in your Terraform outputs; do not assume an old IP is still current.</p><p>· When finished with the lab, use terraform destroy from the infra folder only if you intend to remove the provisioned resources.</p><p>cd infra\nterraform destroy</p><h3>High-Level CI/CD Workflow</h3><p>. Prepare the Charitize application and Dockerfile, then verify the container locally.</p><p>. Commit and push the project files to the GitHub repository.</p><p>. Define Azure infrastructure in Terraform and validate the configuration.</p><p>. Apply the Terraform configuration to provision the Azure resources, including the application and Jenkins virtual machines and ACR.</p><p>. Connect to the Jenkins server over SSH, complete the initial Jenkins setup and create the pipeline job.</p><p>. Configure the pipeline to retrieve its Jenkinsfile from the GitHub repository and add the required SSH credential.</p><p>. Run the pipeline to build the Docker image, push it to ACR and deploy the application.</p><p>. Verify the application in a browser and update/check the DNS record.</p><h3>Preparing the Charitize project and checking local tools</h3><pre>az version<br>git --version<br>Get-Content Dockerfile<br>docker images</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*lPRR9_q4ulWYoUdNxpWCWA.png" /></figure><p>The VS Code workspace shows the PHP Charitize application, Dockerfile, Jenkinsfile and supporting project files. The terminal verifies the Azure CLI and Git versions, displays the Dockerfile content, and lists the locally available Docker images including the Charitize image.</p><h3>Checking and starting the Charitize container</h3><pre>docker ps<br>docker start charitize-app<br>docker ps</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*mgXGsWDssm3MlrlT5meaKA.png" /></figure><p><em>These commands check the running containers, start the existing Charitize container, and check the container list again.</em></p><h3>Verifying the Charitize website locally</h3><p>The browser displays the Charitize charity website homepage, including its navigation menu and main banner. This provides a visual check that the web application is available and rendering in a browser.</p><p><strong>Repository address</strong></p><pre>https://github.com/MarvDev-Arch/Charitize-Azure-Jenkins-DevOps.git</pre><p><strong>Browser evidence</strong></p><pre>http://localhost:8080</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*SCi99EjaG76lb36mjuKHuA.png" /></figure><p><strong>Terraform file</strong></p><pre>infra/variables.tf</pre><h3>Configuring Git identity and checking the repository</h3><pre>git config - global user.name &quot;…&quot;<br> git config - global user.email &quot;…&quot;<br> git status<br> git log - oneline<br> git remote -v</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*fOBD9Dtf-fy7G5dBYRRJMw.png" /></figure><p><em>This shows Git identity configuration followed by repository status, commit history and remote checks. The exact username and email values are not legible in the screenshot, so they are not guessed here.</em></p><h3>Reviewing the Charitize GitHub repository</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*GNjTRNt4mm02K5w8YzWWmg.png" /></figure><p>The GitHub page shows the project repository and its tracked source files. This provides evidence that the application and deployment-related files are maintained in a remote Git repository for version control and collaboration.</p><h3>Reviewing Terraform infrastructure files</h3><pre>cd infra<br> Get-ChildItem<br> Get-Content versions.tf</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*JhV-bLZLbo61Fr_0uudmIQ.png" /></figure><p><em>These commands enter the infrastructure folder, list its files, and display the Terraform provider/version configuration.</em></p><p><strong>Jenkins setup action</strong></p><p>Complete the Create First Admin User form and select Save and Continue.</p><p><em>Enter your own administrator details securely.</em></p><h3>Reviewing Terraform input variables</h3><p>The `variables.tf` file defines inputs for the Azure subscription, deployment location, project name, administrator IP range, SSH public key and virtual machine size. The visible defaults include West US 3, the project name `charitize` and a Standard_B2s VM size.</p><pre>Get-Content variables.tf</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*c5T7ddFSRSg1eRfHSUvd4Q.png" /></figure><h3>Formatting and validating Terraform configuration</h3><p><strong>Jenkins dashboard action</strong></p><pre>terraform fmt<br> terraform validate<br> terraform plan</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*b5qC7M7fOiX2czqzaamYww.png" /></figure><p><em>These are the Terraform formatting, validation and planning commands shown in the terminal. The validation output reports that the configuration is valid.</em></p><p><strong>Jenkins job setup action</strong></p><p>Select New Item → enter Charitize-CI-CD → choose Pipeline → select OK.</p><p><em>These are the Jenkins interface actions used to create the pipeline job.</em></p><p><strong>Pipeline SCM configuration</strong></p><pre>Repository URL: https://github.com/MarvDev-Arch/Charitize-Azure-Jenkins-DevOps.git<br> Branch: */main<br> Script path: Jenkinsfile<br> SCM polling schedule: H/5</pre><p><em>Enter these values in the Jenkins Pipeline configuration when using Pipeline script from SCM. The polling schedule checks the configured source repository approximately every five minutes.</em></p><h3>Inspecting the Terraform plan and infrastructure files</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*YfDfsB_dmT8V_QX_7-fE-w.png" /></figure><p>The VS Code Explorer shows the Terraform state files and the infrastructure configuration files in the project directory. The terminal output shows Terraform planning the creation of the Azure Linux application virtual machine and associated infrastructure.</p><pre>terraform plan</pre><h3>Applying the Terraform configuration</h3><p><strong>Jenkins plugin setup action</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*danx1eLmlJuWFvo94H3I4w.png" /></figure><p><em>The screenshot records the Jenkins console result. These are pipeline stages executed by the Jenkinsfile, not commands to paste into a terminal; consult the Jenkinsfile in the repository for the exact stage implementation</em></p><pre>terraform apply</pre><p><strong>Pipeline result</strong></p><p>Jenkins pipeline stages: checkout → PHP syntax validation → Docker build → Azure login → push to ACR → SSH deployment.</p><p><em>Jenkinsfile in the repository for the exact stage implementation.</em></p><h3>Confirming Azure infrastructure creation and connecting to Jenkins</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*ZnlbVNRPYmb-H4CyyM9hPQ.png" /></figure><p>Terraform reports that the apply completed with four resources added and provides outputs for the ACR login server, application public IP, Jenkins public IP and VM names. The Azure CLI output shows both virtual machines running, and the SSH command connects to the Jenkins VM using the configured private key.</p><pre>az vm list -d -o table<br> ssh -i &quot;$env:USERPROFILE\.ssh\charitize-azure&quot; azureuser@20.118.174.102</pre><p><strong>Git change / pipeline trigger</strong></p><pre>git add .<br> git commit -m &quot;Update homepage for CI/CD testing&quot;<br> git push origin main</pre><h3>Accessing the Jenkins server and retrieving its initial password</h3><p><strong>Azure portal action</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*IdK_nk-vKGp9bPD6zSflGg.png" /></figure><pre>sudo cat /var/lib/jenkins/secrets/initialAdminPassword</pre><p><strong>DNS record values</strong></p><pre>Type: A<br> Host/name: ifycharitizeapp.name.ng<br> Points to: 172.182.220.228<br> TTL: 14400 seconds</pre><h3>Unlocking Jenkins</h3><p><strong>Jenkins browser step</strong></p><p>Copy the initial administrator password from the server and paste it into the Unlock Jenkins page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*wcGm3fmhXk2L8q3yuJAf8w.png" /></figure><p>The Jenkins setup wizard displays the Unlock Jenkins page and requests the initial administrator password. This step authenticates the administrator and allows the first-time Jenkins configuration to continue.</p><h3>Choosing Jenkins plugins</h3><p><strong>Jenkins browser step</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*aDuvMIYbYp-pxXYL0INDTg.png" /></figure><p>The setup wizard presents the option to install suggested plugins or select plugins manually. The suggested-plugins option is highlighted, providing a straightforward initial plugin setup for the Jenkins server. Select Install suggested plugins.</p><h3>Creating the first Jenkins administrator</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*N1aa_WWRJ-QL480C5FCbiw.png" /></figure><p>The Jenkins wizard displays the Create First Admin User form with fields for username, password, full name and email address. Completing this form establishes the administrator account used to manage Jenkins. Complete the Create First Admin User form.</p><h3>Configuring the Jenkins instance URL</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*PMKLN2Lwq7S5Cf-Rq8PbIA.png" /></figure><p>The Instance Configuration page asks the administrator to confirm the Jenkins URL. This URL is important because Jenkins uses it when generating links in notifications and other system-generated messages.</p><pre>TConfirm the Jenkins URL: http://20.118.174.102:8080/</pre><h3>Completing the Jenkins setup</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*RAzq8UT6efDYuaZkx0_RNw.png" /></figure><p>The setup wizard displays the Jenkins is ready confirmation after the initial configuration steps. The administrator can select Start using Jenkins to enter the Jenkins dashboard. Select Start using Jenkins.</p><h3>Opening the Jenkins dashboard</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*WRhn-8WRgtsmjPb9kb-LFQ.png" /></figure><p>The Jenkins dashboard is displayed with the welcome message and the main navigation options. From this page, the administrator can create jobs, manage credentials, configure plugins and monitor pipeline activity.</p><h3>Creating a new Jenkins pipeline job</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*QTbdztsdewahcke5IMa-SQ.png" /></figure><p>The New Item page contains the job name `Charitize-CI-CD` and shows Pipeline as the selected job type. Choosing Pipeline creates a job that can define multiple automated build, test and deployment stages.</p><p>Create a new item named Charitize-CI-CD.<br> Select Pipeline, then continue.</p><h3>Configuring the pipeline to use GitHub</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*Yd_FSjedpxDxpjkA8IjfNA.png" /></figure><p>The pipeline configuration uses the Pipeline script from SCM option and selects Git as the source control system. The repository URL points to the Charitize Azure Jenkins DevOps GitHub repository, allowing Jenkins to retrieve the pipeline definition from source control.</p><p><strong>Pipeline configuration shown</strong></p><p>Definition: Pipeline script from SCM<br> SCM: Git<br> Repository URL: <a href="https://github.com/MarvDev-Arch/Charitize-Azure-Jenkins-DevOps.git">https://github.com/MarvDev-Arch/Charitize-Azure-Jenkins-DevOps.git</a></p><h3>Selecting an SSH credential type</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*8IhIeqyradgh1YVdDRDcIw.png" /></figure><p>The Jenkins Add Credentials window is open, and “SSH Username with private key” is selected. This credential type is appropriate when a pipeline needs to authenticate to a remote Linux server using an SSH private key.</p><p><strong>Jenkins credential selection</strong></p><p>SSH Username with private key</p><h3>Saving the production SSH credential</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*sudoiCMYImbH8Gv70UynFA.png" /></figure><p>The Jenkins Global credentials page shows a credential named “charitize-prod-ssh” with the username “azureuser”. Its description identifies it as the Charitize production SSH credential, making it easier to select in pipeline configuration.</p><p><strong>Credential details shown</strong></p><p>Credential ID: charitize-prod-ssh_azureuser</p><h3>Installing the SSH Agent plugin</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*pOvh5uVHToOae9j9ZIh99w.png" /></figure><p>The Available plugins page shows the SSH Agent plugin selected for installation. This plugin enables Jenkins jobs to make configured SSH credentials available to build steps that need SSH authentication.</p><p><strong>Jenkins plugin selection</strong></p><p>Manage Jenkins → Plugins → Available plugins → search SSH Agent → Install</p><h3>Running and tracking Jenkins builds</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*5hMPSu-DYXAldDDQy8kg4A.png" /></figure><p>The Charitize-CI-CD job page shows the Build Now action and a build history containing successful and failed runs. Green status icons indicate successful builds, while the red icon identifies a failed run that can be investigated through its console output.</p><p><strong>Jenkins browser step</strong></p><p>Open Charitize-CI-CD and select Build Now.</p><h3>Reviewing the successful pipeline console output</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*JmsK5Ex5i47uejLNXU2SBw.png" /></figure><p>The Jenkins console output states that Charitize was built, pushed to ACR and deployed successfully. The final status is “Finished: SUCCESS”, confirming that this pipeline execution completed without a reported pipeline failure.</p><p><strong>Pipeline output shown</strong></p><p>docker image prune -f<br> Charitize built, pushed to ACR and deployed successfully.<br> Finished: SUCCESS</p><h3>Verifying the deployed Charitize website</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*Dd60cjEsJmpG0_3SIMhQdg.png" /></figure><p>The browser displays the Charitize website at the public IP address 20.38.13.213. The visible homepage confirms that the application responds in a browser after deployment, providing a basic application-level verification. <strong>Browser verification</strong>Open the deployed Charitize website in the browser.</p><h3>Confirming a pipeline run triggered by a Git change</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*XPdB9fzl3ED9ODjknLAPfQ.png" /></figure><p>Jenkins build #6 is marked successful and shows that it was started by an SCM change. The build details identify the Charitize GitHub repository and show a commit message describing a homepage update for CI/CD testing.</p><p><strong>Jenkins build evidence</strong></p><p>Started by an SCM change<br> Commit message: Update Charitize homepage for CI/CD testing</p><h3>Reviewing Azure resource groups</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*SViF_6xiEoNQm9fUamdXeA.png" /></figure><p>The Azure portal Resource groups page shows the resource groups `charitize-rg` and `NetworkWatcherRG` under Azure subscription 1. Both entries are displayed in the West US 3 region, providing evidence of the Azure resource-group environment.</p><p><strong>Azure portal step</strong></p><p>Azure portal → Resource groups → charitize-rg</p><h3>Updating the domain DNS A record</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*Eo0iwPlMtfnnSd7ezwSVPg.png" /></figure><p>The DNS Manager page shows an A record for `ifycharitizeapp.name.ng` pointing to `172.182.220.228`, with a TTL of 14400 seconds. The successful update message indicates that the DNS record changes were saved by the DNS management portal.</p><p><strong>DNS record values shown</strong></p><p>Host: ifycharitizeapp.name.ng.<br> TTL: 14400<br> Type: A<br> Value: 172.182.220.228</p><h3>Caddy Reverse Proxy and HTTPS</h3><p>Caddy is a web server and reverse proxy. It receives public requests and forwards them to the application running locally on the same VM. It can automatically obtain and renew TLS certificates when DNS and network access are correct.</p><h3>Install Caddy</h3><pre># Ubuntu production VM<br> sudo apt update<br> sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl<br> curl -1sLf &#39;https://dl.cloudsmith.io/public/caddy/stable/gpg.key&#39; | sudo gpg - dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg<br> curl -1sLf &#39;https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt&#39; | sudo tee /etc/apt/sources.list.d/caddy-stable.list<br> sudo apt update<br> sudo apt install caddy -y<br> caddy version</pre><p>The installed version recorded was v2.11.8.</p><h3>Move container to loopback port 8080</h3><pre>docker stop charitize<br> docker rm charitize<br> docker run -d - name charitize - restart unless-stopped -p 127.0.0.1:8080:80 charitizesgjk3u.azurecr.io/charitize:3<br> docker ps<br> sudo ss -tulpn | grep -E &quot;:80|:443|:8080&quot;</pre><h3>Caddyfile</h3><pre>docker stop charitize<br> docker rm charitize<br> docker run -d - name charitize - restart unless-stopped -p 127.0.0.1:8080:80 charitizesgjk3u.azurecr.io/charitize:3<br> docker ps<br> sudo ss -tulpn | grep -E &quot;:80|:443|:8080&quot;</pre><p>sudo nano /etc/caddy/Caddyfile<br> <br> ifycharitizeapp.name.ng, <a href="http://www.ifycharitizeapp.name.ng/">www.ifycharitizeapp.name.ng</a> {<br> reverse_proxy 127.0.0.1:8080<br> }</p><p>In Nano, Ctrl+K cuts the current line; repeat to clear old content. Paste the new configuration. Save with Ctrl+O, Enter, then Ctrl+X.</p><p>sudo caddy validate — config /etc/caddy/Caddyfile<br> sudo systemctl restart caddy<br> sudo systemctl status caddy — no-pager<br> sudo journalctl -u caddy -n 50 — no-pager</p><p>Validation returned ‘Valid configuration’ and the restart command completed. This does not by itself prove a certificate was issued or HTTPS works.</p><h3>HTTPS verification still required</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R8TCHGeqn51HHZSmWNV6bQ.jpeg" /></figure><p>· Create and verify inbound TCP 443 in the production NSG using an authorised Azure account.</p><p>· Confirm inbound TCP 80 is still allowed.</p><p>· Confirm root and www hostnames resolve to the correct public IP.</p><p>· Check Caddy logs for certificate issuance and ACME errors.</p><p>· Open <a href="https://ifycharitizeapp.name.ng/">https://ifycharitizeapp.name.ng</a> and confirm the browser shows a valid certificate.</p><p>sudo journalctl -u caddy -n 100 — no-pager<br> curl -I <a href="http://127.0.0.1:8080/">http://127.0.0.1:8080</a><br> nslookup ifycharitizeapp.name.ng<br> nslookup <a href="http://www.ifycharitizeapp.name.ng/">www.ifycharitizeapp.name.ng</a></p><h3>Reviewing Jenkins pipeline status and build history</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*uHb1Nu7aBYXUMyEOELtAFA.png" /></figure><p>The Charitize-CI-CD job status page shows successful build #3 with a green status indicator. The build history also shows earlier failed runs, demonstrating that the pipeline was tested and that successful execution was subsequently achieved.</p><p><strong>Jenkins browser step</strong></p><p>Open Charitize-CI-CD and review Build History.</p><h3>Results Achieved</h3><p>· The Charitize application was packaged as a Docker image and a running container was verified locally.</p><p>· The project source code and Jenkins pipeline configuration were stored in the GitHub repository.</p><p>· Terraform validation succeeded, and the displayed apply output reports four resources added.</p><p>· The Azure outputs identify the ACR login server, application public IP, Jenkins public IP and virtual machine names.</p><p>· The Jenkins server was accessed through SSH and its initial setup was completed.</p><p>· A Jenkins pipeline job was configured to use the GitHub repository and the SSH Agent plugin was selected for installation.</p><p>· The Jenkins console reports that the Charitize image was built, pushed to ACR and deployed successfully.</p><p>· The deployed Charitize website was displayed in a browser.</p><h3>LESSONS LEARNED</h3><p>This project gave me practical experience in managing Azure infrastructure, using Terraform, Docker, Jenkins, ACR and SSH for automated application deployment. I also learned how to troubleshoot real deployment issues, configure secure access, manage networking and resolve service conflicts.</p><p>Most importantly, I understood how these tools work together to build and deploy an application securely and efficiently.</p><h3>Challenges and Resolutions</h3><h3>Challenge 1: Terraform VM availability and quota errors</h3><p>Problem: Some VM sizes were unavailable in the selected region or restricted by subscription quota.</p><p>Resolution: Checked VM SKUs and quota, selected a supported region/size, and validated/planned changes before applying.</p><p>Lesson learned: Check region, SKU availability and quota before provisioning.</p><h3>Challenge 2: Accidental resource group deletion</h3><p>Problem: Deleting the group removed project resources and interrupted both environments.</p><p>Resolution: Reviewed Terraform configuration and recreated infrastructure. Recorded rebuild showed 16 added, 0 changed and 0 destroyed in that apply.</p><p>Lesson learned: Protect Terraform state and review destructive actions.</p><h3>Challenge 3: Missing Jenkins SSH Agent plugin</h3><p>Problem: Pipeline failed with ‘No such DSL method: sshagent’.</p><p>Resolution: Installed the Jenkins SSH Agent plugin and reran the pipeline.</p><p>Lesson learned: Install and verify plugins required by pipeline steps.</p><h3>Challenge 4: Old production VM IP in Jenkinsfile</h3><p>Problem: Jenkins attempted old IP 20.38.13.213 after VM recreation.</p><p>Resolution: Changed APP_HOST to 172.182.220.228, committed and pushed.</p><p>Lesson learned: Update dependent configuration when cloud resources are recreated.</p><h3>Challenge 5: SSH authentication for deployment</h3><p>Problem: Jenkins needed a private key to connect to production.</p><p>Resolution: Created SSH Username with private key credential for azureuser, ID charitize-prod-ssh.</p><p>Lesson learned: Store private keys in Jenkins Credentials, never in Git.</p><h3>Challenge 6: ACR permissions</h3><p>Problem: Jenkins needed to push images; production needed to pull them.</p><p>Resolution: Assigned AcrPush to Jenkins identity and AcrPull to production identity.</p><p>Lesson learned: Use Managed Identity and least-privilege RBAC.</p><h3>Challenge 7: Docker and Caddy port conflict</h3><p>Problem: Docker used host port 80, which Caddy also needs.</p><p>Resolution: Moved container to 127.0.0.1:8080:80 so Caddy can own public ports 80 and 443.</p><p>Lesson learned: Plan port allocation when introducing a reverse proxy.</p><h3>Challenge 8: Azure NSG AuthorizationFailed</h3><p>Problem: NSG command ran inside production VM with identity lacking network rule write permission.</p><p>Resolution: Exit SSH and run from PowerShell using an Azure account authorised to modify NSGs. Port 443 still needs confirmation.</p><p>Lesson learned: Use identity with the correct role and scope.</p><h3>Challenge 9: QServers DNS manager issue</h3><p>Problem: DNS Manager initially displayed a domain invalid/disabled message.</p><p>Resolution: Later accessed DNS Manager and updated root A record to 172.182.220.228.</p><p>Lesson learned: Verify DNS control-panel access and records before requesting certificates.</p><h3>Challenge 10: Jenkins security</h3><p>Problem: Jenkins needed protection from anonymous and unauthorised access.</p><p>Resolution: Used Jenkins user database, disabled sign-up and anonymous read, and restricted dashboard access through NSG.</p><p>Lesson learned: Protect CI/CD servers because they can access code and deployment credentials.</p><h3>CONCLUSION</h3><p>The document the Charitize project from local application and Docker checks through Terraform-based Azure provisioning, Jenkins setup, pipeline configuration and deployment verification. The Jenkins console confirms a successful pipeline run that built the application image, pushed it to Azure Container Registry and deployed the application. The remaining check highlighted by the evidence is to ensure that the domain’s DNS A record matches the application’s current public IP address.</p><h3>GitHub Repository</h3><p><strong>Repository: </strong><a href="https://github.com/MarvDev-Arch/Charitize-Azure-Jenkins-DevOps.git">https://github.com/MarvDev-Arch/Charitize-Azure-Jenkins-DevOps.git</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fe597598e782" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AWS EC2 + EBS STORAGE]]></title>
            <link>https://medium.com/@akpatiifeany/aws-ec2-ebs-storage-385fc80746c3?source=rss-cf8cd6654d2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/385fc80746c3</guid>
            <category><![CDATA[aws-configuration]]></category>
            <category><![CDATA[ec2-instance]]></category>
            <category><![CDATA[aws-volume]]></category>
            <category><![CDATA[aws-disk]]></category>
            <dc:creator><![CDATA[ifeanyi marvelous akpati]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 20:57:57 GMT</pubDate>
            <atom:updated>2026-11-09T20:57:57.859Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Launching a Linux server and attaching additional block storage</em></p><p><strong>PROJECT OVERVIEW<br> I used Amazon EC2 to launch an Ubuntu server and Amazon EBS to create a separate 5 GiB storage volume. I then attached that volume to the running instance, practising how compute and storage work together in AWS.</strong></p><h3>Project Introduction</h3><p>For this hands-on project, I wanted to understand how an AWS virtual server uses storage outside its main operating system disk. I launched an Ubuntu EC2 instance named “ebs-server-pro” and created an additional Amazon EBS volume so I could practise the basic storage attachment process.</p><p>The work was completed in the US East (N. Virginia) region. The EC2 instance used a t3.micro instance type, an Ubuntu 26.04 AMI, an existing key pair, and a security group with SSH access. I created a separate 5 GiB General Purpose SSD (gp3) EBS volume in the same Availability Zone as the instance.</p><p>Purpose SSD (gp3) EBS volume in the same Availability Zone as the instance.</p><h3>What I Did — Step-by-Step Guide</h3><h3>Launch the EC2 instance</h3><p>I opened the EC2 launch wizard, named the server ebs-server-pro, selected Ubuntu 26.04 LTS and chose the t3.micro instance type. I kept one instance and selected my existing SSH key pair so I could connect to the Linux server.</p><h3>Configure networking and security</h3><p>I selected the default VPC and a subnet in us-east-1a, then enabled automatic public IP assignment. I created a security group and allowed SSH on port 22; for a real production server, I would restrict this rule to my own trusted IP address rather than leave it open to everyone.</p><h3>Configure the root disk and launch</h3><p>I reviewed the default 8 GiB gp3 root volume and checked the launch summary before starting the instance. AWS confirmed that the launch was successful and provided the new EC2 instance ID.</p><h3>Connect to Ubuntu over SSH</h3><p>I opened the EC2 connection instructions and used the SSH client option to view the username and public DNS name. From the VS Code terminal, I connected with my private key and the Ubuntu username, then confirmed that I had reached the server shell.</p><h3>Create an additional EBS volume</h3><p>From EC2 → Elastic Block Store → Volumes, I selected Create volume and chose General Purpose SSD (gp3). I set the new volume size to 5 GiB and selected us-east-1a, matching the instance’s Availability Zone.</p><h3>Attach the EBS volume</h3><p>After the volume was created, I selected it and chose Actions → Attach volume. I selected the running ebs-server-pro instance, used the suggested device name /dev/sdf, and confirmed the attachment.</p><h3>Verify the attachment in AWS</h3><p>AWS displayed a success message confirming that the volume was attached to the EC2 instance. The volume state changed to In-use, showing that AWS had connected the storage resource to the server.</p><h3>Project Implementation Walkthrough</h3><p>This section highlights the practical steps I followed while building the AWS EC2 and EBS storage project, from launching and connecting to my Ubuntu server to creating and attaching additional storage.</p><p><strong>EC2 instance name and Ubuntu selection.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*i-NHcfcCdw4d0YLnRQY-1g.png" /></figure><p>I named my virtual server ebs-server-pro so I could identify it easily in the EC2 dashboard. I selected Ubuntu as the operating system for this practical exercise.</p><p><strong>AMI, instance type and key pair.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*_PEJHfKwKjnTqFIaXP43lw.png" /></figure><p>I selected the Ubuntu 26.04 LTS machine image and the t3.micro instance type. I also selected my existing ebs-key11 key pair, which I used later to connect securely through SSH.</p><p><strong>VPC, subnet and security group.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*qSrSeelM15S-u13GZi12qg.png" /></figure><p>I selected the default VPC and a subnet in the us-east-1a Availability Zone. I enabled a public IP and created a security group for controlling access to the server.</p><p><strong>EC2 launch confirmation.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*tNBEF8F0hetODpDCTWpqkA.png" /></figure><p>AWS confirmed that the launch request for my ebs-server-pro instance was successful. This showed that the instance had been created and was ready for its status to be checked.</p><p><strong>Running EC2 instance details.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*x19ELxbBVmb9T5Q4M9hABw.png" /></figure><p>The instance summary showed that ebs-server-pro was running and displayed its public and private IP addresses. I used the connection details to prepare for accessing the Ubuntu server.</p><p><strong>SSH connection instructions.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*qFR5KD6myM-xK9j4psrRNQ.png" /></figure><p>I opened the SSH client tab to view the server’s public DNS name and the Ubuntu login username. AWS also displayed the SSH command and reminded me to protect my private key file.</p><p><strong>Successful SSH connection from VS Code.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*UljU5auY8HjFJsDV5COqQw.png" /></figure><p>I opened my project folder in VS Code and used the ebs-key.pem private key to connect to the server. The Ubuntu terminal prompt confirmed that I had successfully logged in.</p><p><strong>EBS Volumes dashboard.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*ZrkaE6fd_2Ks_Iew1Xz4pA.png" /></figure><p>I opened the Elastic Block Store Volumes page to view the storage already associated with my EC2 environment. From this page, I selected the option to create an additional volume.</p><p><strong>New EBS volume configuration.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*38qaSfOmeaxASEuIhGU-MA.png" /></figure><p>I chose General Purpose SSD (gp3) and set the new volume size to 5 GiB. I selected us-east-1a to make sure the volume was in the same Availability Zone as my EC2 instance.</p><p><strong>EBS volume creation success.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*RD_F2K8kXmai6lqK4P7M4w.png" /></figure><p>AWS confirmed that the new 5 GiB EBS volume had been created successfully. The volume appeared in the Volumes list with its own volume ID and an Available state.</p><p><strong>Selecting the Attach volume action.<br> </strong>I selected the new EBS volume and opened the Actions menu. I chose Attach volume to connect the additional storage to my running EC2 instance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*qZQvOmWqWXT9sPSAx3Oudg.png" /></figure><p><strong>Choosing the EC2 instance and device name.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*b_WJoIsv4cg4w74afzXKFg.png" /></figure><p>I selected ebs-server-pro as the target instance because it was in the same Availability Zone as the volume. I kept the suggested device name /dev/sdf and proceeded with the attachment.</p><p><strong>EBS attachment confirmation.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*o4Tp6CkBrxwamGtWaYPKfQ.png" /></figure><p>AWS displayed a success message confirming that the volume had been attached to the selected EC2 instance. This verified that the storage was connected at the AWS infrastructure level.</p><p><strong>Final volume state.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*x6p1HtzyntUtmcMGFFijLg.png" /></figure><p>The Volumes page showed the additional EBS volume with an In-use status. This confirmed the attachment, although I still needed to format and mount the disk inside Ubuntu before using it for files.</p><h3>Challenges I Faced</h3><p><strong>. </strong>One important detail I had to pay attention to was the Availability Zone. An EBS volume must be attached to an EC2 instance in the same Availability Zone, so I made sure both resources were in us-east-1a. I also had to locate my private key file and use the correct Ubuntu SSH username when connecting.</p><p><strong>. </strong>Another thing I noticed was the SSH security warning. Allowing port 22 from 0.0.0.0/0 makes the server reachable from any IPv4 address, so I learned that this should be narrowed to a trusted IP whenever possible. After attaching the disk, I also learned that AWS showing “In-use” confirms attachment, but the disk still needs to be identified, formatted and mounted inside Linux before I can store files on it.</p><h3>Key Commands for the Next Step</h3><p>The following commands are for the Linux-side setup after confirming the correct new device name with lsblk. Device names can differ, so I must verify the disk before formatting it.</p><p>lsblk</p><p>sudo file -s /dev/xvdf</p><p>sudo mkfs -t ext4 /dev/xvdf</p><p>sudo mkdir -p /data</p><p>sudo mount /dev/xvdf /data</p><p>df -h</p><p><strong>Important: </strong>Only run the formatting command after verifying the new, empty EBS device. Formatting the wrong device can erase data. On this Ubuntu instance, AWS may expose the attached disk as /dev/nvme1n1 rather than /dev/xvdf; use the actual device shown by lsblk.</p><h3>Conclusion — What I Learned</h3><p>This project helped me understand the difference between an EC2 instance and an EBS volume. EC2 provides the virtual server, while EBS provides persistent block storage that I can attach separately. I successfully launched and connected to an Ubuntu instance, created a 5 GiB gp3 volume, and attached it in the correct Availability Zone.</p><p>My next step is to log in to Ubuntu, identify the new disk with lsblk, create a filesystem, mount it, and configure it to mount automatically after a reboot. This will complete the Linux-side storage setup and help me build more confidence working with AWS infrastructure.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=385fc80746c3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[END-TO-END AZURE INFRASTRUCTURE AND WEB APPLICATION DEPLOYMENT USING TERRAFORM (LINUX VM…]]></title>
            <link>https://medium.com/@akpatiifeany/end-to-end-azure-infrastructure-and-web-application-deployment-using-terraform-linux-vm-3ebddb490f8b?source=rss-cf8cd6654d2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/3ebddb490f8b</guid>
            <category><![CDATA[vm]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[azure-terraform-deplyment]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[ifeanyi marvelous akpati]]></dc:creator>
            <pubDate>Sun, 25 Oct 2026 02:57:53 GMT</pubDate>
            <atom:updated>2026-10-25T02:57:53.192Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>END-TO-END AZURE INFRASTRUCTURE AND WEB APPLICATION DEPLOYMENT USING TERRAFORM (LINUX VM, NETWORKING &amp; PHP WEB APP FROM GITHUB)</strong></p><h3>Introduction</h3><p>Terraform is an Infrastructure as Code (IaC) tool. It lets me describe cloud resources in configuration files and create or manage them with commands instead of building every resource manually in the portal. In these two labs, I used Terraform with Azure to deploy a Linux virtual machine and networking, then worked through a second lab for a PHP website hosted on Azure infrastructure</p><h3>Project objectives</h3><p>· Create Azure infrastructure using Terraform configuration files.</p><p>· Deploy and access an Ubuntu Linux virtual machine using SSH.</p><p>· Install and start Apache, then confirm the web server works in a browser.</p><p>· Use separate Terraform files for main configuration, variables, and outputs in the PHP lab.</p><p>· Deploy the PHP web application lab infrastructure and verify the website using its public IP.</p><h3>Prerequisites</h3><p>· A Microsoft Azure account with an active subscription and permission to create resources.</p><p>· A Windows computer with Visual Studio Code and PowerShell.</p><p>· Terraform CLI installed and available in the terminal.</p><p>· Azure CLI installed and signed in using az login.</p><p>· An SSH client and an SSH key pair for connecting to the Linux VM.</p><p>· Internet access and a GitHub repository containing the PHP website files for the PHP deployment lab.</p><p>· Enough Azure quota for the chosen VM size in the selected region.</p><h3>Installing Terraform on Windows</h3><p>. Open the official installation guide: <a href="https://developer.hashicorp.com/terraform/install.">https://developer.hashicorp.com/terraform/install.</a></p><p>. Download the Windows AMD64 Terraform package and extract terraform.exe into a folder, for example C:\Terraform.</p><p>. Add that folder to the Windows PATH environment variable, then close and reopen PowerShell or VS Code.</p><p>. Check the installation by running: terraform -version.</p><p>. Install Azure CLI using <a href="https://learn.microsoft.com/cli/azure/install-azure-cli-windows,">https://learn.microsoft.com/cli/azure/install-azure-cli-windows,</a> then sign in with: az login.</p><p>. In each project folder, run terraform init to install the providers required by that configuration.</p><h3>Tools and services used</h3><p>Terraform, Microsoft Azure, Azure CLI, Visual Studio Code, PowerShell, Ubuntu Linux, SSH, Apache2, GitHub (for the PHP web app source), and a web browser.</p><p><strong>PROJECT 1: DEPLOYING AZURE INFRASTRUCTURE AND A LINUX VIRTUAL MACHINE USING TERRAFORM</strong></p><h3>Project folder and main Terraform file</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*Sm6mG_bFCQTilfXUJE5DPg.png" /></figure><p>I created a separate folder for the Linux VM project and started defining Azure resources in main.tf. Keeping the configuration in one place made it easier to manage and review.</p><h3>Creating an SSH key</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*zFoagxEYDrWrpky-6fuzqw.png" /></figure><p>I generated an SSH key pair so I could connect to the Linux VM securely. Azure uses the public key during setup, while the private key stays on my computer.</p><pre>ssh-keygen -t rsa</pre><h3>Initializing and validating Terraform</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*A4XgCtlKn2eDuty-jwvKvw.png" /></figure><p>I ran terraform init to download the Azure provider, then terraform validate to check the configuration. Terraform confirmed that the configuration was valid before I planned the deployment.</p><pre>terraform init &amp;&amp; terraform validate</pre><h3>Reviewing the deployment plan</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*IgSt1-MBvKWu7u9oNf3Q1g.png" /></figure><p>I ran terraform plan and reviewed the resources Terraform intended to create. The plan showed eight resources to add and no changes or deletions.</p><pre>terraform plan</pre><h3>Deploying the Linux VM</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*d44cBWzLKb9glzWgve8Owg.png" /></figure><p>I approved the plan with terraform apply. Terraform created the Linux virtual machine successfully and reported one resource added.</p><pre>terraform apply</pre><h3>Connecting to the Linux VM over SSH</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*4xb1CqOnhEB7UHJMBcWwTQ.png" /></figure><p>I retrieved the VM’s public IP and connected as azureuser using SSH. After accepting the host key, I reached the Ubuntu terminal.</p><pre> az vm show -d -g my-terraform-rg -n my-linux-vm --query publicIps -o tsv</pre><h3>Updating Ubuntu packages</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*coD0NqYOa4srzGEPFXdHew.png" /></figure><p>I updated the package lists and upgraded installed packages on the VM. This prepared the server before I installed the web server.</p><pre>ssh azureuser@public-ip</pre><h3>Installing Apache</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*mDWzBmp7g2QAfTo8TuUYdA.png" /></figure><p>I installed Apache2 on Ubuntu using apt. This added the web server package needed to serve a website over HTTP.</p><pre>sudo apt update</pre><h3>Starting Apache</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*lVhHlURYX9VTkW8El5gaCg.png" /></figure><p>I enabled Apache2 to start automatically and started the service. This made the web server ready to handle browser requests.</p><pre>sudo apt install apache2 -y</pre><h3>Checking the default Apache page</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*UP_TShkhNOAloWztVnDq9A.png" /></figure><p>I opened the VM’s public IP in a browser and saw the Apache2 Ubuntu default page. This confirmed that the web server was responding over HTTP.</p><pre>sudo systemctl enable apache2 &amp;&amp; sudo systemctl start apache2</pre><h3>Checking the web root</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*4Zy-JTTc4eSPWuwnStEYug.png" /></figure><p>I went to /var/www/html and listed the files in the web root. I opened index.html to inspect the default page before replacing it with my own content.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*7MQK-jK5Qk3Kty_cmJW__w.png" /></figure><p>going strait to the root file for editing and replace with my own website file.</p><pre>cd /var/www/html/ <br><br>sudo rm -f index.html<br><br>sudo git clone https://github.com/yourtechie/babycare-website.git .</pre><h3>Checking the web root</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c2S7-fMVFOS2qrfmD3IQ2Q.png" /></figure><p>verifying that the site is up by using the ip address provided.</p><p><strong>PROJECT 2: END-TO-END TERRAFORM DEPLOYMENT(VM+PHP WEB APP FROM GITHUB)</strong></p><h3>Creating the PHP lab folder and configuration</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f7-H4LJLsiPhwjJRnI_7UQ.png" /></figure><p>I created a separate terraform-azure-php-lab folder for the second project.</p><pre>mkdir terraform-azure-php-lab<br>cd terraform-azure-php-lab</pre><h3>Defining Terraform main.tf</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*awe2uPk6MUgLh9ZRMnh2zw.png" /></figure><p><strong>main.tf:</strong> I defined the Azure infrastructure and configured the Linux VM to install Apache, PHP, and Git, then clone the Charitize website from GitHub automatically.</p><pre>provider &quot;azurerm&quot; {<br>  features {}<br>}<br><br><br>resource &quot;azurerm_resource_group&quot; &quot;rg&quot; {<br>  name     = &quot;php-app-rg&quot;<br>  location = var.location<br>}<br><br><br>resource &quot;azurerm_virtual_network&quot; &quot;vnet&quot; {<br>  name                = &quot;php-vnet&quot;<br>  address_space       = [&quot;10.0.0.0/16&quot;]<br>  location            = azurerm_resource_group.rg.location<br>  resource_group_name = azurerm_resource_group.rg.name<br>}<br><br><br>resource &quot;azurerm_subnet&quot; &quot;subnet&quot; {<br>  name                 = &quot;php-subnet&quot;<br>  resource_group_name  = azurerm_resource_group.rg.name<br>  virtual_network_name = azurerm_virtual_network.vnet.name<br>  address_prefixes     = [&quot;10.0.1.0/24&quot;]<br>}<br><br><br># ---------------------------<br># NSG ADDED HERE<br># ---------------------------<br>resource &quot;azurerm_network_security_group&quot; &quot;nsg&quot; {<br>  name                = &quot;php-vm-nsg&quot;<br>  location            = azurerm_resource_group.rg.location<br>  resource_group_name = azurerm_resource_group.rg.name<br>}<br><br><br># Allow SSH<br>resource &quot;azurerm_network_security_rule&quot; &quot;ssh&quot; {<br>  name                        = &quot;Allow-SSH&quot;<br>  priority                    = 1001<br>  direction                   = &quot;Inbound&quot;<br>  access                      = &quot;Allow&quot;<br>  protocol                    = &quot;Tcp&quot;<br>  source_port_range           = &quot;*&quot;<br>  destination_port_range      = &quot;22&quot;<br>  source_address_prefix       = &quot;*&quot;<br>  destination_address_prefix  = &quot;*&quot;<br>  resource_group_name         = azurerm_resource_group.rg.name<br>  network_security_group_name = azurerm_network_security_group.nsg.name<br>}<br><br><br># Allow HTTP<br>resource &quot;azurerm_network_security_rule&quot; &quot;http&quot; {<br>  name                        = &quot;Allow-HTTP&quot;<br>  priority                    = 1002<br>  direction                   = &quot;Inbound&quot;<br>  access                      = &quot;Allow&quot;<br>  protocol                    = &quot;Tcp&quot;<br>  source_port_range           = &quot;*&quot;<br>  destination_port_range      = &quot;80&quot;<br>  source_address_prefix       = &quot;*&quot;<br>  destination_address_prefix  = &quot;*&quot;<br>  resource_group_name         = azurerm_resource_group.rg.name<br>  network_security_group_name = azurerm_network_security_group.nsg.name<br>}<br><br><br># Attach NSG to Subnet<br>resource &quot;azurerm_subnet_network_security_group_association&quot; &quot;nsg_assoc&quot; {<br>  subnet_id                 = azurerm_subnet.subnet.id<br>  network_security_group_id = azurerm_network_security_group.nsg.id<br>}<br># ---------------------------<br><br><br>resource &quot;azurerm_public_ip&quot; &quot;pip&quot; {<br>  name                = &quot;php-public-ip&quot;<br>  location            = azurerm_resource_group.rg.location<br>  resource_group_name = azurerm_resource_group.rg.name<br>  allocation_method   = &quot;Static&quot;<br>}<br><br><br>resource &quot;azurerm_network_interface&quot; &quot;nic&quot; {<br>  name                = &quot;php-nic&quot;<br>  location            = azurerm_resource_group.rg.location<br>  resource_group_name = azurerm_resource_group.rg.name<br><br><br>  ip_configuration {<br>    name                          = &quot;internal&quot;<br>    subnet_id                     = azurerm_subnet.subnet.id<br>    private_ip_address_allocation = &quot;Dynamic&quot;<br>    public_ip_address_id          = azurerm_public_ip.pip.id<br>  }<br>}<br><br><br>resource &quot;azurerm_linux_virtual_machine&quot; &quot;vm&quot; {<br>  name                = &quot;php-vm&quot;<br>  resource_group_name = azurerm_resource_group.rg.name<br>  location            = azurerm_resource_group.rg.location<br>  size                = var.vm_size<br>  admin_username      = var.admin_username<br>  network_interface_ids = [<br>    azurerm_network_interface.nic.id<br>  ]<br><br><br>  admin_password = &quot;Password1234!&quot;<br>  disable_password_authentication = false<br><br><br>  os_disk {<br>    caching              = &quot;ReadWrite&quot;<br>    storage_account_type = &quot;Standard_LRS&quot;<br>  }<br><br><br>  source_image_reference {<br>    publisher = &quot;Canonical&quot;<br>    offer     = &quot;0001-com-ubuntu-server-jammy&quot;<br>    sku       = &quot;22_04-lts&quot;<br>    version   = &quot;latest&quot;<br>  }<br><br><br>  custom_data = base64encode(&lt;&lt;EOF<br>#!/bin/bash<br>apt update -y<br>apt install -y apache2 php git<br><br><br>cd /var/www/html<br>rm -f index.html<br><br><br>git clone https://github.com/yourtechie/charitize.git .<br><br><br>systemctl restart apache2<br>EOF<br>  )<br>}</pre><h3>Defining Terraform variables</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZnQ1P19gImlDbekBpScvpg.png" /></figure><p>I placed the location, VM size, and admin username in variables.tf. This makes key settings easier to change without editing the main resource definitions.</p><pre>variable &quot;location&quot; {<br>  default = &quot;East US&quot;<br>}<br><br><br>variable &quot;vm_size&quot; {<br>  default = &quot;Standard_B1s&quot;<br>}<br><br><br>variable &quot;admin_username&quot; {<br>  default = &quot;azureuser&quot;<br>}</pre><pre>mkdir terraform-azure-php-lab<br>cd terraform-azure-php-lab</pre><h3>Defining Terraform outputs</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*AxTozbCUdSc5duNtHdgd0g.png" /></figure><p>I added an output for the public IP address in output.tf. Terraform can display this address after deployment so I can open the web app.</p><pre>output &quot;public_ip&quot; {<br>  value = azurerm_public_ip.pip.ip_address<br>}</pre><h3>Initializing the PHP lab</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*5sASI8iJoNuEMVDNkeOiNg.png" /></figure><p><strong>Terraform initialization:</strong> I ran terraform init to install the Azure provider and prepare the project for deployment.</p><pre>terraforn init</pre><h3>Deploying the PHP lab VM</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/830/1*0AAv8C1n502RBQBOpWwK7g.png" /></figure><p>I ran terraform plan and reviewed the proposed resources. The plan showed ten resources to add, with no existing resources being changed or destroyed at that stage.</p><pre>terraform plan</pre><h3>Terraform apply</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/891/1*ApcUODC1771o-0OzN-NzMA.png" /></figure><p>I ran terraform apply and confirmed the deployment. Terraform reported that the VM was created and displayed its public IP address.</p><pre>terraform apply</pre><h3>Viewing the deployed PHP website</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*dL4mgsl9lJybbMAZItPhYA.png" /></figure><p>I opened the public IP address in a browser and saw the Charitize website. This confirmed that the website was reachable from the internet.</p><h3>Reviewing the Azure resource group</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*4R1bnm_x6bsMUx6HeoCZCA.png" /></figure><p>I checked the php-app-rg resource group in the Azure portal. The resource list showed the VM, network interface, public IP, and network security group created for the lab.</p><h3>CHALLENGES FACED AND HOW I SOLVED THEM</h3><h3>Azure VM size quota and availability</h3><p>Some VM sizes were blocked because the subscription did not have approved cores for that VM family, or the size was unavailable in the chosen region. I checked SKU and quota information and adjusted the region or VM size to one supported by the subscription before trying again.</p><h3>Terraform state and an existing resource group</h3><p>Terraform reported that the resource group already existed but was not tracked in the state file. I checked the Azure resources and deleted the resource group when I decided to rebuild, then removed the stale Terraform state reference.</p><h3>Terraform provider initialization</h3><p>Terraform could not apply while the provider selection in the lock file was inconsistent. I ran terraform init to install the AzureRM provider before validating and planning again.</p><h3>Checking the web server</h3><p>The browser initially showed the default Apache page rather than my intended website. I checked the Apache service and web root, then used the public IP in a browser to confirm HTTP access worked.</p><h3>Conclusion</h3><p>These two labs gave me practical experience using Terraform to create Azure resources instead of setting everything up manually. I deployed and accessed an Ubuntu VM, installed Apache, and verified a website in the browser; I also built out the Terraform configuration for a PHP web application lab and confirmed the deployed site was reachable. The main lesson was to check the plan, region, VM quota, and Terraform state carefully before applying changes.</p><h3>Useful commands</h3><p><strong>terraform init — </strong>Download providers and initialize the working directory.</p><p><strong>terraform validate — </strong>Check the configuration for syntax and consistency errors.</p><p><strong>terraform plan — </strong>Preview the changes Terraform intends to make.</p><p><strong>terraform apply — </strong>Apply the reviewed plan and create or update resources.</p><p><strong>terraform output — </strong>Display configured outputs, such as the public IP.</p><p><strong>az login — </strong>Sign in to Azure CLI.</p><p><strong>ssh azureuser@&lt;public-ip&gt; — </strong>Connect to the Linux VM; replace &lt;public-ip&gt; with the VM address.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3ebddb490f8b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploying Azure Infrastructure and a static website using Terraform.]]></title>
            <link>https://medium.com/@akpatiifeany/deploy-azure-infrastructure-and-a-static-website-using-terraform-d57a943a25df?source=rss-cf8cd6654d2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/d57a943a25df</guid>
            <category><![CDATA[storage]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[terraform-azure]]></category>
            <category><![CDATA[azure-cli]]></category>
            <dc:creator><![CDATA[ifeanyi marvelous akpati]]></dc:creator>
            <pubDate>Wed, 21 Oct 2026 13:24:26 GMT</pubDate>
            <atom:updated>2026-10-23T10:45:17.183Z</atom:updated>
            <content:encoded><![CDATA[<p>In this project, I used Terraform to create Azure resources and publish a simple static website on Azure Storage. It helped me practise writing infrastructure as code, checking a deployment plan, fixing a region issue, and confirming that the website was available in a browser.</p><h3>What is Terraform?</h3><p>Terraform is a tool that lets you create and manage cloud resources by writing configuration files. Instead of creating every resource manually in the Azure Portal, I describe what I need in .tf files and Terraform works out what to create, update, or remove.</p><p>The main commands I used were: terraform init (prepare the working folder), terraform validate (check the configuration), terraform plan (preview the changes), and terraform apply (make the changes).</p><h3>Project goals</h3><p><strong>·</strong> Create an Azure Resource Group, Virtual Network, and Subnet using Terraform.</p><p><strong>· </strong>Create an Azure Storage account and configure it to host a static website.</p><p><strong>·</strong> Upload an index.html page and open the website using its web endpoint.</p><p><strong>·</strong> Practise the Terraform workflow and troubleshoot a real deployment error.</p><h3>Prerequisites</h3><p><strong>·</strong> A Windows laptop with internet access.</p><p><strong>·</strong> An Azure account and an active subscription with permission to create resources.</p><p><strong>· </strong>Visual Studio Code (VS Code) for editing Terraform and HTML files.</p><p><strong>·</strong> Terraform CLI installed and available from PowerShell.</p><p><strong>· </strong>Azure CLI installed and signed in with az login.</p><p><strong>·</strong> A browser to test the published website.</p><h3>Installation and setup</h3><p>1. <strong>Install VS Code: </strong>Download and install Visual Studio Code from the official website: <a href="https://code.visualstudio.com/">https://code.visualstudio.com/.</a></p><p>2. <strong>Install Terraform: </strong>Follow HashiCorp’s official Windows installation guide: <a href="https://developer.hashicorp.com/terraform/install.">https://developer.hashicorp.com/terraform/install.</a> Confirm the installation in PowerShell with: terraform — version</p><p>3. <strong>Install Azure CLI: </strong>Follow Microsoft’s guide: <a href="https://learn.microsoft.com/cli/azure/install-azure-cli-windows.">https://learn.microsoft.com/cli/azure/install-azure-cli-windows.</a> Confirm it with: az — version</p><p>4. <strong>Sign in to Azure: </strong>Run az login in PowerShell, complete the browser sign-in, then check the active subscription with: az account show — output table</p><p>5. <strong>Create a project folder: </strong>Create a folder named static-website inside Terraform Pro and open that folder in VS Code. Keep the project files together.</p><p>Note: Azure service availability and subscription restrictions can differ by region. If Azure rejects a region, choose a region allowed for your subscription and use it consistently for resources that need to be in the same region.</p><h3>What I built</h3><p>For the infrastructure part, I defined a resource group, a virtual network with address space 10.0.0.0/16, and a subnet using 10.0.1.0/24. Terraform created the network resources after I changed the location from West Europe to West US 3, which Azure accepted for that deployment.</p><p>For the static website part, I used Terraform configuration files to create a resource group, a storage account, and a blob container for the website files. I added index.html, enabled static website hosting, and used the primary web endpoint shown by Terraform to open the site in my browser.</p><h3>Select the project folder</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*PHbzhuezVpRN4IeHCCEk7g.png" /></figure><p>I selected the Terraform Pro folder in the VS Code Open Folder window. This gave me one place to keep the infrastructure and website project files.</p><h3>Review the Terraform configuration</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*FlGhY3x1_G3jKt3a5mfY6w.png" /></figure><p>I opened main.tf and checked the Azure provider and resource group settings. The file tells Terraform which Azure resources I want it to manage.</p><h3>Check the tools and initialise Terraform</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*z72etTPULHuFvktkv-b-fw.png" /></figure><p>I checked the Terraform version and Azure account, then ran terraform init. Terraform downloaded the required Azure provider and prepared the working directory.</p><h3>Validate and plan</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*eiqfgOzK-qiSTEkEJt9_hA.png" /></figure><p>I ran terraform validate and got a success message, then ran terraform plan. The plan showed that Terraform intended to create the resource group.</p><h3>Create the resource group</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*pY9gbSMwnaZo4o2_6xSHcw.png" /></figure><p>I ran terraform apply and approved the plan by typing yes. Terraform created the resource group successfully.</p><h3>Confirm in Azure Portal</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*5JsH75cNDyx7v-h_TiP8Cg.png" /></figure><p>I opened Resource groups in the Azure Portal and found marvdev-terraform-rg. This confirmed that the resource group was created in Azure.</p><h3>Define the virtual network and subnet</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*L166Wf7JANwmvIRuVL9rMg.png" /></figure><p>I added the virtual network and subnet blocks to main.tf. The network uses 10.0.0.0/16, while the subnet uses the smaller range 10.0.1.0/24.</p><h3>Validate and review network changes</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*eMou8r8yvL6Dx-TqKL8fpg.png" /></figure><p>I validated the updated configuration and ran terraform plan. Terraform showed that it was going to create the virtual network and subnet.</p><h3>Review the planned changes</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*DYVmXQFLfAAfT0MgeckTbg.png" /></figure><p>The plan showed two resources to add and none to change or destroy. I checked the proposed actions before applying them.</p><h3>Detect the region error</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*3CXMzevO4JFqq2PgePvdOg.png" /></figure><p>The first deployment failed because Azure did not allow me to create resources in West Europe.</p><h3>Apply after changing the region</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*q-o85cNXA63Ksg64-O-Xog.png" /></figure><p>I changed the location to West US 3 and applied the configuration again. Terraform completed the deployment and reported three resources added, with one resource destroyed during replacement.</p><h3>Verify the subnet in Azure</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*qfKXCDlmyategcoTziJBAg.png" /></figure><p>I opened the virtual network’s Subnets page and confirmed that the subnet was present. Azure displayed its address range as 10.0.1.0/24.</p><h3>Create the static website folder and file</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*X4vI_vGEMnBbn5Dbe5Ohsg.png" /></figure><p>I created the static-website folder and added index.html in VS Code. The HTML file contains the heading, welcome message, and test button shown on the website.</p><h3>Configure Terraform providers</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*mR2UaGNUoxZxOIh1uCY4Fw.png" /></figure><p>I created providers.tf and declared the AzureRM and random providers. These providers let Terraform work with Azure resources and generate a storage account name.</p><h3>Initialise the static website project</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*O2znxCcpzgFJdZia9mbVTw.png" /></figure><p>I ran terraform init -upgrade in the static-website folder. Terraform downloaded the provider versions required by this configuration.</p><h3>Create a saved Terraform plan</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*Rs_0e6AqzhbmE6MqB1887A.png" /></figure><p>I ran terraform plan -out main.tfplan to review and save the proposed deployment. The plan included the resource group, storage account, and website-related resources.</p><h3>Reviewing the Terraform Deployment Plan</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*kE4Amj-yQlG6bakI21lbXA.png" /></figure><p>I ran terraform plan -out main.tfplan to check the resources Terraform was going to create before deployment. The plan showed 5 resources to add, with no changes or deletions.</p><h3>Apply the saved plan</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*mV513tvegwSTl4tX02YKMQ.png" /></figure><p>I ran terraform apply main.tfplan and waited for Azure to create the resources. Terraform finished successfully and displayed the website endpoint.</p><h3>Final deployment result</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*vVu9hDAO3pujskGW82Vjeg.png" /></figure><p>The final screen shows the successful website deployment and its endpoint. This was my confirmation that the Terraform-created storage website was working.</p><h3>Verifying the storage account container</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kx2DN23Dp3Zje_80uK_Prw.png" /></figure><p>The storage account was created successfully, with the $web container available to host the website files. The container is set to private access.</p><h3>Destroying Azure Resources with Terraform</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SJqYkS7_cPYKFdMVg33zpA.png" /></figure><p>I ran terraform destroy to remove the Azure resources created for the project. Terraform confirmed that all 5 resources were successfully destroyed, helping me avoid unnecessary cloud costs.</p><h3>Confirming Resource clean-up</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fEG-sQ3PAL6bDjEQJfhD0w.png" /></figure><p>I checked the Azure portal and confirmed that no resource groups were showing under the selected subscription. This helped me verify the current state of my Azure resources.</p><h3>Challenges faced and how I solved them</h3><p><strong>·</strong> <strong>Azure region restriction: </strong>The virtual network deployment failed with a 403 error saying the selected region was not accepting new customers. I changed the location to West US 3, reviewed the new plan, and applied again.</p><p><strong>· Resource replacement after changing the location: </strong>Terraform showed that the resource group had to be replaced because its location changed. I reviewed the plan before approving it and checked that the dependent network resources were created successfully afterward.</p><p><strong>·</strong> <strong>Keeping the two projects separate: </strong>I worked in separate folders for the network lab and static website. This kept each Terraform configuration and its state files separate and made it easier to understand which resources each project managed.</p><h3>Key things I learned</h3><p><strong>·</strong> Terraform configuration files describe the resources I want; Terraform uses a plan before making changes.</p><p><strong>·</strong> terraform init, validate, plan, and apply each have a different purpose.</p><p><strong>·</strong> A valid Terraform file can still fail if Azure subscription or regional restrictions block a resource.</p><p><strong>·</strong> A virtual network address space is larger than the subnet range placed inside it.</p><p><strong>·</strong> Azure Storage static website hosting provides a web endpoint for HTML files without needing a virtual machine.</p><p><strong>·</strong> I should review plans carefully, especially when Terraform says a resource will be destroyed or replaced.</p><h3>Conclusion</h3><p>This project gave me practical experience using Terraform to build Azure infrastructure and publish a static website. I also learned to read deployment errors, check Terraform plans before approving changes, and verify the result in the Azure Portal and browser. It was a useful step in my Cloud and DevOps learning because I could see the configuration turn into real cloud resources.</p><h3>Clean-up and cost reminder</h3><p>When finished testing, remove resources that are no longer needed to avoid possible Azure charges. Run terraform destroy from the correct project folder only after checking which resources it will remove. Do not delete a resource group or run destroy if it contains resources you still need.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d57a943a25df" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[DEPLOYING AND MANAGING
 WORKLOADS ON AZURE AKS]]></title>
            <link>https://medium.com/@akpatiifeany/deploying-and-managing-workloads-on-azure-aks-cf8b66ed80a4?source=rss-cf8cd6654d2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/cf8b66ed80a4</guid>
            <category><![CDATA[servive]]></category>
            <category><![CDATA[azure-k8s]]></category>
            <category><![CDATA[yaml]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[manifest]]></category>
            <dc:creator><![CDATA[ifeanyi marvelous akpati]]></dc:creator>
            <pubDate>Mon, 19 Oct 2026 01:32:41 GMT</pubDate>
            <atom:updated>2026-10-19T02:28:58.795Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>DEPLOYING AND MANAGING<br> WORKLOADS ON AZURE AKS</strong></p><p><em>A combined report of two hands-on projects</em></p><p><strong>1. Creating and Scaling Workloads on Azure AKS with Azure CLI</strong></p><p><strong>Tools Used:</strong></p><ul><li>Azure Portal and Azure CLI</li><li>Azure Kubernetes Service (AKS)</li><li>kubectl</li><li>Docker and Docker Hub</li><li>Visual Studio Code (VS Code)</li><li>SSH key pair and web browser</li></ul><p><strong>Prerequisites:</strong></p><ul><li>Active Azure subscription with sufficient permissions and quota.</li><li>Azure CLI and kubectl installed.</li><li>Docker Hub account and a working application image.</li><li>SSH key pair for cluster creation.</li></ul><p><strong>2. Deploying an Application on an AKS Cluster Using a Kubernetes</strong> Manifest File</p><p><strong>Tools Used:</strong></p><ul><li>Azure Portal and Azure CLI</li><li>Azure Kubernetes Service (AKS)</li><li>kubectl</li><li>Visual Studio Code</li><li>Kubernetes YAML manifest (aks-store.yaml)</li><li>Container images and a web browser</li></ul><p><strong>Prerequisites:</strong></p><ul><li>Active Azure subscription and a running AKS cluster.</li><li>Azure CLI and kubectl installed and configured.</li><li>Basic knowledge of Kubernetes pods, deployments, and services.</li><li>Valid YAML manifest and accessible container images.</li><li>Azure permissions and quota to create the required resources.</li></ul><h3>Project Overview</h3><p>I worked on two AKS projects to practicalize deploying applications and managing workloads in Azure with<strong> Kubernetes(K8s)</strong>. In the first project, I created an AKS cluster with Azure CLI, deployed my CardioCare application, scaled the deployment to three replicas, and exposed it through a public LoadBalancer IP.</p><p>In the second project, I used a Kubernetes YAML manifest to deploy a sample online store with RabbitMQ and application services. I applied the manifest with kubectl and checked the pods and services to confirm that the workloads were running.</p><h3>Project 1: Creating and Scaling Workloads on Azure AKS with Azure CLI</h3><p>The aim was to create an AKS cluster, connect kubectl to it, deploy the CardioCare container image, run multiple replicas, and make the website available through an external IP address.</p><h3>Project 2: Deploying an Application on an AKS Cluster Using a Kubernetes Manifest File</h3><p>In this project, I deployed a simple online pet store application on Azure Kubernetes Service (AKS) using a YAML manifest file. The application has four main parts that work together to display products and process customer orders.</p><ul><li><strong>Store Front:</strong> The website where customers can view products and place orders.</li><li><strong>Product Service:</strong> Provides product details, including names, prices, and descriptions.</li><li><strong>Order Service:</strong> Handles orders placed by customers.</li><li><strong>RabbitMQ:</strong> Helps manage order messages between the services.</li></ul><p>I used a Kubernetes YAML file to deploy all four components and connected them so they could work together. This project helped me understand how different services communicate within a Kubernetes cluster.</p><h3>Project 1 — Create an SSH key folder</h3><p>I created a `.ssh` folder inside my project directory to keep the SSH key files together. This gave me a clear place to save the key pair for the AKS setup.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qKPQ_uMv2N2w0CAl2JxENg.png" /></figure><pre># Make a directory<br>mkdir .ssh<br></pre><h3>Generate an SSH key pair</h3><p>I used `ssh-keygen` to create a private key and a public key for the cluster setup. The public key was saved as `aks-ssh.pub`, while the private key stayed on my computer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FS1LhNVcA0KIIufljxQ3bA.png" /></figure><pre><br><br># Generate ssh key<br>ssh-keygen -f .ssh/aks-ssh</pre><h3>Create and clean up resource groups</h3><p>I tested creating a resource group and then used the delete command to remove the test group. After that, I created `aks-rg` in West US so I could keep the AKS resources organised.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wf3NnukAhmkULbimK4ghZQ.png" /></figure><pre>az group create --name testrg --location eastus </pre><h3>Create the AKS cluster</h3><p>I ran `az aks create` to create `MyAKSCluster` with one node and autoscaling settings. I supplied the public SSH key and selected the node size and node-pool settings for the cluster.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uTQNzEZKlGfN91ox84lHAA.png" /></figure><pre>az aks create --resource-group testrg --name MyAKSCluster --node-count 1 --nodepool-name systemp --node-resource-group myNodeRG --ssh-key-value .ssh/aks-ssh.pub --network-plugin azure --enable-cluster-autoscaler --min-count 1 --max-count 2 --zones 1</pre><h3>Confirm the cluster in Azure Portal</h3><p>I opened the `aks-rg` resource group in the Azure Portal and confirmed that `MyAKSCluster` had been created. This helped me verify the cluster from the portal as well as from the command line.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*394IL8lNhGovvqPc8xGqNg.png" /></figure><h3>Review AKS-managed resources</h3><p>I checked the managed resource group created by AKS and saw resources such as the virtual network, load balancer, public IP, and virtual machine scale set. These resources support the cluster’s networking and worker nodes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rtpe9tJHddgxpL4PIlH0Og.png" /></figure><h3>Connect kubectl and deploy CardioCare</h3><p>I downloaded the AKS credentials with `az aks get-credentials` and checked that the node was Ready. I then created a `frontend` namespace and deployed the CardioCare image with three replicas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mMyohiwmyi669epUrGI-GQ.png" /></figure><pre>az aks create --resource-group testrg --name MyAKSCluster --node-count 1 --nodepool-name systemp --node-resource-group myNodeRG --ssh-key-value .ssh/aks-ssh.pub --network-plugin azure --enable-cluster-autoscaler --min-count 1 --max-count 2 --zones 1</pre><h3>Expose the application</h3><p>I exposed the `my-app` deployment using a LoadBalancer service on port 80. The service returned a public external IP address, which I used to open the application in a browser.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DCihvFR-ESmIC5Hoqd7cQw.png" /></figure><pre>kubectl expose deployment my-app  --name=nginx-service --type=LoadBalancer --port=80 --protocol=TCP</pre><h3>Verify the live website</h3><p>I opened the external IP in my browser and confirmed that the CardioCare homepage loaded. This showed that the container was running in AKS and was reachable from outside the cluster.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iQirq5kE1MOE46AYIE9m1w.png" /></figure><h3>Project 2 — Create a folder for the manifest</h3><p>I moved back to the `k8s` project folder and created an `aks-store` directory. I used this folder to keep the Kubernetes manifest for the store deployment in one place.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aSc1bENObNxSxRd2rTJ4Zw.png" /></figure><h3>Aks-store.yaml</h3><pre>Create a file named aks-store.yaml and copy in the following manifest:<br><br>apiVersion: apps/v1<br>kind: Deployment<br>metadata:<br>  name: rabbitmq<br>spec:<br>  replicas: 1<br>  selector:<br>    matchLabels:<br>      app: rabbitmq<br>  template:<br>    metadata:<br>      labels:<br>        app: rabbitmq<br>    spec:<br>      nodeSelector:<br>        &quot;kubernetes.io/os&quot;: linux<br>      containers:<br>      - name: rabbitmq<br>        image: mcr.microsoft.com/mirror/docker/library/rabbitmq:3.10-management-alpine<br>        ports:<br>        - containerPort: 5672<br>          name: rabbitmq-amqp<br>        - containerPort: 15672<br>          name: rabbitmq-http<br>        env:<br>        - name: RABBITMQ_DEFAULT_USER<br>          value: &quot;username&quot;<br>        - name: RABBITMQ_DEFAULT_PASS<br>          value: &quot;password&quot;<br>        resources:<br>          requests:<br>            cpu: 10m<br>            memory: 128Mi<br>          limits:<br>            cpu: 250m<br>            memory: 256Mi<br>        volumeMounts:<br>        - name: rabbitmq-enabled-plugins<br>          mountPath: /etc/rabbitmq/enabled_plugins<br>          subPath: enabled_plugins<br>      volumes:<br>      - name: rabbitmq-enabled-plugins<br>        configMap:<br>          name: rabbitmq-enabled-plugins<br>          items:<br>          - key: rabbitmq_enabled_plugins<br>            path: enabled_plugins<br>---<br>apiVersion: v1<br>data:<br>  rabbitmq_enabled_plugins: |<br>    [rabbitmq_management,rabbitmq_prometheus,rabbitmq_amqp1_0].<br>kind: ConfigMap<br>metadata:<br>  name: rabbitmq-enabled-plugins<br>---<br>apiVersion: v1<br>kind: Service<br>metadata:<br>  name: rabbitmq<br>spec:<br>  selector:<br>    app: rabbitmq<br>  ports:<br>    - name: rabbitmq-amqp<br>      port: 5672<br>      targetPort: 5672<br>    - name: rabbitmq-http<br>      port: 15672<br>      targetPort: 15672<br>  type: ClusterIP<br>---<br>apiVersion: apps/v1<br>kind: Deployment<br>metadata:<br>  name: order-service<br>spec:<br>  replicas: 1<br>  selector:<br>    matchLabels:<br>      app: order-service<br>  template:<br>    metadata:<br>      labels:<br>        app: order-service<br>    spec:<br>      nodeSelector:<br>        &quot;kubernetes.io/os&quot;: linux<br>      containers:<br>      - name: order-service<br>        image: ghcr.io/azure-samples/aks-store-demo/order-service:latest<br>        ports:<br>        - containerPort: 3000<br>        env:<br>        - name: ORDER_QUEUE_HOSTNAME<br>          value: &quot;rabbitmq&quot;<br>        - name: ORDER_QUEUE_PORT<br>          value: &quot;5672&quot;<br>        - name: ORDER_QUEUE_USERNAME<br>          value: &quot;username&quot;<br>        - name: ORDER_QUEUE_PASSWORD<br>          value: &quot;password&quot;<br>        - name: ORDER_QUEUE_NAME<br>          value: &quot;orders&quot;<br>        - name: FASTIFY_ADDRESS<br>          value: &quot;0.0.0.0&quot;<br>        resources:<br>          requests:<br>            cpu: 1m<br>            memory: 50Mi<br>          limits:<br>            cpu: 75m<br>            memory: 128Mi<br>      initContainers:<br>      - name: wait-for-rabbitmq<br>        image: busybox<br>        command: [&#39;sh&#39;, &#39;-c&#39;, &#39;until nc -zv rabbitmq 5672; do echo waiting for rabbitmq; sleep 2; done;&#39;]<br>        resources:<br>          requests:<br>            cpu: 1m<br>            memory: 50Mi<br>          limits:<br>            cpu: 75m<br>            memory: 128Mi<br>---<br>apiVersion: v1<br>kind: Service<br>metadata:<br>  name: order-service<br>spec:<br>  type: ClusterIP<br>  ports:<br>  - name: http<br>    port: 3000<br>    targetPort: 3000<br>  selector:<br>    app: order-service<br>---<br>apiVersion: apps/v1<br>kind: Deployment<br>metadata:<br>  name: product-service<br>spec:<br>  replicas: 1<br>  selector:<br>    matchLabels:<br>      app: product-service<br>  template:<br>    metadata:<br>      labels:<br>        app: product-service<br>    spec:<br>      nodeSelector:<br>        &quot;kubernetes.io/os&quot;: linux<br>      containers:<br>      - name: product-service<br>        image: ghcr.io/azure-samples/aks-store-demo/product-service:latest<br>        ports:<br>        - containerPort: 3002<br>        resources:<br>          requests:<br>            cpu: 10m<br>            memory: 64Mi<br>          limits:<br>            cpu: 100m<br>            memory: 128Mi<br>---<br>apiVersion: v1<br>kind: Service<br>metadata:<br>  name: product-service<br>spec:<br>  type: ClusterIP<br>  ports:<br>  - name: http<br>    port: 3002<br>    targetPort: 3002<br>  selector:<br>    app: product-service<br>---<br>apiVersion: apps/v1<br>kind: Deployment<br>metadata:<br>  name: store-front<br>spec:<br>  replicas: 1<br>  selector:<br>    matchLabels:<br>      app: store-front<br>  template:<br>    metadata:<br>      labels:<br>        app: store-front<br>    spec:<br>      nodeSelector:<br>        &quot;kubernetes.io/os&quot;: linux<br>      containers:<br>      - name: store-front<br>        image: ghcr.io/azure-samples/aks-store-demo/store-front:latest<br>        ports:<br>        - containerPort: 8080<br>          name: store-front<br>        env:<br>        - name: VUE_APP_ORDER_SERVICE_URL<br>          value: &quot;http://order-service:3000/&quot;<br>        - name: VUE_APP_PRODUCT_SERVICE_URL<br>          value: &quot;http://product-service:3002/&quot;<br>        resources:<br>          requests:<br>            cpu: 1m<br>            memory: 200Mi<br>          limits:<br>            cpu: 1000m<br>            memory: 512Mi<br>---<br>apiVersion: v1<br>kind: Service<br>metadata:<br>  name: store-front<br>spec:<br>  ports:<br>  - port: 80<br>    targetPort: 8080<br>  selector:<br>    app: store-front<br>  type: LoadBalancer<br><br></pre><p>I moved back to the main k8s directory and created a new folder named aks-store for Project 2. This folder will hold my Kubernetes manifest YAML file and help me keep the project files organised.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TocLJQy_619PYu_i_0p_yw.png" /></figure><pre>mkdir aks-store</pre><h3><strong>Create RG</strong></h3><p>I used the following commands to create the aks-resource group with the location as westus3 for my application to work well.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2J39uSLAPQQwlTF7QjwMYg.png" /></figure><pre>az group create --name aks-rg --location westus3<br></pre><h3>Create an AKS Cluster</h3><p>I tried creating the AKS cluster using Azure CLI, but the connection was forcibly closed by the remote host. I encountered a ConnectionResetError (10054), so I needed to troubleshoot the network by switching wifi connections and retry the cluster creation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xn0nGRS9ZJnrUedX1D_F7Q.png" /></figure><p>I connected to my AKS cluster using az aks get-credentials and applied the aks-store.yaml manifest using kubectl apply. Kubernetes created the RabbitMQ, Product Service, Order Service, and Store Front resources, and I checked the pods to confirm that the application components were running.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wb0TyGthq9SQsbEAG9RviA.png" /></figure><pre>az aks create --resource-group aks-rg --name my-aks-cluster --node-count 1 --generate-ssh-keys</pre><h3>Check the services and public endpoint</h3><p>I ran the kubectl get the pods and `kubectl get service` to review the pods and ClusterIP and LoadBalancer services. The store-front service had an external IP address, which I used to open the sample store.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GE5tOOXcerAehbkxnFEUjA.png" /></figure><pre>kubectl get pods<br>kubectl get service</pre><h3>Review resource groups in Azure</h3><p>I checked the resource groups in the Azure Portal and found both the AKS resource group and the AKS-managed resource group. This helped me understand how Azure separates the resources I create from those it manages for the cluster.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wfq8YAlwJT27Oh77LAqsXA.png" /></figure><h3>Review the RabbitMQ manifest</h3><p>The YAML file defines a RabbitMQ Deployment, including its image, ports, environment variables, and resource settings. It also includes a ConfigMap for the enabled plugins, which Kubernetes mounts into the container.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GM7JrJxc52ThG7fKR9APvw.png" /></figure><h3>Verify the sample store in a browser</h3><p>I opened the store-front external IP and confirmed that the Contoso Pet Store page was visible. This was a practical check that the service could route browser traffic to the deployed application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yhNVv_KGxe9lOZ50vscplQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R-LQYFHHDyAu8s903mROjg.png" /></figure><h3>Resource Group Cleanup</h3><p>I checked the AKS resource group and confirmed that no resources were listed inside it. This helped me verify the current state of the resource group before finishing the cleanup.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*Ec5xpkX4RE4xInT0uxreVA.png" /></figure><pre>az group delete --resource-group aks-rg<br>az group delete --name NetworkWatcherRG --yes --no-wait</pre><h3>Checking All Azure Resources</h3><p>I opened Azure’s All resources page to check whether any resources were still available in the subscription view. The page showed no matching resources because filters were applied, so I would clear the filters and refresh before confirming that everything had been removed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*8H7W0tmIaS9sHhQKfy0whQ.png" /></figure><h3>Challenges Faced and How I Resolved Them</h3><p>· <strong>Setting up SSH access: </strong>I had to make sure the SSH key files were created in the correct project folder. I used `ssh-keygen` and checked that both the private and public key files appeared before creating the cluster.</p><p>· <strong>Connecting kubectl to the right cluster: </strong>I needed kubectl to use the AKS cluster I had just created. I ran `az aks get-credentials` and checked the cluster by listing its nodes and namespaces.</p><p>· <strong>Making the application reachable: </strong>A running deployment is not automatically available from the internet. I exposed the deployment with a LoadBalancer service, checked the service output, and opened its external IP in the browser.</p><p>· <strong>Understanding the Kubernetes manifest: </strong>The YAML file had several nested sections, including Deployment, container, ports, environment variables, volumes, and ConfigMap settings. I reviewed the indentation and then used `kubectl apply` and `kubectl get pods` to check the result.</p><p>· <strong>Keeping Azure resources organised: </strong>AKS creates a separate managed resource group for supporting infrastructure. I checked both resource groups in the Azure Portal so I could tell the resources I created apart from the resources managed by AKS.</p><h3>Conclusion</h3><p>These two projects helped me understand how an application moves from a container image or YAML file to a running workload on AKS. I practised creating a cluster with Azure CLI, deploying and scaling pods, using a LoadBalancer service, and checking the result in the browser. I also learned to use Kubernetes manifests to define resources in a repeatable way and to troubleshoot by checking the output from kubectl and the Azure Portal.</p><p>My main lesson is that deployment does not end when a command succeeds. I still need to check the pods, services, and application endpoint to confirm that everything is working as expected.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cf8b66ed80a4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[KUBERNETES: FROM ZERO TO LOCAL DEPLOYMENT]]></title>
            <link>https://medium.com/@akpatiifeany/kubernetes-from-zero-to-local-deployment-584a51fd8a43?source=rss-cf8cd6654d2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/584a51fd8a43</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[pods]]></category>
            <dc:creator><![CDATA[ifeanyi marvelous akpati]]></dc:creator>
            <pubDate>Wed, 14 Oct 2026 15:32:26 GMT</pubDate>
            <atom:updated>2026-10-14T15:32:26.224Z</atom:updated>
            <content:encoded><![CDATA[<h3>A Practical Project Guide to Deploying the CardioCare Web Application Locally with Kubernetes and Minikube</h3><p>A practical guide to Kubernetes architecture, core concepts, commands, troubleshooting, and deploying the CardioCare web app locally with Minikube.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*Cg02tN--fE9-M0bGOEDCmw.png" /></figure><p>Learning goal: understand what Kubernetes does, how its parts work together, and how to run and inspect a real web application.</p><h3>What is Kubernetes?</h3><p>Kubernetes (often shortened to K8s) is an open-source platform that manages containerised applications. It helps deploy applications, keep them running, scale them up or down, and connect them to a network. Think of a container as a packed lunchbox containing your app and what it needs to run. Kubernetes is the organiser that decides where those lunchboxes should run, checks whether they are healthy, and replaces them when something goes wrong.</p><h3>Why was Kubernetes created?</h3><p>· Running one container manually is manageable; running many applications and replicas becomes difficult.</p><p>· If a container stops, someone would otherwise need to notice and restart it.</p><p>· When traffic grows, you may need more copies of an app.</p><p>· Applications need a reliable way to find and communicate with one another.</p><p>· Deployments need controlled updates and ways to roll back to an earlier version.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EyVpXM2DqGlyXvJoPD8c3Q.png" /></figure><h3>Introduction</h3><p>This project demonstrates how I deployed my CardioCare heart-care website locally using Kubernetes and Minikube on Windows 11. I used an existing Docker image, created a Deployment, exposed it through a NodePort Service, opened the application in a browser, and scaled the Deployment to three replicas to practise basic Kubernetes operations.</p><p>The goal was to move beyond running a container directly with Docker and learn how Kubernetes manages application Pods, provides network access, and maintains the requested number of replicas. This is a local learning environment, not a production healthcare deployment.</p><h3>Project Environment and Tools</h3><p>·<strong> Operating system:</strong> Windows 11 Pro.</p><p>·<strong> Code Editor:</strong> Visual Studio Code (VS Code).</p><p><strong>· Container platform: </strong>Docker Desktop; the Docker engine was running.</p><p><strong>· Local Kubernetes cluster:</strong> Minikube v1.39.0 using the Docker driver.</p><p><strong>· Kubernetes command-line tool:</strong> kubectl.</p><p><strong>· Application image:</strong> marvdev94/cardiocare:v4.</p><p><strong>· Deployment name: app.</strong></p><p><strong>· Service type:</strong> NodePort, with Service port 80.</p><h3>Check Docker Desktop and the CardioCare image</h3><p>Docker Desktop was running, and the local image list showed the CardioCare v1–v4 images. I selected the v4 image for the Kubernetes deployment, so Kubernetes could run the website from a packaged container image.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/953/1*E1B5-gKUysv0o-rPeL1SUg.png" /></figure><h3>Start Minikube</h3><p>I ran `minikube start` from the project terminal, and Minikube created a local Kubernetes cluster using Docker. The successful completion message confirmed that kubectl was configured to use the Minikube cluster.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/953/1*tGHl9IXa3YxgfyXJDcvugQ.png" /></figure><pre>minikube start<br> minikube service app --url</pre><p>I created a Deployment named `app` using `marvdev94/cardiocare:v4`. Kubernetes then created the workload definition that manages the CardioCare Pods.</p><p>I ran `kubectl expose deployment app — type=NodePort — port=80` to create a Service for the Deployment. This gave the application a network entry point so it could be opened from a browser through Minikube.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/953/1*Y0rsyc5Fdn0ddQgJ9nZD2A.png" /></figure><pre>kubectl create deployment app --image=marvdev94/ca<br>kubectl expose deployment app --type=NodePort --port=80<br> minikube service app --url</pre><h3>Open CardioCare in a browser</h3><p>I ran `minikube service app — url`, which returned a local URL, and opened it in Chrome. The CardioCare homepage loaded successfully, confirming that traffic reached the Nginx-hosted website through the Kubernetes Service.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/953/1*nVS6Rv6phYypXh1uxHQ5zw.png" /></figure><h3>Review the full website</h3><p>I checked the lower section of the website, including its awards and recent health articles. This provided an additional visual check that the deployed site content was being served rather than only confirming that the URL responded.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/953/1*1RQiOxwnTJitvjP4KJwNww.png" /></figure><h3>Scale the Deployment to three replicas</h3><p>I ran `kubectl scale deployment app — replicas=3` and checked the Pods. The terminal showed three Pods in Running status, demonstrating that the Deployment could maintain three instances of the CardioCare container.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/953/1*GKCsq9hbDxxrm2JVvVd89g.png" /></figure><pre>kubectl scale deployment app --replicas=3<br>kubectl get pod</pre><h3>View the Minikube dashboard</h3><p>I launched the Kubernetes dashboard using `minikube dashboard`. The dashboard provided a visual way to inspect workloads and cluster resources, complementing the kubectl commands used in the terminal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/953/1*tMYM8otTrHnurgT7ZqqPQQ.png" /></figure><pre>minikube dashboard</pre><h3>Verify Deployments, Pods, and ReplicaSet</h3><p>The dashboard showed one Deployment, three running Pods, and one ReplicaSet for the `app` workload. This confirmed that the Deployment controller had created the expected replicas from the selected CardioCare v4 image.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/953/1*VdCJU0hbKfITfcGnTlbGxA.png" /></figure><h3>Main Commands Used</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZMHHHtsXMdWtbxcoeuC-oA.png" /></figure><h3>Challenges Faced</h3><p>The first challenge was understanding the difference between Docker images, Kubernetes Deployments, Pods, and Services. The initial `kubectl get pod` returned “No resources found” because the cluster had started successfully but no application had been deployed yet.</p><p>Another point to understand was local networking on Windows: Minikube printed a temporary `127.0.0.1` URL and warned that the terminal needed to remain open when using the Docker driver. I kept the service command running while testing the site in the browser.</p><p>Scaling also required checking the actual Pod status instead of assuming the command had worked. I verified that all three replicas were Running and then checked the dashboard for the Deployment, Pods, and ReplicaSet.</p><h3>Resolutions</h3><p>· Started Minikube and checked its completion message before creating Kubernetes resources.</p><p>· Created the `app` Deployment with the correct CardioCare image tag, then exposed it with a NodePort Service.</p><p>· Used `minikube service app — url` to obtain a URL supported by the local Minikube networking setup and kept the terminal open while testing.</p><p>· Used `kubectl get pod` and the dashboard to verify that all three replicas were Running.</p><p>· Confirmed the website visually in the browser and reviewed the Deployment and ReplicaSet state in the dashboard.</p><h3>Outcome</h3><p>CardioCare was successfully deployed and accessed locally through Kubernetes. The Deployment was scaled to three running Pods, and the Minikube dashboard showed the expected workload structure: one Deployment, one ReplicaSet, and three Pods.</p><p>This project gave me hands-on practice with the Kubernetes workflow: package an application as an image, deploy it, expose it through a Service, scale replicas, and verify the result through both kubectl and the dashboard.</p><h3>Conclusion</h3><p>This exercise helped me understand how Kubernetes manages a containerised web application beyond a single Docker run command. I learned to create a Deployment, expose it through NodePort, access the site with Minikube, and scale it to three replicas. The next step is to improve the project with a YAML manifest, health probes, resource settings, and a repeatable update and rollback process.</p><h3>Appendix — Quick Verification Commands</h3><pre>kubectl get deployments<br>kubectl get pods -o wide<br>kubectl get services<br>kubectl get replicasets<br>kubectl describe deployment app<br>kubectl logs deployment/app</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=584a51fd8a43" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[FROM VIRTUAL MACHINES TO MANAGED CONTAINERS]]></title>
            <link>https://medium.com/@akpatiifeany/deploying-charitize-with-azure-iaas-and-cardiocare-with-azure-container-instances-paas-f31db3478039?source=rss-cf8cd6654d2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/f31db3478039</guid>
            <category><![CDATA[azure-devops]]></category>
            <category><![CDATA[azure-vm]]></category>
            <category><![CDATA[azure-deployment]]></category>
            <category><![CDATA[azure-container-instances]]></category>
            <dc:creator><![CDATA[ifeanyi marvelous akpati]]></dc:creator>
            <pubDate>Wed, 07 Oct 2026 15:00:16 GMT</pubDate>
            <atom:updated>2026-10-07T15:30:05.673Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>FROM VIRTUAL MACHINES TO MANAGED CONTAINERS</strong></p><h3><strong>Deploying Charitize with Azure IaaS and CardioCare with Azure Container Instances (PaaS)</strong></h3><p><em>A hands-on Azure deployment walkthrough</em></p><p>Documented from practical Project work • October 2026</p><h3>Introduction</h3><p>In this hands-on project, I deployed two web applications on Microsoft Azure using two different cloud approaches. The Charitize PHP application was deployed on an Azure Virtual Machine using Infrastructure as a Service (IaaS), while the CardioCare web application was deployed as a container using Azure Container Instances (ACI)=&gt;(PaaS), giving me a practical comparison between managing the underlying server and using a managed container platform.</p><p>The goal was not just to get the applications running, but to understand what happens from infrastructure creation to application access: networking, SSH access, Docker installation, image pulling, container execution, public access, and the differences between IaaS and PaaS.</p><h3>Projects at a Glance</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_Y_0RcW6MR5-APnWFqw2fA.png" /></figure><h3>What I Used</h3><p>· Microsoft Azure Portal</p><p>· Azure Virtual Machine (Ubuntu Server 24.04 LTS)</p><p>· Azure Container Instances (ACI)</p><p>· Docker and Docker Hub</p><p>· SSH from Windows/VS Code terminal</p><p>· Linux/Ubuntu commands</p><p>· Public IP and DNS-based access</p><h3>Charitize App: Deployment with Azure IaaS</h3><p>For the Charitize project, I chose the IaaS approach. This meant creating and managing an Ubuntu virtual machine, connecting to it over SSH, installing Docker, pulling the application image from Docker Hub, running the container, and exposing the application through the VM’s public IP address.</p><p><strong>Opening the Azure Virtual Machine creation workflow</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*7JqjGhmevH63R8wsROFgmg.png" /></figure><p>I started from Azure Compute infrastructure and selected Virtual machines to create the server that would host the Charitize application. This is the starting point of the IaaS deployment because the VM provides the compute infrastructure I manage.</p><p><strong>Configuring the VM basics</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*2dRs-uWjl0N0T-je3xdRRg.png" /></figure><p>I selected the Azure subscription and created the resource group, then named the VM docker-vm and selected West US 3. The basic configuration establishes where the virtual machine and its supporting resources will be deployed.</p><p><strong>Selecting the OS, architecture and VM size</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*I1xzrHKS3emBiDkxncOTag.png" /></figure><p>I selected Ubuntu Server 24.04 LTS with the x64 architecture and chose a suitable VM size. I also selected SSH public key authentication so the server could be accessed securely without using a normal password.</p><p><strong>Creating the SSH key and allowing inbound ports</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*PTTcY9zPR02FqxOzSG9PRQ.png" /></figure><p>I configured Azure to generate an SSH key pair and selected HTTP (80) and SSH (22) as the required inbound ports. Port 22 is needed for administration, while port 80 allows the web application to receive HTTP traffic.</p><p><strong>Downloading the private SSH key</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*TpkbXcvd5cXe07k6z_VP5g.png" /></figure><p>Azure displayed the private-key download step before creating the VM, reminding me that the private key is not stored by Azure. I downloaded the key and kept it locally so I could authenticate to the new Ubuntu VM.</p><p><strong>Reviewing the completed VM deployment</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*OMtsb8Z-q8zQ9eC612b6aQ.png" /></figure><p>The VM was successfully created and its overview showed the running state, Ubuntu operating system, West US 3 location and public IP address. This confirmed that the infrastructure was ready for the application deployment stage.</p><p><strong>Opening the VM’s Native SSH connection details</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*JB3PB3QL55Lc_ie5_zrZAQ.png" /></figure><p>I opened the Connect section and used Azure’s Native SSH instructions to confirm the public IP, port 22 and local private-key path. Azure generated the exact SSH command needed to connect from my Windows terminal.</p><p><strong>Accepting the SSH host fingerprint</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*J-Oo8aOROj1zZXatLWJN-Q.png" /></figure><pre>yes</pre><h3>Verify the website in the browser</h3><p>The first SSH connection asked me to verify the server’s host fingerprint before continuing. I accepted it with yes, allowing the terminal to establish trust with the new VM.</p><p><strong>Successfully connecting to Ubuntu</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*PwJQQanPcBSDSiCQELenYw.png" /></figure><p>The SSH session opened successfully and I reached the azureuser@docker-vm prompt. At this point I had direct command-line access to the Ubuntu server and could begin preparing it for Docker.</p><p><strong>Updating Ubuntu packages</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*JXYYCecfcFSMImWWHehkDQ.png" /></figure><pre>sudo apt update</pre><p>I ran sudo apt update to refresh the Ubuntu package indexes and check for available updates. Keeping the server package information current is an important preparation step before installing software.</p><p><strong>Installing Docker on the VM</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*SJSsiKZIRea1bb5XVFVkYQ.png" /></figure><pre>sudo apt install -y docker.io</pre><p>I installed Docker using the Ubuntu package manager with sudo apt install -y docker.io. This added the Docker engine and its required dependencies to the VM so the application container could be executed.</p><p><strong>Enabling and starting Docker, then pulling the image</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*tSN3lgkCRK9InD72ud7e1w.png" /></figure><pre>sudo systemctl enable docker<br>sudo systemctl start docker sudo docker </pre><p>I enabled and started the Docker service and pulled marvdev94/charitize from Docker Hub. The successful pull confirmed that the VM could reach Docker Hub and download the application image.</p><p><strong>Running the Charitize container</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*CZx4YikyFAte0wniA5118Q.png" /></figure><pre>sudo docker run -d -p 80:80 marvdev94/charitize:latest</pre><p>I started the Charitize container in detached mode and mapped host port 80 to container port 80. The returned container ID confirmed that Docker created and started the web container successfully.</p><p><strong>Verifying the image on Docker Hub</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*Ybe5-1uOoZHB7AY-pntlZA.png" /></figure><p>Docker Hub showed the application repository and its available image tags, confirming that the Charitize image was published and available remotely. This made it possible to deploy the same image to the Azure VM without rebuilding it on the server.</p><p><strong>Accessing the live Charitize application</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*k6GE8DaCTlqUpgJvD4al8w.png" /></figure><p>Finally, I opened the VM’s public IP address in a browser and the Charitize website loaded successfully. This completed the IaaS deployment from Azure infrastructure creation through Docker-based application delivery.</p><h3>CardioCare App: Deployment with Azure PaaS</h3><p>For the CardioCare project, I used Azure Container Instances (ACI), a managed container service. Instead of creating and maintaining a full virtual machine, I supplied Azure with a public Docker image and the networking information required to run it. This gave me a practical example of how a PaaS-style container service reduces infrastructure management.</p><p><strong>Opening Azure Container Instances</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*A9l-iqu-enQ5cG6RRnJuDw.png" /></figure><p>I searched Azure for Container instances and opened the service to begin the managed-container deployment. This approach removes the need to provision a separate VM before running the application container.</p><p><strong>Configuring the CardioCare container basics</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*2IoD9BCme-4c-N5JWqdUrA.png" /></figure><p>I created the cardioCare resource group and named the container instance cardiocare-we-app in West US 3. I selected the Standard SKU, which provides the managed container environment needed for this deployment.</p><p><strong>Selecting the Docker image</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*OKqND-E1IArPYPc8wjPgeQ.png" /></figure><p>I chose Other registry as the image source, selected Public as the image type and entered marvdev94/cardiocare:v4. Azure could then pull the Linux image directly from Docker Hub and use it to create the container instance.</p><p><strong>Configuring public networking and port 80</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*QZw3T6vPwSTuH5NbGOJh8g.png" /></figure><p>I selected Public networking and assigned the DNS name label cardiocare, then exposed TCP port 80. This configuration gives the container a public endpoint so users can access the web application over HTTP.</p><p><strong>Reviewing and creating the CardioCare container</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*wOU-vNzBhjpRW-3R3upzKQ.png" /></figure><p>The Review + create page showed the selected resource group, region, container name, image and networking settings. After validation, the deployment could be created, completing the PaaS container setup.</p><p><strong>Confirming the container is running in Azure</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*eZXFC_XnCInjMwa2mnHuyw.png" /></figure><p>After creating the CardioCare container instance, I continued by validating the deployment from the user side and from the Azure management side. These final checks confirmed that the application was publicly accessible and that Azure reported the container as running normally.</p><p><em>The Azure Container Instances page showed cardiocare-we-app in the Running state with the marvdev94/cardiocare:v4 image. The event history also confirmed that Azure successfully pulled the image and started the container.</em></p><p><strong>Verifying the live CardioCare application</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*Najpkf-lxvi8o0fkYj7Suw.png" /></figure><h3>Challenges Faced and How I Resolved Them</h3><p><strong>SSH connection and host verification</strong></p><p>The first SSH connection displayed a host authenticity warning. I verified the connection details from Azure and accepted the fingerprint, after which the SSH session connected successfully.</p><p><strong>Keeping the Ubuntu VM ready for deployment</strong></p><p>The VM reported that packages were available for update. I ran sudo apt update before installing Docker so the package indexes were refreshed.</p><p><strong>Docker permission denied</strong></p><p>Running Docker without elevated privileges initially returned a permission-denied error for the Docker socket. I used sudo for the Docker commands, which allowed the image to be pulled and the container to run successfully.</p><p><strong>Getting the correct Docker image</strong></p><p>The deployment depended on the correct Docker Hub repository and tag. I verified the repository on Docker Hub and used the correct image reference, including the CardioCare v4 tag for the ACI deployment.</p><p><strong>Making the application reachable</strong></p><p>For Charitize, I mapped VM port 80 to container port 80 and ensured HTTP was allowed on the VM. For CardioCare, I selected public networking and exposed TCP port 80 in Azure Container Instances.</p><p><strong>Understanding IaaS versus PaaS</strong></p><p>At first, both deployments can look similar because both ultimately run containers. The practical difference became clear during the work: the VM required server administration, while ACI handled the underlying compute infrastructure for the container.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OTdSoAoh1PkLYzRiUZ_BhA.png" /></figure><h3>Conclusion</h3><p>These two projects gave me practical experience deploying applications on Azure using two different cloud service models. <strong>Charitize</strong> was deployed using <strong>IaaS with an Azure Virtual Machine</strong>, where I managed the Ubuntu server, installed Docker, configured networking, and ran the application container. <strong>CardioCare</strong> was deployed using <strong>PaaS with Azure Container Instances</strong>, where Azure managed the underlying infrastructure while I focused mainly on the container image and application.</p><p>Overall, the projects helped me understand the real difference between <strong>IaaS and PaaS</strong>, Docker deployment, Azure networking, public access, Linux administration, and troubleshooting. More importantly, I learned that errors are part of the learning process and that solving them builds stronger practical cloud and DevOps skills.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f31db3478039" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[DOCKER PROJECT DOCUMENTATION]]></title>
            <link>https://medium.com/@akpatiifeany/docker-project-documentation-c9cd2aa7f500?source=rss-cf8cd6654d2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/c9cd2aa7f500</guid>
            <category><![CDATA[azure-deployment]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[containerization]]></category>
            <category><![CDATA[dockerhub]]></category>
            <dc:creator><![CDATA[ifeanyi marvelous akpati]]></dc:creator>
            <pubDate>Sat, 03 Oct 2026 14:31:14 GMT</pubDate>
            <atom:updated>2026-10-03T14:31:14.965Z</atom:updated>
            <content:encoded><![CDATA[<h3>Containerizing Web Application with Docker HTML/CSS /JS Website + PHP Web Application</h3><p><strong>Hands-on project documentation: CardioCare &amp; Charitize</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xGfdoQN_wuUMx2w3gFkDIA.png" /></figure><h3>Introduction</h3><p><strong>Topic: </strong>Containerizing Web Applications with Docker — Static HTML/CSS and PHP Applications.</p><p>This practical combines two related Docker exercises into one workflow: first, packaging a static HTML/CSS CardioCare website inside an Nginx container; second, packaging the PHP-based Charitize website inside a PHP/Apache container. The lab demonstrates the complete basic lifecycle — preparing a project, writing a Dockerfile, building an image, running a container, testing through localhost, logging in to Docker Hub, tagging and pushing an image, and pulling a published image back for testing.</p><h3>Learning Objectives</h3><p><strong>· </strong>Understand how a Dockerfile turns website source code into a reusable image.</p><p><strong>·</strong> Use appropriate web-server base images: Nginx for the static CardioCare site and PHP 8.2 with Apache for Charitize.</p><p><strong>·</strong> Build, run, stop, inspect and test Docker containers locally.</p><p><strong>·</strong> Authenticate to Docker Hub and publish images under the marvdev94 account.</p><p><strong>·</strong> Use image tags such as v1 and v4 to represent different application versions.</p><p><strong>· </strong>Pull a published image from Docker Hub and run it locally without the original source directory.</p><h3>Prerequisites</h3><p><strong>·</strong> Docker Desktop installed and running on Windows.</p><p><strong>·</strong> Visual Studio Code or another editor.</p><p><strong>· </strong>A working website project containing the required HTML/CSS/JS/assets or PHP files.</p><p><strong>·</strong> A Docker Hub account; the screenshots use marvdev94.</p><p><strong>·</strong> A browser for testing localhost URLs.</p><h3>Start Docker and Log In</h3><p>Before building or running either project, start Docker Desktop and wait until the Docker engine is ready. Then authenticate from PowerShell so Docker can push images to Docker Hub; never place your Docker Hub password directly inside a command or Dockerfile.</p><pre>docker login 📋 COPY<br>When prompted, enter your Docker Hub credentials or use a personal access token where required.<br>docker info 📋 COPY<br>Optional verification that the Docker engine is responding.<br>docker ps 📋 COPY<br>Shows currently running</pre><h3>Practical Workflow at a Glance</h3><p><strong>Build → Run → Test → Login → Create/Use Repository → Tag → Push → Pull → Run again</strong> The same lifecycle is applied to both projects, while the base image and runtime differ.</p><h3>PROJECT 1 — Dockerize the HTML/CSS Website (CardioCare)</h3><p>CardioCare is a static front-end website made from HTML, CSS, JavaScript and image/assets files. Because it does not require a server-side application runtime, Nginx is used as the lightweight web server inside the container.</p><h3>CardioCare Dockerfile</h3><pre>FROM nginx:latest<br>WORKDIR /usr/share/nginx/html<br>COPY . /usr/share/nginx/html<br>EXPOSE 80</pre><h3>Open the CardioCare Project</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*7CWda4xZGyTMTULaHTuJpg.png" /></figure><p>The project folder is opened in Visual Studio Code so the website files and Dockerfile can be managed together. Keeping the Dockerfile at the project root allows Docker to use the complete website folder as the build context.</p><p>The project folder is opened in Visual Studio Code so the website files and Dockerfile can be managed together. Keeping the Dockerfile at the project root allows Docker to use the complete website folder as the build context.</p><h3>Create and review the Dockerfile</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*Z1cv2DdzRfvURoPf0h4e-A.png" /></figure><p>The Dockerfile selects the official Nginx image and sets Nginx’s default HTML directory as the working location. The website files are then copied into that directory so Nginx can serve the site on port 80.</p><h3>Build the CardioCare image</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*SUitp_R9Ulm0zWS4mfkwAg.png" /></figure><p>The build command creates a local Docker image named cardiocare:v1 from the Dockerfile in the current directory. The successful output shows that the base image was downloaded, files were copied, and the image was exported.</p><pre>docker build -t cardiocare:v1 .</pre><h3>Run the CardioCare container</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*sQr7ItadUL_9FZAhYZQ1OQ.png" /></figure><p>The container is started in detached mode and host port 8080 is mapped to container port 80. The startup log confirms that the Nginx entrypoint is processing its normal configuration.</p><h3>Run the CardioCare container</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*sQr7ItadUL_9FZAhYZQ1OQ.png" /></figure><p>The container is started in detached mode and host port 8080 is mapped to container port 80. The startup log confirms that the Nginx entrypoint is processing its normal configuration.</p><pre><br>docker run -d -p 8080:80 cardiocare:v1</pre><h3>Verify the website in the browser</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*ZtF5jG41pICFUMhOQ6LmjA.png" /></figure><p>The CardioCare site loads successfully through localhost, proving that Nginx is serving the files from the container. This is the first functional test before publishing the image to Docker Hub.</p><pre>docker run -d -p 8080:80 cardiocare:v1</pre><h3>Authenticate with Docker Hub</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CI4RyPY7ghLE6CRdL5Glww.png" /></figure><p>Docker Hub authentication succeeds for the marvdev94 account, enabling the local Docker client to push images to repositories owned by that account. This step is normally completed before tagging and publishing.</p><pre>docker login</pre><h3>Create the Docker Hub repository</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6R4pXQIhsAom4u83Tt3lIw.png" /></figure><p>A public repository named cardiocare is created under the Docker Hub account and given a short application description. The repository becomes the remote destination for CardioCare image tags.</p><h3>Tag and push CardioCare v1</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9F-6YcDaJSvHEhgvawu2Ig.png" /></figure><p>The local image is associated with the Docker Hub repository name and pushed to the remote registry. “Pushed” and “Mounted” messages show that Docker uploaded new layers while reusing layers already present in the registry.</p><pre>docker tag cardiocare:v1 marvdev94/cardiocare:v1<br>docker push marvdev94/cardiocare:v1</pre><h3>Update the website content</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G4g-P4jV0H7JRmZFv4wS-w.png" /></figure><p>The CardioCare homepage is edited to add the IFECO branding to the hero heading. This demonstrates a practical version change that can be captured in a new Docker image tag.</p><h3>Build and run CardioCare v4</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gxSPMrk2CTzYbe6wpM9cFw.png" /></figure><p>A new image version is built after the website change and the v4 container is started on host port 8083. A different host port avoids conflict with another container already using port 8080.</p><pre>docker build -t cardiocare:v4 .<br>docker run -d -p 8083:80 cardiocare:v4</pre><h3>Confirm the Docker Hub v4 tag</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qb0cw-oMRMAWfxR1CFRHDw.png" /></figure><p>The Docker Hub repository shows multiple CardioCare tags, including v1 and v4. Tags make it possible to distinguish application versions without creating a separate repository.</p><h3>Pull the published v4 image</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zIEPrmmnU4nZeQFtR-oFwA.png" /></figure><p>The v4 image is pulled from Docker Hub and the local image list confirms that the remote image is now available. This simulates what another developer or server would do when deploying the published application.</p><pre>docker pull marvdev94/cardiocare:v4<br>docker images</pre><h3>Run the pulled CardioCare image</h3><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*gxSPMrk2CTzYbe6wpM9cFw.png" /></figure><p>The Docker Hub repository shows multiple CardioCare tags, including v1 and v4. Tags make it possible to distinguish application versions without creating a separate repository.</p><pre>docker run -d -p 8000:80 marvdev94/cardiocare:v4</pre><h3>Verify the pulled image</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*28-hUbAy102kw9UqU-OKSw.png" /></figure><p>The browser displays the updated CardioCare site from the image pulled from Docker Hub. The successful page load confirms that the published v4 image contains the expected application version.</p><pre>docker run -d -p 8000:80 marvdev94/cardiocare:v4</pre><h3>PROJECT 2 — Dockerize the PHP Website (Charitize)</h3><p>Charitize is a PHP-based website containing PHP pages, CSS, JavaScript, images and supporting libraries. Unlike the static CardioCare project, it needs a PHP-capable web server, so the Dockerfile uses the official PHP 8.2 Apache image.</p><h3>Charitize Dockerfile</h3><pre>FROM php:8.2-apache<br>WORKDIR /var/www/html<br>COPY . /var/www/html<br>EXPOSE 80</pre><h3>Download and prepare the Charitize project</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DF7hiH3_tmTpmNx8Tm3Y6Q.png" /></figure><p>The Charitize project archive is downloaded from Google Drive and prepared for extraction on the Windows machine. This creates the local source package that will later become the Docker build context.</p><h3>Extract the project files</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Qbz2dpmLbNLTBUe9RIXSfA.png" /></figure><p>The compressed Charitize archive is extracted into the LABS directory so the complete project can be opened in Visual Studio Code. The extracted folder contains the PHP pages and supporting web assets.</p><h3>Create the PHP/Apache Dockerfile</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VUtqakSr-SobQRKIL8MGFg.png" /></figure><p>The Dockerfile uses PHP 8.2 with Apache, sets /var/www/html as the working directory, and copies the application into Apache’s document root. Port 80 is exposed so browser requests can reach the application through a host-to-container mapping.</p><h3>Build and run the Charitize image</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-2Cym1Q2QK3bwd1YoUbBdg.png" /></figure><p>The Charitize image is built as charitize-app and then started in detached mode with host port 8080 mapped to Apache port 80. The successful container start provides the runtime needed to serve the PHP website.</p><pre>docker build -t charitize-app .<br>docker run -d -p 8080:80 charitize-app</pre><h3>Verify the PHP application</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L8NXurhYrdmgktL68J11ig.png" /></figure><p>The Charitize website opens successfully at localhost:8080, confirming that Apache and PHP are serving the application from inside the container. This validates the local container before publishing it.</p><pre>http://localhost:8080/</pre><h3>Tag and push the Charitize image</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2PMFSnuIaS9kbGKZJ1hrVQ.png" /></figure><p>The local charitize-app image is tagged with the Docker Hub namespace and pushed to the marvdev94/charitize repository. Publishing the image makes the packaged PHP application available for reuse on another Docker host.</p><pre>docker tag charitize-app marvdev94/charitize<br>docker push marvdev94/charitize</pre><h3>Verifying the Charitize Image on Docker Hub</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hoc9tSCuVAobRCGhTIxb7A.png" /></figure><p>The Docker Hub screenshot confirms that the <strong>marvdev94/charitize</strong> repository has been successfully created and the latest image tag has been pushed. This verifies that the Charitize PHP application image is available in the Docker Hub repository for future pulling and deployment.</p><h3>Challenges Faced and Resolutions</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*774Z6E0pzYiBY8LKyPZYuQ.png" /></figure><h3>Project Docker Best Practices Demonstrated</h3><p><strong>·</strong> Keep the Dockerfile in the project root so the build context is predictable.</p><p><strong>· </strong>Choose a base image appropriate to the application runtime.</p><p><strong>·</strong> Use explicit version tags for meaningful releases instead of relying only on latest.</p><p><strong>·</strong> Use .dockerignore to avoid sending unnecessary files into the build context.</p><p><strong>·</strong> Test the container locally before pushing it to Docker Hub.</p><p><strong>·</strong> Use different host ports when multiple containers expose the same internal port.</p><p><strong>·</strong> Do not store passwords, API keys or access tokens in Dockerfiles or source repositories.</p><p><strong>·</strong> For repeatable deployments, pull a specific tag such as v4 rather than depending on an unspecified latest image.</p><h3>Conclusion</h3><p>These two practical projects demonstrate how Docker can package different types of web applications into portable, repeatable runtime environments. CardioCare shows static website containerization with Nginx, while Charitize demonstrates PHP application containerization with PHP 8.2 and Apache.</p><p>The complete workflow — Docker login, Dockerfile creation, image build, container run, browser testing, Docker Hub tagging, push and pull — provides a strong foundation for moving from local development toward cloud and CI/CD deployment. A natural next step is to automate the build and push process with GitHub Actions and deploy the published images to a cloud platform.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c9cd2aa7f500" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PROJECT DOCUMENTATION]]></title>
            <link>https://medium.com/@akpatiifeany/project-documentation-fe980c89c903?source=rss-cf8cd6654d2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/fe980c89c903</guid>
            <category><![CDATA[azure-functions]]></category>
            <category><![CDATA[azure-logic-apps]]></category>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[azure-deployment]]></category>
            <dc:creator><![CDATA[ifeanyi marvelous akpati]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 06:01:29 GMT</pubDate>
            <atom:updated>2026-09-28T06:01:29.876Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Automated Document Approval System Using Azure Logic App</strong></h3><p>Azure Blob Storage + Azure Functions + Local Development Workflow</p><p><strong>Practical Implementation Guide &amp; Screenshot Walkthrough</strong></p><h3>Project Introduction</h3><p>The Automated Document Approval System is a cloud-based workflow designed to receive documents, store them securely, process approval decisions, and support notification of the final outcome. In this practical implementation, Azure Blob Storage is used to organize document containers, while an Azure Functions HTTP endpoint provides the serverless processing logic. The project also demonstrates local Azure Functions development with Node.js, testing through a browser, and preparation of the Function App deployment environment in Azure.</p><p><strong>Core services and tools used:</strong></p><p><strong>· </strong>Microsoft Azure Portal — resource creation and management.</p><p><strong>·</strong> Azure Resource Group — logical container for project resources.</p><p><strong>· </strong>Azure Storage Account / Blob Storage — document and workflow storage.</p><p><strong>·</strong> Azure Functions — serverless HTTP-based document processing.</p><p><strong>· </strong>Node.js and Azure Functions Core Tools — local development and testing.</p><p><strong>·</strong> Visual Studio Code — source-code editing and terminal operations.</p><h3>Project Flow</h3><p>The practical flow documented by the screenshots is:</p><p><strong>Azure Login → Resource Group → Storage Account → Blob Containers → VS Code Project → Node.js Function → Local Test → Function App → Document Upload → Blob Trigger → HTTP/Azure Function → Blob Content → Approval Email → Run History-&gt;Azure Deployment.</strong></p><h3>Prerequisites</h3><p><strong>· </strong>An active Microsoft Azure account/subscription.</p><p><strong>·</strong> Azure CLI installed and available in PowerShell or Command Prompt.</p><p><strong>· </strong>Node.js installed on the development computer.</p><p><strong>· </strong>Azure Functions Core Tools installed.</p><p><strong>· </strong>Visual Studio Code installed.</p><p><strong>· </strong>Internet connectivity and permission to create Azure resources.</p><h3>How to Log in to Azure First</h3><p><strong>:</strong> Open your browser and go to <a href="https://portal.azure.com/?utm_source=chatgpt.com">Azure Portal</a>.</p><p><strong>:</strong> Click <strong>Sign in</strong> and enter your Microsoft/Azure account details.</p><p><strong>:</strong> After login, you should see the <strong>Azure Portal Dashboard</strong>.</p><p><strong>:</strong> If you are using PowerShell or VS Code, run:</p><pre>az login</pre><p>After successful login then:</p><h3>Open Azure Resource Groups</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*2m3zSVgL_Rp44vUeFo2J9g.png" /></figure><p>The Azure Resource Groups page is opened to confirm the subscription context before working with the document approval resources.</p><h3>Create the Project Resource Group</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IaA-Xpm16znhgVEkfEvPwg.png" /></figure><p>The Create a resource group page is used to define the project container. The subscription is set to Azure subscription 1, the resource group is named doc-approval-rg, and the region is West US 2. The Review + create button is then used to validate the configuration before deployment.</p><h3>Find the Storage Account Service</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IYFXbDSumY3NenUh1UYFCw.png" /></figure><p>The Azure Portal search is used to locate Storage accounts. The Storage accounts service appears under Azure services and is selected to begin the Blob Storage setup. This keeps the storage creation process inside the same Azure subscription and project resource group.</p><h3>Create the Azure Storage Account</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8Mwz3BPleDN5PimwQlY0qg.png" /></figure><p>The storage account is configured inside doc-approval-rg in West US 2. The account name shown is docapprovalstorage123, with Standard performance, Blob Storage as the primary service, and locally redundant storage (LRS). These settings provide a simple general-purpose storage foundation for the document approval workflow.</p><h3>Verify the Storage Account</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZkSs-sf0eOiA6rtZwLk5_w.png" /></figure><p>The storage account overview confirms that docapprovalstorage123 was provisioned successfully. The page shows the resource group, West US 2 location, Standard performance, LRS replication, and StorageV2 account kind. The Succeeded provisioning state indicates that the storage resource is ready for further configuration.</p><h3>Create the Uploads Container</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vtaN4H8N4eojBc7D9QMa7Q.png" /></figure><p>The Containers section is opened from the storage account under Data storage. A private container named uploads is created for incoming documents. Anonymous access remains disabled, which is appropriate for documents that should not be publicly exposed.</p><h3>Create Workflow Containers</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mUfUCf4RTy6EogirjpHzWQ.png" /></figure><p>The Containers page shows four containers: $logs, approved, rejected, and uploads. The approved and rejected containers provide separate destinations for documents after an approval decision, while uploads acts as the initial landing area. All project containers shown are private, keeping anonymous blob access disabled.</p><h3>Open the Local Function Project in VS Code</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3z8W3KORPUMtnXgEhKfqjA.png" /></figure><p>Visual Studio Code is used to open the local Doc-approval-function project. The folder is located under the LABS directory and becomes the working directory for the Azure Functions code. This establishes the local development environment before creating and testing the HTTP-triggered function.</p><h3>Initialize the Azure Functions Node.js Project</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f5eOiJ1_JA7kg5SMcK8d5A.png" /></figure><p>Azure Functions Core Tools is used with func init to initialize the local project. The Node worker runtime is selected from the available runtime choices, creating the required Azure Functions project structure. The project can then be extended with a function trigger.</p><pre>func init </pre><p><strong>Portal action: </strong>Run func init → choose Node.</p><h3>Create the HTTP Trigger</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2tZtWcGPVPlNs9Dagjjxcw.png" /></figure><p>The func new command opens the trigger selection menu in Azure Functions Core Tools. HTTP trigger is selected because the document approval endpoint needs to receive HTTP requests such as document metadata or approval actions. The function is named ProcessDocument to make the endpoint easy to identify.</p><pre>func new --name ProcessDocument --template &quot;HTTP trigger&quot;</pre><p><strong>Portal action: </strong>Run func new → choose HTTP trigger → Function name: ProcessDocument.</p><h3>Confirm Function Creation</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yf56rsrw28STlqeJ85H-BQ.png" /></figure><p>The terminal confirms that the ProcessDocument function was created successfully from the HTTP trigger template. The project explorer also shows the generated source structure, including the src folder and configuration files. This confirms that the local function scaffold is ready for coding.</p><pre>dir<br>func --list-functions</pre><p><strong>Portal action: </strong>Verify the success message: “The function ProcessDocument was created successfully from the HTTP trigger template.”</p><h3>Install Project Dependencies</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WkscblKcHnMQ9EUccxqejA.png" /></figure><p>The npm install command is executed inside the project directory. The output shows that the Azure Functions package dependencies were installed and audited successfully. The result reports zero vulnerabilities in the packages checked during this installation.</p><pre>npm install</pre><p><strong>Portal action: </strong>Run npm install in the project root and confirm the audit result.</p><h3>Start the Function Locally</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ohHSCHebChwxhBi0EJkObQ.png" /></figure><p>The ProcessDocument.js file contains logic that returns document information with a Waiting for approval status. Running func start launches the local Azure Functions host and exposes the ProcessDocument endpoint at localhost:7071. The terminal also shows a storage health-check warning, but the HTTP endpoint is still listed and available for local testing.</p><pre>func start</pre><p><strong>Portal action: </strong>Run func start → confirm ProcessDocument is available at <a href="http://localhost:7071/api/ProcessDocument.">http://localhost:7071/api/ProcessDocument.</a></p><h3>Test the Local HTTP Endpoint</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1TxeV82Xl-d-ptUyu8cofA.png" /></figure><p>The browser is used to call the ProcessDocument endpoint with fileName and fileSize query parameters. The response returns the filename report.pdf, file size 200, a received timestamp, and the status Waiting for approval. This confirms that the HTTP trigger can receive input and return structured JSON locally.</p><pre>Invoke-RestMethod -Uri &quot;http://localhost:7071/api/ProcessDocument?fileName=report.pdf&amp;fileSize=200&quot; -Method GET</pre><p><strong>Portal action: </strong>Open the local endpoint with query parameters and verify the JSON response.</p><h3>Open Function App in Azure</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YUBJNJ4DBIZjH_WFDwlOPQ.png" /></figure><p>The Azure Portal search is used to locate Function App resources. The portal shows the doc-approval-rg resource group in West US 2, confirming that the project resource group is available for the serverless deployment. Selecting Function App starts the process of creating the cloud-hosted function environment.</p><pre>az functionapp list --resource-group doc-approval-rg -o table</pre><p><strong>Portal action: </strong>Search for “Function App” → select Function App → Create.</p><h3>Select the Flex Consumption Hosting Plan</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IL-kN1u8sjuxv1d3VME2Xw.png" /></figure><p>Azure presents several hosting options for Function Apps, including Flex Consumption, Functions Premium, App Service, and other plans. Flex Consumption is selected in the screenshot and supports event-driven scaling and scale-to-zero behavior. The Select button is used to continue with the chosen hosting model.</p><pre>az functionapp plan list --resource-group doc-approval-rg -o table</pre><p><strong>Portal action: </strong>Choose Flex Consumption → click Select.</p><h3>Configure the Function App</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5KHuMlPuJ9qmVqhH9WwRew.png" /></figure><p>The Function App is configured with the name doc-approval-rg in West US 2. Node.js 22 LTS is selected as the runtime, the instance size is 2048 MB, and zone redundancy is disabled in the shown configuration. The Review + create action validates these settings before Azure provisions the Function App.</p><pre>az functionapp create --name doc-approval-rg --resource-group doc-approval-rg --storage-account docapprovalstorage123 --runtime node --runtime-version 22 --functions-version 4 --consumption-plan-location westus2</pre><p><strong>Portal action: </strong>Name: doc-approval-rg<br> Region: West US 2<br> Runtime: Node.js 22 LTS<br> Memory: 2048 MB</p><h3>Monitor the Azure Deployment</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XefcBDs9wUhIRBabIxYpHA.png" /></figure><p>The deployment overview shows that Azure is provisioning the resources required for the Function App. Several deployment components are already marked OK, including storage-related resources and the hosting plan. This screen is used to monitor deployment progress and confirm that the resource group is receiving the expected infrastructure.</p><pre>az deployment group show --resource-group doc-approval-rg --name &lt;deployment-name&gt; -o table</pre><h3>Azure CLI Login</h3><p>This screenshot shows the Azure CLI login command being executed in the VS Code PowerShell terminal. after creating a processDocument file inside a function folder and provided the needed parameters.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*mH9X5r0cRH9ZYETmqoW4cw.png" /></figure><p><strong>Parameters:</strong></p><pre>const { app } = require(&#39;@azure/functions&#39;);<br><br>app.http(&#39;ProcessDocument&#39;, {<br>    methods: [&#39;GET&#39;, &#39;POST&#39;],<br>    authLevel: &#39;function&#39;,<br>    handler: async (request, context) =&gt; {<br><br>        const fileName =<br>            request.query.get(&#39;fileName&#39;) ||<br>            request.body?.fileName ||<br>            &#39;Unknown file&#39;;<br><br>        const fileSize =<br>            request.query.get(&#39;fileSize&#39;) ||<br>            request.body?.fileSize ||<br>            &#39;0&#39;;<br><br>        const result = {<br>            fileName: fileName,<br>            fileSize: fileSize,<br>            receivedTime: new Date().toISOString(),<br>            status: &#39;Waiting for approval&#39;<br>        };<br><br>        return {<br>            status: 200,<br>            jsonBody: result<br>        };<br>    }<br>});</pre><h3>Deploy the Azure Function</h3><p>The Azure Functions Core Tools deployment command is shown in the VS Code terminal. The highlighted message confirms that the Function App deployment completed successfully and provides the deployed ProcessDocument endpoint.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*l1Cqgk-uS6zXBcYnka24Dg.png" /></figure><pre>func azure functionapp publish doc-approval-rg </pre><h3>Test the Deployed Function</h3><p>The PowerShell test uses the deployed Function URL to call the HTTP-triggered function. The returned table confirms that the function received the test data and reported the document as waiting for approval.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*q9zeIMasb0SbG41WPHGUCA.png" /></figure><pre>Invoke-RestMethod -Uri $url -Method GET</pre><h3>Get the Azure Function URL</h3><p>The Azure portal Code + Test page for ProcessDocument is open and the Get function URL panel is displayed. This URL is the endpoint later used by the Logic App to communicate with the Function.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*k9OTysxMsGuG8uueV3lXXg.png" /></figure><h3>Choose Logic App Hosting</h3><p>The Create Logic App page shows the Consumption hosting option selected under the multi-tenant model. Consumption was selected to provide a managed, pay-per-operation workflow suitable for this practical.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*Sgs1ufKGlVxco5QKeRh9og.png" /></figure><h3>Configure the Logic App</h3><p>The Logic App creation form shows the Azure subscription, doc-approval-rg resource group, application name, West US 2 region, and Stateful workflow type. These settings establish the environment in which the approval workflow will run.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*TqAY4nVf1TYa2OXXIPu8xw.png" /></figure><h3>Open the Logic App Designer</h3><p>The newly created document-approval-logicapp is opened in Logic App Designer. The blank designer is ready for the blob trigger that will start the document approval workflow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*IcMgnuG2kNbrRNg4tg3Lsw.png" /></figure><h3>Create the Blob Trigger Connection</h3><p>A connection is created for the Azure Blob Storage trigger using Access Key authentication. The storage account name and access key connect the Logic App to the document storage account.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*ZLkCzfIDembu6U-TEwTGXA.png" /></figure><h3>Configure the Blob Trigger</h3><p>The trigger ‘When a blob is added or modified (properties only) (V2)’ is configured for the /uploads container. This makes a new or modified document in the uploads container the event that starts the workflow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*kZoyq1MXYwpYueNpULrzEw.png" /></figure><h3>Add the HTTP Function Call</h3><p>An HTTP action is added after the blob trigger and configured to use the POST method. The action passes document information from the trigger to the deployed Azure Function for processing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*C6ohsx_hIzUq8v3Z1Eeq3A.png" /></figure><h3>Retrieve Blob Content</h3><p>The ‘Get blob content using path (V2)’ action is added to retrieve the uploaded file from Azure Blob Storage. The Blob path uses the file path supplied by the trigger.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*P9I6GD7HrZF9uwwrHN1WRw.png" /></figure><h3>Configure the Email Connection</h3><p>The workflow initially attempts to create an Office 365 Outlook connection for the approval email. The connection screen shows the sign-in requirement needed before the connector can send messages.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*dh7HCRhWOXDKOmNShDguGw.png" /></figure><h3>Select the Microsoft Account</h3><p>The Microsoft account selection window appears during Outlook connector authentication. The appropriate account is selected to authorize the email connection for the Logic App.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*cTZhwHP8qUoisRoYQZx8VA.png" /></figure><h3>Verify the Uploaded Blob</h3><p>The uploads container is opened and a document is visible inside it. This confirms that the storage container is receiving files that can trigger the workflow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e0AuwLTfU251hCMo_3bDZA.png" /></figure><h3>Review the Complete Workflow</h3><p>The Logic App Designer now shows the complete workflow from the blob trigger through HTTP processing, blob content retrieval, and email notification. The sequence demonstrates the end-to-end document approval automation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*zrPUkAAfOWTPdXq0GDLVxQ.png" /></figure><h3>Verify the Approval Email</h3><p>The approval notification is visible in Gmail with the subject ‘Document Approval Required’. The message contains the document metadata supplied by the workflow, confirming that the notification stage worked.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rRA9iZcFsV772eMhGUAf3g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JYhVCJ01ZtcPsUkf5S88yQ.png" /></figure><h3>Approve or Reject</h3><p>This clearly shows the image of approved or rejected document feedback.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TXpkVrH7MxbDqZHbHc1KTw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qXJcp704fgguZH_xTDpn1g.png" /></figure><h3>Run History</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QrdwtA39uJwRNI5iJVl_Mw.png" /></figure><h3>Challenges &amp; Resolution</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*r4BKsGLN_dSk93OSVp-ygQ.png" /></figure><h3>Conclusion</h3><p>The <strong>Automated Document Approval System</strong> successfully demonstrated how Azure cloud services can be combined to automate a document review and approval workflow. The project integrated <strong>Azure Blob Storage, Azure Logic Apps, and Azure Functions</strong> to detect uploaded documents, process their details, and send approval notifications automatically.</p><p>Through the project, the workflow was successfully tested from <strong>document upload → function processing → approval email → workflow execution</strong>, while several configuration and deployment challenges were resolved. Overall, the project provided practical experience in <strong>serverless computing, cloud automation, API integration, Azure Functions deployment, and event-driven workflows</strong>.</p><h3>GitHub Repository</h3><p><strong>Project Repository: </strong><a href="https://github.com/MarvDev-Arch/Az-Automated-Doc-Approval">https://github.com/MarvDev-Arch/Az-Automated-Doc-Approval</a></p><p>Visit the GitHub repository to review the source code, follow the implementation, suggest improvements, report issues, and contribute to the project.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fe980c89c903" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Azure SQL Database Student Registration Portal]]></title>
            <link>https://medium.com/@akpatiifeany/azure-sql-database-student-registration-portal-947247752f5d?source=rss-cf8cd6654d2e------2</link>
            <guid isPermaLink="false">https://medium.com/p/947247752f5d</guid>
            <category><![CDATA[azure-devops]]></category>
            <category><![CDATA[vscode]]></category>
            <category><![CDATA[azure-sql-database]]></category>
            <category><![CDATA[azure-networking]]></category>
            <dc:creator><![CDATA[ifeanyi marvelous akpati]]></dc:creator>
            <pubDate>Wed, 16 Sep 2026 19:02:35 GMT</pubDate>
            <atom:updated>2026-09-16T19:02:35.615Z</atom:updated>
            <content:encoded><![CDATA[<p>Cloud Database Deployment, SQL Configuration and Front-End Setup</p><h3>Project Topic</h3><p>Deploying an Azure SQL Database for a Student Registration Application and preparing the application front end.</p><h3>Architecture</h3><p>Microsoft Azure Portal • Azure SQL Database • Azure SQL Logical Server • SQL Server Management Studio (SSMS) • Visual Studio Code • HTML/CSS/javerScript</p><h3>Project Workflow</h3><p>Azure login → Azure SQL Database → Resource Group → SQL Server → Networking/Firewall → SSMS →</p><p>Students table → Test data → VS Code Student Registration form</p><h3>Introduction</h3><p>This project demonstrates the creation and configuration of a cloud-hosted relational database for a Student Registration application. The database is deployed in Microsoft Azure as Azure SQL Database, secured through SQL Server networking and a firewall rule, and accessed using SQL Server Management Studio. A Students table is created and tested with sample data, providing evidence that the database is ready to support application data. The project then moves into Visual Studio Code, where the Student Registration front-end form is prepared.</p><h3>How to Login to Microsoft Azure First</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mfKosP--2KnmD6EnIONQMw.png" /></figure><h3>Project Overview</h3><p>The project begins by locating Azure SQL Database and selecting the free database offer. It then creates a resource group and SQL logical server, configures StudentPortalDB, reviews the deployment, and verifies the resources. Networking is configured with selected public access and a client firewall rule so SSMS can connect. The database is then created and tested before the Student portal front end is opened in VS Code.</p><h3>Open Azure SQL Database</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*URuQLeMLQlfH-hFM-fJ1oQ.png" /></figure><p>The screenshot shows the Azure Portal search for <strong>Azure SQL Database</strong>. The search results provide access to the SQL Database service, which is used to create and manage the cloud database for the <strong>Student Registration application</strong>.</p><h3>Start the Free SQL Database offer</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FIsTG-1XJdRpqJQGFL58cA.png" /></figure><p>The Azure SQL databases page shows that no databases currently exist. The <strong>Create</strong> menu is opened, with <strong>SQL database (Free offer)</strong> selected. This option provides a suitable free environment for the Student Registration learning project. The step begins the process of creating the Azure SQL database.</p><h3>Create the Resource Group</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lpnu5LDYast6WSd6zoRZwg.png" /></figure><p>The screenshot shows the <strong>Create SQL Database</strong> page with the <strong>Create new resource group</strong> dialog open. The resource group name <strong>student-portal-rg</strong> is entered to organize the database and related Azure resources. Confirming the dialog creates the resource group and makes it available for the deployment.</p><h3>Configure the SQL Logical Server</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*81Xlcj-vlyyzXNwGGTfQ8g.png" /></figure><p>The screenshot shows the <strong>Create SQL Database Server</strong> configuration page. The logical server is named <strong>student-portal-server1</strong>, with <strong>West US 2</strong> selected as the location and <strong>SQL authentication</strong> enabled. The administrator login is set to <strong>sqladmin</strong>, with a password provided. These settings configure the logical server that will host the <strong>StudentPortalDB</strong> database.</p><h3>Configure the Database</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*18DLbhxY5uGby6Z2zxSdRA.png" /></figure><p>The screenshot shows the <strong>database details</strong> section of the Azure SQL creation page. The database is named <strong>StudentPortalDB</strong> and uses the <strong>student-portal-server1</strong> server in <strong>West US 2</strong>. It is associated with the <strong>student-portal-rg</strong> resource group created earlier. The <strong>Review + create</strong> button is available to validate the configuration before deployment.</p><h3>Review the Configuration</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oDeYe94cYGWA7iUNgq_7pA.png" /></figure><p>The screenshot shows the <strong>Review + create</strong> page with the main deployment settings for the Azure SQL Database. It confirms the <strong>student-portal-rg</strong> resource group, <strong>West US 2</strong> region, <strong>StudentPortalDB</strong>, SQL authentication, server details, and free-offer configuration. Reviewing these settings ensures the database configuration is correct before deployment.</p><h3>Confirm successful deployment</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1HnmJShNkXV3VuOKX1hBww.png" /></figure><p>The screenshot shows a green confirmation that the <strong>Azure SQL Database deployment is complete</strong>. The deployment is associated with the <strong>student-portal-rg</strong> resource group, with an option to view the deployed resources. This confirms that the database provisioning was completed successfully.</p><h3>Verify deployed resources</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mwKrIIvw_lS8TswTqOT2Yg.png" /></figure><p>The screenshot shows the <strong>student-portal-rg</strong> resource group overview in Azure. It contains the <strong>student-portal-server1</strong> SQL server and <strong>StudentPortalDB</strong> database, both located in <strong>West US 2</strong>. This confirms that the main Azure resources required for the project were successfully created and grouped together.</p><h3>Configure SQL Server networking</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B2IE7AygBvPRSjbVDhQabA.png" /></figure><p>The screenshot shows <strong>student-portal-server1</strong> networking settings with public access limited to <strong>Selected networks</strong>. This allows specific firewall rules to control access and enables <strong>SSMS</strong> to connect securely to the Azure SQL server.</p><h3>Add the client IP firewall rule</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YhYtnz5VLH_CB3486WsZCQ.png" /></figure><p>The screenshot shows the <strong>Firewall rules</strong> section where the client’s IPv4 address is added as an allowed rule. Saving the configuration applies the firewall rule needed for the development connection.</p><h3>Connect from SQL Server Management Studio</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x05qNCkowk_VCRCKUNfJqg.png" /></figure><p>The screenshot shows the <strong>SSMS Connect</strong> dialog configured with the Azure SQL server details. <strong>SQL Server Authentication</strong> is selected with the sqladmin username and password, and <strong>Trust Server Certificate</strong> is enabled to establish the connection.</p><h3>Confirm the Azure database connection</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BtTd7PEfXA4RxAG85NPN4A.png" /></figure><p>The screenshot shows <strong>SSMS Object Explorer</strong> after connecting to the Azure SQL server. The <strong>StudentPortalDB</strong> database is visible under the Databases node, confirming that the connection was successful.</p><h3>Create the Students table</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WtbBOBz_l5gkXWFDpCLFAg.png" /></figure><p>The screenshot shows a SQL query creating the <strong>Students</strong> table in <strong>StudentPortalDB</strong>. The table includes <strong>StudentID</strong> as an identity primary key, along with <strong>FullName, Email, Course,</strong> and <strong>RegistrationDate</strong> fields. The successful execution confirms that the table was created correctly.</p><h3>Verify the table structure</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8hA75rREckkc2-RSLJ_fUA.png" /></figure><p>The screenshot shows a <strong>SELECT * FROM Students</strong> query being executed in SSMS. The results display the <strong>StudentID, FullName, Email, Course,</strong> and <strong>RegistrationDate</strong> columns. The empty results confirm that the table is created and ready to store student records.</p><h3>Insert Test Student Data</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L0NqtfMIJ6ZI0G4QagWnzQ.png" /></figure><p>The screenshot shows an <strong>INSERT INTO Students</strong> statement being executed in SSMS. A test student’s <strong>name, email, and Cloud Engineering course</strong> are entered, while the database handles the identity and registration date. The message confirming <strong>one row was affected</strong> shows that the student record was successfully inserted.</p><h3>Verify the Inserted Record</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*636Oo70biwrl6_tJPBTHJQ.png" /></figure><p>The screenshot shows the <strong>SELECT * FROM Students</strong> query being executed again after the test data was inserted. The results display <strong>StudentID 1</strong> with the student’s details, Cloud Engineering course, and registration date. This confirms that the record was successfully stored in <strong>StudentPortalDB</strong> and the database is working correctly.</p><h3>Open the Application Project in VS Code</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W37PqjFkUaQvH8QGN16S0Q.png" /></figure><p>The screenshot shows <strong>Visual Studio Code</strong> with the <strong>File</strong> menu open and <strong>Open Folder</strong> selected. This allows the correct Student Registration project folder to be opened. It marks the transition from database administration to front-end application development.</p><h3>Select the Student Portal Project Folder</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PrK2Bu2brlDojXt6BvqQ_Q.png" /></figure><p>The screenshot shows the <strong>Windows folder-selection dialog</strong> inside the LABS directory. The <strong>Student portal</strong> folder is selected to be opened in VS Code. This establishes the project workspace where the Student Registration interface can be edited and tested.</p><h3>Build the Registration Form</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*czgBMla9hJsQiOBHczjBzg.png" /></figure><p>The screenshot shows <strong>index.html</strong> open in Visual Studio Code within the Student portal project. The form includes fields for <strong>Full Name, Email, and Course</strong>, with required inputs and a linked <strong>style.css</strong> file. This establishes the basic front-end structure for the Student Registration application.</p><h3>Complete the HTML form structure</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7tI4DRa4ZFyupMHVu-Qjxg.png" /></figure><p>The screenshot shows the lower section of <strong>index.html</strong> with the <strong>Course</strong> dropdown and available options. The options include <strong>Cloud Engineering, DevOps Engineering,</strong> and <strong>Azure Administration</strong>, followed by the <strong>Register</strong> button. This completes the visible Student Registration form and prepares it for further application logic and database integration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OoYpONtx1CmoFuDLzvM_8w.png" /></figure><p>The screenshot shows the lower section of the Student Registration HTML form, including the course selection and Registered Students table. The Load Students button and table structure prepare the page to display records retrieved from the application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JpylD9TU-PwuXuSJsGhvbA.png" /></figure><p>The screenshot shows the general styling section of style.css for the Student Registration page. It defines the page layout, background, fonts, container size, spacing, and overall appearance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mvEndkVseaL9bgXnf2rYFw.png" /></figure><p>The screenshot shows the form and input styling in style.css. The rules control the layout, labels, input fields, borders, spacing, and focus effects for a cleaner registration interface.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*04gcNEezMYwKpj5ZTWSMmg.png" /></figure><p>The screenshot shows the button styling section of style.css. It defines the appearance, hover effects, colors, spacing, and behavior of the registration and Load Students buttons.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N1u-lGzLye-exQBGBfsAPw.png" /></figure><p>The screenshot shows the table styling section of style.css. It formats the table width, header, cells, borders, spacing, and row appearance for displaying student records.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IVUQEX6Sj3qip3ahiTMkHw.png" /></figure><p>The screenshot shows the responsive design rules in style.css. These rules adjust the container, table, text size, and spacing so the registration page remains usable on smaller screens.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zEXsQV_DJd4pHKvGsdSH_w.png" /></figure><p>The screenshot shows script.js containing the front-end JavaScript logic for the Student Registration form. It collects the student name, email, and course and prepares the data for a POST request to the API.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fiIXVnwpNuVefcbqamO3oQ.png" /></figure><p>The screenshot shows the remaining form submission logic in script.js. It processes the API response, displays a successful registration message, resets the form, and reports errors when the request fails.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aY0ypmqeyA2LNAfS-8WWlA.png" /></figure><p>The screenshot shows the VS Code context menu for index.html with the option to open the file using another method. This step provides access to options for running or viewing the Student Registration page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1L7ksYEIItABeJEXRRp-hw.png" /></figure><p>The screenshot shows the VS Code Run menu with Run Without Debugging selected. This starts the application without attaching the debugger so the HTML page can be tested.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y_IYrDW-_olmkJLbPCjd9Q.png" /></figure><p>The screenshot shows the Student Registration page running in a web browser. The form displays Full Name, Email, Course options, the Load Students button, and the table header for registered students.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PekioUw6uBa4V92AjpXhJw.png" /></figure><p>The screenshot shows the Azure Functions command palette in VS Code with Create New Project selected. This begins the process of creating the backend Azure Functions project for the Student Registration application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_l-xlqYxEKWmWh1YXGIlcQ.png" /></figure><p>The screenshot shows the folder selection dialog with the student-api folder selected. Selecting this folder sets the location where the Azure Functions backend project will be created.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H3YJqPPtjE9tjEg_xwRnMQ.png" /></figure><p>The screenshot shows the Azure Functions project type selection with JavaScript selected. JavaScript is chosen as the programming language for the backend function project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uhzANYFHAxTe6lTRLT_fXA.png" /></figure><p>The screenshot shows the Azure Functions trigger selection with HTTP trigger highlighted. An HTTP trigger allows the Student Registration application to communicate with the backend through web requests.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BybeoUJeZmUFhhQ2jQWZig.png" /></figure><p>The screenshot shows the function name field containing studentsdata. This name identifies the HTTP-triggered Azure Function that will handle student-related requests.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*olRV5uczIRy1XnfwBHhtqA.png" /></figure><p>The screenshot shows the generated studentsdata Azure Function in VS Code. The function is configured for GET and POST requests and confirms that the JavaScript Azure Functions project was created successfully.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bo2GfEC0ValokCtqRhauBg.png" /></figure><p>The screenshot shows the terminal running npm install mssql inside the student-api project. The command installs the SQL Server package required for the backend to communicate with the Azure SQL database.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Yk4Blw4gLmYPRNIVlWsc1g.png" /></figure><p>The screenshot shows the completed Azure Functions project and the generated studentsdata HTTP trigger. The successful creation messages confirm that the JavaScript function project and HTTP trigger were initialized correctly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*raTZ_5HDARH_bD-H1phVhw.png" /></figure><p>The screenshot shows the student-api terminal after installing the mssql package. The installation completed successfully with packages added and no reported vulnerabilities.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0uvsgMhxSpXfERatsaewEw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0uvsgMhxSpXfERatsaewEw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GP_YF-3yKnBd5U_mp8Wsdg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yBEH9Zg7J-3OLJAoeIXFFA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xn-WAge834etB5ycOfiRSA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xn-WAge834etB5ycOfiRSA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xn-WAge834etB5ycOfiRSA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t-_ETUf8esfpTlzABwseIg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zws5PnLuVsA-zP7BXykf9g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zws5PnLuVsA-zP7BXykf9g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zws5PnLuVsA-zP7BXykf9g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-jsALm91KiN0aO2QpVnphw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3DKdIQyJ-V4lPQT1eO_imw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2pM0yMa1Pp2YMdAoZZgVMQ.png" /></figure><h3>Conclusion</h3><p>The <strong>Student Registration project was successfully completed</strong>, integrating the front end, Azure Function API, and Azure SQL Database. Users can register students, securely store their information, and view registered records through a simple interface.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eLDRPhb2C9b_hesodPpheQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=947247752f5d" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>