Hinweis:

App-Gateway mit Oracle Analytics Server in OCI Identity and Access Management-Domains für Single Sign-On bereitstellen

Einführung

Wenn Sie Single Sign-On (SSO) für Oracle Analytics Server On Premise mit Oracle Cloud Infrastructure Identity and Access Management-(OCI IAM-)Domains implementieren möchten, wird empfohlen, das App-Gateway für SSO mit IAM-Domains für Oracle Analytics Server-Anwendungen einzurichten. Mit diesem Setup können Benutzer ihre IAM-Domainzugangsdaten verwenden und sich bei der Oracle Analytics Server-Anwendung anmelden.

Wichtige Vorteile

Ziele

Implementieren Sie SSO für den Zugriff auf Enterprise Oracle Analytics Server, und erfahren Sie, wie Sie das Docker-Image des App-Gateways für SSO mit IAM bereitstellen.

Voraussetzungen

  1. Oracle Apps Premium-SKU für IAM-Domains.

  2. Admin-Account für die IAM-Domain.

  3. Ein Rechner zum Ausführen des App-Gateways.

  4. Oracle Analytics Server-Anwendung. Wenn Sie keine Oracle Analytics Server-Anwendung haben, können Sie eine mit dem Marketplace-Image erstellen. Informationen hierzu finden Sie unter Oracle Analytics Server auf Oracle Cloud bereitstellen.

Aufgabe 1: Enterprise-Anwendung in IAM-Domain erstellen

Sie können eine Enterprise-Anwendung in einer IAM-Domain mit zwei Methoden erstellen:

Ansatz 1: Enterprise-Anwendung manuell über die Konsole erstellen

  1. Registrieren Sie die Enterprise-Anwendung in der IAM-Domain. Dies stellt Ihre Oracle Analytics Server-Anwendung dar. Geben Sie die erforderlichen Details an, um die Anwendung in der IAM-Domain zu registrieren und die SSO-Konfiguration zu bearbeiten. Sie können die Standardressource hinzufügen, um den Zugriff auf alle Ressourcen zuzulassen. Andernfalls können Sie jede Ressource manuell hinzufügen, um Zugriff auf bestimmte Ressourcen zu erhalten. Außerdem können Sie unter SSO mit Oracle Identity Cloud Service und App-Gateway konfigurieren die hinzuzufügenden Ressourcen prüfen.

    Bild 4

    Standardressource: /.*

    Bild 1

    Aktivieren Sie das Kontrollkästchen für CORS zulassen, Sichere Cookies erforderlich und Verwaltete Ressourcen hinzufügen.

    Bild 3

  2. Fügen Sie die Ressourcen zur Authentifizierungs-Policy hinzu. Fügen Sie die Standardressource hinzu, um alle Ressourcen abzudecken. Denken Sie beim Hinzufügen zur Authentifizierungs-Policy daran, den Header als iv-user hinzuzufügen und dem Benutzernamen zuzuordnen.

    Bild 2

Ansatz 2: Unternehmensanwendung über Python-Code erstellen

  1. Erstellen Sie eine vertrauliche Anwendung, und rufen Sie die Client-ID und das Client Secret ab, mit dem Sie dann einen REST-API-Aufruf an OCI IAM zum Abrufen von Zugriffstoken und nachfolgenden API-Endpunkten ausführen können. Informationen hierzu finden Sie unter Oracle Identity Cloud Service: Erster REST-API-Aufruf.

  2. Richten Sie die Konfigurationsdatei auf dem lokalen Rechner ein. Die Datei config.json enthält Informationen zur Identitätsdomain-URL, zur Client-ID und zum Client Secret, mit dem das Zugriffstoken generiert wird.

    {
"iamurl"         : "https://idcs-###########.identity.oraclecloud.com",
"client_id"      : "#######################",
"client_secret"  : "#######################"
}

  3. Generieren Sie das Zugriffstoken, mit dem Sie weitere REST-API-Aufrufe an die OCI-IAM-Endpunkte ausführen können.

    Im folgenden Code-Snippet nimmt die Funktion _get_encoded_ Client-ID und Client Secret als Argumente auf und gibt die base64-codierte Zeichenfolge zurück. Diese codierte Zeichenfolge wird weiter als Argument an die Funktion get_access_token als Autorisierungsheader übergeben, um das Zugriffstoken durch Ausführen einer POST-Anforderung abzurufen.

    #get base64 encoded
