Slik beskytter du to mikro-frontender med ulike tilgangsbehov på en AWS-backend

Balanserer sikkerhet og tilgjengelighet i AWS Micro-Frontend Architecture

Å designe sikre og skalerbare skyarkitekturer innebærer ofte å balansere tilgjengelighet og begrenset tilgang. I AWS-oppsettet ditt har du to mikrogrensesnitt med unike tilgangskrav. FE-A må begrenses til en spesifikk statisk IP, mens FE-B bør være offentlig tilgjengelig. Å møte disse behovene samtidig kan være en utfordring. 😅

Utfordringen oppstår ved konfigurering av sikkerhetsgruppene i EC2. Hvis du tillater tilgang til 0.0.0.0, blir begge grensesnittene offentlig tilgjengelige, noe som kompromitterer FE-As sikkerhet. På den annen side nekter begrensning av tilgang til en enkelt statisk IP offentlig tilgjengelighet for FE-B. Dette skaper en kompleks balansegang mellom åpenhet og trygghet.

Selv om en Lambda-funksjon for dynamisk oppdatering av IP-områder kan virke levedyktig, introduserer den ekstra overhead og er ikke en optimal langsiktig løsning. Det kan for eksempel øke kostnadene og kompleksiteten over tid. Dessuten kan det være tungvint og utsatt for feil å administrere hyppige oppdateringer til sikkerhetsgrupper.

Det er avgjørende å finne en kostnadseffektiv løsning som oppfyller disse kravene. Målet er å beskytte FE-A og samtidig sikre at FE-B forblir tilgjengelig globalt uten å introdusere unødvendig kompleksitet. La oss utforske hvordan du oppnår dette ved å bruke AWS beste praksis. 🚀

Strategier for å sikre mikro-frontender med AWS

Det første skriptet utnytter egenskapene til AWS Web Application Firewall (WAF) for å håndheve distinkte tilgangspolicyer for to mikrogrensesnitt. Ved å lage en WebACL, brukes spesifikke IP-regler på FE-A for å tillate kun trafikk fra en utpekt statisk IP, og sikrer at det forblir et lukket system. For FE-B tillater en egen regel allmennhet. Denne tilnærmingen sentraliserer tilgangskontrollen til applikasjonslaget, noe som gjør den ideell for å administrere trafikk effektivt uten å endre de underliggende EC2-sikkerhetsgruppene. Du kan for eksempel begrense FE-A til et kontornettverk samtidig som du lar FE-B forbli globalt tilgjengelig, og sørger for både bedriftssikkerhet og brukervennlighet. 🌍

WebACL er deretter assosiert med en Application Load Balancer (ALB), som sikrer at all trafikk som passerer gjennom ALB filtreres i henhold til disse reglene. Kommandoen waf_client.create_web_acl er sentral i å definere reglene, mens waf_client.associate_web_acl kobler WebACL til ressursen. Dette oppsettet er svært skalerbart og tillater fremtidige justeringer, som å legge til nye IP-er eller endre tilgangspolicyer, med minimal innsats. Overvåkingsfunksjoner som CloudWatch-beregninger kan også spore effektiviteten til reglene, og gir verdifull innsikt i trafikkmønstre.

Derimot oppdaterer den Lambda-baserte løsningen dynamisk EC2-sikkerhetsgrupperegler. Dette skriptet henter IP-områder som er spesifikke for AWS-regionen din og konfigurerer dem som ingress-regler i sikkerhetsgruppen. Funksjonen ec2.authorize_security_group_ingress legger til eller oppdaterer de tillatte IP-områdene, slik at FE-B kan være offentlig tilgjengelig samtidig som den opprettholder streng kontroll for FE-A. Denne tilnærmingen er spesielt nyttig i miljøer med hyppig skiftende IP-krav, for eksempel skybaserte utviklingsoppsett eller skiftende bedriftskontorer. For eksempel, hvis et nytt avdelingskontor er etablert, kan du automatisk legge til IP-adressen til hvitelisten uten manuell inngripen. 🏢

Lambda-funksjonen, kombinert med en planlagt CloudWatch-hendelse, automatiserer disse oppdateringene daglig, noe som reduserer administrative overhead. Selv om denne tilnærmingen tilfører kompleksitet, gir den finmasket kontroll over trafikken. Enhetstester som er inkludert i skriptet validerer funksjonaliteten, og sikrer at sikkerhetsreglene brukes riktig uten å introdusere feil. Enten du velger WAF eller Lambda, prioriterer begge metodene kostnadseffektivitet og fleksibilitet, og balanserer behovet for offentlig og begrenset tilgang. Til syvende og sist demonstrerer disse løsningene allsidigheten til AWS når det gjelder å møte ulike krav og samtidig opprettholde robust sikkerhet. 🔒

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

Optimalisering av sikkerhet og tilgjengelighet for mikro-frontend-applikasjoner i AWS

En annen effektiv måte å møte utfordringen med å balansere begrenset og offentlig tilgang i mikro-frontend-arkitekturen din, er ved å utnytte AWS Amplifys integrerte funksjoner. Amplify forenkler hosting og distribusjon samtidig som det gir verktøy for å konfigurere backend-API-er på en sikker måte. For FE-A kan du implementere nettverkstilgangskontroll ved å begrense dens backend API-endepunkter til spesifikke IP-er ved å bruke en AWS API-gateway. Dette oppsettet sikrer at kun forhåndsdefinerte statiske IP-er kan samhandle med backend, mens FE-Bs endepunkter kan forbli ubegrensede for offentlig tilgang. Dette forbedrer ikke bare sikkerheten, men integreres også sømløst med Amplifys CI/CD-arbeidsflyter. 🌐

En annen vurdering er å bruke Amazon CloudFront med tilpassede retningslinjer for opprinnelsestilgang. CloudFront kan rute trafikk til riktig backend basert på URL-banen, og fungerer som en gatekeeper for mikrogrensesnittene dine. FE-A-trafikk kan filtreres gjennom CloudFront ved å bruke en opprinnelsesforespørselspolicy som sjekker for IP-restriksjoner eller spesifikke overskrifter. For eksempel kan en bedrift som distribuerer et internt verktøy gjennom FE-A legge til et IP-områdefilter samtidig som FE-B er globalt tilgjengelig for sluttbrukere. Denne tilnærmingen optimerer både skalerbarhet og ytelse, spesielt for applikasjoner som krever global distribusjon. 🚀

Til slutt, implementering av AWS Cognito for brukerautentisering legger til et ekstra lag med sikkerhet. FE-A kan låses bak et påloggingssystem som krever brukerautentisering med spesifikke roller eller grupper, mens FE-B kan bruke en lettere autentiseringsmekanisme eller ingen i det hele tatt for offentlig tilgang. Ved å kombinere autentisering og nettverkstilgangsbegrensninger oppnår du en robust sikkerhetsmodell som er skreddersydd for behovene til hver mikrogrensesnitt. Denne strategien er spesielt effektiv for startups og små og mellomstore bedrifter som leter etter rimelige, skalerbare og sikre skyløsninger. 🔐