Implémentation d'un système de traitement d'images distribué hautement évolutif : application et pratique du go-zero

Avec le développement de la technologie moderne, la technologie de traitement d'image joue un rôle croissant dans tous les domaines. Des systèmes de surveillance dans les villes intelligentes au diagnostic et au traitement de l’imagerie médicale, en passant par les jeux et la production cinématographique et télévisuelle dans l’industrie du divertissement, les algorithmes de traitement d’images constituent l’une des technologies de base indispensables. Cependant, avec la croissance des données d'images et du nombre d'utilisateurs, les solutions de traitement d'images traditionnelles sont progressivement incapables de répondre aux besoins de concurrence élevée, de faible latence et d'évolutivité élevée. Par conséquent, les systèmes de traitement d'images distribués sont progressivement devenus une solution courante.

Parmi les nombreux frameworks de traitement d'images distribués, go-zero est un framework de développement back-end digne d'attention. Il fournit un ensemble complet de solutions de microservices distribués, notamment une passerelle API, une gouvernance des services, une limitation de courant et un disjoncteur, ainsi qu'un stockage massif de données. et transactions distribuées et autres fonctions. Lors du développement et de l'application de systèmes de traitement d'images, le support complet de go-zero peut considérablement améliorer la fiabilité et les performances du système. Cet article présentera l'application et la pratique du go-zero dans le traitement d'images distribué sous divers aspects tels que les scénarios d'application, la conception de l'architecture, la sélection de la technologie et la mise en œuvre du code.

1. Scénarios d'application

Le système de traitement d'images est une application typique gourmande en données et en calcul. Les principaux problèmes auxquels elle est confrontée sont les suivants :

1. Grande quantité de données et concurrence élevée des requêtes : pour les systèmes de surveillance en temps réel, les scénarios. qui nécessitent une réponse instantanée, comme les systèmes de diffusion en direct, peuvent générer des centaines de milliers, voire des millions de données d'image par seconde. Ils doivent être capables de traiter rapidement ces données et de fournir des services à haut débit et à faible latence.
2. Calculs de tâches complexes : face à des tâches de calcul intensives telles que des algorithmes d'image complexes et des modèles d'apprentissage en profondeur, il est nécessaire d'effectuer rapidement et avec précision diverses opérations de traitement d'image telles que l'extraction, la classification, la reconnaissance et la synthèse de caractéristiques d'image.
3. Haute disponibilité et haute évolutivité : face à l'évolution des besoins de l'entreprise, le système doit être hautement disponible et évolutif, capable de faire face à des situations anormales telles que des trafics soudains et des pannes de nœuds, et d'assurer des services continus et stables.

go-zero peut être appliqué à une variété de scénarios qui rencontrent les problèmes ci-dessus, tels que :

1. Système de classification d'images : classer les images, telles que la reconnaissance automatique des visages, des modèles de voitures, de la nourriture, etc.
2. Système de synthèse d'images : combinez plusieurs images en une seule image, comme l'épissage d'images, la synthèse d'images de produits concrets, etc.
3. Système de surveillance : effectuez un traitement des images en temps réel, tel que des statistiques de flux de personnes, la reconnaissance de texte, etc., et convertissez les données d'image en données statistiques utilisables.

2. Conception de l'architecture

Afin de répondre aux besoins ci-dessus, nous devons concevoir un système de traitement d'image distribué fiable, évolutif et efficace. Avec l'aide de go-zero, nous pouvons réaliser la conception d'infrastructure suivante :

1. API Gateway : fournit des services de passerelle d'interface API Web pour gérer uniformément les demandes de différents clients.
2. Service RPC : Service métier, responsable de tâches spécifiques de traitement d'images, utilisant un modèle de microservice distribué, divisé et déployé selon les métiers.
3. Service de configuration : service de configuration, qui gère et distribue uniformément les configurations publiques.
4. Gestion des ressources : gestion des ressources, y compris la surveillance, le contrôle de flux, la dégradation du disjoncteur, la limitation de courant et d'autres fonctions, pour garantir une utilisation raisonnable des ressources du système et des performances stables.
5. Service de stockage : stockez les données traitées dans le système de stockage partagé distribué dans le cloud pour faciliter l'accès et les requêtes ultérieures des entreprises.

