Note:

Este tutorial requiere acceso a Oracle Cloud. Para registrarse en una cuenta gratuita, consulte Introducción a la cuenta gratuita de Oracle Cloud Infrastructure.
Utiliza valores de ejemplo para credenciales, arrendamiento y compartimentos de Oracle Cloud Infrastructure. Al finalizar el laboratorio, sustituya estos valores por otros específicos del entorno en la nube.

Despliegue del gateway de aplicación con Oracle Analytics Server en dominios de gestión de identidad y acceso de OCI para conexión única

Introducción

Si desea implantar la conexión única (SSO) para Oracle Analytics Server local mediante dominios de Oracle Cloud Infrastructure Identity and Access Management (OCI IAM), recomendamos configurar el gateway de aplicación para SSO con dominios de IAM para la aplicación Oracle Analytics Server. Esta configuración permitirá a los usuarios utilizar sus credenciales de dominio de IAM y conectarse a la aplicación Oracle Analytics Server.

Ventajas Clave

El usuario puede utilizar las credenciales almacenadas en los dominios de IAM.
El usuario también puede aprovechar el proveedor de identidad (IDP) de 3a parte federado con el dominio de IAM.

Objetivos

Implante SSO para acceder a Enterprise Oracle Analytics Server y aprenda a desplegar la imagen de docker del gateway de aplicación para SSO con IAM.

Requisitos

SKU premium de Oracle Apps para dominios de IAM.
Cuenta de administrador para el dominio de IAM.
Máquina para ejecutar el gateway de aplicación.
Aplicación de Oracle Analytics Server. Si no tiene una aplicación de Oracle Analytics Server, puede crear una con la imagen de Marketplace. Consulte Despliegue de Oracle Analytics Server en Oracle Cloud.

Tarea 1: Creación de una aplicación empresarial en un dominio de IAM

Puede crear una aplicación empresarial en un dominio de IAM mediante dos enfoques:

Enfoque 1: Creación manual de la aplicación empresarial a través de la consola

Registre la aplicación de empresa en el dominio de IAM. Esto representará la aplicación Oracle Analytics Server. Proporcione los detalles necesarios para registrar la aplicación en el dominio de IAM y editar la configuración de SSO. Puede agregar el recurso por defecto para permitir el acceso a todos los recursos; de lo contrario, puede agregar cada recurso manualmente para obtener acceso a recursos específicos. Además, puede comprobar Configurar SSO con Oracle Identity Cloud Service y el gateway de aplicación para conocer los recursos que desea agregar.

Recurso por defecto: /.*

Marque la casilla Permitir CORS, Requerir cookies seguras y Agregar recursos gestionados.
Agregue los recursos a la política de autenticación. Agregue el recurso predeterminado para cubrir todos los recursos. Al agregarla para la política de autenticación, recuerde agregar la cabecera como iv-user y asignarla al User Name (Nombre de usuario).

Enfoque 2: Creación de la aplicación empresarial mediante código Python

Cree una aplicación confidencial y recupere el ID de cliente y el secreto de cliente, que se pueden utilizar para realizar una llamada de API de REST a OCI IAM para recuperar el token de acceso y los puntos finales de API posteriores. Consulte Oracle Identity Cloud Service: primera llamada de API de REST.
Configure el archivo de configuración en la máquina local. El archivo config.json tiene información sobre la URL del dominio de identidad, el ID de cliente y el secreto de cliente que se utiliza para generar el token de acceso.
```
{
"iamurl"         : "https://idcs-###########.identity.oraclecloud.com",
"client_id"      : "#######################",
"client_secret"  : "#######################"
}
```

Genere el token de acceso, que se puede utilizar para realizar más llamadas a la API de REST a los puntos finales de OCI IAM.

En el siguiente fragmento de código, la función _get_encoded_ toma el ID de cliente y el secreto de cliente como argumentos y devuelve la cadena codificada base64. Esta cadena codificada se transfiere como argumento a la función get_access_token como cabecera de autorización para obtener el token de acceso mediante una solicitud POST.

#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

Cree la aplicación Enterprise en el dominio de IAM mediante el siguiente fragmento de código de Python.

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")

Necesitará un archivo csv que contenga todos los recursos que se van a crear mediante el fragmento de código anterior. Este es el enlace al recurso AppResources.csv.

Nota: Asegúrese de que tiene instalado Python 3.x en el sistema y los paquetes Python urllib3, requests y pandas también para utilizar el fragmento de código anterior. Además, el fragmento de código anterior es solo para fines de referencia y también puede crear su propia lógica para lograr lo mismo.

Tarea 2: Creación de gateway de aplicación en dominio de IAM

