Acceso autenticado mediante una aplicación

Requisitos previos

• Se han preparado los datos. Específicamente, ha creado una aplicación de IA en el estado Normal de ModelArts.
• La cuenta no está en mora para garantizar los recursos disponibles para la ejecución del servicio.
• Se ha obtenido la ruta local al archivo de inferencia. La ruta puede ser una ruta absoluta (por ejemplo, D:/test.png para Windows y /opt/data/test.png para Linux) o una ruta relativa (por ejemplo, ./test.png).

Habilitación de la autenticación de aplicaciones

Al desplegar una aplicación de IA como servicio en tiempo real, puede habilitar la autenticación de aplicaciones. También puede modificar un servicio en tiempo real desplegado para admitir la autenticación de aplicaciones.

1. Inicie sesión en la consola de gestión de ModelArts y elija Service Deployment > Real-Time Services.
2. Habilite la autenticación de aplicaciones.
   • Al desplegar un modelo como servicio en tiempo real, configure los parámetros necesarios y habilite la autenticación de aplicaciones en la página Deploy.
   • Para un servicio en tiempo real desplegado, vaya a la página Real-Time Services y haga clic en Modify en la columna Operation del servicio. En la página de modificación de servicio que se muestra, habilite la autenticación de aplicaciones.
     Figura 1 Habilitación de la autenticación de aplicaciones
     
3. Seleccione una solicitud de autorización en la lista desplegable. Si no hay ninguna aplicación disponible, cree una de la siguiente manera:
   • Haga clic en Create Application a la derecha, introduzca el nombre y la descripción de la aplicación y haga clic en OK. De forma predeterminada, el nombre de la aplicación comienza con app_. Puede cambiar el nombre de la aplicación.
   • En la página Service Deployment > Real-Time Services, haga clic en Authorize. En la página Manage Authorization of Real-Time Services, haga clic en Create Application. Para más detalles, véase Gestión de la autorización de servicios en tiempo real.
4. Después de habilitar la autenticación de aplicaciones, autorice un servicio que admita la autenticación de aplicaciones en la aplicación. A continuación, puede usar AppKey/AppSecret o AppCode generados para invocar a la API del servicio que admite la autenticación de aplicaciones.

Gestión de la autorización de servicios en tiempo real

Si desea utilizar la autenticación de aplicaciones, es una buena práctica crear una aplicación en la página de gestión de autorizaciones antes de desplegar un servicio en tiempo real. En el panel de navegación, seleccione Service Deployment > Real-Time Services. En la página Real-Time Services, haga clic en Authorize. Aparecerá el cuadro de diálogo Manage Authorization of Real-Time Services. Desde allí, puede crear y gestionar aplicaciones, incluida la visualización, el restablecimiento y la eliminación de aplicaciones, la desvinculación de servicios en tiempo real de las aplicaciones y la obtención de AppKey/AppSecret o AppCode.

Figura 2 Gestión de la autorización para servicios en tiempo real

• Crear una aplicación

  Haga clic en Create Application, introduzca el nombre y la descripción de la aplicación y haga clic en OK. Por defecto, el nombre de la aplicación comienza con app_. Puede cambiar el nombre de la aplicación.

• Consultar, restablecer o eliminar una aplicación

  Consultar, restablecer o eliminar una aplicación haciendo clic en el icono correspondiente en la columna Operation de la aplicación. Después de crear una aplicación, la AppKey y la AppSecret se generan automáticamente para la autenticación de la aplicación.

• Desvincular un servicio

  Delante del nombre de la aplicación de destino, haga clic en para ver los servicios en tiempo real asociados a la aplicación. Haga clic en Unbind en la columna Operation para cancelar la asociación. Entonces, esta API no se puede invocar.