3. Sélection technologique

Lors de la conception de solutions techniques spécifiques, nous pouvons d'abord sélectionner certaines technologies et algorithmes traditionnels adaptés au traitement d'image, puis utiliser le cadre de microservices fourni par go-zero et certaines technologies distribuées grand public pour réaliser les fonctions de l'ensemble du système.

Plus précisément, les technologies suivantes peuvent être utilisées pour y parvenir :

1. Algorithme de traitement d'image : à l'aide d'algorithmes de traitement d'image traditionnels, tels que OpenCV, PIL et d'autres bibliothèques, ainsi que de certains modèles d'apprentissage profond, l'extraction, la classification, la reconnaissance et la la synthèse d'images peut être réalisée ainsi que d'autres tâches de traitement d'image.
2. Cadre de microservices : grâce au cadre de microservices de go-zero, vous pouvez rapidement créer un système de traitement d'image distribué pour réaliser la division des tâches, le développement de la logique métier, l'équilibrage de charge, la récupération des pannes et d'autres fonctions.
3. Technologie distribuée : les technologies de coordination distribuées telles que etcd et zookeeper peuvent être utilisées pour réaliser des fonctions telles que l'enregistrement et la découverte de services, la gestion de la configuration, etc., rendant le système plus stable et fiable.
4. Couche de stockage : vous pouvez choisir un système de stockage partagé distribué, tel que FastDFS, etc., pour partager et gérer les données traitées.

4. Implémentation du code

Lors de la mise en œuvre spécifique des fonctions ci-dessus, nous pouvons utiliser le cadre de code fourni par go-zero pour compléter la logique métier et la mise en œuvre technique spécifiques. Ce qui suit est un exemple de programme qui représente le processus de développement d’un système complet de traitement d’images distribué.

Tout d'abord, introduisez le framework et les packages de dépendances nécessaires dans main.go :

package main

import (
    "github.com/tal-tech/go-zero/core/conf"
    "github.com/tal-tech/go-zero/core/logx"
    "github.com/tal-tech/go-zero/rest"
)

func main() {
    logx.Disable()
    var c Config
    conf.MustLoad(&c)

    server := rest.MustNewServer(c.RestConf)
    defer server.Stop()

    InitHandlers(server.Group("/"))

    go func() {
        select {
        case <-server.Done():
            logx.Info("Stopping...")
        }
    }()
    server.Start()
}

Parmi eux, la structure Config stocke les informations de configuration du système et est configurée dans config.toml ; une logique métier spécifique est implémentée dans la fonction InitHandlers

func InitHandlers(group *rest.Group) {
    group.POST("/image/:type", func(ctx *rest.Context) {
    // 业务逻辑：根据type参数分发图像任务，调用具体的RPC服务进行处理
    })
}

Ensuite, la logique métier spécifique est implémentée dans le package des gestionnaires.

package handlers

import (
    "context"
    "encoding/base64"
    "github.com/tal-tech/go-zero/core/logx"
    "github.com/tal-tech/go-zero/rest/httpx"
    "github.com/tal-tech/go-zero/zrpc"
    "github.com/yanyiwu/gojieba"
    "go-zero-example/service/image/api/internal/logic"
    "go-zero-example/service/image/api/internal/svc"
    "go-zero-example/service/image/rpc/image"
)

const (
    FACE_DETECT = iota
    FACE_RECOGNITION
    COLOR_DETECT
)

var jieba = gojieba.NewJieba()

type ImageType int32

type ImageHandler struct {
    ctx    context.Context
    svcCtx *svc.ServiceContext
}