Cree el gateway de aplicación en el dominio de IAM en el separador Seguridad. Proporcione los detalles necesarios para completar la configuración. Los detalles necesarios para registrar el gateway de aplicación son el nombre del gateway de aplicación y el host, que es la IP pública de la máquina en la que desea desplegar la imagen del gateway de aplicación. Seleccione la casilla de control SSL activado y agregue el certificado en la sección Propiedades adicionales que va a utilizar para el gateway de aplicación con el siguiente formato. Agregue la ruta correcta del certificado en el gateway de aplicación.
```
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;
```
Nota: Puede utilizar el certificado SSL público para el paso anterior y, si no tiene ningún certificado público, también puede utilizar el certificado autofirmado. Puede generar el certificado autofirmado con el siguiente comando openSSL.
```
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"
```
Agregue la aplicación Enterprise en el gateway de aplicación que hemos registrado en el primer paso como Aplicaciones. Seleccione la aplicación empresarial que ha creado en Aplicación, seleccione Host en Seleccionar un Host. Proporcione el prefijo de recurso como / y, en Servidor de origen, proporcione la URL para Oracle Analytics Server y guarde los cambios.

Tarea 3: Despliegue de la imagen de Docker del gateway de aplicación

Descargue la imagen de docker del gateway de aplicación. En Dominio de IAM, en el menú de la izquierda, haga clic en Configuración y, a continuación, en Descargas. Descargue la imagen de Docker de gateway de aplicación para Identity Cloud Service y la herramienta Cartera de gateway de aplicación. Mantenga la herramienta Imagen y cartera de Docker del gateway de aplicación en directorios independientes. Por ejemplo: /home/opc/appgateway para el gateway de aplicación y /home/opc/cwallet para la herramienta Cartera.
Cree un archivo de cartera que contenga el identificador de cliente y el secreto de cliente del gateway de aplicación que se creó en el dominio de IAM. Utilice los siguientes pasos para crear el archivo de cartera.
```
env LD_LIBRARY_PATH=./lib ./cgwallettool --create -i **ClientID of AppGateway in IAM Domain**.
```
Nota: al ejecutar lo anterior, solicitará Secreto de cliente del gateway de aplicación. Estos pasos crearán el archivo cwallet.sso para el gateway de aplicación.

Instale Docker en la máquina del gateway de aplicación mediante los siguientes comandos.

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

Nota: Hemos utilizado Oracle Linux 7 para configurar la imagen de docker del gateway de aplicación.

Puede utilizar el certificado de cualquier autoridad de certificación pública de confianza o crear el certificado autofirmado también mediante openSSL. El ejemplo de certificado autofirmado es el siguiente:
```
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"
```
Como la imagen de docker tiene el formato tar.gz, necesitamos extraer la imagen para crear el contenedor de docker con el siguiente paso. Cargue el archivo tar.gz en el registro de Docker local mediante el siguiente comando:
```
$ docker load -i **filename.tar.gz**
```

Tarea 4: Crear archivo ENV de gateway de aplicación

Para ejecutar el contenedor Docker de gateway de aplicación, se deben definir las siguientes variables de entorno en el archivo appgateway-env. CG_APP_TENANT=<tenant name> IDCS_INSTANCE_URL=<idcs instance url>. URL necesaria para acceder a la instancia de Identity Cloud Service. NGINX_DNS_RESOLVER=<resolver ip>.

Nota Realice nslookup de la URL de dominio de IAM y la IP de servidor será el valor que necesite.

Ejecute Docker con el comando siguiente.

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

Reinicie el docker con los siguientes comandos:

docker stop conatiner_ID
docker start conatiner_ID

Tarea 5: Crear afirmación de identidad en el servidor WebLogic de Oracle Analytics Server

Inicie sesión como administrador en la consola de administración del servidor WebLogic.
Vaya a myrealm y a Providers. Cree OAMIdentityAsserter como proveedor.
Después de crear el proveedor, edite el mismo para cambiar el indicador de control a Necesario y, a continuación, seleccione los tipos activos como iv-user.
Defina iv-user en las propiedades Provider Specific en SSOHeader Name y haga clic en Save.
Reordene la lista de profesionales asistenciales y mantenga el profesional asistencial recién creado en la parte superior.
Reinicie el servidor WebLogic mediante el script como se muestra a continuación.
```
sudo su oracle
cd /u01/data/domains/bi/bitools/bin
./stop.sh
./start.sh
```
Una vez que el servidor vuelva a estar activo, estará listo para probar SSO.

Tarea 6: Prueba del SSO

Pruebe la SSO accediendo a la URL de gateway de aplicación https://AppGateway.example.com:4443/analytics, redirigirá al usuario al dominio de identidad de OCI IAM para la autenticación y, después de la autenticación correcta, el usuario obtendrá acceso a Oracle Analytics Server según su rol.

Nota: AppGateway.example.com es una referencia aquí, utilice la URL correcta según su entorno y asegúrese de tener el enrutamiento de DNS correcto para ella.

Agradecimientos

Autor: Sagar Takkar (Arquitecto Superior de Seguridad)

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de aprendizaje gratuito en el canal YouTube de Oracle Learning. Además, visite education.oracle.com/learning-explorer para convertirse en Oracle Learning Explorer.

Para obtener documentación sobre el producto, visite Oracle Help Center.

Título e Información de Copyright

Deploy App Gateway with Oracle Analytics Server on OCI Identity and Access Management Domains for Single Sign-On

F88066-01

October 2023