• Obtenerlas AppKey/AppSecret o AppCode

  La autenticación de la aplicación es necesaria para las invocaciones a la API. Las AppKey y AppSecret se generan automáticamente durante la creación de la aplicación. Haga clic en en la columna Operation de la aplicación en el cuadro de diálogo Manage Authorization of Real-Time Services para ver la AppSecret completa. Haga clic en delante del nombre de la aplicación para expandir la lista desplegable. Haga clic en +Add AppCode para generar un AppCode automáticamente. Luego, haga clic en en la columna Operation para ver el AppCode completo.

  Figura 3 Agregar el AppCode
  

Autenticación de aplicaciones

Cuando un servicio en tiempo real que admite la autenticación de aplicaciones está en estado Running, se puede invocar a la API del servicio. Antes de invocar a la API, realice la autenticación de la aplicación.

Cuando se utiliza la autenticación de aplicaciones y se habilita el modo de autenticación simplificada, puede usar las AppKey/AppSecret para la firma y la verificación, o AppCode para la autenticación simplificada de solicitudes de API. (ModelArts utiliza la autenticación simplificada de forma predeterminada.) Se recomienda la autenticación basada en AppKey/AppSecret porque es más segura que la autenticación basada en AppCode.

• AppKey/AppSecret-based authentication: Las AppKey y AppSecret se utilizan para cifrar una solicitud, identificar al remitente y evitar que se modifique la solicitud. Cuando utilice la autenticación basada en AppKey/AppSecret, utilice un SDK de firma dedicado para firmar solicitudes.
  • AppKey: ID de clave de acceso de la aplicación, que es un identificador único utilizado junto con una clave de acceso secreta para firmar solicitudes criptográficamente.
  • AppSecret: clave de acceso secreta de la aplicación, utilizada junto con el ID de clave de acceso para cifrar la solicitud, identificar al remitente y evitar que la solicitud sea templada.

  AppKeys se puede utilizar para la autenticación simplificada. Cuando se invoca a una API, se agrega el parámetro apikey (valor:AppKey) al encabezado de solicitud de HTTP para acelerar la autenticación.

• AppCode-based authentication: Requests are authenticated using AppCodes.

  En la autenticación basada en AppCode, se agrega el parámetro X-Apig-AppCode (valor: AppCode)al encabezado de solicitud de HTTP cuando se llama a una API. No es necesario firmar el contenido de la solicitud. El gateway de API solo verifica el AppCode y logra una respuesta rápida.

Puede obtener la API, AppKey/AppSecret y AppCode desde la pestaña Guías de uso en la página de detalles del servicio (véase Figura 4) o desde la página de gestión de autorizaciones de servicio en tiempo real (véase Figura 2). Utilice la URL de la API en el cuadro rojo de la siguiente figura. Si se define una ruta para apis en el archivo de configuración del modelo, la URL debe ir seguida de la ruta definida por el usuario, por ejemplo, {URL of the real-time service}/predictions/poetry.

Figura 4 Obtención de la dirección de API

Método 1: Utilice Python para enviar una solicitud de inferencia a través de la autenticación basada en AppKey/AppSecret

