Acceso autenticado mediante una aplicación

Prerrequisitos

• Se han preparado 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 implementar un modelo como servicio en tiempo real, puede habilitar la autenticación de aplicaciones. También puede modificar un servicio en tiempo real implementado para admitir la autenticación de aplicaciones.

1. Inicie sesión en la consola de gestión ModelArts y elija Service Deployment > Real-Time Services.
2. Habilite la autenticación de aplicaciones.
   • Al implementar 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 implementado, 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 Habilitar 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, consulte 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 llamar 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 implementar un servicio en tiempo real. En la página Service Deployment > Real-Time Services, haga clic en Authorize. Se muestra la página Manage Authorization of Real-Time Services. En esta página, 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

• Creación de una aplicación

  Haga clic en Create Application, 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.

• Ver, restablecer o eliminar una aplicación

  Para ver, restablecer o eliminar una aplicación, haga clic en el icono correspondiente de la columna Operation de la aplicación. Después de crear una aplicación, el AppKey y el 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 vinculados a la aplicación. Haga clic en Unbind en la columna Operation para cancelar el enlace. Entonces, esta API no se puede llamar.

• Obtención de AppKey/AppSecret o AppCode

  La autenticación de la aplicación es necesaria para las llamadas a la API. Los AppKey y AppSecret se generan automáticamente durante la creación de la aplicación. El AppCode se obtiene mediante la adición de un AppCode.

  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 llamar a la API del servicio. Antes de llamar a la API, realice la autenticación de la aplicación.

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

• Autenticación basada en AppKey/AppSecret: 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 simple. Cuando se llama a una API, el parámetro apikey (valor:AppKey) se agrega al encabezado de solicitud HTTP para acelerar la autenticación.

• Autenticación basada en AppCode: las solicitudes se autentican mediante AppCodes.

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

Puede obtener la API, AppKey/AppSecret y AppCode desde la pestaña Usage Guides en la página de detalles del servicio (consulte Figura 4). o desde la página de gestión de autorización de servicio en tiempo real (consulte Figura 2). Asegúrese de que se utiliza la dirección API que se muestra en el cuadro rojo de la siguiente figura.

Figura 4 Obtención de la dirección 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 más información sobre los parámetros de files, consulte Tabla 1.

     Tabla 1 Parámetros de files

     Parámetro	Obligatorio	Descripción
     Request parameter	Sí	Introduzca el 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: text/plain jpg/jpeg: image/jpeg png: image/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. Se recomienda que el nombre del parámetro sea el mismo que el del parámetro de entrada del tipo de string.

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 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. Se recomienda que el nombre del parámetro sea 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. Se recomienda que el nombre del parámetro sea el mismo que el del parámetro de entrada del tipo de string.

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 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. Se recomienda que el nombre del parámetro sea 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.