func NewImageHandler(ctx context.Context, svcCtx *svc.ServiceContext) *ImageHandler {
    return &ImageHandler{ctx: ctx, svcCtx: svcCtx}
}

func (l *ImageHandler) Handle(reqTypes []ImageType, base64Data string) (*image.Data, error) {
    req := logic.ImageReq{
        ReqTypes:   reqTypes,
        Base64Data: base64Data,
    }

    // 将图像处理请求分发给所有RPC服务
    results := make([]*image.Data, 0, len(reqTypes))
    for _, reqType := range reqTypes {
        data, err := l.svcCtx.ImageRpcClient.DoImage(l.ctx, &image.ImageReq{
            ImageType: int32(reqType),
            ImageData: base64Data,
        })
        if err != nil {
            logx.WithError(err).Warnf("image rpc call failed: %v", data)
            return nil, httpx.Error(500, "服务内部错误")
        }

        results = append(results, data)
    }

    // 直接返回结果
    return logic.MergeResults(results), nil
}

// 字符串转float
func str2float(str string, defVal float64) float64 {
    if len(str) == 0 {
        return defVal
    }
    val, err := strconv.ParseFloat(str, 64)
    if err != nil {
        return defVal
    }
    return val
}

// 字符串转int
func str2int(str string, defVal int64) int64 {
    if len(str) == 0 {
        return defVal
    }
    val, err := strconv.ParseInt(str, 10, 64)
    if err != nil {
        return defVal
    }
    return val
}

// 合并处理结果
func (l *ImageHandler) MergeResults(datas []*image.Data) *image.Data {
    if len(datas) == 1 {
        return datas[0]
    }
    mergeData := &image.Data{
        MetaData: &image.MetaData{
            Status:  0,
            Message: "success",
        },
    }

    for _, data := range datas {
        if data.MetaData.Status != 0 {
            return data // 异常情况
        }
        switch data.DataType {
        case image.DataType_STRING:
            if mergeData.StringData == nil {
                mergeData.StringData = make(map[string]string)
            }
            for k, v := range data.StringData {
                mergeData.StringData[k] = v
            }
        case image.DataType_NUMBER:
            if mergeData.NumberData == nil {
                mergeData.NumberData = make(map[string]float64)
            }
            for k, v := range data.NumberData {
                mergeData.NumberData[k] = v
            }
        case image.DataType_IMAGE:
            if mergeData.ImageData == nil {
                mergeData.ImageData = make([]*image.ImageMeta, 0)
            }
            mergeData.ImageData = append(mergeData.ImageData, data.ImageData...)
        }
    }
    return mergeData
}

Enfin, nous pouvons définir l'interface spécifique du service RPC dans image.proto, comme indiqué ci-dessous :

syntax = "proto3";

package image;

service ImageApi {
    rpc DoImage(ImageReq) returns (Data) {}
}

message ImageReq {
    int32 image_type = 1;
    string image_data = 2;
}

message ImageMetaData {
    int32 status = 1;
    string message = 2;
}

message Data {
    ImageMetaData meta_data = 1;
    DataType data_type = 2;
    map<string, string> string_data = 3; 
    map<string, float> number_data = 4;
    repeated ImageMeta image_data = 5;

}

// 可返回的数据类型
enum DataType {
    STRING = 0;
    NUMBER = 1;
    IMAGE = 2;
}

message ImageMeta {
    string url = 1;
    int32 width = 2;
    int32 height = 3;
}

至此，一个完整的分布式图像处理系统就具备了基础的功能和业务逻辑，可以部署到服务器中，供用户使用。

五、总结

本文介绍了go-zero在分布式图像处理中的应用和实践，从应用场景、架构设计、技术选型、代码实现等方面对图像处理系统进行了详细阐述。针对图像处理系统的特点，go-zero提供了一套全面的分布式微服务解决方案，可以快速搭建高可扩展性的系统，提高系统的性能和可靠性，同时也为开发者提供了产品支持和服务保障，适用于多种应用场景。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!