Andras Medvediev💡’s Post

Spring Boot vs. Spring Boot 3+: A Modern Java Showdown! 🚀 For Java developers, Spring Boot has been a game-changer, simplifying application development like never before. But with the advent of Spring Boot 3+ (and its underlying Spring Framework 6+), we're seeing some significant shifts, especially with the embrace of GraalVM Native Images and Jakarta EE 9/10. So, how do the two stack up? Let's dive into some key similarities and differences 🔍: ✅ Similarities (What Stays the Same): 🎓 Ease of Learning & Development: Both maintain Spring Boot's signature convention-over-configuration approach, making them easy to pick up and efficient for development. 🧩 Robust Ecosystem: The vast Spring ecosystem (Spring Data, Security, Cloud, etc.) is available and continues to evolve with both versions. 📈 Scalability & Performance (JVM): On the JVM, both offer excellent scalability and performance, leveraging Spring's reactive capabilities. ☁️ Cloud Support: Both are incredibly cloud-native friendly, offering first-class support for deployment to various cloud platforms. 💡 Key Differences & Spring Boot 3+ Advantages: 🔄 Jakarta EE Baseline: Spring Boot 3+ mandates Jakarta EE 9/10 (replacing Java EE). This is a crucial modernization step, requiring package updates from javax to jakarta. ⭐ GraalVM Native Images: This is the biggest differentiator! Spring Boot 3+ has first-class support for generating native executables with GraalVM. ⚡ Performance (Native): Blazing fast startup times and significantly reduced memory footprint compared to traditional JVM applications. 🚀 Scalability (Native): Faster cold starts are a game-changer for serverless functions and microservices, leading to more efficient resource utilization. ⚙️ AOT Processing (Ahead-Of-Time): Essential for native images, AOT processing analyzes your application at build time, optimizing it for smaller, faster executables. ☕ Minimum Java Version: Spring Boot 3+ requires Java 17+, pushing developers towards more modern Java features. 🤔 Which one should you choose? If you're starting a new project or looking to significantly modernize an existing one, especially if you're keen on the performance benefits of native images and are comfortable with Java 17+, Spring Boot 3+ is the way to go. For existing projects on older Java versions, upgrading will require a bit more effort due to the Jakarta EE transition, but the long-term benefits are substantial. If you’re attached to a legacy app on Java 8/11, many libraries haven’t yet upgraded, or your team isn’t ready for a big jump — then staying on Spring Boot for now (while planning for Boot 3+) can be a valid strategy. What are your thoughts on the transition to Spring Boot 3+? Share your experiences below! 👇 #SpringBoot #SpringBoot3 #Java #GraalVM #NativeImages #SoftwareDevelopment #JakartaEE #CloudNative

🚀 Spring Boot 4 & Spring Framework 7 The upcoming Spring Boot 4 release (built on Spring Framework 7) marks a major milestone for modern Java development. Here are the highlights—perfect to share with your LinkedIn network. 🧩 Key Platform Updates in Spring Boot 4 Java & JVM support: Minimum JDK 17, recommended JDK 25 (Sep 2025). Full alignment with GraalVM 24 for native image builds. Jakarta EE 11 alignment: Upgraded specs such as Servlet 6.1, JPA 3.2 + Hibernate 7.0, Bean Validation 3.1. Kotlin 2.2 support: Smoother coroutine support, better Gradle integration. Cloud-native and containerization: Faster image layering via Buildpacks, improved Docker-native builds, integration with Micrometer 2.x + OpenTelemetry. Productivity & developer experience: CLI improvements, new Actuator endpoints, streamlined property/profile management. Security enhancements: Built on Spring Security 7, stronger OAuth 2.2 / OIDC support, improved crypto defaults. Future-proofing with Spring AI & native APIs: Initial hooks for Spring AI, better support for GraalVM native image hints. 🔧 Top Features in Spring Framework 7 Elegant API Versioning: Versioning support via @RequestMapping(version="x") makes managing multiple API versions much simpler. Null safety via JSpecify: Method parameters, return types, and fields can benefit from stronger null-contracts. Programmatic bean registration (BeanRegistrar): Allows dynamic bean registration beyond @Bean methods—a win for modular, runtime-flexible apps. Improved SpEL support for Optional: Safer expressions with null-safe operations and Elvis operator in configuration. Resilience annotations: @Retryable, @ConcurrencyLimit, @EnableResilientMethods allow building more robust services with less boilerplate. HTTP client enhancements: @ImportHttpServices for cleaner client grouping/configuration; streaming support (InputStream/OutputStream) for handling large payloads efficiently. New messaging & JDBC clients: JmsClient, enhanced JdbcClient provide more fluent APIs for messaging & DB access. Centralised configuration for HTTP message converters: Simplifies serialization/deserialization setup globally. New RestTestClient for API testing: Offers a fluent testing API for REST services, whether live or mocked. Enhanced path matching: Upgraded PathPattern support replaces legacy routing options for more flexible URIs. API removals & deprecations: A number of legacy modules/features removed—e.g., javax.annotation, XML config in Spring MVC, older Jackson/JUnit versions. Migration recommended. #Java #SpringBoot #Spring #SpringFramework #JavaDeveloper #SpringBoot4 #SpringFramework7

