E-MapReduce:FAQ

Comment accéder à OSS depuis un autre compte ?

Par défaut, EMR Serverless StarRocks permet d'accéder sans mot de passe aux buckets OSS situés dans le même compte. Pour accéder aux ressources OSS d'un autre compte, vous devez désactiver cette option par défaut, configurer la paire AccessKey du compte cible et appliquer la nouvelle configuration.

1. Désactivez l'accès sans mot de passe : sous l'onglet Parameter Configuration, effacez les valeurs des éléments de configuration suivants dans les fichiers spécifiés.

   • core-site.xml

     fs.oss.credentials.provider =

   • jindosdk.cfg

     fs.oss.provider.format =
     fs.oss.provider.endpoint =

2. Ajoutez la paire AccessKey du compte cible : sous l'onglet Parameter Configuration, cliquez sur Add Configuration Item et ajoutez les configurations suivantes aux fichiers spécifiés.

   • core-site.xml

     fs.oss.accessKeyId = AccessKey ID of the target account
     fs.oss.accessKeySecret = AccessKey Secret of the target account

   • jindosdk.cfg

     fs.oss.accessKeyId = AccessKey ID of the target account
     fs.oss.accessKeySecret = AccessKey Secret of the target account

3. Appliquez la configuration : sous l'onglet Parameter Configuration, cliquez sur Submit Parameters.

Utilisation des pilotes UDF et JDBC connector

Avant d'utiliser les pilotes UDF et JDBC, vous devez obtenir les fichiers JAR requis depuis une source externe.

1. Téléchargez les fichiers JAR vers OSS. Pour plus d'informations, consultez la section Télécharger des fichiers.

   Lors du téléchargement des fichiers, définissez la valeur object ACL sur Public Read/Write afin d'accorder des autorisations de lecture et d'écriture publiques aux fichiers JAR.

2. Obtenez l'URL de chaque fichier JAR.

   Dans la console OSS, localisez le lien correspondant à chaque fichier JAR correctement téléchargé. Utilisez l'URL HTTP du endpoint interne, qui doit respecter l'un des formats suivants :

   • Pour un pilote JDBC : http://<YourBucketName>.oss-cn-xxxx-internal.aliyuncs.com/mysql-connector-java-*.jar.

   • Pour une UDF : http://<YourBucketName>.oss-cn-xxxx-internal.aliyuncs.com/<YourPath>/<jar_package_name>.

3. Utilisez les fichiers JAR. Pour plus d'informations, consultez les sections Java UDF et JDBC Catalog.

Comment réinitialiser le mot de passe de l'instance ?

1. Accédez à la page des détails de l'instance.

   1. Connectez-vous à la console E-MapReduce.

   2. Dans le volet de navigation de gauche, choisissez EMR Serverless > StarRocks.

   3. Cliquez sur le nom de l'instance cible.

2. Sur la page Instance Details, dans la section Basic Information, cliquez sur Reset Password.

3. Dans la boîte de dialogue qui s'affiche, saisissez et confirmez le nouveau mot de passe, puis cliquez sur OK.

Erreur lors de l'écriture de données dans les tables Paimon

• Symptôme : lorsque vous utilisez StarRocks pour écrire des données dans une table Paimon, le message d'erreur suivant peut s'afficher :

  (5025, 'Backend node not found. Check if any backend node is down.')

• Cause : une vérification des autorisations dans les tables Paimon peut empêcher StarRocks d'identifier correctement les nœuds BE lors des opérations d'écriture.

• Solution :

  • Mettre à niveau la version (recommandé) : si la version de votre instance est antérieure à l'une des versions suivantes, effectuez une mise à jour mineure pour appliquer le correctif.

    • StarRocks 3.2 : 3.2.11-1.89 ou version ultérieure

    • StarRocks 3.3 : 3.3.8-1.88 ou version ultérieure

  • Solution de contournement : sous l'onglet Parameter Configuration de l'instance StarRocks, ajoutez l'élément de configuration suivant au fichier core-site.xml.

    dlf.permission.clientCheck=false

Que faire si vous recevez l'erreur not a RAM user lors de la création d'une table étrangère dans StarRocks ?

• Symptôme : lors de la création d'une table étrangère dans StarRocks, le message d'erreur suivant peut s'afficher :

  current user is not a RAM user

• Cause : cette erreur est due à des autorisations insuffisantes ou à une version obsolète de l'instance.

• Solution :

  1. Vérifiez les autorisations de l'utilisateur RAM : assurez-vous que l'utilisateur Resource Access Management (RAM) dispose des autorisations requises pour StarRocks. Pour plus d'informations, consultez la section Accorder des autorisations à un utilisateur RAM.

  2. Si les autorisations sont correctes, vérifiez et mettez à niveau la version du noyau sur la page Instance Details de StarRocks.

     Si la version de votre instance est antérieure à l'une des versions suivantes, effectuez une mise à jour mineure pour appliquer le correctif.

     • StarRocks 3.2 : 3.2.11-1.89 ou version ultérieure

     • StarRocks 3.3 : 3.3.8-1.88 ou version ultérieure