1. Descargue el SDK de Python y configúrelo en la herramienta de desarrollo. Para obtener más información, consulte Integración del SDK de Python para la firma de solicitudes de API.
2. Cree un cuerpo de solicitud para inferencia.
   • Ingreso de archivo

     1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

     # coding=utf-8 import requests from apig_sdk import signer if __name__ == '__main__': # Config url, ak, sk and file path. url = "URL of the real-time service" app_key = "AppKey" app_secret = "AppSecret" file_path = "Local path to the inference file" # Create request, set method, url, headers and body. method = 'POST' headers = {"x-sdk-content-sha256": "UNSIGNED-PAYLOAD"} request = signer.HttpRequest(method, url, headers) # Create sign, set the AK/SK to sign and authenticate the request. sig = signer.Signer() sig.Key = app_key sig.Secret = app_secret sig.Sign(request) # Send request files = {'images': open(file_path, 'rb')} resp = requests.request(request.method, request.scheme + "://" + request.host + request.uri, headers=request.headers, files=files) # Print result print(resp.status_code) print(resp.text)

     Formato del cuerpo de la solicitud de files: files = {"Request parameter": ("Load path", File content, "File type")}. Para obtener detalles sobre los parámetros de files, véase Tabla 1.

     Tabla 1 Parámetros de files

     Parámetro	Obligatorio	Descripción
     Request parameter	Sí	Nombre del parámetro del servicio en tiempo real.
     Load path	No	Ruta de acceso en la que se almacena el archivo.
     File content	Sí	Contenido del archivo que se va a cargar.
     File type	No	Tipo del archivo que se va a cargar, que puede ser una de las siguientes opciones: txt: texto/plano jpg/jpeg: imagen/jpeg png: imagen/png

   • Ingreso de texto (JSON)

     A continuación se muestra un ejemplo del cuerpo de la solicitud para leer el archivo de inferencia local y realizar la codificación Base64:

     # coding=utf-8
     
     import base64
     import json
     import requests
     from apig_sdk import signer
     
     if __name__ == '__main__':
         # Config url, ak, sk and file path.
         url = "URL of the real-time service"
         app_key = "AppKey"
         app_secret = "AppSecret"
         file_path = "Local path to the inference file"
         with open(file_path, "rb") as file:
             base64_data = base64.b64encode(file.read()).decode("utf-8")
     
         # Create request, set method, url, headers and body.
         method = 'POST'
         headers = {
             'Content-Type': 'application/json'
         }
         body = {
             'image': base64_data
         }
         request = signer.HttpRequest(method, url, headers, json.dumps(body))
     
         # Create sign, set the AppKey&AppSecret to sign and authenticate the request.
         sig = signer.Signer()
         sig.Key = app_key
         sig.Secret = app_secret
         sig.Sign(request)
     
         # Send request
         resp = requests.request(request.method, request.scheme + "://" + request.host + request.uri, headers=request.headers, data=request.body)
     
         # Print result
         print(resp.status_code)
         print(resp.text)

     El nombre de body viene determinado por el parámetro de entrada del servicio en tiempo real. El nombre del parámetro debe ser el mismo que el del parámetro de entrada del tipo de cadena. image se utiliza como ejemplo. El valor de base64_data de body es del tipo de cadena.

Método 2: Utilice Java para enviar una solicitud de inferencia a través de la autenticación basada en AppKey/AppSecret

