Anuncio de gRPC Kotlin 1.0 para Android y Cloud


Publicado por Louis Wasserman, ingeniero de software, y James Ward, promotor de desarrolladores

Kotlin es ahora el cuarto lenguaje de programación “más popular” Millones de desarrolladores lo usan para Android, backends del lado del servidor / en la nube y varios otros tiempos de ejecución de destino. En Google, hemos creado más aplicaciones y backends con Kotlin para aprovechar la expresividad, la seguridad y el gran soporte de escribir código asincrónico con corrutinas.

Dado que todo en Google se ejecuta en gRPC, necesitábamos un método idiomático para hacer gRPC con Kotlin. Ya en abril de 2020 Hemos anunciado el código abierto de gRPC Kotlin, algo que construimos originalmente para nosotros mismos. Desde entonces, hemos visto más de 30.000 descargas y aplicaciones en Android y en la nube. La comunidad y nuestros ingenieros trabajaron duro para pulir documentos, corregir errores y mejorar el proyecto. ¡Lo más destacado es la nueva y brillante versión 1.0! Sumérgete directamente en eso Inicio rápido de gRPC Kotlin!

Para aquellos que son nuevos en gRPC y Kotlin, echemos un vistazo rápido a algunas de las cosas impresionantes. gRPC se basa en búferes de protocolo, también conocidos como “protos” (intercambio de datos potente e independiente del lenguaje), y agrega el protocolo de red para una comunicación eficiente con Protos. Todos los servidores, clientes y objetos de transferencia de datos se pueden generar a partir de una protodefinición. Aquí hay un prototipo simple de gRPC:

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

En un proyecto de Kotlin, puede definir la implementación del servicio SayHello de Greeter de la siguiente manera:

object : GreeterGrpcKt.GreeterCoroutineImplBase() {
    override suspend fun sayHello(request: HelloRequest) =
        HelloReply
            .newBuilder()
            .setMessage("hello, ${request.name}")
            .build()
}

Encontrará que la función contiene “suspender” porque usa las corrutinas de Kotlin, un método integrado para manejar E / S asíncronas / reactivas. el proyecto de muestra del servidor.

GRPC genera los “stubs” del cliente que simplifican la conexión a los servicios gRPC. Para el protocolo anterior, el código auxiliar del cliente en Kotlin se puede utilizar con:

val stub = GreeterCoroutineStub(channel)
val request = HelloRequest.newBuilder().setName("world").build()
val response = stub.sayHello(request)
println("Received: ${response.message}")

En este ejemplo, el método “sayHello” es también una función de “suspensión” que utilizan las corrutinas de Kotlin para facilitar las E / S reactivas. Revisa el proyecto de muestra del cliente.

Kotlin también tiene una API llamada Flow para realizar E / S reactivas en transmisiones (a diferencia de las solicitudes). gRPC Kotlin genera stubs de cliente y servidor utilizando la API de Flow para la entrada y salida de la transmisión. El proto puede definir un servicio de transmisión unario o bidireccional, como

service Greeter {
  rpc SayHello (stream HelloRequest) returns (stream HelloReply) {}
}

En este ejemplo, el “sayHello” del servidor se puede implementar con flujos:

object : GreeterGrpcKt.GreeterCoroutineImplBase() {
  override fun sayHello(requests: Flow<HelloRequest>): Flow<HelloReply> {
    return requests.map { request ->
      println(request)
      HelloReply.newBuilder().setMessage("hello, ${request.name}").build()
    }
  }
}

En este ejemplo, cada elemento “HelloRequest” del flujo se convierte en un elemento del flujo de salida / “HelloReply”.

El cliente de flujo bidireccional es similar al cliente de rutina, pero en su lugar pasa un flujo al método stub “sayHello” y luego procesa el flujo devuelto:

val stub = GreeterCoroutineStub(channel)
val helloFlow = flow {
  while(true) {
    delay(1000)
    emit(HelloRequest.newBuilder().setName("world").build())
  }
}

stub.sayHello(helloFlow).collect { helloResponse ->
  println(helloResponse.message)
}

En este ejemplo, el cliente envía un “HelloRequest” al servidor a través del flujo una vez por segundo. Cuando el cliente recibe artículos en el flujo de salida, solo se imprimen. Revisa el proyecto de muestra de transmisión bidi.

Como ha visto, la creación de objetos y servicios de comunicación a su alrededor se vuelve elegante y simple con gRPC Kotlin. Pero hay algunas otras cosas interesantes que podemos hacer con él …

Clientes de Android

Los compiladores de Protobuf pueden tener un modo “Lite” que genera clases más pequeñas y de mayor rendimiento que se adaptan mejor a Android. Dado que gRPC Kotlin usa gRPC Java, aprovecha el modo ligero de gRPC Java. El código generado funciona muy bien en Android y hay un artefacto “grpc-kotlin-stub-lite” que depende del “grpc-protobuf-lite” asociado. El cliente stub de Kotlin generado se utiliza como con la JVM. Probar esto Ejemplo de Stub de Android y Ejemplo de Android.

Clientes de imágenes nativas de GraalVM

El modo GRPC Lite también es excelente para GraalVM Native Image, que convierte las aplicaciones basadas en JVM en imágenes nativas precompiladas, lo que significa que se ejecutan sin una JVM. Estas aplicaciones pueden ser más pequeñas, usar menos memoria y comenzar mucho más rápido, lo que las hace adecuadas para entornos con ajuste de escala automático e interfaz de línea de comandos. Revisa el proyecto de muestra del cliente nativo Esto crea una pequeña y agradable aplicación cliente ejecutable de 14 MB (no se requiere JVM) y se inicia, se conecta al servidor, realiza una solicitud, procesa la respuesta y sale en menos de una centésima de segundo con solo 18 MB de memoria.

Listo para Google Cloud

Los servicios backend creados con gRPC Kotlin se pueden empaquetar fácilmente para su implementación en Kubernetes, Cloud Run o realmente en cualquier lugar donde se puedan ejecutar contenedores Docker o aplicaciones JVM. Ejecutar en la nube es un servicio en la nube que ejecuta contenedores Docker y escala automáticamente según sea necesario, por lo que solo paga cuando su servicio maneja las solicitudes. Si desea probar un servicio de gRPC Kotlin, pruebe Cloud Run:

  1. Implemente la aplicación con solo unos clics
  2. En Cloud Shell, ejecute el cliente para conectarse a su aplicación en la nube:
    export PROJECT_ID=PUT_YOUR_PROJECT_ID_HERE
    docker run -it gcr.io/$PROJECT_ID/grpc-hello-world-mvn 
    "java -cp target/classes:target/dependency/* io.grpc.examples.helloworld.HelloWorldClientKt YOUR_CLOUD_RUN_DOMAIN_NAME"

Aquí hay un video de cómo se ve:

Revisa Más ejemplos de Cloud Run gRPC Kotlin

¡Muchas gracias!

¡Estamos muy emocionados de haber logrado 1.0 para gRPC Kotlin y estamos increíblemente agradecidos con todos los que informaron errores, enviaron solicitudes de extracción y probaron las versiones preliminares! Aún queda mucho por hacer. Entonces, si quiere ayudar o participar, Mira el proyecto en GitHub.

¡También un gran agradecimiento a Brent Shaffer, Patrice Chalin, David Winer, Ray Tsang, Tyson Henning y Kevin Bierhoff por todas sus contribuciones a este lanzamiento!