🚀 Big news for the Java ecosystem: Spring Framework 7.0 is officially here! (And yes—it’s a meaningful leap for modern Java development.) Here’s why the latest release deserves attention—and what tech professionals can take away from it: 🔍 Key Technical Highlights Spring Framework 7.0 raises the bar by supporting Java 25 as its target (while still maintaining a Java 17 baseline). It aligns with the latest enterprise Java standards: Jakarta EE 11 APIs such as Servlet 6.1, JPA 3.2 and Bean Validation 3.1. Major upgrades include null-safety support using JSpecify annotations, ensuring stronger API contracts and safer code. The dependency ecosystem has been modernized: like full support for Jackson 3.0, Kotlin 2.2, JUnit 6.0—all part of the upgrade path. 🎯 Why This Release Matters For developers and teams: it signals that the Spring ecosystem continues evolving, not just patching. This means staying relevant means embracing these modern baselines. For enterprise & microservice architectures: support for Jakarta EE 11 and null-safety means frameworks can now more confidently enable safer, faster, leaner applications. For developer tooling and platform engineering: this release encourages forward-thinking tech stacks (Java 25, modern frameworks, stronger typing) and sets the stage for ecosystem-wide upgrades. 🛠 What You Can Implement Right Now Evaluate your code-base baseline: if you’re using older Java (e.g., Java 11/17) and earlier Spring versions, begin planning your upgrade path. Leverage the null-safety gains: adding or enforcing JSpecify annotations in your APIs can help prevent runtime null-errors and make your code more self-documenting. Update dependency strategy: moving to Jackson 3.0 or targeting Kotlin 2.x? Use this as a trigger to revisit library versions, breakpoints and deprecation plans. Align with enterprise standards: if you manage microservices or enterprise applications, take advantage of Servlet 6.1, JPA 3.2 support to modernize your stacks and avoid getting locked into legacy versions. #Java #SpringFramework #Spring7 #EnterpriseJava #DeveloperProductivity #TechLeadership #SoftwareEngineering https://lnkd.in/gwzrVKzN

🚀 Java + React: a perfect match between reliability and innovation Integrating Java (backend) and React (frontend) is one of the most powerful combinations in modern development — blending security, performance, and scalability from Java with agility and user experience from React. 💡 Best practices for integration Well-defined REST APIs Use Spring Boot to expose clean, versioned endpoints (/api/v1/...). Example: @GetMapping("/users") public List<User> listUsers() { return userService.findAll(); } In React: useEffect(() => { fetch('/api/v1/users') .then(res => res.json()) .then(setUsers); }, []); Standardize contracts Use DTOs and ResponseEntities to ensure consistency between front and back. Authentication and security Combine Spring Security + JWT for secure endpoints and session control in React. CORS configuration Avoid common errors by allowing only trusted domains on the backend: @CrossOrigin(origins = "https://lnkd.in/dyztjbX9") Optimized build and deployment Generate the React build and serve it directly through Spring Boot or Docker Compose, simplifying deployments. 🤖 Innovation and AI in the ecosystem The future of the Java + React stack lies in intelligent automation: Spring AI and LangChain4j integrating generative models into Java systems; React + AI enabling chatbots and contextual assistants; No-code and low-code accelerating productivity and democratizing development. These technologies allow traditional Java applications to modernize without losing reliability, leveraging AI for testing, code generation, and predictive analytics. ⚙️ Strengths ✅ Scalability and maturity of Java ✅ React’s speed and interactivity ✅ Full cloud support (AWS, GCP, Azure) ✅ Strong community and modern tools ⚠️ Points of attention ⚠️ Avoid coupling between front and back — maintain clear API contracts ⚠️ Strictly control versions and dependencies ⚠️ Manage memory and serialization carefully for large payloads 🔥 Conclusion The Java + React stack remains one of the most reliable and innovative in the industry. When combined with best practices, automation, and AI, it delivers agile, scalable, and future-ready solutions. 👉 And you? Are you already integrating AI or automation into your Java + React stack? Share your experience in the comments! 💬 #Java #React #SpringBoot #AI #Innovation #SoftwareEngineering #LowCode #NoCode #Workupy

