Multicloud Resume Challenge

A comprehensive multicloud serverless resume application built in response to the Meta Resume Challenge, demonstrating professional cloud development skills across AWS, Azure, and Google Cloud Platform.

🌟 Project Overview

This project showcases a complete three-tier serverless application deployed across multiple cloud providers with complete isolation, demonstrating expertise in:

• Multicloud Architecture: Single codebase deployed to AWS, Azure, and GCP
• Serverless Computing: Cloud Functions, Lambda, and Cloud Run
• Infrastructure as Code: Terraform for all cloud resources
• CI/CD: GitHub Actions for automated deployments
• Modern Web Development: Angular with responsive design
• Enterprise Java: Spring Boot with comprehensive testing

🏗️ Architecture

High-Level Architecture

Frontend (Angular) ──► API Gateway ──► Serverless Functions ──► Cloud Databases
     │                     │                    │                      │
   Static Web          Load Balancer       Business Logic        Data Storage
  (CDN + Storage)                         (Spring Boot)         (NoSQL DBs)

Cloud Platform Distribution

Component	AWS	Azure	GCP
Frontend	CloudFront + S3	Static Web Apps	Cloud Storage + CDN
API	API Gateway + Lambda	Function App	Cloud Run
Database	DynamoDB	Cosmos DB	Firestore
Storage	S3 Buckets	Blob Storage	Cloud Storage
CDN	CloudFront	Front Door	Cloud CDN

🛠️ Technology Stack

Backend

• Java 11 with Spring Boot 2.5.4
• Maven for dependency management
• Spring Cloud Function for serverless compatibility
• Lombok for code generation
• Swagger/OpenAPI for API documentation
• JUnit 5 + Mockito for comprehensive testing

Frontend

• Angular 11 with TypeScript
• NgRx for state management
• Angular Material for UI components
• Bootstrap for responsive design
• FontAwesome for icons
• SCSS for styling

Infrastructure

• Terraform for Infrastructure as Code
• GitHub Actions for CI/CD
• Docker for containerization
• AWS CodeArtifact for artifact management

📁 Project Structure

multicloud-resume/
├── app/                   # Backend applications
│   ├── core/              # Shared business logic and models
│   ├── aws/               # AWS Lambda implementation
│   ├── azure/             # Azure Functions implementation
│   └── gcp/               # Google Cloud Run implementation
├── web/                   # Angular frontend application
├── iac/                   # Infrastructure as Code
│   ├── terraform/         # Terraform configurations
│   │   ├── aws/           # AWS resources
│   │   ├── azure/         # Azure resources
│   │   └── gcp/           # GCP resources
│   ├── data/              # Resume data (JSON/Excel)
│   ├── diagrams/          # Architecture diagrams
│   └── scripts/           # Deployment scripts
└── README.md

🚀 Getting Started

Prerequisites

• Java 11+
• Node.js 14+
• Maven 3.6+
• Angular CLI
• Terraform 1.0+
• Docker
• Cloud CLI tools (AWS CLI, Azure CLI, gcloud)

Local Development

1. Clone the repository

   git clone https://github.com/wheeleruniverse/multicloud-resume.git
   cd multicloud-resume

2. Build the core module

   cd app/core
   mvn clean install

3. Run cloud-specific applications

   # AWS (requires SAM CLI)
   cd app/aws
   mvn clean package
   sam local start-api
   
   # Azure (requires Azure Functions Core Tools)
   cd app/azure
   mvn clean package
   func start
   
   # GCP (standard Spring Boot)
   cd app/gcp
   mvn spring-boot:run

4. Start the frontend

   cd web
   npm install
   ng serve

Deployment

Each cloud platform has dedicated Terraform configurations:

# AWS
cd iac/terraform/aws
terraform init
terraform plan
terraform apply

# Azure  
cd iac/terraform/azure
terraform init
terraform plan
terraform apply

# GCP
cd iac/terraform/gcp
terraform init
terraform plan
terraform apply