1. Descargue el SDK de Java y configúrelo en la herramienta de desarrollo. Para obtener más información, consulte Integración del SDK de Java para la firma de solicitudes de API.
2. Cree un cuerpo de solicitud Java para inferencia.

   En el SDK de Java de APIG, request.setBody() solo puede ser una string. Por lo tanto, solo se admiten solicitudes de inferencia de texto.

   A continuación se muestra un ejemplo del cuerpo de la solicitud (JSON) para leer el archivo de inferencia local y realizar la codificación Base64:

   // Package name of the demo.
   package com.apig.sdk.demo;
   
   import com.cloud.apigateway.sdk.utils.Client;
   import com.cloud.apigateway.sdk.utils.Request;
   import org.apache.http.HttpHeaders;
   import org.apache.http.client.methods.CloseableHttpResponse;
   import org.apache.http.client.methods.HttpPost;
   import org.apache.http.client.methods.HttpRequestBase;
   import org.apache.http.impl.client.HttpClients;
   import org.apache.http.util.EntityUtils;
   
   public class MyAkSkTest {
   
       public static void main(String[] args) {
           String url = "URL of the real-time service";
           String appKey = "AppKey";
           String appSecret = "AppSecret";
           String body = "{}";
   
           try {
               // Create request
               Request request = new Request();
   
               // Set the AK/AppSecret to sign and authenticate the request.
               request.setKey(appKey);
               request.setSecret(appSecret);
   
               // Specify a request method, such as GET, PUT, POST, DELETE, HEAD, and PATCH.
               request.setMethod(HttpPost.METHOD_NAME);
   
               // Add header parameters
               request.addHeader(HttpHeaders.CONTENT_TYPE, "application/json");
   
               // Set a request URL in the format of https://{Endpoint}/{URI}.
               request.setUrl(url);
   
               // Special characters, such as the double quotation mark ("), contained in the body must be escaped.
               request.setBody(body);
   
               // Sign the request.
               HttpRequestBase signedRequest = Client.sign(request);
   
               // Send request.
               CloseableHttpResponse response = HttpClients.createDefault().execute(signedRequest);
   
               // Print result
               System.out.println(response.getStatusLine().getStatusCode());
               System.out.println(EntityUtils.toString(response.getEntity()));
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   }

   body está determinado por el formato de texto. JSON se utiliza como ejemplo.

Método 3: Utilice Python para enviar una solicitud de inferencia a través de la autenticación basada en AppCode

1. Descargue el SDK de Python y configúrelo en la herramienta de desarrollo. Para obtener más información, consulte Integración del SDK de Python para la firma de solicitudes de API.
2. Cree un cuerpo de solicitud para inferencia.
   • Ingreso de archivo

     1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

     # coding=utf-8 import requests if __name__ == '__main__': # Config url, app code and file path. url = "URL of the real-time service" app_code = "AppCode" file_path = "Local path to the inference file" # Send request. headers = { 'X-Apig-AppCode': app_code } files = { 'images': open(file_path, 'rb') } resp = requests.post(url, headers=headers, files=files) # Print result print(resp.status_code) print(resp.text)

     El nombre de files viene determinado por el parámetro de entrada del servicio en tiempo real. El nombre del parámetro debe ser el mismo que el del parámetro de entrada del tipo de archivo. En este ejemplo, se utilizan images.

   • Ingreso de texto (JSON)

     A continuación se muestra un ejemplo del cuerpo de la solicitud para leer el archivo de inferencia local y realizar la codificación Base64:

     1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

     # coding=utf-8 import base64 import requests if __name__ == '__main__': # Config url, app code and request body. url = "URL of the real-time service" app_code = "AppCode" file_path = "Local path to the inference file" with open(file_path, "rb") as file: base64_data = base64.b64encode(file.read()).decode("utf-8") # Send request headers = { 'Content-Type': 'application/json', 'X-Apig-AppCode': app_code } body = { 'image': base64_data } resp = requests.post(url, headers=headers, json=body) # Print result print(resp.status_code) print(resp.text)

     El nombre de body viene determinado por el parámetro de entrada del servicio en tiempo real. El nombre del parámetro debe ser el mismo que el del parámetro de entrada del tipo de cadena. image se utiliza como ejemplo. El valor de base64_data de body es del tipo de cadena.

Método 4: Utilice Java para enviar una solicitud de inferencia a través de la autenticación basada en AppCode

1. Descargue el SDK de Java y configúrelo en la herramienta de desarrollo. Para obtener más información, consulte Integración del SDK de Java para la firma de solicitudes de API.
2. (Opcional) Si la entrada de la solicitud de inferencia está en el formato de archivo, el proyecto Java depende del módulo httpmime.
   1. Agregue httpmime-x.x.x.jar a la carpeta libs. Figura 5 muestra una biblioteca de dependencias Java completa.

      Se recomienda utilizar httpmime-x.x.x.jar 4.5 o una versión posterior. Descargue httpmime-x.x.x.jar desde https://mvnrepository.com/artifact/org.apache.httpcomponents/httpmime.

      Figura 5 Biblioteca de dependencias Java
      
   2. Después de agregar httpmime-x.x.x.jar, agregue la información httpmime al archivo .classpath del proyecto Java de la siguiente manera:

      <?xml version="1.0" encoding="UTF-8"?>
      <classpath>
      <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
      <classpathentry kind="src" path="src"/>
      <classpathentry kind="lib" path="libs/commons-codec-1.11.jar"/>
      <classpathentry kind="lib" path="libs/commons-logging-1.2.jar"/>
      <classpathentry kind="lib" path="libs/httpclient-4.5.13.jar"/>
      <classpathentry kind="lib" path="libs/httpcore-4.4.13.jar"/>
      <classpathentry kind="lib" path="libs/httpmime-x.x.x.jar"/>
      <classpathentry kind="lib" path="libs/java-sdk-core-3.1.2.jar"/>
      <classpathentry kind="lib" path="libs/okhttp-3.14.9.jar"/>
      <classpathentry kind="lib" path="libs/okio-1.17.2.jar"/>
      <classpathentry kind="output" path="bin"/>
      </classpath>

3. Cree un cuerpo de solicitud Java para inferencia.
   • Ingreso de archivo
     Un cuerpo de solicitud Java de ejemplo es el siguiente:

     1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

     // Package name of the demo. package com.apig.sdk.demo; import org.apache.http.Consts; import org.apache.http.HttpEntity; import org.apache.http.client.methods.CloseableHttpResponse; import org.apache.http.client.methods.HttpPost; import org.apache.http.entity.ContentType; import org.apache.http.entity.mime.MultipartEntityBuilder; import org.apache.http.impl.client.HttpClients; import org.apache.http.util.EntityUtils; import java.io.File; public class MyAppCodeFile { public static void main(String[] args) { String url = "URL of the real-time service"; String appCode = "AppCode"; String filePath = "Local path to the inference file"; try { // Create post HttpPost httpPost = new HttpPost(url); // Add header parameters httpPost.setHeader("X-Apig-AppCode", appCode); // Special characters, such as the double quotation mark ("), contained in the body must be escaped. File file = new File(filePath); HttpEntity entity = MultipartEntityBuilder.create().addBinaryBody("images", file).setContentType(ContentType.MULTIPART_FORM_DATA).setCharset(Consts.UTF_8).build(); httpPost.setEntity(entity); // Send post CloseableHttpResponse response = HttpClients.createDefault().execute(httpPost); // Print result System.out.println(response.getStatusLine().getStatusCode()); System.out.println(EntityUtils.toString(response.getEntity())); } catch (Exception e) { e.printStackTrace(); } } }

     El nombre addBinaryBody viene determinado por el parámetro de entrada del servicio en tiempo real. El nombre del parámetro debe ser el mismo que el del parámetro de entrada del tipo de archivo. En este ejemplo, se utilizan images.

   • Ingreso de texto (JSON)

     A continuación se muestra un ejemplo del cuerpo de la solicitud para leer el archivo de inferencia local y realizar la codificación Base64:

     1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

     // Package name of the demo. package com.apig.sdk.demo; import org.apache.http.HttpHeaders; import org.apache.http.client.methods.CloseableHttpResponse; import org.apache.http.client.methods.HttpPost; import org.apache.http.entity.StringEntity; import org.apache.http.impl.client.HttpClients; import org.apache.http.util.EntityUtils; public class MyAppCodeTest { public static void main(String[] args) { String url = "URL of the real-time service"; String appCode = "AppCode"; String body = "{}"; try { // Create post HttpPost httpPost = new HttpPost(url); // Add header parameters httpPost.setHeader(HttpHeaders.CONTENT_TYPE, "application/json"); httpPost.setHeader("X-Apig-AppCode", appCode); // Special characters, such as the double quotation mark ("), contained in the body must be escaped. httpPost.setEntity(new StringEntity(body)); // Send post CloseableHttpResponse response = HttpClients.createDefault().execute(httpPost); // Print result System.out.println(response.getStatusLine().getStatusCode()); System.out.println(EntityUtils.toString(response.getEntity())); } catch (Exception e) { e.printStackTrace(); } } }

     body está determinado por el formato de texto. JSON se utiliza como ejemplo.