#java 🟩 Day 50 – Docker Basics + Containerizing Spring Boot + React App (HinEnglish, Step-by-Step, #Tech50) आज का लक्ष्य: Apne Java + React application ko container mein daalna — taaki kahin bhi deploy ho sake, bina “it works on my machine” ke --- 🔹 Step 1: What is Docker? HinEnglish: Docker ek containerization platform hai jo aapke application ko dependencies ke saath ek isolated unit mein pack karta hai — jise kahin bhi run kiya ja sakta hai. 🧠 Real-world analogy: > Ek tiffin box jisme khana, spoon, aur napkin sab kuch ready hota hai — bas open karo aur enjoy karo. ✅ Benefits: - Consistent environment - Easy deployment - Lightweight and fast - Works on any OS with Docker installed --- 🔹 Step 2: Dockerizing Spring Boot App 1. Create Dockerfile in root folder 2. Use OpenJDK base image 3. Copy JAR file and expose port 4. Build and run container 🧱 Sample Dockerfile: `dockerfile FROM openjdk:17 COPY target/app.jar app.jar ENTRYPOINT ["java", "-jar", "/app.jar"] EXPOSE 8080 ` --- 🔹 Step 3: Dockerizing React App 1. Create Dockerfile in React root 2. Use Node image for build, Nginx for serve 3. Copy build files to Nginx directory 🧱 Sample Dockerfile: `dockerfile FROM node:18 AS build WORKDIR /app COPY . . RUN npm install && npm run build FROM nginx:alpine COPY --from=build /app/build /usr/share/nginx/html EXPOSE 80 ` --- 🔹 Step 4: Docker Compose (Optional) - Use docker-compose.yml to run backend + frontend + DB together - Define services, ports, volumes, and networks 🧱 Sample: `yaml version: '3' services: backend: build: ./backend ports: - "8080:8080" frontend: build: ./frontend ports: - "3000:80" ` --- 🔹 Step 5: Java Full Stack Integration ✅ Spring Boot: Dockerize backend with JAR ✅ React: Dockerize frontend with Nginx ✅ MySQL/Postgres: Use official DB images ✅ Postman: Test APIs inside container ✅ GitHub: Push Dockerfiles + Compose + README ✅ CI/CD: Auto-build and deploy containers --- 🔹 Step 6: DSA + Tools Relevance ✅ DSA: Graph = container dependency mapping ✅ Tools: - Docker CLI + Docker Desktop - VS Code Docker extension - GitHub Actions for Docker builds ✅ Security: Use .dockerignore, avoid root user ✅ Monitoring: Use docker stats, logs, and health checks --- 🔹 Step 7: Interview Questions - Q1: What is the difference between VM and Docker container? - Q2: How do you containerize a Spring Boot app? - Q3: What is the role of Docker Compose? - Q4: How do you manage environment variables in Docker? - Q5: How do you debug a failing container? --- 🔹 Step 8: Practice Tasks - ✅ Create Dockerfile for Spring Boot app - ✅ Create Dockerfile for React app - ✅ Build and run both containers - ✅ Use Docker Compose to run fullstack app - ✅ Document logic in Day50_DockerFullstack/README.md - ✅ Push code, Dockerfiles, and screenshots to GitHub --- #JavaFullStack #Docker #SpringBoot #ReactJS #Containerization #JavaMastery

