<?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 Dadsummercodingclass on Medium]]></title>
        <description><![CDATA[Stories by Dadsummercodingclass on Medium]]></description>
        <link>https://medium.com/@dadsummercodingclass?source=rss-e2a78040fba9------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*RGLnAHWSUqQ5QovH</url>
            <title>Stories by Dadsummercodingclass on Medium</title>
            <link>https://medium.com/@dadsummercodingclass?source=rss-e2a78040fba9------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 02:12:39 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@dadsummercodingclass/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[Understanding Kubernetes NodePort Services: Exposing Applications and Troubleshooting Pod…]]></title>
            <link>https://medium.com/@dadsummercodingclass/understanding-kubernetes-nodeport-services-exposing-applications-and-troubleshooting-pod-d0ed6126ec02?source=rss-e2a78040fba9------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0ed6126ec02</guid>
            <category><![CDATA[nginx]]></category>
            <category><![CDATA[dockerfiles]]></category>
            <category><![CDATA[node]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[azure-kubernetes-service]]></category>
            <dc:creator><![CDATA[Dadsummercodingclass]]></dc:creator>
            <pubDate>Sat, 07 Nov 2026 06:42:44 GMT</pubDate>
            <atom:updated>2026-11-07T06:42:44.454Z</atom:updated>
            <content:encoded><![CDATA[<h3>Understanding Kubernetes NodePort Services: Exposing Applications and Troubleshooting Pod Connectivity</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*43kHLfIfZp2uPirNOY_VjA.jpeg" /></figure><p><em>An hands-on DevOps learning experience exploring Kubernetes Services, NodePort networking, EndpointSlices, label selectors, and Kubernetes self-healing.</em></p><h3>Introduction</h3><p>One of the important concepts in Kubernetes is understanding how applications running inside a cluster communicate with one another and how they can be accessed from outside the cluster.</p><p>During my DevOps Micro Internship (DMI) with Agentic AI, I completed a practical Kubernetes networking exercise focused on <strong>NodePort Services</strong>.</p><p>The goal was to deploy an NGINX application, expose it through a Kubernetes NodePort Service, test connectivity from within the cluster, deliberately introduce a configuration problem, troubleshoot it, and observe Kubernetes self-healing in action.</p><p>This exercise helped me understand that exposing an application in Kubernetes involves more than simply assigning a port. The Service must correctly identify its backend Pods, the Pods must be healthy, and the cluster’s networking configuration must allow traffic to reach the application.</p><p>In this article, I’ll walk through the key concepts, practical activities, troubleshooting process, and lessons learned.</p><h3>1. Understanding Kubernetes Services</h3><p>In Kubernetes, Pods are the smallest deployable units. They run application containers, but they are not designed to provide a permanent network identity.</p><p>A Pod can be deleted and recreated, potentially receiving a different IP address. This creates a challenge when other applications need to communicate with it consistently.</p><p>Kubernetes Services solve this problem by providing a stable network endpoint for accessing a group of Pods.</p><p>A Service uses a selector to identify the Pods that should receive traffic.</p><p>For example, imagine an NGINX application running in two Pods:</p><ul><li>nginx-pod-1</li><li>nginx-pod-2</li></ul><p>A Kubernetes Service can use a label selector to identify both Pods and distribute traffic to the available endpoints.</p><p>This means applications can communicate with the Service without needing to know the individual Pod IP addresses.</p><h3>2. What Is a NodePort Service?</h3><p>A NodePort is a Kubernetes Service type that exposes an application on a specific port across the cluster’s nodes.</p><p>It allows traffic to reach the application through:</p><p><strong>Node IP address + NodePort</strong></p><p>For this practical exercise, I created a NodePort Service to expose an NGINX application using:</p><ul><li><strong>Application:</strong> NGINX</li><li><strong>Service type:</strong> NodePort</li><li><strong>NodePort:</strong> 32305</li></ul><p>The application could then be accessed through a cluster node’s IP address and the assigned NodePort, provided the cluster networking configuration allowed the traffic.</p><h3>How NodePort works</h3><p>The traffic flow can be understood as:</p><ol><li>A client sends a request to a Kubernetes node IP address.</li><li>The request targets the assigned NodePort.</li><li>Kubernetes networking routes the traffic through the Service.</li><li>The Service forwards the request to an available backend Pod.</li><li>The NGINX application processes the request and returns a response.</li></ol><p>NodePort provides a straightforward way to expose an application, particularly in development, testing, and learning environments.</p><p>However, it is important to remember that NodePort does not automatically make an application accessible from every external network.</p><h3>3. Understanding Service Selectors and Pod Labels</h3><p>One of the most important lessons from this exercise was understanding the relationship between Kubernetes Services and Pod labels.</p><p>Kubernetes Services use label selectors to determine which Pods should receive traffic.</p><p>For example, an NGINX Pod might have this label:</p><pre>labels:<br>  app: nginx</pre><p>The corresponding Service selector could be:</p><pre>selector:<br>  app: nginx</pre><p>The selector tells Kubernetes to identify Pods carrying the matching label.</p><p>If the Service selector does not match the Pod labels, Kubernetes cannot identify the intended backend Pods.</p><p>The Service may still exist, but it will have no matching endpoints to receive traffic.</p><p>This distinction is important: <strong>a successfully created Service does not necessarily mean that the application is reachable.</strong></p><h3>4. Understanding EndpointSlices</h3><p>Another important concept I explored was Kubernetes EndpointSlices.</p><p>EndpointSlices track the network endpoints associated with a Service. They provide information about the backend endpoints that Kubernetes can use when routing traffic.</p><p>When a Service selector matches healthy, ready Pods, Kubernetes maintains the corresponding endpoint information.</p><p>When there are no matching Pods, the Service can have an empty endpoint list.</p><p>This makes EndpointSlices useful when troubleshooting connectivity problems.</p><p>For example, if an application is unreachable, checking the EndpointSlices can help determine whether Kubernetes has discovered the expected backend Pods.</p><p>The troubleshooting process should therefore include checking:</p><ul><li>Whether the Service exists.</li><li>Whether the Service selector matches the Pod labels.</li><li>Whether the expected Pods are running and ready.</li><li>Whether the Service has the expected endpoints.</li></ul><h3>5. Testing NodePort Connectivity from Inside the Cluster</h3><p>After configuring the NodePort Service, I tested access to the NGINX application using a tester Pod running inside the Kubernetes cluster.</p><p>The test involved accessing the application through the node IP address and NodePort 32305.</p><p>This was an important step because it helped verify that the application could be reached through the Kubernetes networking path.</p><p>It also demonstrated that internal cluster connectivity and external client connectivity are not necessarily the same thing.</p><p>A successful request from a tester Pod confirms that the tested internal network path works. It does not automatically prove that someone using a laptop or an external network can reach the same NodePort.</p><h3>6. Deliberately Breaking the Service Selector</h3><p>One of the most valuable parts of this exercise was deliberately introducing a configuration error.</p><p>I changed the Service selector to a label that did not match the NGINX Pods.</p><p>As expected, this caused a connectivity failure.</p><p>The Service could no longer identify the intended backend Pods, resulting in empty endpoints and failed application access.</p><p>This was a useful demonstration of how a small configuration mismatch can affect application availability in Kubernetes.</p><h3>Troubleshooting the issue</h3><p>I approached the problem by examining the relationship between the Service and its backend Pods.</p><p>The key checks were:</p><ol><li>Inspect the labels assigned to the NGINX Pods.</li><li>Inspect the selector configured in the Service.</li><li>Check the Service’s EndpointSlices.</li><li>Identify the mismatch.</li><li>Restore the correct Service selector.</li><li>Test connectivity again.</li></ol><p>Once I restored the correct selector, Kubernetes was able to identify the NGINX Pods as backend endpoints, and connectivity recovered.</p><h3>The key lesson</h3><p>When a Kubernetes Service is reachable as an object but the application is not responding, do not immediately assume that the application container is broken.</p><p>The problem may be in the networking configuration, particularly the relationship between Service selectors and Pod labels.</p><h3>7. Observing Kubernetes Self-Healing</h3><p>Another important part of the practical exercise was observing Kubernetes self-healing.</p><p>I deliberately deleted one of the NGINX Pods to see how Kubernetes would respond.</p><p>Because the application was managed by a Kubernetes controller that maintained the desired number of replicas, Kubernetes automatically created a replacement Pod.</p><p>The remaining ready Pod continued to provide a backend for the Service, while the replacement was added to the available Service endpoints once it became ready.</p><p>This demonstrated an important Kubernetes capability: maintaining the desired state of an application.</p><p>Kubernetes continuously works to reconcile the actual state of the cluster with the desired state declared by the user.</p><p>If a managed Pod disappears, the controller can create another one to restore the expected replica count.</p><p>This is one of the reasons Kubernetes is valuable for running containerized applications.</p><h3>8. Why Internal NodePort Access Does Not Guarantee External Access</h3><p>A particularly important takeaway from this exercise was understanding the difference between accessing a NodePort from inside a cluster and accessing it from an external device.</p><p>Even if an application works through a NodePort from a tester Pod, external access may still fail.</p><p>Several factors can affect external connectivity:</p><ul><li><strong>Network Address Translation (NAT):</strong> Network translation rules may affect how traffic reaches the cluster.</li><li><strong>Firewall rules:</strong> Firewall configurations may block the NodePort.</li><li><strong>Cloud network security rules:</strong> Cloud environments may require explicit inbound access rules.</li><li><strong>Cluster networking:</strong> The Kubernetes networking implementation and node configuration affect traffic routing.</li><li><strong>Routing and public IP configuration:</strong> The node must be reachable through the intended network path.</li></ul><p>This distinction is especially important when deploying Kubernetes workloads on cloud platforms.</p><p>A successful internal connectivity test is valuable evidence, but external access should be tested separately.</p><h3>9. Key Lessons Learned</h3><p>This practical exercise strengthened my understanding of several Kubernetes networking concepts.</p><p><strong>1. Kubernetes Services provide stable application access.</strong></p><p>Services allow applications to communicate with Pods without depending on individual Pod IP addresses.</p><p><strong>2. NodePort exposes applications through cluster nodes.</strong></p><p>A NodePort Service makes an application available through a node IP address and an assigned port, subject to network configuration.</p><p><strong>3. Labels and selectors are critical.</strong></p><p>A Service must have selectors that match the labels on its intended backend Pods.</p><p><strong>4. EndpointSlices are useful troubleshooting tools.</strong></p><p>They help reveal whether Kubernetes has identified the expected backend endpoints.</p><p><strong>5. Kubernetes supports self-healing.</strong></p><p>When a managed Pod is deleted, Kubernetes can automatically create a replacement to maintain the desired replica count.</p><p><strong>6. Internal and external networking are different.</strong></p><p>Successful access from inside a cluster does not guarantee access from a laptop or another external network.</p><h3>10. What I Would Explore Next</h3><p>This exercise provides a foundation for exploring more advanced Kubernetes networking concepts.</p><p>Some areas I would like to investigate further include:</p><ul><li>Comparing ClusterIP, NodePort, and LoadBalancer Services.</li><li>Understanding Kubernetes Ingress and Gateway API.</li><li>Exploring DNS-based Service discovery.</li><li>Investigating NetworkPolicies and traffic restrictions.</li><li>Deploying applications behind cloud load balancers.</li><li>Automating Kubernetes deployments using CI/CD pipelines.</li></ul><p>These concepts build on the networking fundamentals covered in this exercise and are important when designing production-ready Kubernetes environments.</p><h3>Conclusion</h3><p>Working with Kubernetes NodePort Services gave me a practical understanding of how applications are exposed and accessed within a Kubernetes environment.</p><p>More importantly, deliberately breaking the Service selector and observing the resulting connectivity failure helped me understand how Kubernetes Services depend on correctly configured labels and backend endpoints.</p><p>Watching Kubernetes automatically replace a deleted Pod also reinforced the importance of controllers and desired-state management.</p><p>One of my biggest takeaways is that Kubernetes networking is not just about exposing ports. It is about understanding how Services, Pods, labels, EndpointSlices, and network infrastructure work together.</p><p>Every practical lab continues to strengthen my DevOps skills through building, testing, troubleshooting, and learning from real configuration failures.</p><p><strong>Keep learning. Keep building. Keep breaking things safely to understand how to fix them.</strong></p><h3>Project and Learning Resources</h3><ul><li><strong>My graded DevOps progress:</strong> <a href="https://lnkd.in/ewxGF2Wf">https://lnkd.in/ewxGF2Wf</a></li><li><strong>Start your DevOps journey:</strong> <a href="https://lnkd.in/eqdVHQRw">https://lnkd.in/eqdVHQRw</a></li></ul><h3>Suggested Medium Tags</h3><p>Kubernetes · DevOps · Kubernetes Networking · Docker · Cloud Computing</p><h3>Suggested Screenshots to Include</h3><p>To make this article more practical and credible, include screenshots from your actual lab:</p><ol><li><strong>NGINX Pods:</strong> kubectl get pods -o wide showing the NGINX Pods.</li><li><strong>NodePort Service:</strong> kubectl get svc showing the Service and NodePort 32305.</li><li><strong>Service Details:</strong> kubectl describe svc showing the selector and Service configuration.</li><li><strong>EndpointSlices:</strong> kubectl get endpointslices showing the backend endpoints.</li><li><strong>Successful Connectivity:</strong> Terminal output from the tester Pod accessing NGINX through the node IP and NodePort.</li><li><strong>Selector Failure:</strong> Evidence showing empty endpoints after changing the selector.</li><li><strong>Recovered Connectivity:</strong> Evidence after restoring the correct selector.</li><li><strong>Kubernetes Self-Healing:</strong> Output showing the replacement Pod after deleting the original Pod.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0ed6126ec02" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploying a Containerized Book Review Application on Azure Using Docker Compose: A Hands-On DevOps…]]></title>
            <link>https://medium.com/@dadsummercodingclass/deploying-a-containerized-book-review-application-on-azure-using-docker-compose-a-hands-on-devops-126d4aed60f9?source=rss-e2a78040fba9------2</link>
            <guid isPermaLink="false">https://medium.com/p/126d4aed60f9</guid>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[docker-compose]]></category>
            <category><![CDATA[backend-api]]></category>
            <category><![CDATA[containers]]></category>
            <dc:creator><![CDATA[Dadsummercodingclass]]></dc:creator>
            <pubDate>Sat, 07 Nov 2026 06:33:35 GMT</pubDate>
            <atom:updated>2026-11-07T06:33:35.927Z</atom:updated>
            <content:encoded><![CDATA[<h3>Deploying a Containerized Book Review Application on Azure Using Docker Compose: A Hands-On DevOps Project</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ppHi0v0R5iPGOEuW_m8VaQ.jpeg" /></figure><h3>Introduction</h3><p>Containerization has become one of the most important technologies in modern software development and DevOps engineering.</p><p>Applications that once required complex manual installation and configuration can now be packaged into containers, making deployment more consistent, portable, and easier to manage.</p><p>However, deploying a containerized application involves more than simply creating Docker images. Engineers must understand networking, service dependencies, environment variables, persistent storage, database connectivity, and application health checks.</p><p>As part of my <strong>DevOps Micro Internship (DMI) with Agentic AI</strong>, I completed a hands-on project focused on deploying a Book Review Application on Microsoft Azure using Docker and Docker Compose.</p><p>For this assignment, I containerized the frontend, backend API, and MySQL database, then orchestrated all three services using a centralized Docker Compose configuration.</p><p>This project provided practical experience with containerization, multi-container application deployment, persistent database storage, and cloud-based application hosting.</p><p>In this article, I’ll walk through the architecture, technologies, implementation approach, troubleshooting experience, and lessons learned.</p><h3>1. Understanding the Project Architecture</h3><p>The objective was to deploy a complete Book Review Application on an Azure Ubuntu Virtual Machine using Docker Compose.</p><p>Instead of installing and running each application component independently on the virtual machine, I containerized the individual services.</p><p>The architecture consisted of three primary services:</p><h3>Frontend Service</h3><p>The frontend provides the user interface through which users interact with the Book Review Application.</p><p>It communicates with the backend API to retrieve information and submit user requests.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/497/1*Les9Wl8Cm3deW8Z-8uOzqA.jpeg" /></figure><h3>Backend API Service</h3><p>The backend handles application logic and manages communication with the MySQL database.</p><p>It processes user registration, authentication, book review submissions, and other application operations.</p><h3>MySQL Database Service</h3><p>The database stores application information, including user accounts and book review data.</p><p>I configured persistent storage to ensure that database information would survive container removal and recreation.</p><h3>Infrastructure Environment</h3><p>The application was hosted on an Ubuntu Virtual Machine running on Microsoft Azure.</p><p>Docker Compose coordinated the three services, while Azure networking and virtual machine configuration provided the cloud hosting environment.</p><p>The architecture followed a simple but important principle:</p><p><strong>Each application component runs in its own container, while Docker Compose manages how the services work together.</strong></p><h3>2. Setting Up the Azure Ubuntu Environment</h3><p>The first stage involved preparing the cloud environment.</p><p>I provisioned an Ubuntu Virtual Machine on Microsoft Azure to serve as the Docker hosting environment.</p><p>The VM provided the Linux operating system required to install and run Docker.</p><h3>Installing Docker</h3><p>Docker was installed and configured on the Ubuntu virtual machine.</p><p>Docker provides the container runtime required to package and execute applications in isolated environments.</p><h3>Installing Docker Compose</h3><p>I also configured Docker Compose to manage the multiple application services.</p><p>Docker Compose makes it possible to define an application’s services, networks, volumes, and configuration in a centralized YAML file.</p><p>This eliminated the need to manually start and manage each container independently.</p><h3>3. Containerizing the Book Review Application</h3><p>One of the main objectives was to containerize the frontend, backend API, and MySQL database.</p><p>Each service was configured to run independently while communicating with the other required components.</p><h3>Frontend Container</h3><p>The frontend was packaged into a Docker container.</p><p>This allowed the user-facing application to run independently of the backend and database services.</p><h3>Backend Container</h3><p>The backend API was also containerized.</p><p>It handled application requests and communicated with the MySQL database through the configured Docker networking environment.</p><h3>MySQL Container</h3><p>The database was deployed as a separate MySQL container.</p><p>This provided an isolated database service while allowing the backend application to communicate with it through the internal Docker network.</p><p>Separating these services made the application easier to deploy, troubleshoot, and maintain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/907/1*lVNdIOVwng1hkGgajffwhw.jpeg" /></figure><h3>4. Orchestrating Services with Docker Compose</h3><p>One of the most important parts of this project was creating a centralized docker-compose.yml file.</p><p>Docker Compose allowed me to define and manage the three application services in one configuration.</p><p>Instead of running multiple independent Docker commands, I could use a single configuration to describe how the application should operate.</p><p>The Compose configuration brought together:</p><ul><li>Frontend service.</li><li>Backend API service.</li><li>MySQL database service.</li><li>Service dependencies.</li><li>Database health checks.</li><li>Environment variables.</li><li>Internal service communication.</li><li>Persistent database storage.</li></ul><h3>Understanding Service Dependencies</h3><p>A multi-container application requires its services to work together correctly.</p><p>For example, the backend depends on the database being available before it can successfully perform database operations.</p><p>Docker Compose service dependencies help define the startup relationships between services.</p><p>However, simply starting a database container does not necessarily mean that the database is ready to accept connections.</p><p>This is why health checks are important.</p><h3>Implementing MySQL Health Checks</h3><p>I configured MySQL health checks to help determine whether the database service was ready.</p><p>This provided a more reliable foundation for coordinating the startup of dependent application services.</p><p>One important lesson was understanding the difference between a container being started and the application inside that container being ready.</p><p>A running container does not automatically mean that its service is fully operational.</p><h3>5. Configuring Environment Variables and Application Communication</h3><p>Another important part of the deployment was configuring environment variables.</p><p>The frontend, backend, and database needed the correct configuration to communicate with one another.</p><p>Environment variables provided a structured way to manage settings such as:</p><ul><li>Database hostname.</li><li>Database name.</li><li>Database username.</li><li>Database password.</li><li>Backend API endpoint.</li><li>Application runtime configuration.</li></ul><h3>Frontend-to-Backend Communication</h3><p>The frontend needed to communicate with the backend API.</p><p>I configured the necessary API connection settings and CORS (Cross-Origin Resource Sharing) configuration to support communication between the frontend and backend.</p><p>CORS is particularly important when frontend and backend services are accessed through different origins.</p><p>A misconfigured CORS policy can prevent browser-based applications from communicating with their APIs even when the backend is running correctly.</p><p>This project helped me understand how application-level configuration and container networking work together.</p><h3>Protecting Sensitive Configuration</h3><p>Database credentials and other sensitive values should not be hardcoded into public source code.</p><p>For a production deployment, I would strengthen the configuration further through secure secrets management and appropriate access restrictions.</p><h3>6. Implementing Persistent Database Storage with Docker Volumes</h3><p>One of the most valuable technical lessons from this project involved Docker volumes.</p><p>Containers are designed to be replaceable.</p><p>A container can be stopped, removed, and recreated without necessarily preserving the data stored in its writable filesystem.</p><p>This creates an important challenge for database applications.</p><p>If database files are stored only inside a container’s writable layer, removing that container can result in data loss.</p><h3>Why Docker Named Volumes Matter</h3><p>To address this, I configured a named Docker volume for MySQL database storage.</p><p>A Docker named volume provides persistent storage that exists independently of an individual container’s lifecycle.</p><p>This means that database information can survive container removal and recreation when the same volume is reused.</p><p>For a database-driven application, this is essential.</p><h3>Testing Data Persistence</h3><p>One of the most important tests I performed was deliberately removing and recreating the application containers.</p><p>After recreating the containers, I verified that the database information remained available.</p><p>This demonstrated the value of separating persistent database storage from the container lifecycle.</p><p>The exercise reinforced an important principle:</p><p><strong>Containers may be disposable, but application data must be protected.</strong></p><p>It was one of the most rewarding parts of this assignment because it allowed me to validate a core containerization concept through practical testing rather than theory alone.</p><h3>7. Deploying the Application on Microsoft Azure</h3><p>After configuring the containers and Docker Compose environment, I deployed the application on the Azure Ubuntu Virtual Machine.</p><p>The application was exposed through the VM’s public IP address.</p><p>I also configured the Azure networking environment to allow the required application traffic.</p><p>An important security consideration was ensuring that MySQL was not exposed through public ports.</p><p>The database remained accessible through the internal container communication environment rather than being directly exposed to external users.</p><p>This helped reinforce the importance of limiting external access to only the services that need it.</p><h3>8. Testing and Validating the Application</h3><p>A successful container deployment requires more than confirming that Docker containers are running.</p><p>The application must also be tested to ensure that its different components work together correctly.</p><p>I performed several functional tests.</p><h3>User Registration</h3><p>I tested user registration to verify that users could create accounts through the application.</p><h3>User Login</h3><p>I tested the login functionality to confirm that the authentication workflow was operating correctly.</p><h3>Book Review Submission</h3><p>I tested the submission of book reviews to verify that the frontend and backend communicated successfully.</p><h3>Database Persistence</h3><p>I also verified that application data remained available after removing and recreating containers.</p><p>This was particularly important because it confirmed that the MySQL named volume was preserving database information.</p><h3>Network Security</h3><p>I verified that the application could be accessed through the Azure VM’s public endpoint while MySQL remained off public ports.</p><p>Together, these tests provided evidence that the containerized application was functioning as intended.</p><h3>9. Troubleshooting and Challenges</h3><p>One of the most valuable aspects of this assignment was gaining experience troubleshooting issues that can occur in multi-container deployments.</p><h3>Database Connectivity</h3><p>The backend and database containers needed to communicate through the correct Docker networking configuration.</p><p>Incorrect hostnames, environment variables, or service configuration can prevent database connections.</p><h3>Service Startup Dependencies</h3><p>The backend application depended on the database being ready.</p><p>This highlighted the importance of service dependencies and database health checks.</p><h3>CORS Configuration</h3><p>Frontend-to-backend communication required appropriate CORS configuration.</p><p>Incorrect settings can cause browser requests to fail even when the backend API itself is operational.</p><h3>Azure Network Security</h3><p>The application needed to be externally accessible without exposing the database unnecessarily.</p><p>This required attention to the Azure VM’s network security configuration.</p><p>Working through these challenges helped me better understand how application configuration, Docker networking, and cloud security interact.</p><h3>10. Technology Stack</h3><p>The project brought together several important technologies.</p><p>TechnologyPurposeMicrosoft AzureCloud hostingUbuntu LinuxServer operating systemDockerApplication containerizationDocker ComposeMulti-container orchestrationMySQLDatabase managementDocker Named VolumesPersistent database storageCORSFrontend/backend communicationYAMLDocker Compose configurationCloud NetworkingApplication access and security</p><p>More importantly, I learned how these technologies work together to deliver a complete application deployment.</p><h3>11. Key Lessons Learned</h3><p>This project reinforced several important containerization and DevOps principles.</p><h3>1. Containerization Simplifies Deployment</h3><p>Packaging applications into containers makes it easier to deploy and manage individual application components.</p><h3>2. Docker Compose Simplifies Multi-Service Applications</h3><p>A centralized Compose configuration provides a structured way to manage frontend, backend, and database services.</p><h3>3. Health Checks Improve Service Reliability</h3><p>A container being started does not necessarily mean the service inside it is ready.</p><p>Health checks help verify service readiness and improve startup coordination.</p><h3>4. Persistent Storage Is Essential</h3><p>Database data must exist independently of individual container lifecycles.</p><p>Docker named volumes provide a practical way to achieve this.</p><h3>5. Environment Variables Improve Configuration Management</h3><p>Environment variables allow application services to receive the configuration they need without embedding every setting directly in application code.</p><p>Sensitive values still require appropriate secrets management.</p><h3>6. Network Security Must Be Considered</h3><p>Only the necessary application services should be exposed externally.</p><p>Database services should remain protected from unnecessary public access.</p><h3>7. Testing Must Go Beyond Container Status</h3><p>A deployment is not complete simply because containers are running.</p><p>Real application functionality and data persistence must also be verified.</p><h3>12. What’s Next in My DevOps Journey?</h3><p>Completing this assignment represents another important milestone in my Cloud and DevOps learning journey.</p><p>I am continuing to build practical experience in:</p><ul><li>Docker and advanced containerization.</li><li>Docker Compose and multi-container architectures.</li><li>Kubernetes orchestration.</li><li>Terraform and Infrastructure as Code.</li><li>CI/CD pipeline automation.</li><li>Azure cloud architecture.</li><li>Container security.</li><li>Monitoring and observability.</li><li>Automated deployment and testing.</li></ul><p>I am particularly interested in progressing from Docker Compose deployments to orchestrating containerized applications using Kubernetes.</p><p>This will provide an opportunity to explore container orchestration, service discovery, scaling, and automated recovery in greater depth.</p><h3>Conclusion</h3><p>Deploying the Book Review Application on Microsoft Azure using Docker Compose was a valuable hands-on learning experience.</p><p>From containerizing the frontend, backend, and MySQL database to configuring health checks, environment variables, CORS, and persistent volumes, this assignment strengthened my understanding of modern containerized application deployment.</p><p>The most important takeaway was successfully testing database persistence by removing and recreating containers while retaining the underlying MySQL data.</p><p>It reinforced a fundamental principle of container engineering:</p><p><strong>A container should be replaceable without putting persistent application data at risk.</strong></p><p>I’m grateful for the opportunity to continue learning through the <strong>DevOps Micro Internship (DMI) with Agentic AI</strong>.</p><p>Every assignment provides another opportunity to build, experiment, troubleshoot, and improve.</p><p><strong>Containerize applications. Automate deployments. Protect persistent data. Keep learning.</strong></p><h3>Project Resources</h3><p><strong>My Graded Internship Progress:</strong> <a href="https://lnkd.in/ewxGF2Wf">https://lnkd.in/ewxGF2Wf</a></p><p><strong>DevOps Micro Internship:</strong> <a href="https://lnkd.in/eqdVHQRw">https://lnkd.in/eqdVHQRw</a></p><h3>Medium Tags</h3><p>Docker, Docker Compose, Microsoft Azure, DevOps, Containerization</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=126d4aed60f9" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>