🥇Zréck op Mikroservicer mat Istio. Deel 3

Note. iwwersat.: Éischten Deel Dës Serie war gewidmet fir d'Fäegkeete vum Istio kennen ze léieren an se an Aktioun ze demonstréieren, déi zweet - fein ofgestëmmte Routing an Netzwierkverkéiersmanagement. Elo wäerte mir iwwer Sécherheet schwätzen: fir d'Basisfunktiounen ze weisen, déi domat verbonne sinn, benotzt den Auteur den Auth0 Identitéitsservice, awer aner Ubidder kënnen op eng ähnlech Manéier konfiguréiert ginn.

Mir hunn e Kubernetes Cluster opgeriicht an deem mir Istio an eng Beispill Mikroservice Applikatioun, Sentiment Analysis, ofgesat hunn, fir d'Istio seng Fäegkeeten ze demonstréieren.

Mat Istio konnte mir eis Servicer kleng halen well se keng Schichten wéi Retries, Timeouts, Circuit Breakers, Tracing, Monitoring brauchen ëmzesetzen. Zousätzlech hu mir fortgeschratt Testen an Deployment Techniken benotzt: A / B Testen, Spigelen a Kanaresch Rollouts.

Am neie Material wäerte mir déi lescht Schichten um Wee zum Geschäftswäert beschäftegen: Authentifikatioun an Autorisatioun - an am Istio ass et e richtege Genoss!

Authentifikatioun an Autorisatioun an Istio

Ech hätt ni gegleeft datt ech vun Authentifikatioun an Autorisatioun inspiréiert ginn. Wat kann Istio aus enger technologescher Perspektiv ubidden fir dës Themen lëschteg an nach méi inspiréierend fir Iech ze maachen?

D'Äntwert ass einfach: Istio verschéckt d'Verantwortung fir dës Fäegkeeten vun Äre Servicer op den Envoy Proxy. No der Zäit wou d'Ufroen d'Servicer erreechen, si si scho authentifizéiert an autoriséiert ginn, also alles wat Dir maache musst ass e geschäftlechen nëtzlechen Code ze schreiwen.

Kléngt gutt? Kucke mer dobannen!

Authentifikatioun mat Auth0

Als Server fir Identitéit an Zougangsmanagement benotze mir Auth0, déi eng Testversioun huet, ass intuitiv ze benotzen an ech hunn et einfach gär. Wéi och ëmmer, déiselwecht Prinzipien kënnen op all aner applizéiert ginn OpenID Connect Implementatiounen: KeyCloak, IdentityServer a vill anerer.

Als éischt, gitt op Auth0 Portal mat Ärem Kont, engem Locataire schafen (Locataire - "Locataire", logesch Eenheet vun Isolatioun, fir méi Detailer kuckt Dokumentatioun — ca. Iwwersetzung) a gitt op Uwendungen> Default Appwielt Domain, wéi am Screenshot hei ënnen gewisen:

Gitt dës Domain an der Datei un resource-manifests/istio/security/auth-policy.yaml (Quell):

apiVersion: authentication.istio.io/v1alpha1
kind: Policy
metadata:
  name: auth-policy
spec:
  targets:
  - name: sa-web-app
  - name: sa-feedback
  origins:
  - jwt:
      issuer: "https://{YOUR_DOMAIN}/"
      jwksUri: "https://{YOUR_DOMAIN}/.well-known/jwks.json"
  principalBinding: USE_ORIGIN

Mat esou enger Ressource, Pilot (ee vun den dräi Basis Kontrollplane Komponenten an Istio - ongeféier Iwwersetzung) konfiguréiert Envoy fir Ufroen ze authentifizéieren ier se op d'Servicer weidergeleet ginn: sa-web-app и sa-feedback. Zur selwechter Zäit gëtt d'Konfiguratioun net op Service Envoys applizéiert sa-frontend, erlaabt eis de Frontend onauthentifizéiert ze loossen. Fir d'Politik z'applizéieren, fuert de Kommando aus:

$ kubectl apply -f resource-manifests/istio/security/auth-policy.yaml
policy.authentication.istio.io “auth-policy” created

Zréck op d'Säit a maacht eng Ufro - Dir wäert gesinn datt et mam Status endet 401 Net autoriséiert. Loosst eis elo Frontend Benotzer viruleeden fir mat Auth0 ze authentifizéieren.

Authentifizéierung vun Ufroe mat Auth0

Fir Endbenotzer Ufroen ze authentifizéieren, musst Dir eng API an Auth0 erstellen, déi déi authentifizéiert Servicer representéieren (Rezensiounen, Detailer a Bewäertungen). Fir eng API ze kreéieren, gitt op Auth0 Portal > APIen > API erstellen a fëllt de Formulaire aus:

Déi wichteg Informatioun hei ass Identifikatioun, déi mir spéider am Skript benotzen. Loosst eis et esou opschreiwen:

Audience: {YOUR_AUDIENCE}

Déi reschtlech Detailer déi mir brauchen sinn um Auth0 Portal an der Rubrik Applicatioun - wielt Test Applikatioun (automatesch erstallt zesumme mat der API).

Hei wäerte mir schreiwen:

Domain: {YOUR_DOMAIN}
Client ID: {YOUR_CLIENT_ID}

Scroll op Test Applikatioun zum Textfeld Erlaabt Callback URLen (geléist URLen fir den Callback), an deem mir d'URL spezifizéieren wou den Uruff no der Authentifikatioun ofgeschloss ass. An eisem Fall ass et:

http://{EXTERNAL_IP}/callback

A fir Erlaabt Logout URLen (erlaabt URLen fir auszeloggen) addéieren:

http://{EXTERNAL_IP}/logout

Loosst eis op de Frontend goen.

Frontend Update

Wiesselt op Filial auth0 repository [istio-mastery]. An dëser Branche gëtt de Frontend Code geännert fir d'Benotzer op Auth0 fir d'Authentifikatioun ze redirectéieren an de JWT Token an Ufroen un aner Servicer ze benotzen. Déi lescht gëtt wéi follegt ëmgesat (App.js):