🔧 Configuration

Environment-Specific Settings

The application supports multiple deployment environments through configuration files:

• web/src/environments/environment.aws.ts - AWS configuration
• web/src/environments/environment.azure.ts - Azure configuration
• web/src/environments/environment.gcp.ts - GCP configuration

Cloud Provider Endpoints

Provider	Frontend URL	API URL
AWS	wheelercloudguru.com	api.aws.wheelercloudguru.com
Azure	wheelercloudguru.azurewebsites.net	wheelercloudguru.azurewebsites.net/api
GCP	gcp.wheelercloudguru.com	api.gcp.wheelercloudguru.com

Note: these URLs are not active or registered anymore

📊 Features

Core Resume Sections

• About: Personal introduction and photos
• Experience: Professional work history with detailed descriptions
• Education: Academic background and achievements
• Skills: Technical and professional competencies with proficiency levels
• Certifications: Industry certifications with vendor information
• Projects: Portfolio of significant projects with architecture diagrams
• Visitor Counter: Real-time visitor tracking across all platforms

Technical Features

• Responsive Design: Optimized for desktop, tablet, and mobile
• Real-time Data: Dynamic content loading from cloud databases
• Cross-Platform: Consistent experience across all cloud providers
• SEO Optimized: Proper meta tags and structured data
• Performance: CDN distribution and caching strategies
• Security: HTTPS enforcement and secure API endpoints

🧪 Testing

Backend Testing

cd app/core
mvn test                    # Unit tests
mvn integration-test        # Integration tests

Frontend Testing

cd web
npm test                    # Unit tests
npm run e2e                 # End-to-end tests
npm run lint                # Code linting

📈 CI/CD Pipeline

The project uses GitHub Actions for automated deployments with separate workflows:

• app-core.yml: Builds and tests the shared core module
• app-aws.yml: Deploys AWS Lambda functions
• app-azure.yml: Deploys Azure Functions
• app-gcp.yml: Deploys GCP Cloud Run services
• web.yml: Builds and deploys the frontend to all platforms

Deployment Strategy

1. Code Push: Triggers automated builds
2. Testing: Runs comprehensive test suites
3. Build: Creates deployment artifacts
4. Deploy: Pushes to respective cloud platforms
5. Validate: Performs health checks

🏆 Challenge Compliance

This project fulfills all requirements of the Meta Resume Challenge:

✅ Core Requirements

• Three-tier architecture: Frontend, Backend, Database
• Multiple cloud providers: AWS, Azure, GCP with complete isolation
• Serverless architecture: Functions, Lambda, Cloud Run
• Infrastructure as Code: Complete Terraform configurations
• CI/CD Pipeline: GitHub Actions for all components
• Version Control: Git with proper branching strategy
• Domain Registration: Custom domains for each platform

✅ Technical Implementation

• Database Storage: Resume data stored in cloud databases (not hardcoded)
• API Development: RESTful APIs with proper documentation
• Frontend Framework: Modern Angular application
• Responsive Design: Mobile-first approach
• Security: HTTPS, CORS, secure endpoints
• Monitoring: Application insights and logging

✅ Advanced Features

• Visitor Counter: Real-time tracking across platforms
• Performance Optimization: CDN, caching, compression
• Code Quality: Comprehensive testing, linting, code coverage
• Documentation: Detailed README, API documentation
• Architectural Diagrams: Visual system representation

📚 Additional Resources

Original Challenge References

• AWS Cloud Resume Challenge
• Azure Cloud Resume Challenge
• GCP Cloud Resume Challenge
• Meta Resume Challenge Blog Post

Architecture Diagrams

• Meta Resume Challenge Architecture
• Serverless Resume Architecture

📄 License

This project is open source and available under the MIT License.

📧 Contact

For questions or collaboration opportunities, please reach out through LinkedIn.

---

This project demonstrates enterprise-level cloud development skills and serves as a comprehensive example of multicloud architecture implementation.