def get_encoded(self,clid, clsecret):
    encoded = clid + ":" + clsecret
    baseencoded = base64.urlsafe_b64encode(encoded.encode('UTF-8')).decode('ascii')
    return baseencoded

#get access token
def get_access_token(self,url, header):
    para = "grant_type=client_credentials&scope=urn:opc:idm:__myscopes__"
    response = requests.post(url, headers=header, data=para, verify=False)
    jsonresp = json.loads(response.content)
    access_token = jsonresp.get('access_token')
    return access_token

#print access token
def printaccesstoken(self):
    obj = IAM()
    encodedtoken = obj.get_encoded(clientID, clientSecret)
    extra = "/oauth2/v1/token"
    headers = {'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
            'Authorization': 'Basic %s' % encodedtoken, 'Accept': '*/*'}
    accesstoken = obj.get_access_token(idcsURL + extra, headers)
    return accesstoken

  4. Erstellen Sie eine Enterprise-Anwendung in der IAM-Domain mit dem folgenden Python-Code-Snippet.

    def createapplication(self):
    global clID
    global appID
    global resID1
    obj = IAM()
    obj.searchapps()
    accesstoken = obj.printaccesstoken()
    extra = "/admin/v1/Apps"
    headers = {'Accept': '*/*', 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + accesstoken}
    para = json.dumps({
    "schemas": [
        "urn:ietf:params:scim:schemas:oracle:idcs:App",
        "urn:ietf:params:scim:schemas:oracle:idcs:extension:samlServiceProvider:App",
        "urn:ietf:params:scim:schemas:oracle:idcs:extension:requestable:App",
        "urn:ietf:params:scim:schemas:oracle:idcs:extension:managedapp:App",
        "urn:ietf:params:scim:schemas:oracle:idcs:extension:webTierPolicy:App"
    ],
    "displayName": "OAS Enterprise App",
    "description": "New Enterprise Application for OAS",
    "landingPageURL": "http://150.xx.xx.xx:9502/analytics",
    "basedOnTemplate": {
        "value": "CustomEnterpriseAppTemplateId"
    },
    "isSamlServiceProvider": False,
    "isOAuthResource": False,
    "isOAuthClient": False,
    "showInMyApps": False,
    "isWebTierPolicy": False,
    "active": True,
    "isEnterpriseApp": True,
    "urn:ietf:params:scim:schemas:oracle:idcs:extension:requestable:App": {
    "requestable": False
    },
    "urn:ietf:params:scim:schemas:oracle:idcs:extension:webTierPolicy:App": {
    "webTierPolicyAZControl": "local"
    }
    })
    resp = requests.post(idcsURL + extra, headers=headers, verify=False, data=para)
    jsonresp = json.loads(resp.content)
    clID = jsonresp.get("name")
    #clSecret = jsonresp.get("clientSecret")
    appID = jsonresp.get("id")
    print("OAS Enterprise Application created with Client ID")
    print(clID)
    print("App ID of the created OAS Enterprise Application is :")
    print(appID)

    extra1 = "/admin/v1/AppResources"
    extra5 = "/admin/v1/Apps/"+appID
    headers1 = {'Accept': '*/*', 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + accesstoken}

    data= pd.read_csv("AppResourse.csv",delimiter=',')
    x=0  # For Reading the Data from the CSV file
    i=1  # For Providing the sequence vaule to the Web Policy

