Cette exploration aborde les concepts fondamentaux des fonctions cloud uniCloud, en détaillant comment accéder à des espaces de services non liés et établir une communication en temps réel entre le client et le serveur.

Accéder à des Espaces uniCloud Non Liés

Lorsqu'une applicasion doit interagir avec des ressources situées dans un espace de service uniCloud différent de celui par défaut, ou qui n'est pas directement lié au projet actuel, une initialisation manuelle est indispensable. Cette approche confère une grande souplesse pour la gestion de multiples environnements cloud.

L'initialisation est supportée côté client pour les fournisseurs Tencent et Alibaba. Cependent, côté serveur, la méthode uniCloud.init est exclusive à Tencent Cloud et ne peut créer des instances uniCloud qu'avec des espaces de service Tencent Cloud appartenant au même compte d'utilisateur.

// Initialisation d'une instance pour un espace de service uniCloud spécifique
const cloudInstance = uniCloud.init({
  provider: 'aliyun', // Type de fournisseur : 'aliyun', 'tencent', 'alipay'
  spaceId: 'votre-identifiant-espace', // L'ID de l'espace, trouvé dans la console uniCloud
  clientSecret: 'votre-secret-client', // Requis pour Alibaba Cloud
  accessKey: 'votre-cle-acces', // Requis pour Alipay Cloud
  secretKey: 'votre-cle-secrete', // Requis pour Alipay Cloud
  spaceAppId: 'votre-app-id-espace', // Requis pour Alipay Cloud
  endpoint: 'https://api.next.bspapp.com', // Optionnel, URL du service pour Alibaba Cloud Commercial
});

// Utilisation de l'instance pour effectuer des appels API
cloudInstance.callFunction({ name: 'maFonctionDistant' });
cloudInstance.uploadFile({ filePath: 'chemin/local/vers/fichier.jpg' });

Types de Fonctions Cloud dans uniCloud

L'écosystème uniCloud classifie ses fonctions cloud en plusieurs catégories pour s'adapter à divers scénarios de développement :

• Fonctions Cloud Standard
• Objets Cloud
• Modules Communs (Partagés)

Communication Client-Serveur en Temps Réel avec SSE

Pour les opérations de longue durée ou nécessitant des mises à jour de progression régulières, uniCloud facilite une communication bidirectionnelle entre le client et les fonctions/objets cloud via des canaux SSEChannel (Server-Sent Events). Ce mécanisme permet au client de recevoir des messages intermédiaires et des notifications de fin d'exécution.

Mise en Œuvre Côté Client

Le client configure un canal d'événements pour écouter les données diffusées par la fonction cloud. Voici comment gérer ces événements :

const sseManager = new uniCloud.SSEChannel(); // Instanciation du gestionnaire de canal

export default {
  data() {
    return {
      messagesRecus: []
    };
  },
  mounted() {
    this.initialiserEcouteurs();
  },
  beforeDestroy() {
    this.nettoyerEcouteurs();
    this.fermerCanal();
  },
  methods: {
    initialiserEcouteurs() {
      sseManager.on('message', this.gererMessageEntrant);
      sseManager.on('end', this.gererFinDiffusion);
      sseManager.on('error', this.gererErreurCanal);
    },
    nettoyerEcouteurs() {
      sseManager.off('message', this.gererMessageEntrant);
      sseManager.off('end', this.gererFinDiffusion);
      sseManager.off('error', this.gererErreurCanal);
    },
    gererMessageEntrant(data) {
      console.log('Nouveau message de progression:', data);
      this.messagesRecus.push(data);
    },
    gererFinDiffusion(finalPayload) {
      console.log('Canal de diffusion terminé. Charge utile finale:', finalPayload);
      // Traitement des données finales de la tâche
    },
    gererErreurCanal(error) {
      console.error('Une erreur est survenue sur le canal:', error);
      // Logique de récupération d'erreur
    },
    
    async demarrerTacheCloud() {
      await sseManager.open(); // L'ouverture du canal doit précéder l'appel cloud
      console.log('Canal SSE ouvert avec succès.');

      // Appel de la fonction cloud, en transmettant l'objet canal
      try {
        const result = await uniCloud.callFunction({
          name: 'traitement-longue-duree',
          data: { sseChannel: sseManager } // Essentiel : passer l'instance du canal SSE
        });
        console.log('Exécution de la fonction cloud achevée:', result);
      } catch (err) {
        console.error('Erreur lors de l\'exécution de la fonction cloud:', err);
      }
    },
    
    async fermerCanal() {
      await sseManager.close();
      console.log('Canal SSE fermé.');
    }
  }
}

Diffusion de Progression Côté Cloud

Les fonctions cloud ou les objets cloud peuvent envoyer des messages de progression au client en utilisant le canal désérialisé.

Exemple pour une Fonction Cloud Standard

// Code d'une fonction cloud standard
exports.main = async (event, context) => {
  const commLink = uniCloud.deserializeSSEChannel(event.sseChannel);
  
  await commLink.write({ id: 1, etape: 'initialisation', statut: 'en cours' });
  // Exécuter la première partie du traitement
  await new Promise(resolve => setTimeout(resolve, 600)); 

  await commLink.write({ id: 2, etape: 'traitement_donnees', statut: 'en cours' });
  // Exécuter la deuxième partie du traitement
  await new Promise(resolve => setTimeout(resolve, 600)); 

  await commLink.write({ id: 3, etape: 'finalisation_resultats', statut: 'en cours' });
  // Finaliser le traitement
  await commLink.end({ success: true, message: 'Processus terminé' }); // Informe le client de la fin
  
  return { resultat: 'confirmé' };
};

Exemple pour un Objet Cloud

// Code d'un objet cloud
module.exports = {
  async executerProcessusComplexe(parametres) {
    const commLink = uniCloud.deserializeSSEChannel(parametres.sseChannel);

    await commLink.write({ phase: 'pre-traitement', avancement: '20%' });
    // Implémentation de la logique métier
    await new Promise(resolve => setTimeout(resolve, 500));

    await commLink.write({ phase: 'traitement_principal', avancement: '70%' });
    // Poursuite de la logique métier
    await new Promise(resolve => setTimeout(resolve, 500));

    await commLink.end({ etat: 'finalise', donnees: { /* données du résultat */ } });
    
    return { conclusion: 'opération effectuée' };
  }
}

Génération de Code avec schema2code

La fonctionnalité schema2code de uniCloud est un outil puissant qui automatise la génération de code. En se basant sur la définition de votre schéma de base de données, il est capable de générer automatiquement des pages front-end ou back-end complètes (comprenant HTML, CSS et la logique fonctionnelle pour les opérations CRUD comme l'ajout, l'édition, la liste et la suppression de données).