Einführung in OAuth und Streamlit
Willkommen zu einer schnellen Einführung in OAuth und Streamlit, zwei Schlüsseltechnologien, die in der modernen Web-App-Entwicklung eine große Rolle spielen.
OAuth: Standard für sichere Autorisierung
OAuth ist ein weit verbreiteter Autorisierungsstandard, der es Anwendungen erlaubt, auf Dienste im Namen eines Benutzers zuzugreifen, ohne dass dieser seine Zugangsdaten (wie ein Passwort) direkt preisgeben muss. Statt Benutzername und Passwort direkt zu verwenden, arbeitet OAuth mit Tokens, die spezifische Zugriffsrechte vergeben. Diese Methode erhöht die Sicherheit, da sie den Zugriff auf Benutzerdaten strikt kontrolliert und gleichzeitig das Risiko eines Passwortdiebstahls minimiert.
Streamlit: Leichtgewichtige Lösungen für Web-App-Entwicklung
Streamlit ist ein Open-Source-Framework, das die Entwicklung von Daten- und Analyse-Web-Apps vereinfacht. Es ermöglicht Entwicklern, mit wenigen Zeilen Python-Code visuell ansprechende und interaktive Web-Apps zu erstellen. Die Stärke von Streamlit liegt in seiner Einfachheit und der Fähigkeit, schnell Prototypen erstellen zu können, ohne sich in die Webentwicklung vertiefen zu müssen.
Integration von OAuth in Streamlit
Die Kombination von OAuth mit Streamlit ermöglicht es, sichere und personalisierte Benutzererfahrungen zu schaffen. Durch die Integration von OAuth in eine Streamlit-App kann der Entwickler den Benutzern sicheren Zugriff auf ihre Daten gewähren und gleichzeitig die App um Authentifizierungs- und Autorisierungsfunktionen erweitern. Diese Integration bedeutet, dass Benutzer ihre Daten in einer Streamlit-App sicher nutzen können, ohne sensible Informationen preiszugeben. Die Integration von OAuth in Streamlit-Apps stellt einen Schritt dar, um sowohl Sicherheit als auch Benutzerfreundlichkeit zu gewährleisten. Im Folgenden werden wir konkrete Implementierungsbeispiele und Best Practices untersuchen, um zu demonstrieren, wie Sie diese Technologien in Ihren eigenen Projekten effektiv nutzen können.
Grundlagen der Authentifizierung mit Azure und Streamlit für Entwickler
In diesem Abschnitt konzentrieren wir uns auf die technischen Grundlagen der Integration von Azure-basierter OAuth-Authentifizierung in Streamlit-Web-Apps.
Azure Active Directory (Azure AD) bietet OAuth 2.0‑Endpunkte, die Sie für die Authentifizierung in Ihren Anwendungen nutzen können. Durch die Verwendung von Azure AD zur Authentifizierung können Entwickler den Zugriff auf ihre Anwendungen sicher steuern und gleichzeitig die Identitätsverwaltung und den Schutz sensibler Informationen sicherstellen.
Der Authentifizierungsprozess mit OAuth 2.0 in Azure AD umfasst mehrere Schritte:
- Anforderung eines Autorisierungscodes: Die App leitet den Benutzer zu einem Azure AD-Login-Formular weiter. Nach erfolgreicher Authentifizierung wird ein Autorisierungstoken an Ihre App zurückgegeben.
- Einlösen des Autorisierungscodes: Die App sendet den erhaltenen Autorisierungstoken an Azure AD zurück, um Zugriffstokens zu erhalten.
- Zugriff auf geschützte Ressourcen: Mit dem Zugriffstoken kann die App im Namen des Benutzers auf geschützte Ressourcen zugreifen.
Streamlit-Integration
Streamlit ermöglicht es Entwicklern, schnell interaktive Web-Apps für Datenprojekte zu erstellen. Um OAuth-Authentifizierung in eine Streamlit-App zu integrieren, müssen Sie:
- Azure OAuth-Konfiguration vorbereiten: Registrieren Sie Ihre Anwendung in Azure AD, um die client_id, client_secret und tenant_id zu erhalten. Diese Werte sind für die Authentifizierung erforderlich.
- Authentifizierungs-Flow implementieren: Verwenden Sie die erhaltenen Konfigurationswerte, um den OAuth-Authentifizierungs-Flow in Ihrer Streamlit-App einzurichten. Dies beinhaltet zunächst die Erstellung eines Login-Buttons, der den Benutzer zur Azure AD-Anmelde-Seite weiterleitet. Anschließend erfolgt die Verarbeitung des Autorisierungscodes, den Azure AD nach erfolgreicher Anmeldung zurückgibt.
- Zugriffstoken nutzen: Nachdem Sie den Autorisierungstoken eingelöst haben, erhalten Sie ein Zugriffstoken. Verwenden Sie dieses Token, um im Namen des Benutzers auf geschützte Ressourcen zuzugreifen.
- Benutzerinterface aktualisieren: Integrieren Sie Logik in Ihre Streamlit-App, die das Benutzerinterface basierend auf dem Authentifizierungsstatus aktualisiert. Zeigen Sie beispielsweise bestimmte Informationen oder Funktionen nur authentifizierten Benutzern an.
Best Practices
- Sicherheit: Stellen Sie sicher, dass client_secret und andere sensible Informationen sicher gespeichert und nicht im Frontend-Code oder in öffentlich zugänglichen Bereichen exponiert werden.
- Benutzererfahrung: Implementieren Sie eine klare und intuitive Benutzerführung durch den Authentifizierungsprozess. Stellen Sie sicher, dass Benutzer verstehen, was passiert und warum bestimmte Berechtigungen erforderlich sind.
- Fehlerbehandlung: Entwickeln Sie robuste Fehlerbehandlungsmechanismen, um auf Probleme während des Authentifizierungsprozesses angemessen reagieren zu können.
Rollenbasierte Zugriffssteuerung in Streamlit-Apps mit Azure OAuth
Rollenbasierte Zugriffssteuerung (Role-Based Access Control, RBAC) ist ein entscheidender Bestandteil moderner Web-Anwendungen, um sicherzustellen, dass Benutzer nur Zugriff auf die für ihre Rolle erforderlichen Ressourcen und Funktionen haben.
Grundkonzept der RBAC
RBAC teilt Benutzern Rollen zu, basierend auf ihrer Funktion innerhalb der Organisation oder in der App. Jede Rolle ist mit bestimmten Berechtigungen verbunden, die den Zugriff auf Ressourcen und Aktionen in der App steuern. Dieser Ansatz vereinfacht die Verwaltung von Berechtigungen, da Sie lediglich die Rollen und deren Berechtigungen definieren und dann Benutzer diesen Rollen zuordnen müssen.
Implementierung in Azure und Streamlit
- Rollen Definition: Definieren Sie die verschiedenen Benutzerrollen und die zugehörigen Berechtigungen in Ihrer Anwendung. Dies kann auf verschiedene Arten geschehen, beispielsweise durch die Verwendung einer JSON-Datei, die die Rollen und ihre Berechtigungen abbildet, oder direkt in Azure AD.
- Azure AD Gruppen: Nutzen Sie Azure AD Gruppen, um Benutzern Rollen zuzuweisen. Erstellen Sie für jede Rolle in Ihrer App eine entsprechende Gruppe in Azure AD und fügen Sie Benutzer zu diesen Gruppen hinzu.
- Zugriff in Streamlit steuern: Innerhalb Ihrer Streamlit-App können Sie die Benutzeridentität und Gruppenmitgliedschaft prüfen, um zu bestimmen, welche Inhalte und Funktionen dem Benutzer angezeigt werden. Nutzen Sie das Zugriffstoken, das von Azure OAuth bereitgestellt wird, um die Zugehörigkeit zu Azure AD Gruppen abzurufen.
- Integration in den Authentifizierungsfluss: Integrieren Sie die Logik zur Überprüfung der Benutzerrollen und ‑berechtigungen nahtlos in den Authentifizierungsprozess. Nachdem ein Benutzer sich erfolgreich angemeldet hat, prüfen Sie seine Rolle(n) und passen Sie die Benutzeroberfläche und den Zugriff entsprechend an.
Best Practices für RBAC mit Azure OAuth in Streamlit
- Minimale Berechtigungen: Folgen Sie dem Prinzip der minimalen Berechtigungen, indem Sie Benutzern nur die Zugriffsrechte gewähren, die unbedingt für ihre Rolle benötigt werden.
- Dynamische Rollenprüfung: Implementieren Sie eine dynamische Rollenprüfung, die es ermöglicht, die Rollen und Berechtigungen der Benutzer bei Bedarf zu aktualisieren, ohne die Anwendung neu starten zu müssen.
- Sicherheit und Datenschutz: Achten Sie darauf, dass bei der Implementierung der RBAC und während des Authentifizierungsprozesses die Sicherheit und der Datenschutz der Benutzerdaten gewahrt bleiben.
- Durch die Anwendung von RBAC in Verbindung mit Azure OAuth können Sie eine sicherere und benutzerfreundlichere Streamlit-App erstellen. Dieser Ansatz ermöglicht es Ihnen, den Zugriff auf App-Funktionen präzise zu steuern und gleichzeitig eine skalierbare Lösung für die Zugriffsverwaltung zu bieten.
Praktische Anwendung: Integration von Azure OAuth in Streamlit
Die Einbindung von Azure OAuth in Streamlit eröffnet Entwicklern die Möglichkeit, ihre Web-Apps mit einer robusten Authentifizierung und rollenbasierten Zugriffssteuerung auszustatten. Im Folgenden wird anhand eines Beispiels erläutert, wie Azure OAuth für die Authentifizierung und Autorisierung innerhalb einer Streamlit-App verwendet werden kann.
Einrichtung der Azure_Oauth Klasse
Die Azure_Oauth Klasse bildet das Herzstück der Authentifizierung:
class Azure_Oauth:
def __init__(self, client_id, client_secret, tenant_id, subscriptionId, redirect_uri='http://localhost:8501/'):
self.client_id = client_id
self.client_secret = client_secret
self.tenant_id = tenant_id
self.subscriptionId = subscriptionId
self.redirect_uri = redirect_uri
self.auth_code = NoneDiese Klasse initialisiert die für die Authentifizierung notwendigen Parameter wie client_id, client_secret, und die tenant_id.
Authentifizierungslink generieren
Die Methode _get_auth_link erstellt den URL-Link zur Anmeldeseite von Microsoft:
def _get_auth_link(self, scope):
auth_link = f"https://login.microsoftonline.com/{self.tenant_id}/oauth2/v2.0/authorize?" + f"""
client_id={self.client_id}&
response_type=code&
redirect_uri={urllib.parse.quote(self.redirect_uri, safe="")}&
scope={urllib.parse.quote(scope[0], safe="")}&
form_post=query
""".replace("\n", "").replace(" ", "")
st_logger.info("Auth link: " + auth_link)
return auth_linkAnmeldebutton in Streamlit anzeigen
Mit show_login_button wird ein Anmeldebutton in der Streamlit-App eingefügt:
def show_login_button(self):
auth_link = self._get_auth_link(scope=["offline_access https://management.azure.com/.default"])
button = f"""<a href="{auth_link}" target="_blank">...Sign in with Microsoft...</a>"""
with st.sidebar:
st.components.v1.html(button, height=50)Benutzeranmeldung verarbeiten
Die Methode logged_in überprüft, ob der Benutzer angemeldet ist und verarbeitet den Anmeldestatus:
def logged_in(self):
if st.query_params.get("code") is not None:
self.auth_code = st.query_params.get("code")
st.query_params.clear()
st.session_state["userName"], st.session_state["ad_groups"] = self._get_user_information()
if st.session_state.get("logged_in", False):
with st.sidebar:
st.markdown(f"**Logged in as:** {st.session_state['userName']} <br>**Role:** {self.get_role().role_name}", unsafe_allow_html=True)
return True
return Falsewichtig ist es, die Informationen im Session State von Streamlit zu speichern, damit die Anwendung den Anmeldestatus des Benutzers über mehrere Seitenaufrufe hinweg verfolgen kann.
Nutzung der get_app_access_token Funktion
Die Funktion get_app_access_token(scope) ist entscheidend für das Anfordern eines Zugriffstokens von Azure AD. Das Token wird dann für autorisierte Anfragen an die Microsoft Graph API oder andere Azure-Dienste verwendet. Der Parameter scopes spezifiziert die Zugriffsberechtigungen, die die Anwendung anfordert. Zum Beispiel gibt https://graph.microsoft.com/.default der App allgemeine Berechtigungen zum Zugriff auf Nutzerdaten in Microsoft Graph.
def get_app_access_token(self, scope):
if not st.session_state.get("logged_in", False):
st_logger.error("User not logged in")
return None
if scope == st.session_state.get("app_current_scope") and \
st.session_state.get("app_access_token") is not None:
return st.session_state["app_access_token"]
data = {
"grant_type": "client_credentials",
"client_id": self.client_id,
"scope": scope,
"client_secret": self.client_secret
}
response = requests.post(
f"https://login.microsoftonline.com/{self.tenant_id}/oauth2/v2.0/token", data=data
)
st.session_state["app_access_token"] = response.json()["access_token"]
st.session_state["app_current_scope"] = scope
return st.session_state["app_access_token"]get_app_access_token speichert das Zugriffstoken im Session State von Streamlit, um es für spätere Anfragen zu verwenden, ohne es erneut anfordern zu müssen. Es kann immer nur ein Scope angefordert werden, bei Bedarf muss ein neues Token angefordert werden.
Abrufen der Azure AD Gruppen eines Nutzers
Sobald ein gültiges Zugriffstoken vorliegt, kann es verwendet werden, um Anfragen an die Microsoft Graph API zu autorisieren. Ein typisches Beispiel ist das Abrufen der Azure AD Gruppen, denen der Nutzer angehört. Dies ermöglicht es der Anwendung, rollenbasierte Zugriffskontrollen zu implementieren, indem sie den Zugriff basierend auf den Gruppenmitgliedschaften des Nutzers steuert.
Der folgende Code-Schnipsel illustriert, wie man die Azure AD Gruppen des angemeldeten Nutzers abruft, indem das Zugriffstoken in der Anfrage verwendet wird:
response_json_user_ad_groups = requests.get(
"https://graph.microsoft.com/v1.0/me/memberOf",
headers={"Authorization": "Bearer " + token}
)
st.session_state["ad_groups"] = [group["displayName"] for group in response_json_user_ad_groups.json()["value"]]Diese Methode ermöglicht es der Streamlit-App, dynamisch zu reagieren und bestimmte Inhalte oder Funktionen nur Benutzern innerhalb spezifischer Gruppen zugänglich zu machen.
Rollenbasierte Zugriffssteuerung in Streamlit
Die Rolle des Benutzers wird mit der Role Klasse definiert:
class Role:
def __init__(self, role_name: str, ad_group: str, has_access_to_app_resources: bool = False):
self.role_name = role_name
self.ad_group = ad_group
self.has_access_to_app_resources = has_access_to_app_resourcesDie Verwendung dieser Klasse ermöglicht es, den Zugriff innerhalb der Streamlit-App basierend auf der Benutzerrolle zu steuern.
Integration in Streamlit
Zur Nutzung der Authentifizierung in einer Streamlit-App wird die Azure_Oauth Klasse wie folgt instanziiert und verwendet:
app = Azure_Oauth(client_id, client_secret, tenant_id, subscriptionId, redirect_uri)
if app.logged_in():
user_role = app.get_role()
if user_role.has_access_to_app_resources:
# Hier kann der Code der App stehen, der nur für autorisierte Benutzer zugänglich sein soll
else:
st.markdown("#### Login required")
app.show_login_button()Dieser Ansatz stellt sicher, dass die Streamlit-App nur für authentifizierte Benutzer mit den entsprechenden Berechtigungen zugänglich ist.
Die get_role Methode der Azure_Oauth Klasse prüft die Gruppenmitgliedschaft des Benutzers und ordnet ihm die entsprechende Rolle zu:
def get_role(self):
if not st.session_state.get("logged_in", False):
st_logger.error("User not logged in")
return None
for role in [Role(**role) for role in self._get_role_dicts()]:
if role.ad_group in st.session_state["ad_groups"]:
return roleDie _get_role_dicts Methode liefert eine Liste von Rollen und den zugehörigen Azure AD Gruppen, die für die Rollenmitgliedschaft erforderlich sind.
Fazit und weiterführende Schritte
Die Integration von Azure OAuth in Streamlit ermöglicht Entwicklern sichere und personalisierte Web-Anwendungen mit Azure Active Directory für Authentifizierung und Zugriffssteuerung.
Unser Blog beschreibt präzise die Schritte zur Implementierung von Azure OAuth in Streamlit, von der Einrichtung der Azure_Oauth Klasse bis zur Verwaltung von Zugriffstokens und rollenbasierter Zugriffssteuerung, mit praktischen Code-Beispielen für jede Phase.
Besonders interessant ist die Nutzung von Azure AD Gruppen zur feingranularen Kontrolle über den App-Zugriff, basierend auf Benutzerrollen und Gruppenzugehörigkeit.
Für tiefere Einblicke bieten wir Python-Dateien mit vollständigem Integrationscode zum Download an, die als Ausgangspunkt für eigene Anwendungen dienen.