### This part of the code reads the data from CSV file adds the AppResource to the Enterprise application and also adds the Web Policy for all the added resources###

    for line in data.iterrows() :
        AppRsUrl=data.AppResourseURL[x] ## Take Application Resource URL as input from CSV file at xth Location
        ##print(AppRsUrl)
        metD=data.accessMode[x] ## Take Access method for Application Resource URL as input from CSV file at xth Location
        ResName=data.ResourceName[x] ## Take Application Resource Name as input from CSV file at xth Location
        para1 = json.dumps({
        "schemas": [
        "urn:ietf:params:scim:schemas:oracle:idcs:AppResource"
        ],
        "name": ResName,
        "resourceURL": AppRsUrl,
        "isRegex": True,
        "description": "OAS App Resourse",
        "app": {
            "value": appID
            }
        })
        resp1 = requests.request("POST",idcsURL + extra1, headers=headers1, verify=False, data=para1)
        ##print(resp1)
        jsonresp1 = json.loads(resp1.content)
        ##print(jsonresp1)
        resID1= jsonresp1.get("id")
        print("Resourse Added to the OAS Enterprise Application with ID")
        print(resID1)

        para3 = json.dumps({
        "schemas":[
        "urn:ietf:params:scim:api:messages:2.0:PatchOp"
        ],
        "Operations":[
        {
        "op":"add",
        "path":"urn:ietf:params:scim:schemas:oracle:idcs:extension:enterpriseApp:App:appResources",
        "value":[
            {
            "value":resID1
            }
        ]}]})

        resp3 = requests.request("PATCH",idcsURL + extra5, headers=headers1, verify=False, data=para3)
        # print(resp3)
        # jsonresp3 = json.loads(resp3.content)
        # print(jsonresp3)

### Based on the Access Mode the Web Policy will be generated###

        if metD=="oauth":
            jsonBody= "{\"filter\":\""+AppRsUrl+"\",\"headers\":[{\"iv-user\":\"$subject.user.userName\"}],\"comment\":\"abc\",\"resourceRefId\": \""+resID1+"\",\"resourceRefName\":\""+ResName+"\",\"type\":\"regex\",\"sequence\":\""+str(i)+"\",\"method\":\"oauth\"}"+","
        else:
            jsonBody= "{\"filter\":\""+AppRsUrl+"\",\"comment\":\"abc\",\"resourceRefId\": \""+resID1+"\",\"resourceRefName\":\""+ResName+"\",\"type\":\"regex\",\"sequence\":\""+str(i)+"\",\"method\":\"public\"}"+","
        ##print(jsonBody)
        x=x+1
        i=i+1

        with open('data.json', 'a') as f:
            json.dump(jsonBody, f)

## construct the payload for webtier and send it as a Json Body to the REST call###

    with open('data.json', 'r') as file: ## Temp json file to hold the payload before getting formated
        data = file.read()
        data1=data.replace('""','')
        ##print(data1)
    with open('formatedData.json', 'a') as file1: ## Actual json file to hoad the payload for the REST call to PATCH WebPolicy
        file1.writelines('{ \n')
        file1.writelines('"schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"],\n')
        file1.writelines('"Operations": [\n')
        file1.writelines('{"op": "add",\n')
        file1.writelines('"path": "urn:ietf:params:scim:schemas:oracle:idcs:extension:webTierPolicy:App:webTierPolicyJson",\n')
        file1.writelines(R'"value":"{\"cloudgatePolicy\":{\"version\":\"2.6\",\"requireSecureCookies\":true,\"allowCors\":true,\"disableAuthorize\":true,\"webtierPolicy\":[{\"policyName\":\"default\",\"comment\":\"Webtier policy\",\"resourceFilters\":[')
        data2=re.sub(r'.', '', data1, count = 1)
        data3=data2.rstrip(data2[-1])
        data4=data3.rstrip(data3[-1])
        file1.write(data4)
        file1.write(']}]}}"}]}')
        os.remove("data.json")

### REST API Call to PATCH the Web Policy to the created Enterprise Application###

    extra2 = "/admin/v1/Apps/"+appID
    headers2 = {'Accept': '*/*', 'Content-Type': 'application/scim+json', 'Authorization': 'Bearer ' + accesstoken}
    param = {'attributes': "urn:ietf:params:scim:schemas:oracle:idcs:extension:webTierPolicy:App:webTierPolicyJson,urn:ietf:params:scim:schemas:oracle:idcs:extension:webTierPolicy:App:webTierPolicyAZControl,urn:ietf:params:scim:schemas:oracle:idcs:extension:webTierPolicy:App:resourceRef"}
    webPolicy = json.load(open('formatedData.json'))
    payload = json.dumps(webPolicy)
    resp7 = requests.request("PATCH",idcsURL + extra2, headers=headers2, verify=False, data=payload, params=param)
    jsonresp7 = json.loads(resp7.content)
    ##print(resp7)
    ##print(jsonresp7)
    print("The OAS Enterprise Application has been PATCH with the WebPolicy for all the added Resources")
    os.remove("formatedData.json")

  5. Sie benötigen eine csv-Datei mit allen Ressourcen, die mit dem obigen Code-Snippet erstellt werden sollen. Hier ist der Link zur Ressource AppResources.csv.

