Dat ass richteg, no der Verëffentlechung Ufank Mee 2019, am Consul kënnt Dir Uwendungen a Servicer autoriséieren, déi am Kubernetes nativ lafen.
An dësem Tutorial wäerte mir Schrëtt fir Schrëtt erstellen (Proof of Concept, PoC) déi dës nei Feature demonstréiert. Dir sidd erwaart Basiskenntnisser vu Kubernetes an Hashicorp's Consul ze hunn. Während Dir all Cloud Plattform oder on-premises Ëmfeld benotze kënnt, an dësem Tutorial benotze mir d'Google Cloud Plattform.
Iwwersiicht
Wa mir goen , mir kréien e séieren Iwwerbléck iwwer säin Zweck a Gebrauchsfall, wéi och e puer technesch Detailer an en allgemengen Iwwerbléck iwwer d'Logik. Ech recommandéieren et op d'mannst eemol ze liesen ier ech weidergoen, well ech elo alles erklären a kauen.
Diagramm 1: Offiziell Iwwersiicht vun der Consul Autorisatiounsmethod
Loosst eis eran kucken .
Sécher, et gëtt nëtzlech Informatioun do, awer et gëtt kee Guide fir wéi Dir et wierklech alles benotzt. Also, wéi all vernünfteg Persoun, fuert Dir den Internet fir Orientatioun. An dann ... Dir versoen. Et geschitt. Loosst eis dat fixéieren.
Ier mer weidergoen fir eise POC ze kreéieren, loosst eis zréck op den Iwwerbléck iwwer d'Autorisatiounsmethoden vum Consul (Diagram 1) a verfeineren et am Kontext vu Kubernetes.
Architektur
An dësem Tutorial wäerte mir e Consul-Server op enger separater Maschinn erstellen déi mat engem Kubernetes-Cluster mat dem Consul Client installéiert kommunizéiere wäert. Mir erstellen dann eis Dummy-Applikatioun am Pod a benotzen eis konfiguréiert Autorisatiounsmethod fir aus eisem Consul Schlëssel / Wäertgeschäft ze liesen.
D'Diagramm hei drënner detailléiert d'Architektur déi mir an dësem Tutorial erstellen, souwéi d'Logik hannert der Autorisatiounsmethod, déi spéider erkläert gëtt.
Diagramm 2: Kubernetes Autorisatiounsmethod Iwwersiicht
Eng séier Notiz: de Consul-Server brauch net ausserhalb vum Kubernetes-Cluster ze liewen fir datt dëst funktionnéiert. Mee jo, hien kann et esou an dat maachen.
Also, wann Dir de Consult Iwwersiichtsdiagramm (Diagram 1) hëlt an de Kubernetes op et applizéiert, kréie mir den Diagramm uewen (Diagram 2), an d'Logik hei ass wéi follegt:
- All Pod wäert e Servicekonto ugeschloss hunn deen e JWT Token enthält generéiert a bekannt vu Kubernetes. Dësen Token gëtt och als Standard an de Pod agebaut.
- Eis Applikatioun oder Service am Pod initiéiert e Login Kommando fir eise Consul Client. D'Login Ufro wäert och eis Token an Numm enthalen speziell geschaf Autorisatiounsmethod (Kubernetes-Typ). Dëse Schrëtt #2 entsprécht dem Schrëtt 1 vum Consul-Diagramm (Schema 1).
- Eise Consul Client wäert dës Ufro dann un eise Consul Server weiderginn.
- MAGISCH! Dëst ass wou de Consul-Server d'Authentizitéit vun der Ufro verifizéiert, sammelt Informatiounen iwwer d'Identitéit vun der Ufro a vergläicht se mat all assoziéierten virdefinéierte Regelen. Drënner ass en anert Diagramm fir dëst ze illustréieren. Dëse Schrëtt entsprécht de Schrëtt 3, 4 a 5 vum Consul-Iwwerbléckdiagramm (Diagramm 1).
- Eise Consul-Server generéiert e Consul-Token mat Permissiounen no eise spezifizéierte Autorisatiounsmethodregelen (déi mir definéiert hunn) iwwer d'Identitéit vum Ufroer. Et schéckt dann dat Token zréck. Dëst entsprécht Schrëtt 6 vum Consul-Diagramm (Diagramm 1).
- Eise Consul Client schéckt den Token un déi ufroend Applikatioun oder Service weider.
Eis Applikatioun oder Service kann elo dëse Consul-Token benotzen fir mat eise Consul-Donnéeën ze kommunizéieren, wéi bestëmmt duerch d'Privilegien vum Token.
D'Magie gëtt opgedeckt!
Fir déi vun iech, déi net zefridde sinn mat just engem Hues aus engem Hutt a wëlle wëssen, wéi et funktionéiert... Ech weisen Iech wéi déif Kanéngchen Lach".
Wéi virdru scho gesot, eise "Magie" Schrëtt (Figur 2: Schrëtt 4) ass wou de Consul-Server d'Ufro authentifizéiert, d'Ufroinformatioun sammelt, a vergläicht se mat all assoziéierten virdefinéierte Regelen. Dëse Schrëtt entsprécht de Schrëtt 3, 4 a 5 vum Consul-Iwwerbléckdiagramm (Diagramm 1). Drënner ass en Diagramm (Diagramm 3), den Zweck vun deem ass kloer ze weisen wat tatsächlech geschitt ënner der Capot spezifesch Kubernetes Autorisatioun Method.
Diagramm 3: D'Magie gëtt opgedeckt!
- Als Ausgangspunkt schéckt eise Consul Client d'Login Ufro un eise Consul Server mat dem Kubernetes Kont Token a spezifeschen Instanznumm vun der Autorisatiounsmethod déi virdru erstallt gouf. Dëse Schrëtt entsprécht Schrëtt 3 an der viregter Circuit Erklärung.
- Elo muss de Consul-Server (oder Leader) d'Authentizitéit vum kritt Token verifizéieren. Dofir wäert et de Kubernetes Cluster konsultéieren (iwwer de Consul Client) an, mat de passenden Permissiounen, wäerte mir erausfannen ob den Token echt ass a wiem et gehéiert.
- Déi validéiert Ufro gëtt dann un de Consul Leader zréckginn, an de Consul Server kuckt d'Autorisatiounsmethod Instanz mam spezifizéierten Numm vun der Login Ufro (a Kubernetes Typ).
- De Konsul Leader identifizéiert déi spezifizéiert Autorisatiounsmethod Instanz (wann fonnt) a liest de Set vu verbindleche Regelen, déi derbäi sinn. Et liest dann dës Reegelen a vergläicht se mat de verifizéierte Identitéitsattributer.
- TA-dach! Loosst eis op Schrëtt 5 an der viregter Circuit Erklärung goen.
Run Consul-Server op enger regulärer virtueller Maschinn
Vun elo un ginn ech meeschtens Instruktioune fir dës POC ze kreéieren, dacks a Kugelpunkten, ouni voll Saz Erklärungen. Och, wéi virdru bemierkt, wäert ech GCP benotzen fir all d'Infrastruktur ze kreéieren, awer Dir kënnt déiselwecht Infrastruktur soss anzwousch erstellen.
- Start déi virtuell Maschinn (Instanz / Server).
- Erstellt eng Regel fir d'Firewall (Sécherheetsgrupp an AWS):
- Ech hu gär dee selwechte Maschinnnumm un d'Regel an d'Netzwierk Tag, an dësem Fall "skywiz-consul-server-poc".
- Fannt d'IP Adress vun Ärem lokalen Computer a füügt se an d'Lëscht vun de Quell IP Adressen un, fir datt mir op d'Benotzerinterface (UI) kommen.
- Open Port 8500 fir UI. Klickt Erstellen. Mir wäerten dës Firewall geschwënn erëm änneren [].
- Füügt eng Firewall Regel un d'Instanz. Gitt zréck op de VM Dashboard op Consul Server a füügt "skywiz-consul-server-poc" an d'Netzwierk Tags Feld. Klickt op Späicheren.
- Installéiert Consul op enger virtueller Maschinn, kuckt hei. Denkt drun Dir braucht Consul Versioun ≥ 1.5 [Link]
- Loosst eis en eenzegen Node Consul erstellen - d'Konfiguratioun ass wéi follegt.
groupadd --system consul
useradd -s /sbin/nologin --system -g consul consul
mkdir -p /var/lib/consul
chown -R consul:consul /var/lib/consul
chmod -R 775 /var/lib/consul
mkdir /etc/consul.d
chown -R consul:consul /etc/consul.d- Fir e méi detailléierte Guide iwwer d'Installatioun vum Consul an d'Opstellung vun engem Cluster vun 3 Noden, kuckt .
- Erstellt eng Datei /etc/consul.d/agent.json wéi follegt []:
### /etc/consul.d/agent.json
{
"acl" : {
"enabled": true,
"default_policy": "deny",
"enable_token_persistence": true
}
}- Start eise Consul Server:
consul agent
-server
-ui
-client 0.0.0.0
-data-dir=/var/lib/consul
-bootstrap-expect=1
-config-dir=/etc/consul.d- Dir sollt eng Rëtsch Output gesinn an ophalen mat "... Update blockéiert vun ACLs."
- Fannt déi extern IP Adress vum Consul-Server an öffnen e Browser mat dëser IP Adress um Hafen 8500. Vergewëssert Iech datt d'UI opmaacht.
- Probéiert e Schlëssel / Wäertpaar derbäi. Et muss ee Feeler sinn. Dëst ass well mir de Consul-Server mat engem ACL gelueden hunn an all Regelen ausgeschalt hunn.
- Gitt zréck op Är Shell um Consul Server a start de Prozess am Hannergrond oder op eng aner Manéier fir et ze lafen a gitt déi folgend:
consul acl bootstrap- Fannt de "SecretID" Wäert a gitt zréck an d'UI. An der ACL Reiter, gitt déi geheim ID vum Token deen Dir just kopéiert hutt. Kopie SecretID soss anzwousch, mir wäerten et méi spéit brauchen.
- Füügt elo e Schlëssel / Wäertpaar derbäi. Fir dës POC, füügt déi folgend: Schlëssel: "custom-ns/test_key", Wäert: "Ech sinn am Custom-ns Dossier!"
Lancéiere vun engem Kubernetes Cluster fir eis Applikatioun mam Consul Client als Daemonset
- Erstellt e K8s (Kubernetes) Cluster. Mir kreéieren et an der selwechter Zone wéi de Server fir méi séier Zougang, an dofir kënne mir datselwecht Subnet benotze fir einfach mat internen IP Adressen ze verbannen. Mir nennen et "skywiz-app-with-consul-client-poc".
- Als Säit Notiz, hei ass e gudden Tutorial, deen ech begéint hunn, wärend ech e POC Consul Cluster mat Consul Connect opgeriicht hunn.
- Mir wäerten och Hashicorp Helmdiagramm mat enger erweiderter Wäerterdatei benotzen.
- Installéieren a konfiguréieren Helm. Konfiguratioun Schrëtt:
kubectl create serviceaccount tiller --namespace kube-system
kubectl create clusterrolebinding tiller-admin-binding
--clusterrole=cluster-admin --serviceaccount=kube-system:tiller
./helm init --service-account=tiller
./helm update- Helm Chart:
- Benotzt déi folgend Wäertdatei (Notiz datt ech am meeschte behënnert hunn):
### poc-helm-consul-values.yaml
global:
enabled: false
image: "consul:latest"
# Expose the Consul UI through this LoadBalancer
ui:
enabled: false
# Allow Consul to inject the Connect proxy into Kubernetes containers
connectInject:
enabled: false
# Configure a Consul client on Kubernetes nodes. GRPC listener is required for Connect.
client:
enabled: true
join: ["<PRIVATE_IP_CONSUL_SERVER>"]
extraConfig: |
{
"acl" : {
"enabled": true,
"default_policy": "deny",
"enable_token_persistence": true
}
}
# Minimal Consul configuration. Not suitable for production.
server:
enabled: false
# Sync Kubernetes and Consul services
syncCatalog:
enabled: false- Helmdiagramm uwenden:
./helm install -f poc-helm-consul-values.yaml ./consul-helm - name skywiz-app-with-consul-client-poc- Wann et probéiert ze lafen, brauch et Permissiounen fir de Consul Server, also loosst eis se derbäisetzen.
- Notéiert de "Pod Address Range" um Cluster Dashboard a kuckt zréck op eis "skywiz-consul-server-poc" Firewall Regel.
- Füügt d'Adressberäich fir de Pod op d'Lëscht vun den IP Adressen an oppen Ports 8301 an 8300.
- Gitt op d'Konsul UI an no e puer Minutten gesitt Dir eise Stärekoup an der Noden Tab.
Eng Autorisatiounsmethod konfiguréieren andeems Dir Consul mat Kubernetes integréiert
- Zréck op d'Konsul Server Shell an exportéiert den Token deen Dir virdru gespäichert hutt:
export CONSUL_HTTP_TOKEN=<SecretID>- Mir brauchen Informatioun aus eisem Kubernetes Cluster fir eng Instanz vun der Auth-Methode ze kreéieren:
- kubernetes-Host
kubectl get endpoints | grep kubernetes- kubernetes-service-account-jwt
kubectl get sa <helm_deployment_name>-consul-client -o yaml | grep "- name:"
kubectl get secret <secret_name_from_prev_command> -o yaml | grep token:- Den Token ass base64 kodéiert, also entschlësselt se mat Ärem Liiblingsinstrument []
- kubernetes-ca-cert
kubectl get secret <secret_name_from_prev_command> -o yaml | grep ca.crt:- Huelt den "ca.crt" Zertifika (no der Base64 Decodéierung) a schreift se an d'"ca.crt" Datei.
- Instantiéiert elo d'Auth-Methode, ersetzt d'Plazhalter mat de Wäerter déi Dir just kritt hutt.
consul acl auth-method create
-type "kubernetes"
-name "auth-method-skywiz-consul-poc"
-description "This is an auth method using kubernetes for the cluster skywiz-app-with-consul-client-poc"
-kubernetes-host "<k8s_endpoint_retrieved earlier>"
[email protected]
-kubernetes-service-account-
jwt="<decoded_token_retrieved_earlier>"- Als nächst musse mir eng Regel erstellen an se un déi nei Roll befestigen. Fir dësen Deel kënnt Dir Consul UI benotzen, awer mir benotzen d'Kommandozeil.
- Schreift eng Regel
### kv-custom-ns-policy.hcl
key_prefix "custom-ns/" {
policy = "write"
}- Gëlle d'Regel
consul acl policy create
-name kv-custom-ns-policy
-description "This is an example policy for kv at custom-ns/"
-rules @kv-custom-ns-policy.hcl- Fannt d'ID vun der Regel déi Dir just aus der Ausgab erstallt hutt.
- Schafen eng Roll mat enger neier Regel.
consul acl role create
-name "custom-ns-role"
-description "This is an example role for custom-ns namespace"
-policy-id <policy_id>- Elo wäerte mir eis nei Roll mat der Auth-Method Instanz associéieren. Bedenkt datt de "selector" Fändel bestëmmt ob eis Login Ufro dës Roll kritt. Kuckt hei fir aner Selektiounsoptiounen:
consul acl binding-rule create
-method=auth-method-skywiz-consul-poc
-bind-type=role
-bind-name='custom-ns-role'
-selector='serviceaccount.namespace=="custom-ns"'Endlech Konfiguratiounen
Zougangsrechter
- Schafen Zougang Rechter. Mir mussen dem Consul Erlaabnis ginn fir d'Identitéit vum K8s Service Kont Token z'iwwerpréiwen an z'identifizéieren.
- Schreift déi folgend an de Fichier :
###skywiz-poc-consul-server_rbac.yaml
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: review-tokens
namespace: default
subjects:
- kind: ServiceAccount
name: skywiz-app-with-consul-client-poc-consul-client
namespace: default
roleRef:
kind: ClusterRole
name: system:auth-delegator
apiGroup: rbac.authorization.k8s.io
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: service-account-getter
namespace: default
rules:
- apiGroups: [""]
resources: ["serviceaccounts"]
verbs: ["get"]
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: get-service-accounts
namespace: default
subjects:
- kind: ServiceAccount
name: skywiz-app-with-consul-client-poc-consul-client
namespace: default
roleRef:
kind: ClusterRole
name: service-account-getter
apiGroup: rbac.authorization.k8s.io- Loosst eis Zougangsrechter erstellen
kubectl create -f skywiz-poc-consul-server_rbac.yamlVerbindung mam Consul Client
- Wéi bemierkt Et gi verschidde Méiglechkeeten fir mat Daemonset ze verbannen, awer mir ginn op déi folgend einfach Léisung:
- Fëllt déi folgend Datei [].
### poc-consul-client-ds-svc.yaml
apiVersion: v1
kind: Service
metadata:
name: consul-ds-client
spec:
selector:
app: consul
chart: consul-helm
component: client
hasDNS: "true"
release: skywiz-app-with-consul-client-poc
ports:
- protocol: TCP
port: 80
targetPort: 8500- Benotzt dann de folgenden agebaute Kommando fir eng Configmap ze kreéieren []. Notéiert w.e.g. datt mir op den Numm vun eisem Service schwätzen, ersetzen se wann néideg.
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: ConfigMap
metadata:
labels:
addonmanager.kubernetes.io/mode: EnsureExists
name: kube-dns
namespace: kube-system
data:
stubDomains: |
{"consul": ["$(kubectl get svc consul-ds-client -o jsonpath='{.spec.clusterIP}')"]}
EOFTesten d'Autmethod
Loosst eis elo d'Magie an Aktioun gesinn!
- Erstellt e puer méi Schlëssel Ordner mat deemselwechten Top-Level Schlëssel (dh. /sample_key) an e Wäert vun Ärer Wiel. Erstellt entspriechend Politik a Rollen fir nei Schlësselweeër. Mir maachen d'Bindungen spéider.
Benotzerdefinéiert Nummraum Test:
- Loosst eis eisen eegene Nummraum erstellen:
kubectl create namespace custom-ns- Loosst eis e Pod an eisem neien Nummraum erstellen. Schreift d'Konfiguratioun fir de Pod.
###poc-ubuntu-custom-ns.yaml
apiVersion: v1
kind: Pod
metadata:
name: poc-ubuntu-custom-ns
namespace: custom-ns
spec:
containers:
- name: poc-ubuntu-custom-ns
image: ubuntu
command: ["/bin/bash", "-ec", "sleep infinity"]
restartPolicy: Never- Erstellt ënner:
kubectl create -f poc-ubuntu-custom-ns.yaml- Wann de Container leeft, gitt dohinner an installéiert Curl.
kubectl exec poc-ubuntu-custom-ns -n custom-ns -it /bin/bash
apt-get update && apt-get install curl -y- Elo schécken mir eng Umeldungsufro un de Consul mat der Autorisatiounsmethod déi mir virdru erstallt hunn [].
- Fir den aginnen Token vun Ärem Servicekonto ze gesinn:
cat /run/secrets/kubernetes.io/serviceaccount/token- Schreift déi folgend op eng Datei am Container:
### payload.json
{
"AuthMethod": "auth-method-test",
"BearerToken": "<jwt_token>"
}- Login!
curl
--request POST
--data @payload.json
consul-ds-client.default.svc.cluster.local/v1/acl/login- Fir déi uewe genannte Schrëtt an enger Zeil ze kompletéieren (well mir e puer Tester lafen), kënnt Dir déi folgend maachen:
echo "{
"AuthMethod": "auth-method-skywiz-consul-poc",
"BearerToken": "$(cat /run/secrets/kubernetes.io/serviceaccount/token)"
}"
| curl
--request POST
--data @-
consul-ds-client.default.svc.cluster.local/v1/acl/login- Wierker! Op d'mannst soll et. Huelt elo d'SecretID a probéiert Zougang zu de Schlëssel / Wäert ze kréien, op dee mir Zougang sollten hunn.
curl
consul-ds-client.default.svc.cluster.local/v1/kv/custom-ns/test_key --header “X-Consul-Token: <SecretID_from_prev_response>”- Dir kënnt "Value" base64 decodéieren a kucken datt et mam Wäert an Custom-ns/test_key an der UI entsprécht. Wann Dir dee selwechte Wäert uewen an dësem Tutorial benotzt hutt, wier Äre kodéierte Wäert IkknbSBpbiB0aGUgY3VzdG9tLW5zIGZvbGRlciEi.
Benotzer Service Kont Test:
- Erstellt e personaliséierte ServiceAccount mat dem folgenden Kommando [].
kubectl apply -f - <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
name: custom-sa
EOF- Erstellt eng nei Konfiguratiounsdatei fir de Pod. Notéiert w.e.g. datt ech Curl Installatioun abegraff hunn fir Aarbecht ze spueren :)
###poc-ubuntu-custom-sa.yaml
apiVersion: v1
kind: Pod
metadata:
name: poc-ubuntu-custom-sa
namespace: default
spec:
serviceAccountName: custom-sa
containers:
- name: poc-ubuntu-custom-sa
image: ubuntu
command: ["/bin/bash","-ec"]
args: ["apt-get update && apt-get install curl -y; sleep infinity"]
restartPolicy: Never- Duerno lafen eng Schuel am Container.
kubectl exec -it poc-ubuntu-custom-sa /bin/bash- Login!
echo "{
"AuthMethod": "auth-method-skywiz-consul-poc",
"BearerToken": "$(cat /run/secrets/kubernetes.io/serviceaccount/token)"
}"
| curl
--request POST
--data @-
consul-ds-client.default.svc.cluster.local/v1/acl/login- Zougrëff verweigert. Oh, mir hu vergiess eng nei Reegelen ze addéieren déi mat de passenden Permissiounen bindend sinn, loosst eis dat elo maachen.
Widderhuelen déi vireg Schrëtt hei uewen:
a) Erstellt eng identesch Politik fir de Präfix "custom-sa/".
b) Erstellt eng Roll, nennt et "custom-sa-roll"
c) Befestegt d'Politik un d'Roll.
- Erstellt eng Regel-Bindung (nëmme méiglech vu cli / api). Notéiert déi verschidde Bedeitung vum Selektorfändel.
consul acl binding-rule create
-method=auth-method-skywiz-consul-poc
-bind-type=role
-bind-name='custom-sa-role'
-selector='serviceaccount.name=="custom-sa"'- Login erëm aus dem "poc-ubuntu-custom-sa" Container. Erfolleg!
- Préift eisen Zougang zum Custom-sa/ Schlësselwee.
curl
consul-ds-client.default.svc.cluster.local/v1/kv/custom-sa/test_key --header “X-Consul-Token: <SecretID>”- Dir kënnt och suergen datt dëst Token keen Zougang zu kv an "custom-ns/" gëtt. Widderhuelen Just de uewe genannte Kommando nodeems Dir "custom-sa" mam Präfix "custom-ns" ersat hutt.
Zougrëff verweigert.
Overlay Beispill:
- Et ass derwäert ze notéieren datt all reegelverbindleche Mappingen op den Token mat dëse Rechter bäigefüügt ginn.
- Eise Container "poc-ubuntu-custom-sa" ass am Standard Nummraum - also loosst eis et fir eng aner Regelverbindung benotzen.
- Widderhuelen virdrun Schrëtt:
a) Erstellt eng identesch Politik fir de "Standard /" Schlëssel Präfix.
b) Erstellt eng Roll, nennt se "Default-ns-Role"
c) Befestegt d'Politik un d'Roll. - Erstellt eng Regel-Bindung (nëmme méiglech vu cli / api)
consul acl binding-rule create
-method=auth-method-skywiz-consul-poc
-bind-type=role
-bind-name='default-ns-role'
-selector='serviceaccount.namespace=="default"'- Gitt zréck op eise "poc-ubuntu-custom-sa" Container a probéiert op den "Standard/" kv Wee ze kommen.
- Zougrëff verweigert.
Dir kënnt déi spezifizéiert Umeldungsinformatiounen fir all Token an der UI ënner ACL> Tokens kucken. Wéi Dir gesitt, ass eisen aktuellen Token nëmmen eng "Custom-sa-Roll" verbonnen. Den Token, dee mir am Moment benotzen, gouf generéiert wéi mir ageloggt sinn an et war nëmmen eng Regelverbindung, déi dann passt. Mir mussen erëm aloggen an den neien Token benotzen. - Vergewëssert Iech datt Dir vu béide "custom-sa/" an "Default/" kv Weeër liesen kann.
Succès!
Dëst ass well eis "poc-ubuntu-custom-sa" mat den "custom-sa" an "default-ns" Regelbindungen entsprécht.
Konklusioun
TTL Token mgmt?
Zu der Zäit vun dësem Schreiwen gëtt et keen integréierte Wee fir den TTL fir Tokens ze bestëmmen, déi vun dëser Autorisatiounsmethod generéiert ginn. Et wier eng fantastesch Geleeënheet fir eng sécher Automatisatioun vun der Consul Autorisatioun ze bidden.
Et gëtt eng Optioun fir manuell en Token mat TTL ze kreéieren:
Verfallszäit - D'Zäit wou dësen Token zréckgezunn gëtt. (Optional; dobäi am Consul 1.5.0)- Existéiert nëmme fir manuell Kreatioun / Update
Hoffentlech wäerte mir an der nächster Zukunft fäeg sinn ze kontrolléieren wéi Tokens generéiert ginn (pro Regel oder Autorisatiounsmethod) an TTL addéieren.
Bis dohinner gëtt proposéiert datt Dir e Logout Endpunkt an Ärer Logik benotzt.
Liest och aner Artikelen op eisem Blog:
Source: will.com