Erreur liée aux points-virgules dans l'éditeur SQL

• Symptôme : lorsque vous exécutez une instruction SQL contenant un point-virgule (;) dans l'éditeur SQL, une erreur se produit. Le message d'erreur inclut the most similar input is {a legal identifier}.

  Le code d'erreur est 1064 et les détails incluent également Unexpected input '<EOF>', ce qui indique une erreur de syntaxe à la ligne 3, colonne 11.

• Cette erreur survient car l'éditeur SQL utilise le point-virgule (;) comme terminateur d'instruction par défaut. Si votre instruction SQL contient un point-virgule (;), une erreur d'analyse syntaxique se produit.

• Solution :

  1. Définissez un délimiteur personnalisé.

     Avant d'exécuter une instruction SQL contenant un point-virgule, définissez un délimiteur personnalisé pour éviter les erreurs d'analyse syntaxique. Par exemple, vous pouvez remplacer le délimiteur par $$.

     delimiter $$

  2. Exécutez l'instruction SQL contenant un point-virgule. Voici un exemple :

     INSERT INTO sr_test VALUES 
     (1, 'asdsd,asdsads'), 
     (2, 'sadsad;asdsads');

  3. Rétablissez le délimiteur par défaut.

     Une fois l'instruction SQL exécutée, rétablissez le délimiteur par défaut (;) afin que les opérations SQL suivantes puissent s'exécuter comme prévu.

     delimiter ;

  4. Vérifiez le résultat.

     Exécutez une requête pour vérifier que les données ont été insérées correctement.

     delimiter ;
     SELECT * FROM sr_test;

     Output
       test_id    test_desc
     0       1    asdsd,asdsads
     1       2    sadsad;asdsads

Échec de l'importation des données ou de l'accès aux tables étrangères

• Symptôme : lorsque vous utilisez EMR Serverless StarRocks pour importer des données ou accéder à une table étrangère, l'importation ou la connexion peut échouer si la destination est une adresse IP publique.

• Cause : une instance EMR Serverless StarRocks s'exécute par défaut dans un environnement Virtual Private Cloud (VPC), qui peut ne pas avoir d'accès direct à Internet. Par conséquent, les requêtes adressées aux ressources publiques, telles que les importations de données ou les interrogations de tables étrangères, échouent sauf si l'accès à Internet est configuré.

• Solution : vous pouvez déployer une passerelle NAT Internet dans le VPC et activer la fonctionnalité SNAT. Cela permet à l'instance EMR Serverless StarRocks d'accéder aux ressources publiques via la passerelle. Pour plus d'informations, consultez la section Utiliser la fonctionnalité SNAT d'une passerelle NAT Internet pour accéder à Internet.

Empêcher la fermeture de connexion due au délai d'inactivité SLB/CLB

• Symptôme : lors de l'utilisation de SLB avec une instance StarRocks, SLB ferme de force la connexion client si une requête SQL s'exécute pendant plus de 900 secondes, empêchant ainsi la requête de renvoyer un résultat. Pour plus d'informations sur l'activation de SLB, consultez la section Gérer les passerelles.

• Cause : SLB ferme toute connexion TCP inactive depuis plus de 900 secondes. Cela peut se produire lors d'une requête SQL de longue durée, interrompant la connexion avant que StarRocks ne renvoie un résultat.