Understanding jlink — Build Your Own Custom Java Runtime Since Java 9, the JDK introduced a revolutionary tool called jlink, and yet many developers still don’t use it — even though it can drastically reduce runtime size and improve startup performance. So what does jlink do? In short, jlink lets you create a custom Java Runtime Environment (JRE) that includes only the modules your application actually needs — no extras, no overhead. Why use jlink? Smaller runtime size: You don’t need the entire JDK — just the required modules. Faster startup: Fewer modules mean less to load at runtime. Improved security: Removes unused APIs that could increase the attack surface. Perfect for containers: Ideal when building lightweight Docker images. Basic Syntax jlink --module-path $JAVA_HOME/jmods:mods \    --add-modules com.example.app \    --output custom-jre Explanation: --module-path: location of your modules and JDK’s jmods folder --add-modules: which modules to include in the runtime --output: directory where the new runtime will be created Example 1 — Minimal JRE for a CLI App Let’s say your modular app only depends on java.base and java.sql: jlink --module-path $JAVA_HOME/jmods \    --add-modules java.base,java.sql \    --output myruntime This produces a tiny JRE (a few dozen MBs instead of hundreds). Now, you can run your app like this: ./myruntime/bin/java -m com.example.Main Example 2 — Building a Runtime for a Modular Application Assume you have a compiled app in mods/com.example.app: jlink --module-path $JAVA_HOME/jmods:mods \    --add-modules com.example.app \    --launcher runapp=https://lnkd.in/dWs2jFgG \    --output app-runtime This generates a self-contained runtime with a pre-configured launcher (./app-runtime/bin/runapp). Bonus Tip Combine jlink with jpackage to generate native installers or executables for Linux, macOS, or Windows. In short: jlink transforms how we ship Java apps — from bulky runtimes to sleek, optimized distributions. If you’re building microservices, CLI tools, or containerized apps, this tool is your friend. #Java #JDK #jlink #Performance #DevTools #Microservices #JVM #CloudNative #Containers

🚀 Your Ultimate Java Full-Stack Developer Roadmap (2025 Edition) ☕💻 Becoming a Java Full Stack Developer is one of the most rewarding journeys in tech 🌟 You’re not just learning a language — you’re learning to build complete, scalable, and modern web applications from front to back! Let’s dive into the step-by-step roadmap that’ll take you from beginner ➡️ professional 👇 🧱 1️⃣ Core Foundations — The Bedrock of Development Before jumping into frameworks, master the basics. 🎯 Learn: ☕ Java (OOPs, Collections, Exception Handling, Streams, Multithreading) 📘 JDBC (connect Java apps with databases) 📊 MySQL (queries, joins, normalization) 🧠 Data Structures & Algorithms (Logic + Problem Solving) 📌 Goal: Build your first simple Java console app (like a Student Management System). 🎨 2️⃣ Frontend — Make It Look and Feel Amazing Your frontend is the face of your app 👀 Learn to create beautiful, responsive, and dynamic UIs. 🎯 Learn: 🧩 HTML5 — structure your webpage 🎨 CSS3 — style and layout with Flexbox & Grid ⚡ JavaScript (ES6+) — make your app interactive ⚛️ React.js — most in-demand frontend library 📱 Responsive Design — Bootstrap or Tailwind CSS 💡 Practice by building: Personal Portfolio, To-Do App, or Song Player UI ⚙️ 3️⃣ Backend — The Heart of Your Application 🎯 Learn: ☕ Spring Boot — simplifies Java backend development 🧱 REST APIs — connect your backend with the frontend 🔐 Security — implement JWT Authentication & Authorization 🧩 Spring Data JPA — handle database operations easily 📂 Hibernate — ORM framework to simplify queries 💡 Practice by building: Banking App Backend, Employee Management System 🗄️ 4️⃣ Database Mastery 🎯 Learn: 🧾 MySQL / PostgreSQL — for structured data 📦 MongoDB — for NoSQL flexibility 🔍 Write queries, joins, and indexes ⚙️ Connect with Spring Boot using JPA or Hibernate 💡 Practice: Design database schema for real-world projects. 🐳 5️⃣ DevOps & Deployment — Make It Go Live! 🎯 Learn: 🧭 Git & GitHub — version control & collaboration 🐋 Docker — containerize your app 🔁 CI/CD — automate testing & deployment ☁️ Cloud Platforms — AWS / Azure / GCP 📤 Deployment — host your app on Render, Railway, or Heroku 💡 Goal: Deploy your Java + React full-stack project online 🌐 💬 6️⃣ Soft Skills & Developer Habits 🎯 Work On: 🧠 Problem Solving 🧩 Clean Code & Documentation 🤝 Communication & Team Collaboration 🌱 Continuous Learning — stay updated with frameworks & tools 💡 Tip: Contribute to open source or share your learning journey on LinkedIn 👨💻 🌟 7️⃣ Build Real Projects — 💼 Project Ideas: 🏦 Banking Management System (Spring Boot + React) 🎵 Personal Song Player (HTML, CSS, JS) 🧾 Expense Tracker (Spring Boot + MySQL) 🧍♂️ Employee Management System 📝 To-Do App (Full Stack) 📌 Goal: Create at least 3 solid projects for your portfolio. #JavaDeveloper #FullStackDevelopment #SpringBoot #React #WebDevelopment #SoftwareEngineering #CodingJourney #CareerGrowth #LearnToCode #TechCommunity