analyzeSentence() {
    fetch('/sentiment', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${auth.getAccessToken()}` // Access Token
        },
        body: JSON.stringify({ sentence: this.textField.getValue() })
    })
        .then(response => response.json())
        .then(data => this.setState(data));
}

Fir de Frontend z'änneren fir Locatairedaten an Auth0 ze benotzen, oppen sa-frontend/src/services/Auth.js an ersetzen an et d'Wäerter déi mir uewen geschriwwen hunn (Auth.js):

const Config = {
    clientID: '{YOUR_CLIENT_ID}',
    domain:'{YOUR_DOMAIN}',
    audience: '{YOUR_AUDIENCE}',
    ingressIP: '{EXTERNAL_IP}' // Используется для редиректа после аутентификации
}

D'Applikatioun ass prett. Gitt Är Docker ID an de Kommandoen hei ënnen un wann Dir d'Ännerunge bauen an ofbaut:

$ docker build -f sa-frontend/Dockerfile 
 -t $DOCKER_USER_ID/sentiment-analysis-frontend:istio-auth0 
 sa-frontend

$ docker push $DOCKER_USER_ID/sentiment-analysis-frontend:istio-auth0

$ kubectl set image deployment/sa-frontend 
 sa-frontend=$DOCKER_USER_ID/sentiment-analysis-frontend:istio-auth0

Probéiert d'App! Dir wäert op Auth0 ëmgeleet ginn, wou Dir musst aloggen (oder registréieren), duerno gitt Dir op d'Säit zréck geschéckt, vun där scho authentifizéiert Ufroe gemaach ginn. Wann Dir d'Befehle probéiert an den éischten Deeler vum Artikel mat Curl erwähnt, kritt Dir de Code 401 Status Code, Signaler datt d'Ufro net autoriséiert ass.

Loosst eis de nächste Schrëtt huelen - Ufroen autoriséieren.

Autorisatioun mat Auth0

Authentifikatioun erlaabt eis ze verstoen wien e Benotzer ass, awer Autorisatioun ass erfuerderlech fir ze wëssen op wat se Zougang hunn. Istio bitt och Tools fir dëst.

Als Beispill, loosst eis zwou Benotzergruppen erstellen (kuckt d'Diagramm hei ënnen):

Benotzer (Benotzer) - mat Zougang nëmmen zu SA-WebApp an SA-Frontend Servicer;
Moderatoren (Moderatoren) - mat Zougang zu allen dräi Servicer.

Autorisatiounskonzept

Fir dës Gruppen ze kreéieren, benotze mir d'Auth0 Autorisatiounsverlängerung a benotzen Istio fir hinnen verschidden Zougangsniveauen ze bidden.

Installatioun an Configuratioun vun Auth0 Autorisatioun

Am Auth0 Portal, gitt op Extensiounen (Betriebsdauer) an installéieren Auth0 Autorisatioun. No der Installatioun, gitt op Autorisatioun Extensioun, an do - op d'Konfiguratioun vum Mieter andeems Dir uewe riets klickt an déi entspriechend Menüoptioun auswielen (Konfiguratioun). Aktivéiert Gruppen (Gruppen) a klickt op de Knäppchen publizéieren Regel (Regel publizéieren).

Schafen Gruppen

An Autorisatioun Extensioun gitt op Gruppen a schafen eng Grupp Moderatoren. Well mir all authentifizéiert Benotzer als normale Benotzer behandelen, ass et net néideg eng zousätzlech Grupp fir si ze kreéieren.

Wielt eng Grupp Moderatoren, Press Memberen derbäi, Füügt Ären Haaptkonto. Loosst e puer Benotzer ouni Grupp fir sécherzestellen datt se Zougang verweigert ginn. (Nei Benotzer kënnen manuell erstallt ginn via Auth0 Portal > Benotzer > Benotzer erstellen.)

Add Group Claim to Access Token

D'Benotzer goufen an d'Gruppen bäigefüügt, awer dës Informatioun muss och an Zougangstoken reflektéiert ginn. Fir OpenID Connect ze respektéieren a gläichzäiteg d'Gruppen zréckzebréngen déi mir brauchen, muss den Token säin eegene addéieren Benotzerdefinéiert Fuerderung. Ëmgesat duerch Auth0 Regelen.

Fir eng Regel ze kreéieren, gitt op Auth0 Portal fir Regelen, Press Schafen Regel a wielt eng eidel Regel aus de Schabloune.

Kopéiert de Code hei ënnen a späichert et als nei Regel Add Group Claim (namespacedGroup.js):

function (user, context, callback) {
    context.accessToken['https://sa.io/group'] = user.groups[0];
    return callback(null, user, context);
}

Remarque: Dëse Code hëlt déi éischt Benotzergrupp, déi an der Autorisatiounsextensioun definéiert ass, a füügt et un den Zougangstoken als personaliséiert Fuerderung (ënnert sengem Nummraum, wéi néideg vun Auth0).

Zréck op d'Säit Regelen a kontrolléiert datt Dir zwou Regelen an der folgender Uerdnung geschriwwen hutt:

auth0-Autorisatioun-Erweiderung
Add Group Claim

D'Uerdnung ass wichteg well d'Gruppfeld d'Regel asynchron kritt auth0-Autorisatioun-Erweiderung an duerno gëtt et als Fuerderung vun der zweeter Regel dobäigesat. D'Resultat ass en Zougangstoken wéi dëst:

{
 "https://sa.io/group": "Moderators",
 "iss": "https://sentiment-analysis.eu.auth0.com/",
 "sub": "google-oauth2|196405271625531691872"
 // [сокращено для наглядности]
}

Elo musst Dir den Envoy Proxy konfiguréieren fir de Benotzer Zougang ze kontrolléieren, fir deen de Grupp aus der Fuerderung gezunn gëtt (https://sa.io/group) am zréckginn Zougang Token. Dëst ass d'Thema fir déi nächst Sektioun vum Artikel.

Autorisatiounskonfiguratioun an Istio

Fir Autorisatioun ze schaffen, musst Dir RBAC fir Istio aktivéieren. Fir dëst ze maachen, benotze mir déi folgend Konfiguratioun:

apiVersion: "rbac.istio.io/v1alpha1"
kind: RbacConfig
metadata:
  name: default
spec:
  mode: 'ON_WITH_INCLUSION'                     # 1
  inclusion:
    services:                                   # 2
    - "sa-frontend.default.svc.cluster.local"
    - "sa-web-app.default.svc.cluster.local"
    - "sa-feedback.default.svc.cluster.local"

Erklärungen:

1 - aktivéiert RBAC nëmme fir Servicer an Nummraim am Feld opgezielt Inclusion;
2 - mir lëschten eng Lëscht vun eise Servicer.

Loosst eis d'Konfiguratioun mat dem folgenden Kommando uwenden:

$ kubectl apply -f resource-manifests/istio/security/enable-rbac.yaml
rbacconfig.rbac.istio.io/default created

All Servicer verlaangen elo Roll-baséiert Zougang Kontroll. An anere Wierder, Zougang zu all Servicer ass verbueden a wäert zu enger Äntwert féieren RBAC: access denied. Loosst eis elo Zougang zu autoriséierte Benotzer erlaben.

Zougang Configuratioun fir regelméisseg Benotzer

All Benotzer mussen Zougang zu de SA-Frontend an SA-WebApp Servicer hunn. Implementéiert mat de folgende Istio Ressourcen:

Service Roll - bestëmmt d'Rechter déi de Benotzer huet;
ServiceRoleBindung - bestëmmt, wiem dës ServiceRole gehéiert.

Fir normal Benotzer erlaben mir Zougang zu bestëmmte Servicer (servicerole.yaml):

apiVersion: "rbac.istio.io/v1alpha1"
kind: ServiceRole
metadata:
  name: regular-user
  namespace: default
spec:
  rules:
  - services: 
    - "sa-frontend.default.svc.cluster.local" 
    - "sa-web-app.default.svc.cluster.local"
    paths: ["*"]
    methods: ["*"]

An duerno regular-user-binding gëllen ServiceRole op all Säit Besucher (regular-user-service-role-binding.yaml):

apiVersion: "rbac.istio.io/v1alpha1"
kind: ServiceRoleBinding
metadata:
  name: regular-user-binding
  namespace: default
spec:
  subjects:
  - user: "*"
  roleRef:
    kind: ServiceRole
    name: "regular-user"

Heescht "all Benotzer" datt net authentifizéiert Benotzer och Zougang zu der SA WebApp hunn? Nee, d'Politik iwwerpréift d'Gëltegkeet vum JWT Token.

Loosst eis d'Konfiguratiounen uwenden:

$ kubectl apply -f resource-manifests/istio/security/user-role.yaml
servicerole.rbac.istio.io/regular-user created
servicerolebinding.rbac.istio.io/regular-user-binding created

Zougang Configuratioun fir Moderatoren

Fir Moderatore wëlle mir Zougang zu all Servicer erméiglechen (mod-service-rolle.yaml):

apiVersion: "rbac.istio.io/v1alpha1"
kind: ServiceRole
metadata:
  name: mod-user
  namespace: default
spec:
  rules:
  - services: ["*"]
    paths: ["*"]
    methods: ["*"]

Awer mir wëllen esou Rechter nëmme fir déi Benotzer deenen hiren Zougang Token Fuerderung enthält https://sa.io/group mat Bedeitung Moderators (mod-service-rolle-binding.yaml):

apiVersion: "rbac.istio.io/v1alpha1"
kind: ServiceRoleBinding
metadata:
  name: mod-user-binding
  namespace: default
spec:
  subjects:
  - properties:
      request.auth.claims[https://sa.io/group]: "Moderators"
  roleRef:
    kind: ServiceRole
name: "mod-user"

Loosst eis d'Konfiguratiounen uwenden:

$ kubectl apply -f resource-manifests/istio/security/mod-role.yaml
servicerole.rbac.istio.io/mod-user created
servicerolebinding.rbac.istio.io/mod-user-binding created

Wéinst Caching an Envoyen kann et e puer Minutten daueren bis d'Autorisatiounsregelen a Kraaft trieden. Dir kënnt dann dofir suergen datt Benotzer a Moderatoren verschidden Zougangsniveauen hunn.

Conclusioun zu dësem Deel

Eescht awer, hutt Dir jeemools eng méi einfach, ustrengend, skalierbar a sécher Approche fir Authentifikatioun an Autorisatioun gesinn?

Nëmmen dräi Istio Ressourcen (RbacConfig, ServiceRole, an ServiceRoleBinding) waren erfuerderlech fir feinkorrekt Kontroll iwwer d'Authentifikatioun an d'Autorisatioun vum Ennbenotzer Zougang zu Servicer z'erreechen.

Zousätzlech hu mir dës Themen aus eisen Envoy-Servicer gekëmmert, fir z'erreechen:

d'Reduktioun vum Betrag vum generesche Code deen Sécherheetsproblemer a Bugs enthalen kann;
d'Zuel vun den domm Situatiounen erofzesetzen, wou een Endpunkt vu baussen zougänglech erausgestallt huet a vergiess huet ze mellen;
eliminéiert d'Noutwendegkeet fir all Servicer ze aktualiséieren all Kéier wann eng nei Roll oder Recht dobäigesat gëtt;
datt nei Servicer einfach, sécher a séier bleiwen.

Konklusioun

Istio erlaabt Teams hir Ressourcen op geschäftlech kritesch Aufgaben ze fokusséieren ouni Overhead op Servicer ze addéieren, se op de Mikrostatus zréckzekréien.

Den Artikel (an dräi Deeler) huet Basiswëssen a fäerdeg praktesch Instruktioune geliwwert fir mat Istio an echte Projeten unzefänken.

PS vum Iwwersetzer

Liest och op eisem Blog:

"Zréck op Mikroservicer mat Istio": Deel 1 (Aféierung an d'Haaptmerkmale), Deel 2 (Routing, Verkéierskontroll);
«Conduit - liicht Service Mesh fir Kubernetes";
«Wat ass e Service Mesh a firwat brauch ech een [fir eng Cloud Applikatioun mat Mikroservicer]?".

Source: will.com

Zréck op Mikroservicer mat Istio. Deel 3