Prácticas recomendadas para una federación segura

Welcome! In this lesson, we'll explore industry best practices for building secure and resilient Micro Frontend (MFE) systems.

While MFEs offer great flexibility, they also introduce new security considerations. Applying these practices helps protect your applications and users.

The Principle of Least Privilege (PoLP) dictates that each MFE, service, or user should only have the minimum permissions necessary to perform its function.

• Limit API Access: Ensure MFEs only call APIs they absolutely need.
• Scoped Permissions: Grant specific permissions instead of broad ones.
• User Roles: Tie MFE access to granular user roles.

This minimizes the damage if one MFE is compromised.

Content Security Policy (CSP) is a powerful security standard that helps prevent Cross-Site Scripting (XSS) and data injection attacks.

For federated applications, define strict CSPs:

• Source Whitelisting: Specify trusted sources for scripts, styles, images, etc.
• Inline Code: Avoid inline scripts and styles.
• Report-Only Mode: Start with Content-Security-Policy-Report-Only to monitor violations before enforcing.

This ensures only approved content loads.

Cross-Origin Resource Sharing (CORS) is a browser security feature that restricts web pages from making requests to a different domain than the one that served the web page.

In MFEs, you often need to share resources across different origins. Configure CORS carefully:

• Specific Origins: Allow only known and trusted origins to access your MFE resources.
• HTTP Methods: Restrict allowed HTTP methods (e.g., GET, POST).
• Credentials: Be cautious with Access-Control-Allow-Credentials.

All data entering your Micro Frontends, whether from user input, API responses, or other MFEs, must be rigorously validated.

• Server-Side Validation: Always validate on the server, as client-side validation can be bypassed.
• Sanitize Data: Cleanse data to remove malicious characters or scripts.
• Schema Validation: Use defined schemas for expected data structures.

This prevents injection attacks like SQL injection and XSS.

Micro Frontends often rely on many third-party libraries and shared modules. Vulnerabilities in these dependencies can compromise your entire application.

• Regular Updates: Keep all dependencies, including remote modules, updated to the latest secure versions.
• Vulnerability Scanning: Use tools (e.g., Dependabot, Snyk) to scan for known vulnerabilities.
• Minimize Dependencies: Only include what's necessary to reduce the attack surface.

Sensitive information like API keys, database credentials, or third-party service tokens should never be hardcoded or committed to version control.

• Environment Variables: Use environment variables for configuration.
• Secret Management: Employ dedicated secret management tools (e.g., AWS Secrets Manager, HashiCorp Vault) for production.
• No Client-Side Secrets: Never expose sensitive secrets to the client-side MFE.

To limit the impact of a compromised MFE, implement runtime isolation. This means containing each MFE so it cannot affect others directly.

• Iframes: Historically used for strong isolation, though they have communication overhead.
• Web Workers: Can run scripts in a separate global context, limiting DOM access.
• Containerization: Deploying MFEs in separate containers (e.g., Docker) provides OS-level isolation.

This prevents "blast radius" issues.

Integrate security checks throughout your development lifecycle, especially in your Continuous Integration/Continuous Deployment (CI/CD) pipelines.

• Static Application Security Testing (SAST): Analyze code for vulnerabilities before deployment.
• Dynamic Application Security Testing (DAST): Test running applications for vulnerabilities.
• Dependency Scanners: Automatically check for vulnerable libraries.

Proactive scanning catches issues early.

Great job! We covered crucial best practices for building secure Micro Frontend systems.

Remember to apply the Principle of Least Privilege, enforce CSP and CORS, validate inputs, manage dependencies, handle secrets safely, isolate MFEs at runtime, and automate security checks.

By following these guidelines, you can build resilient and trustworthy federated applications.