gRPC + l'Upload d'Images

Je veux créer un simple gRPC extrémité de laquelle l'utilisateur peut télécharger sa photo. Le protocole de la mémoire tampon de la déclaration est la suivante:

message UploadImageRequest {
    AuthToken auth = 1;
    //An enum with either JPG or PNG
    FileType image_format = 2;
    //Image file as bytes
    bytes image = 3;
}

Est cette approche de transfert de photos (et de recevoir des photos) toujours ok, indépendamment de l'avertissement dans le gRPC de la documentation?

Et si non, est la meilleure approche (standard) pour télécharger des photos à l'aide de la formule standard et le stockage de l'emplacement du fichier d'image à la place?

Ce message d'avertissement dans le gRPC documentation parlez-vous?
Les tampons ne sont pas conçus pour gérer les messages volumineux. Comme une règle générale, si vous avez affaire à des messages plus longs que chaque mégaoctet, il pourrait être temps d'envisager une autre stratégie." -developers.google.com/protocol-buffers/docs/techniques?hl=en

OriginalL'auteur Nate Lee | 2016-01-23

grpc protocol-buffers

13

Pour les gros transferts binaires, l'approche standard est de segmentation. Chunking peut servir deux objectifs: 1) réduire la quantité maximale de mémoire nécessaire pour traiter chaque message et 2) de fournir une limite pour la récupération partielle de téléchargements. Pour votre cas d'utilisation, #2 n'est probablement pas très nécessaire.

Dans gRPC, un client de streaming appel permet assez naturel de segmentation car il a le contrôle de flux, le pipelining, et est facile à entretenir contexte dans le code client et serveur. Si vous vous souciez de la récupération partielle de téléchargements, puis bidirectionnel-streaming fonctionne bien depuis le serveur peut être de répondre avec les remerciements de progrès que le client peut utiliser pour reprendre.

De segmentation à l'aide de Rpc individuels est également possible, mais elle a plus de complications. Lors de l'équilibrage de la charge, le backend peut être nécessaire de coordonner avec d'autres backends de chaque morceau. Si vous télécharger les morceaux en série, puis le temps de latence du réseau peuvent ralentir la vitesse de téléchargement que vous passez la plupart du temps d'attente pour recevoir des réponses du serveur. Ensuite, vous devez télécharger en parallèle (mais combien en parallèle?) ou augmenter la taille de bloc. Mais en augmentant le gros morceau à l'augmentation de la taille de la mémoire nécessaire pour traiter chaque morceau et augmente le niveau de granularité pour la récupération a échoué uploads. En parallèle de téléchargement nécessite également le serveur pour gérer de téléchargements.

Donc, vous suggérez un retour de flux (stream octets)? Est-il possible de retourner à la fois les métadonnées & le flux d'octets en une seule?
Je suis en proposant de répondre à un message, avec un champ d'octets. Si vous pourriez avoir des métadonnées comme tous les autres domaines.

OriginalL'auteur Eric Anderson
9

la solution fournie dans la question ne fonctionnera pas pour les fichiers de grandes tailles. il ne fonctionnera que pour les petites tailles d'image.
le meilleur et le standard est l'utilisation de segmentation. grpc prend en charge la diffusion d'un construit en. donc, il est assez facile de les envoyer dans des morceaux
```
syntax = 'proto3'

message UploadImageRequest{
    bytes image = 1;

}

rpc UploadImage(stream UploadImageRequest) returns (Ack); 
```
dans la façon décrite ci-dessus, nous pouvons utiliser la diffusion de chunking.

de chunking toutes les langues fournir sa propre façon de morceau de fichier basé sur la taille de bloc.

Choses à prendre soin:

vous devez gérer la segmentation logique, le streaming permet en envoyant naturellement.
si vous souhaitez envoyer les métadonnées aussi il y a trois approches.

1: utiliser en dessous de la structure
```
message UploadImageRequest{
    AuthToken auth = 1;
    FileType image_format = 2;
    bytes image = 3;
}

rpc UploadImage(stream UploadImageRequest) returns (Ack); 
```
ici octets est encore en gros morceaux et pour le premier morceau envoyer AuthToken et le Type du fichier et pour les autres demandes, il suffit de ne pas envoyer ces métadonnées.

2: vous pouvez également utiliser oneof qui est beaucoup plus facile.
```
message UploadImageRequest{
        oneof test_oneof {
              Metadata meta = 2;
              bytes image = 1;
        }
}
message Metadata{
     AuthToken auth = 1;
     FileType image_format = 2;
}

rpc UploadImage(stream UploadImageRequest) returns (Ack); 
```
3: l'utiliser juste en dessous de la structure et dans le premier morceau envoyer des métadonnées et d'autres morceaux ont des données. vous devez gérer que dans le code.
```
syntax = 'proto3'

message UploadImageRequest{
    bytes message = 1;

}

rpc UploadImage(stream UploadImageRequest) returns (Ack); 
```
enfin pour auth vous pouvez utiliser des en-têtes au lieu de l'envoi de ce message.

donc dans le cas 1) comment pouvez-vous être sûr AuthToken et le Type du fichier ne sont envoyés qu'une fois?
Qu'entendez-vous par l'envoi d'une seule fois? Si vous rencontrez le client, il sera dans votre contrôle pour l'envoyer une fois, si le client est un tiers ils ont le contrôle, dans tous les cas, vous pouvez ignorer les deux après le premier morceau. Si vous voulez une stricte restriction à envoyé qu'une seule fois, puis la méthode 2 est votre option.

OriginalL'auteur Samarendra

Vous devez vous connecter pour publier un commentaire.