🚀 Java Spring boot questions 1. Explain the difference between Comparable and Comparator. Which one is more flexible in real projects? 2. How does Garbage Collector decide which objects to clean? What is the difference between Minor GC & Major GC? 3. Why String is immutable in Java? What benefits does it give in multi-threaded environments? 4. How does ClassLoader work in Java? Can we have multiple classloaders in one JVM? 5. Difference between StringBuffer, StringBuilder, and normal String. Which one to use where? 🔹 Collections & Performance 6. How does CopyOnWriteArrayList work internally? When would you prefer it? 7. What is the difference between fail-fast and fail-safe iterators? 8. If you have millions of records to process, would you use Stream API or traditional loops? Why? 9. How does TreeMap maintain ordering? Can we provide custom sorting logic? 10. How do you find duplicates in a list using Java 8 features? 🔹 Spring & Spring Boot 11. What is the difference between @Transactional at class level vs method level? 12. Can you explain how Spring Boot auto-configuration works internally? 13. How do you configure multiple datasources in Spring Boot? 14. What’s the difference between @RequestParam, @PathVariable, and @RequestBody? 15. How do you monitor and optimize Spring Boot applications in production? 🔹 Microservices & System Design 16. How do you implement distributed logging in microservices? 17. What’s the difference between synchronous vs asynchronous communication in microservices? 18. How would you design a service to handle 1000+ requests per second? 19. How do you handle transactions that span across multiple microservices? 20. Can you explain the circuit breaker pattern? When have you used it? 🔹 Database & Real-time Scenarios 21. How do you implement pagination in SQL + Java? 22. If a query is taking 5 seconds, how would you debug & optimize it? 23. What’s the difference between optimistic and pessimistic locking? Which one is better in microservices? 24. How do you implement caching in Spring Boot + DB to reduce load? 25. Real-world scenario: If one service keeps failing in production, how will you identify whether it’s a code issue, infra issue, or DB issue? 👉 Over to you — If you recently gave an interview, which round felt most challenging for you? (Core Java / Spring Boot / Microservices / SQL)?

Evolution of Server-Side Application Development in Java As part of my ongoing Java Full Stack training sessions, I discussed this evolution with my students and thought it’s worth sharing with the wider developer community. 1. Applets (1990s) Purpose: Run Java programs inside browsers for interactive content. Limitations: Required plug-ins, had security and compatibility issues. Transition: Moved toward server-side and database-driven apps → JDBC. 2. JDBC (Java Database Connectivity) Purpose: Standard API to interact with relational databases via SQL. Strengths: Direct control over SQL and transactions. Limitations: Involved repetitive, error-prone code. 3. Servlets Purpose: Handle HTTP requests and responses on the server. Strengths: Faster and reusable compared to CGI. Limitations: Difficult to manage UI and business logic together. Transition: Introduced JSP for simpler UI development. 4. JSP (JavaServer Pages) Purpose: Combine HTML and Java for dynamic content. Strengths: Easier frontend creation than raw Servlets. Limitations: Mixing Java with HTML reduced maintainability. Transition: Need for structured MVC architecture → Struts / JSF. 5. Struts / JSF Era Purpose: Implement MVC pattern for cleaner code separation. Strengths: Improved structure for large-scale applications. Limitations: Heavy configuration and limited flexibility. Transition: Developers demanded lighter, modular frameworks → Spring. 6. J2EE / Java EE Platform Purpose: Enterprise platform supporting EJB, JMS, JPA, and scalability. Strengths: Robust and enterprise-ready. Limitations: Complex and configuration-heavy for smaller projects. Transition: Simplicity and modularity needs led to Spring Framework. 7. Spring Framework Purpose: Lightweight, modular framework simplifying enterprise development. Key Concepts: Dependency Injection (DI), Inversion of Control (IoC). Strengths: Loose coupling, testability, and integration with multiple tools. Limitations: Early XML-based setup was verbose. Transition: Simplify persistence using Hibernate. 8. Hibernate (ORM Framework) Purpose: Simplify database operations via object-relational mapping. Strengths: Removed boilerplate JDBC code, supported caching and transactions. Limitations: Complex mappings in large systems. Transition: Combined with Spring for a powerful enterprise stack → Spring Boot. 9. Spring Boot Purpose: Simplify Spring development with auto-configuration and embedded servers. Strengths: Fast setup, microservice-ready, and production-ready defaults. Limitations: Higher memory usage for small applications. 10. RESTful Web Services Purpose: Enable lightweight, stateless communication using HTTP/JSON. Strengths: Platform-independent and scalable. Transition: Foundation for Microservices Architecture. 11. Microservices Architecture Purpose: Break monoliths into independently deployable services. Strengths: Scalability, flexibility, and fault tolerance. Limitations: Complex orchestration and monitoring.

