Hur man skyddar två mikro-frontender med olika åtkomstbehov på en AWS-backend

Balansera säkerhet och tillgänglighet i AWS Micro-Frontend Architecture

Att designa säkra och skalbara molnarkitekturer innebär ofta att man balanserar tillgänglighet och begränsad åtkomst. I din AWS-installation har du två mikrogränssnitt med unika åtkomstkrav. FE-A måste begränsas till en specifik statisk IP, medan FE-B bör vara tillgänglig offentligt. Att tillgodose dessa behov samtidigt kan vara en utmaning. 😅

Utmaningen uppstår när man konfigurerar säkerhetsgrupperna i EC2. Om du tillåter åtkomst till 0.0.0.0 blir båda gränssnitten allmänt tillgängliga, vilket äventyrar FE-A:s säkerhet. Å andra sidan förnekar begränsning av åtkomst till en enda statisk IP-adress offentlig tillgänglighet för FE-B. Detta skapar en komplex balansgång mellan öppenhet och trygghet.

Även om en lambdafunktion för att dynamiskt uppdatera IP-intervall kan verka lönsam, introducerar den ytterligare overhead och är inte en optimal långsiktig lösning. Det kan till exempel öka kostnaderna och komplexiteten över tid. Dessutom kan det vara besvärligt och felbenäget att hantera frekventa uppdateringar av säkerhetsgrupper.

Att hitta en kostnadseffektiv lösning som uppfyller dessa krav är avgörande. Målet är att skydda FE-A samtidigt som man säkerställer att FE-B förblir tillgänglig globalt utan att införa onödig komplexitet. Låt oss utforska hur man uppnår detta med hjälp av AWS bästa praxis. 🚀

Strategier för att säkra mikro-gränssnitt med AWS

Det första skriptet utnyttjar funktionerna i AWS Web Application Firewall (WAF) för att upprätthålla distinkta åtkomstpolicyer för två mikrogränssnitt. Genom att skapa en WebACL tillämpas specifika IP-regler på FE-A för att endast tillåta trafik från en angiven statisk IP, vilket säkerställer att det förblir ett slutet system. För FE-B tillåter en separat regel allmänhetens tillträde. Detta tillvägagångssätt centraliserar åtkomstkontrollen till applikationslagret, vilket gör den idealisk för att hantera trafik effektivt utan att modifiera de underliggande EC2-säkerhetsgrupperna. Till exempel kan du begränsa FE-A till ett kontorsnätverk samtidigt som du tillåter FE-B att förbli globalt tillgänglig, vilket tillgodoser både företagssäkerhet och användarvänlighet. 🌍

WebACL associeras sedan med en Application Load Balancer (ALB), som säkerställer att all trafik som passerar genom ALB filtreras enligt dessa regler. Kommandot waf_client.create_web_acl är avgörande för att definiera reglerna, medan waf_client.associate_web_acl länkar WebACL till resursen. Denna inställning är mycket skalbar och tillåter framtida justeringar, som att lägga till nya IP-adresser eller ändra åtkomstpolicyer, med minimal ansträngning. Övervakningsfunktioner som CloudWatch-statistik kan också spåra reglernas effektivitet, vilket ger värdefulla insikter om trafikmönster.

Däremot uppdaterar den Lambda-baserade lösningen dynamiskt EC2 säkerhetsgruppsregler. Det här skriptet hämtar IP-intervall som är specifika för din AWS-region och konfigurerar dem som inträdesregler i säkerhetsgruppen. Funktionen ec2.authorize_security_group_ingress lägger till eller uppdaterar de tillåtna IP-intervallen, vilket gör det möjligt för FE-B att vara allmänt tillgänglig samtidigt som strikt kontroll för FE-A bibehålls. Det här tillvägagångssättet är särskilt användbart i miljöer med ofta föränderliga IP-krav, som molnbaserade utvecklingsinställningar eller byte av företagskontor. Till exempel, om ett nytt filialkontor etableras kan du automatiskt lägga till dess IP till vitlistan utan manuellt ingripande. 🏢

Lambdafunktionen, i kombination med ett schemalagt CloudWatch-evenemang, automatiserar dessa uppdateringar dagligen, vilket minskar administrativa omkostnader. Även om detta tillvägagångssätt ökar komplexiteten, ger det finkornig kontroll över trafiken. Enhetstest som ingår i skriptet validerar funktionaliteten och säkerställer att säkerhetsreglerna tillämpas korrekt utan att införa fel. Oavsett om du väljer WAF eller Lambda, prioriterar båda metoderna kostnadseffektivitet och flexibilitet, vilket balanserar behovet av offentlig och begränsad tillgång. I slutändan visar dessa lösningar mångsidigheten hos AWS när det gäller att möta olika krav och samtidigt bibehålla robust säkerhet. 🔒