• Solution : configurez les paramètres TCP Keepalive côté client pour empêcher SLB de fermer les connexions inactives.

  • Paramètres globaux du noyau (niveau système)

    Modifiez les paramètres du noyau du système d'exploitation pour activer et configurer des paramètres TCP Keepalive appropriés pour toutes les connexions TCP. Cela permet de surveiller l'état des connexions réseau. Le tableau suivant décrit les paramètres à configurer.

    Paramètre	Description	Valeur recommandée
    Linux : net.ipv4.tcp_keepalive_time FreeBSD/macOS : net.inet.tcp.keepidle	Période d'inactivité en secondes après laquelle la première sonde Keepalive est envoyée.	600 secondes
    Linux : net.ipv4.tcp_keepalive_intvl FreeBSD/macOS : net.inet.tcp.keepintvl	Intervalle en secondes entre les retransmissions des sondes Keepalive.	60 secondes
    Linux : net.ipv4.tcp_keepalive_probes FreeBSD/macOS : net.inet.tcp.keepcnt	Nombre d'échecs de sonde consécutifs après lesquels la connexion est abandonnée.	5

    Linux

    • Appliquer les paramètres temporairement

      # Set global Keepalive parameters (root permissions required)
      sudo sysctl -w net.ipv4.tcp_keepalive_time=600   # Corresponds to keepidle (600 seconds)
      sudo sysctl -w net.ipv4.tcp_keepalive_intvl=60   # Corresponds to keepintvl (60 seconds)
      sudo sysctl -w net.ipv4.tcp_keepalive_probes=5   # Corresponds to keepcount (5)

    • Appliquer les paramètres de manière permanente

      Ajoutez le contenu suivant au fichier /etc/sysctl.conf et exécutez sysctl -p pour appliquer les paramètres.

      echo "net.ipv4.tcp_keepalive_time = 600" >> /etc/sysctl.conf
      echo "net.ipv4.tcp_keepalive_intvl = 60" >> /etc/sysctl.conf
      echo "net.ipv4.tcp_keepalive_probes = 5" >> /etc/sysctl.conf

    FreeBSD/macOS

    • Appliquer les paramètres temporairement

      # Set global Keepalive parameters (root permissions required)
      sudo sysctl -w net.inet.tcp.keepidle=600
      sudo sysctl -w net.inet.tcp.keepintvl=60
      sudo sysctl -w net.inet.tcp.keepcnt=5

    • Appliquer les paramètres de manière permanente

      Ajoutez le contenu suivant au fichier /etc/sysctl.conf.

      echo "net.inet.tcp.keepidle = 600" >> /etc/sysctl.conf
      echo "net.inet.tcp.keepintvl = 60" >> /etc/sysctl.conf
      echo "net.inet.tcp.keepcnt = 5" >> /etc/sysctl.conf

  • Paramètres au niveau de l'application

    Vous pouvez utiliser des API spécifiques au langage pour définir les paramètres TCP Keepalive pour une seule connexion.

    Java

    La bibliothèque standard Java offre un support limité pour TCP Keepalive. Toutefois, vous pouvez l'implémenter en utilisant la réflexion ou des options de socket de bas niveau.

    Remarque

    Le code suivant nécessite la prise en charge système d'options telles que tcp_keepidle sous Linux ou FreeBSD. De plus, certaines méthodes, comme la réflexion, peuvent ne pas fonctionner en raison des différences entre les versions de JVM. Nous vous recommandons de tester la compatibilité avant utilisation dans un environnement de production.

    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.net.Socket;
    import java.net.SocketOption;
    import java.nio.channels.SocketChannel;
    public class TcpKeepaliveExample {
        public static void main(String[ ] args) {
            try (Socket socket = new Socket()) {
                // 1. Enable Keepalive
                socket.setKeepAlive(true);
                // 2. Set Keepalive parameters (requires low-level socket options)
                SocketChannel channel = socket.getChannel();
                if (channel != null) {
                    // Set Keepidle (idle time)
                    channel.setOption(StandardSocketOptions.SO_KEEPALIVE, true); // Keepalive must be enabled first
                    setSocketOptionInt(socket, "tcp_keepidle", 600); // Requires system support
                    // Set Keepintvl (retransmission interval)
                    setSocketOptionInt(socket, "tcp_keepintvl", 60);
                    // Set Keepcount (number of failures)
                    setSocketOptionInt(socket, "tcp_keepcnt", 5); // Note: The parameter name may vary by system
                }
                // Connect to the server
                socket.connect(new InetSocketAddress("example.com", 80));
                // ... Other operations ...
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        // Use reflection to set system-specific socket options (such as on Linux/FreeBSD)
        private static void setSocketOptionInt(Socket socket, String optionName, int value) {
            try {
                Class<?> clazz = Class.forName("java.net.Socket$SocketOptions");
                Object options = clazz.getDeclaredMethod("options").invoke(socket);
                Class<?> optionsClass = options.getClass();
                optionsClass.getDeclaredMethod("setOption", String.class, int.class)
                        .invoke(options, optionName, value);
            } catch (Exception e) {
                throw new RuntimeException("Failed to set socket option " + optionName, e);
            }
        }
    }

    Python

    Le module Python socket prend en charge la configuration directe des paramètres TCP Keepalive.

    Remarque

    Les noms de paramètres peuvent varier selon les systèmes d'exploitation. Par exemple, macOS peut nécessiter TCP_KEEPALIVE au lieu de TCP_KEEPIDLE. Certains paramètres peuvent nécessiter des autorisations root pour être définis.

    import socket
    def create_keepalive_socket():
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # 1. Enable Keepalive
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
        # 2. Set Keepalive parameters (Linux/FreeBSD)
        # Keepidle: 600 seconds
        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, 600)
        # Keepintvl: 60 seconds
        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, 60)
        # Keepcount: 5
        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 5)
        return sock
    # Example
    sock = create_keepalive_socket()
    sock.connect(("example.com", 80))
    # ... Other operations ...
    sock.close()

    Golang

    Le package net de Golang fournit une configuration Keepalive de base. Toutefois, vous devez utiliser le package de bas niveau syscall pour définir des paramètres détaillés.

    Remarque

    Les noms de paramètres peuvent varier selon les systèmes d'exploitation. Certains paramètres peuvent nécessiter des autorisations root pour être définis.

    package main
    import (
        "fmt"
        "net"
        "syscall"
    )
    func main() {
        // Create a TCP connection
        conn, err := net.Dial("tcp", "example.com:80")
        if err != nil {
            panic(err)
        }
        defer conn.Close()
        // Get the underlying file descriptor
        file, err := conn.(*net.TCPConn).File()
        if err != nil {
            panic(err)
        }
        defer file.Close()
        fd := int(file.Fd())
    
        // Enable Keepalive
        err = syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_KEEPALIVE, 1)
        if err != nil {
            panic(fmt.Errorf("set SO_KEEPALIVE: %v", err))
        }
        // Set Keepidle (idle time)
        err = syscall.SetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPIDLE, 600)
        if err != nil {
            panic(fmt.Errorf("set TCP_KEEPIDLE: %v", err))
        }
        // Set Keepintvl (retransmission interval)
        err = syscall.SetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPINTVL, 60)
        if err != nil {
            panic(fmt.Errorf("set TCP_KEEPINTVL: %v", err))
        }
        // Set Keepcount (number of failures)
        err = syscall.SetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPCNT, 5)
        if err != nil {
            panic(fmt.Errorf("set TCP_KEEPCNT: %v", err))
        }
        // ... Other operations ...
    }