#java 🟩 Day 58 – Kubernetes Basics + Deploying Java + React Apps on K8s (HinEnglish, Step-by-Step, #Tech58) आज का लक्ष्य: Apne Dockerized apps ko production-grade orchestration dena — Kubernetes ke zariye smart deployment aur scaling ke साथ --- 🔹 Step 1: What is Kubernetes (K8s)? HinEnglish: Kubernetes ek open-source container orchestration platform hai jo multiple containers ko manage, scale aur deploy karta hai — automatically. 🧠 Real-world analogy: > Ek smart traffic controller jo har gaadi (container) ko sahi lane, speed aur destination deta hai — bina rukawat ke. ✅ Features: - Auto-scaling - Self-healing (restart failed pods) - Rolling updates - Load balancing - Secret & config management --- 🔹 Step 2: Core Concepts | Concept | Description | |----------------|-------------| | Pod | Smallest deployable unit (1+ containers) | | Deployment | Manages replica sets and rolling updates | | Service | Exposes pods internally or externally | | ConfigMap | Injects config data into pods | | Secret | Injects sensitive data securely | | Ingress | HTTP routing to services | --- 🔹 Step 3: Deploying Spring Boot App 1. Create Docker image of Spring Boot app 2. Write deployment.yaml and service.yaml 3. Apply using kubectl apply -f 4. Expose via NodePort or Ingress 🧱 Sample: `yaml apiVersion: apps/v1 kind: Deployment metadata: name: springboot-app spec: replicas: 2 selector: matchLabels: app: springboot template: metadata: labels: app: springboot spec: containers: - name: app image: your-dockerhub/springboot-app ports: - containerPort: 8080 ` --- 🔹 Step 4: Deploying React App 1. Build React app → npm run build 2. Serve via Nginx container 3. Create deployment + service YAML 4. Expose via Ingress for domain-based routing --- 🔹 Step 5: Java Full Stack Integration ✅ Spring Boot + React: Both deployed as separate services ✅ Docker: Base for container images ✅ Kubernetes: Manages replicas, scaling, and routing ✅ Postman: Test exposed endpoints ✅ GitHub: Push manifests + Dockerfiles + README ✅ CI/CD: Auto-deploy to K8s cluster (e.g., via GitHub Actions) --- 🔹 Step 6: DSA + Tools Relevance ✅ DSA: Graph = service-to-service communication ✅ Tools: - kubectl, minikube, k9s - Docker Hub - Lens (K8s dashboard) ✅ Security: Use Secrets for DB passwords, tokens ✅ Monitoring: Integrate with Prometheus + Grafana --- 🔹 Step 7: Interview Questions - Q1: What is the difference between Pod and Deployment? - Q2: How does Kubernetes handle scaling? - Q3: What is the role of Ingress? - Q4: How do you manage secrets in K8s? - Q5: What happens when a pod crashes? --- 🔹 Step 8: Practice Tasks - ✅ Setup Minikube locally - ✅ Deploy Spring Boot app with 2 replicas - ✅ Deploy React app with Nginx - ✅ Expose both via Ingress - ✅ Document logic in Day58_KubernetesDeployment/README.md