# Step 1: Define IP restrictions in AWS WAF
# Create a WebACL to allow only specific IP ranges for FE-A and public access for FE-B.
import boto3
waf_client = boto3.client('wafv2')
response = waf_client.create_web_acl(    Name='MicroFrontendAccessControl',    Scope='REGIONAL',    DefaultAction={'Allow': {}},    Rules=[        {            'Name': 'AllowSpecificIPForFEA',            'Priority': 1,            'Action': {'Allow': {}},            'Statement': {                'IPSetReferenceStatement': {                    'ARN': 'arn:aws:wafv2:region:account-id:ipset/ipset-id'                }            },            'VisibilityConfig': {                'SampledRequestsEnabled': True,                'CloudWatchMetricsEnabled': True,                'MetricName': 'AllowSpecificIPForFEA'            }        },        {            'Name': 'AllowPublicAccessForFEB',            'Priority': 2,            'Action': {'Allow': {}},            'Statement': {'IPSetReferenceStatement': {'ARN': 'arn:aws:wafv2:region:account-id:ipset/ipset-id-for-public'}},            'VisibilityConfig': {                'SampledRequestsEnabled': True,                'CloudWatchMetricsEnabled': True,                'MetricName': 'AllowPublicAccessForFEB'            }        }    ],    VisibilityConfig={        'SampledRequestsEnabled': True,        'CloudWatchMetricsEnabled': True,        'MetricName': 'MicroFrontendAccessControl'    })
print("WebACL created:", response)
# Step 2: Associate the WebACL with your Application Load Balancer
response = waf_client.associate_web_acl(    WebACLArn='arn:aws:wafv2:region:account-id:webacl/webacl-id',    ResourceArn='arn:aws:elasticloadbalancing:region:account-id:loadbalancer/app/load-balancer-name')
print("WebACL associated with Load Balancer:", response)

# Import required modules
import boto3
import requests
# Step 1: Fetch public IP ranges for your region
def get_ip_ranges(region):
    response = requests.get("https://ip-ranges.amazonaws.com/ip-ranges.json")
    ip_ranges = response.json()["prefixes"]
    return [prefix["ip_prefix"] for prefix in ip_ranges if prefix["region"] == region]
# Step 2: Update the security group
def update_security_group(security_group_id, ip_ranges):
    ec2 = boto3.client('ec2')
    permissions = [{"IpProtocol": "tcp", "FromPort": 80, "ToPort": 80, "IpRanges": [{"CidrIp": ip} for ip in ip_ranges]}]
    ec2.authorize_security_group_ingress(GroupId=security_group_id, IpPermissions=permissions)
# Step 3: Lambda handler
def lambda_handler(event, context):
    region = "us-west-2"
    security_group_id = "sg-0123456789abcdef0"
    ip_ranges = get_ip_ranges(region)
    update_security_group(security_group_id, ip_ranges)
    return {"statusCode": 200, "body": "Security group updated successfully"}

import unittest
from unittest.mock import patch
class TestSecurityConfigurations(unittest.TestCase):
    @patch("boto3.client")
    def test_update_security_group(self, mock_boto3):
        mock_ec2 = mock_boto3.return_value
        ip_ranges = ["192.168.0.0/24", "203.0.113.0/24"]
        update_security_group("sg-0123456789abcdef0", ip_ranges)
        mock_ec2.authorize_security_group_ingress.assert_called()
    def test_get_ip_ranges(self):
        region = "us-west-2"
        ip_ranges = get_ip_ranges(region)
        self.assertIsInstance(ip_ranges, list)
if __name__ == "__main__":
    unittest.main()

Optimera säkerhet och tillgänglighet för mikrogränssnittsapplikationer i AWS

Ett annat effektivt sätt att ta itu med utmaningen att balansera begränsad och offentlig åtkomst i din mikrofrontend-arkitektur är att utnyttja AWS Amplifys integrerade funktioner. Amplify förenklar hosting och distribution samtidigt som det tillhandahåller verktyg för att konfigurera backend-API:er på ett säkert sätt. För FE-A kan du implementera nätverksåtkomstkontroll genom att begränsa dess backend API-slutpunkter till specifika IP:er med hjälp av en AWS API Gateway. Denna inställning säkerställer att endast fördefinierade statiska IP-adresser kan interagera med backend, medan FE-B:s slutpunkter kan förbli obegränsade för offentlig åtkomst. Detta ökar inte bara säkerheten utan integreras också sömlöst med Amplifys CI/CD-arbetsflöden. 🌐

Ett annat övervägande är att använda Amazon CloudFront med anpassade ursprungsåtkomstpolicyer. CloudFront kan dirigera trafik till lämplig backend baserat på URL-sökvägen, och fungerar som en gatekeeper för dina mikrogränssnitt. FE-A-trafik kan filtreras genom CloudFront med hjälp av en policy för ursprungsbegäran som söker efter IP-begränsningar eller specifika rubriker. Till exempel kan ett företag som distribuerar ett internt verktyg via FE-A lägga till ett IP-intervallfilter samtidigt som FE-B görs globalt tillgängligt för slutanvändare. Detta tillvägagångssätt optimerar både skalbarhet och prestanda, särskilt för applikationer som kräver global distribution. 🚀

Slutligen, implementering av AWS Cognito för användarautentisering lägger till ett extra lager av säkerhet. FE-A kan låsas bakom ett inloggningssystem som kräver användarautentisering med specifika roller eller grupper, medan FE-B kan använda en lättare autentiseringsmekanism eller ingen alls för offentlig åtkomst. Genom att kombinera autentisering och nätverksåtkomstbegränsningar uppnår du en robust säkerhetsmodell som är skräddarsydd för varje mikrogränssnitts behov. Denna strategi är särskilt effektiv för nystartade företag och små och medelstora företag som letar efter prisvärda, skalbara och säkra molnlösningar. 🔐