Sådan beskytter du to mikro-frontender med forskellige adgangsbehov på en AWS-backend

Balancering af sikkerhed og tilgængelighed i AWS Micro-Frontend-arkitektur

Design af sikre og skalerbare cloud-arkitekturer involverer ofte balancering af tilgængelighed og begrænset adgang. I din AWS-opsætning har du to mikro-frontends med unikke adgangskrav. FE-A skal begrænses til en specifik statisk IP, mens FE-B skal være offentligt tilgængelig. At imødekomme disse behov samtidigt kan udgøre en udfordring. 😅

Udfordringen opstår ved konfiguration af sikkerhedsgrupperne i EC2. Hvis du tillader adgang til 0.0.0.0, bliver begge frontends offentligt tilgængelige, hvilket kompromitterer FE-A's sikkerhed. På den anden side nægter begrænsning af adgang til en enkelt statisk IP offentlig tilgængelighed for FE-B. Dette skaber en kompleks balancegang mellem åbenhed og tryghed.

Selvom en Lambda-funktion til dynamisk opdatering af IP-intervaller kan virke levedygtig, introducerer den yderligere overhead og er ikke en optimal langsigtet løsning. For eksempel kan det øge omkostningerne og kompleksiteten over tid. Desuden kan det være besværligt og udsat for fejl at administrere hyppige opdateringer til sikkerhedsgrupper.

Det er afgørende at finde en omkostningseffektiv løsning, der opfylder disse krav. Målet er at beskytte FE-A og samtidig sikre, at FE-B forbliver tilgængeligt globalt uden at indføre unødvendig kompleksitet. Lad os undersøge, hvordan du opnår dette ved hjælp af bedste praksis fra AWS. 🚀

Strategier til sikring af mikro-frontender med AWS

Det første script udnytter funktionerne i AWS Web Application Firewall (WAF) for at håndhæve forskellige adgangspolitikker for to mikro-frontends. Ved at oprette en WebACL anvendes specifikke IP-regler på FE-A for kun at tillade trafik fra en udpeget statisk IP, hvilket sikrer, at det forbliver et lukket system. For FE-B tillader en særskilt regel offentlig adgang. Denne tilgang centraliserer adgangskontrol på applikationslaget, hvilket gør den ideel til at styre trafik effektivt uden at ændre de underliggende EC2-sikkerhedsgrupper. For eksempel kan du begrænse FE-A til et kontornetværk, mens du tillader FE-B at forblive globalt tilgængeligt, hvilket tager højde for både virksomhedens sikkerhed og brugervenlighed. 🌍

WebACL er derefter forbundet med en Application Load Balancer (ALB), der sikrer, at al trafik, der passerer gennem ALB, filtreres i overensstemmelse med disse regler. Kommandoen waf_client.create_web_acl er afgørende for at definere reglerne, mens waf_client.associate_web_acl linker WebACL til ressourcen. Denne opsætning er meget skalerbar og tillader fremtidige justeringer, såsom tilføjelse af nye IP'er eller ændring af adgangspolitikker, med minimal indsats. Overvågningsfunktioner som CloudWatch-målinger kan også spore effektiviteten af ​​reglerne, hvilket giver værdifuld indsigt i trafikmønstre.

I modsætning hertil opdaterer den Lambda-baserede løsning dynamisk EC2-sikkerhedsgruppereglerne. Dette script henter IP-intervaller, der er specifikke for din AWS-region og konfigurerer dem som indgangsregler i sikkerhedsgruppen. Funktionen ec2.authorize_security_group_ingress tilføjer eller opdaterer de tilladte IP-områder, hvilket gør det muligt for FE-B at være offentligt tilgængeligt og samtidig opretholde streng kontrol for FE-A. Denne tilgang er især nyttig i miljøer med hyppigt skiftende IP-krav, såsom cloud-baserede udviklingsopsætninger eller skiftende virksomhedskontorer. For eksempel, hvis et nyt filialkontor er etableret, kan du automatisk tilføje dets IP til hvidlisten uden manuel indgriben. 🏢

Lambda-funktionen kombineret med en planlagt CloudWatch-begivenhed automatiserer disse opdateringer dagligt, hvilket reducerer administrative omkostninger. Selvom denne tilgang tilføjer kompleksitet, giver den finmasket kontrol over trafikken. Enhedstest inkluderet i scriptet validerer funktionaliteten og sikrer, at sikkerhedsreglerne anvendes korrekt uden at introducere fejl. Uanset om du vælger WAF eller Lambda, prioriterer begge metoder omkostningseffektivitet og fleksibilitet, og balancerer behovet for offentlig og begrænset adgang. I sidste ende demonstrerer disse løsninger AWS' alsidighed til at opfylde forskellige krav og samtidig opretholde robust sikkerhed. 🔒

# 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()

Optimering af sikkerhed og tilgængelighed til mikro-frontend-applikationer i AWS

En anden effektiv måde at løse udfordringen med at balancere begrænset og offentlig adgang i din mikro-frontend-arkitektur er ved at udnytte AWS Amplifys integrerede funktioner. Amplify forenkler hosting og implementering og giver samtidig værktøjer til at konfigurere backend-API'er sikkert. For FE-A kan du implementere netværksadgangskontrol ved at begrænse dets backend API-endepunkter til specifikke IP'er ved hjælp af en AWS API Gateway. Denne opsætning sikrer, at kun foruddefinerede statiske IP'er kan interagere med backend, mens FE-B's endepunkter kan forblive ubegrænsede for offentlig adgang. Dette øger ikke kun sikkerheden, men integreres også problemfrit med Amplifys CI/CD-arbejdsgange. 🌐

En anden overvejelse er at bruge Amazon CloudFront med tilpassede oprindelsesadgangspolitikker. CloudFront kan dirigere trafik til den relevante backend baseret på URL-stien, der fungerer som gatekeeper for dine mikro-frontends. FE-A-trafik kan filtreres gennem CloudFront ved hjælp af en oprindelsesanmodningspolitik, der kontrollerer for IP-begrænsninger eller specifikke overskrifter. For eksempel kan en virksomhed, der implementerer et internt værktøj gennem FE-A, tilføje et IP-områdefilter og samtidig gøre FE-B globalt tilgængeligt for slutbrugere. Denne tilgang optimerer både skalerbarhed og ydeevne, især for applikationer, der kræver global distribution. 🚀

Endelig tilføjer implementering af AWS Cognito til brugergodkendelse et ekstra lag af sikkerhed. FE-A kan låses bag et login-system, der kræver brugergodkendelse med specifikke roller eller grupper, mens FE-B kan bruge en lettere godkendelsesmekanisme eller slet ingen til offentlig adgang. Ved at kombinere godkendelses- og netværksadgangsbegrænsninger opnår du en robust sikkerhedsmodel, der er skræddersyet til behovene for hver mikro-frontend. Denne strategi er især effektiv for startups og SMV'er, der leder efter overkommelige, skalerbare og sikre cloud-løsninger. 🔐