Hinweis: Stellen Sie sicher, dass Python 3.x auf Ihrem System und die Python-Packages urllib3, requests und pandas installiert sind, um das obige Code-Snippet zu verwenden. Außerdem dient das obige Code-Snippet nur zu Referenzzwecken und Sie können auch Ihre eigene Logik erstellen, um dasselbe zu erreichen.

Aufgabe 2: App-Gateway in IAM-Domain erstellen

  1. Erstellen Sie das App-Gateway in der IAM-Domain auf der Registerkarte Sicherheit. Geben Sie die erforderlichen Details an, um die Konfiguration abzuschließen. Details zum Registrieren des App-Gateways sind Name des App-Gateways und Host. Dabei handelt es sich um die öffentliche IP des Rechners, auf dem Sie das App-Gatewayimage bereitstellen möchten. Aktivieren Sie das Kontrollkästchen SSL aktiviert, und fügen Sie das Zertifikat im Abschnitt Zusätzliche Eigenschaften hinzu, das Sie für das App-Gateway im folgenden Format verwenden möchten. Fügen Sie den korrekten Pfad des Zertifikats im App-Gateway hinzu.

    ssl_certificate /usr/local/nginx/conf/server.crt;
ssl_certificate_key /usr/local/nginx/conf/server.key;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers HIGH:!aNULL:!MD5;

    Bild 7

    Hinweis: Sie können das öffentliche SSL-Zertifikat für den obigen Schritt verwenden. Wenn Sie über kein öffentliches Zertifikat verfügen, können Sie auch das selbstsignierte Zertifikat verwenden. Sie können das selbstsignierte Zertifikat mit dem folgenden openSSL-Befehl generieren.

    openssl req -x509 -newkey rsa:4096 -keyout /home/opc/certs/key.pem -out /home/opc/certs/cert.pem -sha256 -days 3650 -nodes -subj "/C=US/ST=Florida/L=Miami/O=Oracle/OU=Cloud/CN=oracle"

  2. Fügen Sie die Enterprise-Anwendung im App-Gateway hinzu, das wir im ersten Schritt als Apps registriert haben. Wählen Sie die Enterprise-App aus, die Sie unter Anwendung erstellt haben, und wählen Sie unter Host auswählen die Option Host aus. Geben Sie das Ressourcenpräfix als / und unter Ursprungsserver die URL für Oracle Analytics Server an, und speichern Sie die Änderungen.

    Bild 8

Aufgabe 3: Docker-Image des App-Gateways bereitstellen

  1. Laden Sie das Dockerimage des App-Gateways herunter. Klicken Sie in der IAM-Domain im linken Menü auf Einstellungen und dann auf Downloads. Laden Sie das App-Gateway-Docker-Image für Identity Cloud Service und das App-Gateway-Wallet-Tool herunter. Bewahren Sie das Docker-Image und das Wallet-Tool des App-Gateways in separaten Verzeichnissen auf. Beispiel: /home/opc/appgateway für App-Gateway und /home/opc/cwallet für Wallet-Tool.

  2. Erstellen Sie eine Wallet-Datei mit der Client-ID und dem Client Secret des App-Gateway, das in der IAM-Domain erstellt wurde. Führen Sie die folgenden Schritte aus, um die Wallet-Datei zu erstellen.

    env LD_LIBRARY_PATH=./lib ./cgwallettool --create -i **ClientID of AppGateway in IAM Domain**.

    Hinweis: Wenn Sie den obigen Befehl ausführen, wird das Client Secret des App-Gateways angefordert. Mit diesen Schritten wird die Datei cwallet.sso für das App-Gateway erstellt.

    Bild 9

  3. Installieren Sie Docker auf dem Rechner für das App-Gateway mit den folgenden Befehlen.

    sudo yum-config-manager --disable ol7_UEKR3 ol7_UEKR4