Une erreur « Unexpected exception: Table '' is not a OLAP table » est signalée lors de la sauvegarde des données StarRocks

• Symptôme : le message d'erreur suivant est signalé lorsque vous utilisez StarRocks pour créer une sauvegarde instantanée des données.

  Unexpected exception: Table '<table_name>' is not a OLAP table

• Analyse de la cause :

  • L'instance utilise le mode de séparation stockage-calcul.

    Les instances StarRocks utilisant la séparation stockage-calcul ne prennent pas en charge la sauvegarde et la restauration des données. Seules les instances avec stockage et calcul intégrés prennent en charge cette fonctionnalité.

  • Le type de moteur de table est incompatible.

    La fonctionnalité de sauvegarde StarRocks prend uniquement en charge les tables utilisant le moteur OLAP. Si le type de moteur d'une table n'est pas OLAP, cette erreur est signalée.

• Solution :

  • Vérifiez le type d'instance.

    Sur la page Instance List de StarRocks, vérifiez la valeur Instance Type. Si le type d'instance est Storage-Compute Separation, la sauvegarde et la restauration des données ne sont pas prises en charge. Nous vous recommandons d'utiliser une instance avec stockage et calcul intégrés pour activer la sauvegarde et la restauration. Pour plus d'informations, consultez la section Sauvegarde et restauration.

  • Vérifiez le type de moteur de table.

    Vérifiez la définition DDL de la table cible pour confirmer si ENGINE=OLAP est défini.

    SHOW CREATE TABLE <table_name>;

    Si le moteur de la table n'est pas OLAP, recréez la table en fonction de vos besoins métier et assurez-vous que ENGINE=OLAP est spécifié.

Comment résoudre l'erreur « must be an aggregate expression or appear in GROUP BY clause » dans StarRocks ?

• Symptôme : lorsque vous exécutez une requête SQL contenant une clause GROUP BY dans StarRocks, l'erreur suivante se produit si la liste SELECT contient une colonne non agrégée qui n'est pas incluse dans la clause GROUP BY.

  Getting analyzing error: ... must be an aggregate expression or appear in GROUP BY clause

• Cause : la règle ONLY_FULL_GROUP_BY dans sql_mode déclenche cette erreur. Lorsque cette règle est activée, chaque colonne non agrégée de la liste SELECT doit également apparaître dans la clause GROUP BY.

• Solution :

  1. Connectez-vous à l'instance StarRocks à l'aide de l'éditeur SQL dans StarRocks Manager ou d'un client MySQL.

  2. Exécutez la commande suivante pour effacer sql_mode et supprimer la règle ONLY_FULL_GROUP_BY.

     SET GLOBAL sql_mode='';

  3. Vérifiez que sql_mode est vide.

     SELECT @@GLOBAL.sql_mode;

  Le paramètre SET GLOBAL sql_mode prend effet immédiatement sans redémarrage du service. La désactivation de ONLY_FULL_GROUP_BY peut produire des valeurs inexactes pour les colonnes non agrégées dans les requêtes GROUP BY. Testez cette modification dans un environnement de test avant de l'appliquer en production. Cette opération modifie le paramètre global.