sudo yum-config-manager --enable ol7_UEKR5
sudo yum-config-manager --enable ol7_addons
sudo yum install docker-engine docker-cli -y
sudo systemctl enable --now docker
sudo systemctl status docker
sudo docker info
sudo usermod -a -G docker $USER

    Hinweis: Wir haben Oracle Linux 7 für die Konfiguration des Docker-Images des App-Gateways verwendet.

  4. Sie können das Zertifikat jeder vertrauenswürdigen öffentlichen Certificate Authority verwenden oder das selbstsignierte Zertifikat auch mit openSSL erstellen. Beispiel für ein selbst-signiertes Zertifikat:

    openssl req -x509 -newkey rsa:4096 -keyout /home/opc/certs/key.pem -out /home/opc/certs/cert.pem -sha256 -days 3650 -nodes -subj "/C=US/ST=Florida/L=Miami/O=Oracle/OU=Cloud/CN=oracle"

  5. Da das Docking-Image das Format tar.gz aufweist, müssen wir das Image extrahieren, um den Docking-Container mit dem folgenden Schritt zu erstellen. Laden Sie die tar.gz-Datei mit dem folgenden Befehl in die lokale Docker-Registry:

    $ docker load -i **filename.tar.gz**

Aufgabe 4: ENV-Datei für App-Gateway erstellen

  1. Um den Docker-Container des App-Gateways auszuführen, müssen die folgenden Umgebungsvariablen in der Datei appgateway-env festgelegt sein. CG_APP_TENANT=<tenant name> IDCS_INSTANCE_URL=<idcs instance url>. Die URL, die für den Zugriff auf die Identity Cloud Service-Instanz erforderlich ist. NGINX_DNS_RESOLVER=<resolver ip>.

    Hinweis Führen Sie das nslookup der IAM-Domain-URL und der Server-IP aus.

  2. Führen Sie Docker mit dem folgenden Befehl aus.

    sudo docker run -it -p 4443:4443 --name appgateway --env-file /home/opc/AppgwDocker/appgateway-env --env HOST_MACHINE=`hostname -f` --volume /home/opc/cwallet.sso:/usr/local/nginx/conf/cwallet.sso --volume /home/opc/server.key:/usr/local/nginx/conf/server.key --volume /home/opc/server.crt:/usr/local/nginx/conf/server.crt --net=host idcs/idcs-appgateway:23.2.92-2301160723

  3. Starten Sie den Docker mit den folgenden Befehlen neu:

    docker stop conatiner_ID
docker start conatiner_ID

Aufgabe 5: Identity Asserter auf dem Oracle Analytics Server-Server WebLogic erstellen

  1. Melden Sie sich als Administrator bei der Admin-Konsole des WebLogic-Servers an.

  2. Navigieren Sie zum myrealm und zu Provider. Erstellen Sie OAMIdentityAsserter als Provider.

    Bild 10

  3. Nachdem Sie den Provider erstellt haben, bearbeiten Sie ihn, um das Kontroll-Flag in Erforderlich zu ändern, und wählen Sie unter Aktive Typen den Wert iv-user aus.

    Bild 11

  4. Legen Sie den iv-user in den Providerspezifischen Eigenschaften unter SSOHeader Name fest, und klicken Sie auf Speichern.

    Bild 12

  5. Ordnen Sie die Mitarbeiterliste neu an, und behalten Sie den neu erstellten Mitarbeiter im Vordergrund.

  6. Starten Sie den WebLogic-Server mit dem folgenden Skript neu.

    sudo su oracle
cd /u01/data/domains/bi/bitools/bin
./stop.sh
./start.sh

  7. Sobald der Server wieder hochgefahren ist, können Sie SSO testen.

Aufgabe 6: SSO testen

Testen Sie SSO, indem Sie auf die App-Gateway-URL https://AppGateway.example.com:4443/analytics zugreifen. Der Benutzer wird zur Authentifizierung zur OCI-IAM-Identitätsdomain umgeleitet. Nach erfolgreicher Authentifizierung erhält der Benutzer basierend auf seiner Rolle Zugriff auf Oracle Analytics Server.

Hinweis: AppGateway.example.com dient hier als Referenz. Verwenden Sie die korrekte URL gemäß Ihrer Umgebung, und stellen Sie sicher, dass Sie das richtige DNS-Routing dafür haben.

Danksagungen

Weitere Lernressourcen

Lernen Sie andere Übungen auf docs.oracle.com/learn kennen, oder greifen Sie auf weitere kostenlose Lerninhalte im Oracle Learning YouTube Channel zu. Besuchen Sie außerdem education.oracle.com/learning-explorer, um Oracle Learning Explorer zu werden.

Produktdokumentation finden Sie im Oracle Help Center.