Quick start for the saectl tool - Serverless App Engine - Centre de documentation Alibaba Cloud

Prérequis

Avant de commencer, assurez-vous d'avoir :

Installé et configuré saectl avec un AccessKey ID, un AccessKey secret et une région de déploiement d'application — consultez Installer et configurer l'outil saectl

Démarrage rapide

Les commandes suivantes illustrent le flux de travail minimal pour convertir un fichier YAML Kubernetes et déployer une application sur SAE :

saectl convert -f <k8s-file.yaml> -o <sae-file.yaml>  # Convert a Kubernetes YAML file to an SAE YAML file
saectl apply -f <sae-file.yaml>                        # Deploy the application
saectl get deployment <deployment-name>                # Check deployment status: PUBLISHING = in progress, RUNNING = ready

Pour un exemple complet de bout en bout, consultez Déployer Nginx à l'aide de saectl.

Convertir un fichier YAML Kubernetes en fichier YAML SAE

Les fichiers YAML SAE suivent les spécifications SAE, qui diffèrent des spécifications Kubernetes. Utilisez la commande convert pour générer un fichier compatible SAE à partir d'un fichier YAML Kubernetes existant, puis déployez-le avec apply.

Convertissez le fichier YAML Kubernetes :

saectl convert -f <k8s-compliant-file.yaml> -o <sae-compliant-file.yaml>

Déployez l'application :

saectl apply -f <sae-compliant-file.yaml>

En cas d'erreur, corrigez le fichier YAML SAE selon le message d'erreur, puis exécutez à nouveau apply. Les erreurs se répartissent en deux catégories :
- Champs non pris en charge ou au format différent : Certains champs présents dans les fichiers YAML Kubernetes ne sont pas pris en charge ou requièrent un format différent dans les fichiers YAML SAE. Supprimez ou remplacez ces champs après la conversion. Pour connaître les champs pris en charge et les exigences de format, consultez les autres rubriques de ce répertoire.
- Champs obligatoires manquants : Certains champs requis par les fichiers YAML SAE peuvent être absents du fichier YAML Kubernetes. Après la conversion, un espace réservé ${parameter_name} indique chaque champ manquant. Remplacez l'espace réservé par la valeur réelle. Par exemple, SAE nécessite un Virtual Private Cloud (VPC) lors de la définition d'un namespace, mais les fichiers YAML Kubernetes n'incluent pas ce paramètre. Après la conversion, l'espace réservé ${vpc-id} apparaît dans la sortie :
```
apiVersion: v1
kind: Namespace
metadata:
  annotations:
    sae.aliyun.com/vpc-id: ${vpc-id}
  creationTimestamp: null
  labels:
    kubernetes.io/metadata.name: default
  name: nstest
spec: {}
status: {}
```

Important

Si un fichier YAML Kubernetes définit plusieurs ressources, séparez-les à l'aide du séparateur standard Kubernetes --- dans un seul fichier. saectl convertit toutes les ressources en une seule fois. Toutefois, les ressources contenues dans le même fichier ne doivent pas dépendre d'un ordre d'exécution spécifique. Par exemple, si un Deployment et un Service dépendant de ce Deployment figurent dans le même fichier, le déploiement échoue car les deux ressources sont créées simultanément. Définissez les ressources dont l'ordre est important dans des fichiers distincts et appliquez-les séquentiellement.

Déployer Nginx à l'aide de saectl

Cet exemple déploie Nginx sur SAE à l'aide de deux fichiers YAML Kubernetes — un Deployment et un Service — avant de procéder au nettoyage.

Commencez avec les deux fichiers YAML Kubernetes suivants : nginx-deployment.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
  labels:
    app: nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: registry.cn-beijing.aliyuncs.com/sae-serverless-demo/sae-demo:nginx-v1.23.4
        ports:
        - containerPort: 80
        resources:
          requests:
            cpu: "1"
            memory: "2Gi"

nginx-service.yaml :

apiVersion: v1
kind: Service
metadata:
  name: nginx
spec:
  allocateLoadBalancerNodePorts: true
  ports:
  - port: 80
    protocol: TCP
  selector:
    app: nginx
  type: LoadBalancer

Convertissez les deux fichiers au format YAML SAE :

saectl convert -f nginx-deployment.yaml -o output-nginx-deployment.yaml
saectl convert -f nginx-service.yaml -o output-nginx-service.yaml

Déployez le Deployment et vérifiez son état :

saectl apply -f output-nginx-deployment.yaml
saectl get deployment nginx  # STATE: PUBLISHING = in progress, RUNNING = ready

Attendez que l'état (STATE) soit RUNNING avant de poursuivre.

Créez le Service et obtenez l'adresse IP publique :

saectl apply -f output-nginx-service.yaml
saectl get service internet-nginx -o wide  # EXTERNAL-IP: <pending> = creating, IP address = ready

Dès que EXTERNAL-IP affiche une adresse IP, accédez à l'application :

curl http://<public-ip>:<port>

Nettoyez l'environnement — supprimez le Deployment et le Service une fois terminé :

saectl delete -f output-nginx-deployment.yaml  # The Service is deleted along with the Deployment

Convertir un fichier Docker Compose en fichier YAML SAE

Pour migrer une application depuis Docker Compose vers SAE :

Convertissez le fichier YAML Docker Compose en fichier YAML Kubernetes. Pour obtenir des instructions, consultez la documentation Kompose.
Convertissez le fichier YAML Kubernetes en fichier YAML SAE à l'aide de saectl convert, comme décrit ci-dessus.

Gérer les namespaces

saectl prend en charge la création, la consultation et la suppression de namespaces. La mise à jour des namespaces n'est pas prise en charge.

Créer un namespace

Créez un fichier nommé namespace.yaml avec le contenu suivant :

apiVersion: v1
kind: Namespace
metadata:
  annotations:
    sae.aliyun.com/vpc-id: ${vpc-id}    # Replace with the VPC ID (format: vpc-xxxxxxxxxxxxxxxxxxxxx)
  name: ${namespace}                     # Replace with the namespace name
spec: {}

Appliquez le fichier pour créer le namespace :
```
saectl apply -f namespace.yaml
```

Consulter les namespaces

saectl get ns

Exemple de sortie :

NAME        STATUS   REGION
default     Active   cn-beijing
testns      Active   cn-beijing

Champ	Description
NAME	Nom du namespace. `default` est le namespace par défaut.
STATUS	État du namespace. `Active` signifie que le namespace est disponible.
REGION	Région où se trouve le namespace.

Supprimer un namespace

saectl delete ns <namespace>  # Replace <namespace> with the namespace name

Gérer les applications

saectl prend en charge la création, la consultation, la mise à jour et la suppression d'applications.

Créer une application

Créez un fichier nommé deployment.yaml avec le contenu suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ${deployment-name}              # Replace with the application name
spec:
  replicas: 2                           # Number of application instances
  selector:
    matchLabels:
      sae.aliyun.com/app-name: ${deployment-name}
  template:
    metadata:
      labels:
        sae.aliyun.com/app-name: ${deployment-name}
    spec:
      containers:
      - name: main                      # Use "main" to avoid conflicts
        image: registry.openanolis.cn/openanolis/nginx:1.14.1-8.6

Appliquez le fichier pour créer l'application dans le namespace par défaut :
```
saectl apply -f deployment.yaml
```

Vérifiez que l'application est en cours d'exécution :

saectl get deployment <deployment-name>  # STATE: RUNNING means the application is up

Consultez les instances Pod de l'application :

saectl get pods -l sae.aliyun.com/app-name=<deployment-name>

Consulter la liste des applications

saectl get deployment -n <namespace>  # Omit -n to use the default namespace

Exemple de sortie :

NAME         READY   AVAILABLE   TYPE    STATE     LANGUAGE   AGE
test-yaml    3/3     3           Image   RUNNING   java       6d1h
sc-c         2/2     2           Image   RUNNING   java       13d
sc-b         2/2     2           Image   RUNNING   java       13d
sc-a         1/1     1           Image   RUNNING   java       13d

Champ	Description
NAME	Nom de l'application.
READY	Instances prêtes / instances cibles. Une instance est prête lorsqu'elle réussit le test de readiness probe.
AVAILABLE	Instances actuellement en cours d'exécution.
TYPE	Méthode de déploiement. `Image` signifie que l'application est déployée à partir d'une image de conteneur.
STATE	État de l'application. `RUNNING` signifie que l'application est en cours d'exécution.
LANGUAGE	Stack technologique de l'application.
AGE	Durée d'exécution de l'application.

Consulter les détails d'une application

Utilisez get pour afficher la configuration YAML ou describe pour afficher tous les détails.

Afficher la configuration de l'application

saectl get deployment <deployment-name> -o yaml -n <namespace>  # Omit -n to use the default namespace

Afficher les détails de l'application

saectl describe deployment <deployment-name> -n <namespace>  # Omit -n to use the default namespace

Mettre à jour une application

Trois commandes sont disponibles : scale, edit et apply.

Mettre à l'échelle une application

saectl scale deployment <deployment-name> --replicas=<pod-num> -n <namespace>
# <pod-num>: the desired number of instances
# Omit -n to use the default namespace

Modifier la configuration de l'application en ligne

Ouvrez la configuration YAML de l'application dans un éditeur :

saectl edit deployment <deployment-name> -n <namespace>  # Omit -n to use the default namespace

Modifiez la configuration, puis enregistrez et fermez le fichier. Les modifications sont appliquées automatiquement.

Appliquer la configuration mise à jour à partir d'un fichier

Modifiez deployment.yaml, puis exécutez :

saectl apply -f deployment.yaml

Supprimer une application

saectl delete deployment <deployment-name> -n <namespace>  # Omit -n to use the default namespace

Gérer les instances SLB

Les instances SLB correspondent au type de ressource Service dans Kubernetes. saectl prend en charge la création, la consultation, la mise à jour et le détachement des instances SLB.

Créer une nouvelle instance SLB

Créez un fichier nommé svc.yaml avec le contenu suivant :

apiVersion: v1
kind: Service
metadata:
  name: internet-${deployment-name}     # "internet" = public network; use "intranet" for private network
                                        # Replace ${deployment-name} with the application name
spec:
  ports:
  - name: port-80
    port: 80                            # Port used to access the application
    protocol: TCP
    targetPort: 80                      # Port exposed by the container
  selector:
    sae.aliyun.com/app-name: ${deployment-name}

Appliquez le fichier pour créer l'instance SLB :
```
saectl apply -f svc.yaml
```

Attacher une application à une instance SLB existante

Créez un fichier nommé svc.yaml avec l'annotation sae.aliyun.com/loadbalancer-id :

apiVersion: v1
kind: Service
metadata:
  annotations:
    sae.aliyun.com/loadbalancer-id: ${your-slb-id}   # Replace with the SLB ID
  name: internet-${deployment-name}                   # Replace ${deployment-name} with the application name
spec:
  ports:
  - name: port-80
    port: 80
    protocol: TCP
    targetPort: 80
  selector:
    sae.aliyun.com/app-name: ${deployment-name}

Appliquez le fichier :
```
saectl apply -f svc.yaml
```

Consulter les instances SLB

saectl get service -l sae.aliyun.com/app-name=<deployment-name> -n <namespace>
# Omit -l to list SLB instances for all applications
# Omit -n to use the default namespace

Exemple de sortie :

NAME               TYPE           EXTERNAL-IP    PORT(S)   BOUND    AGE
internet-myapp     LoadBalancer   xxx.x.xx.xx    80/TCP    myapp    6d20h
intranet-myapp     LoadBalancer   xx.xx.xxx.xx   80/TCP    myapp    4d1h

Champ	Description
NAME	Nom du Service au format `<network-type>-<application-name>`. `internet` = réseau public, `intranet` = réseau privé.
TYPE	Type de Service. `LoadBalancer` désigne une instance SLB.
EXTERNAL-IP	Adresse IP de l'instance SLB.
PORT(S)	Mappage de ports de l'instance SLB.
BOUND	Application à laquelle l'instance SLB est attachée.
AGE	Durée d'existence du service.

Consulter les détails d'une instance SLB

saectl get service <service-name> -o yaml -n <namespace>  # Omit -n to use the default namespace

Mettre à jour une instance SLB

Utilisez edit pour mettre à jour en ligne ou apply pour mettre à jour à partir d'un fichier.

Modifier la configuration SLB en ligne

Ouvrez la configuration SLB dans un éditeur :

saectl edit service <service-name> -n <namespace>  # Omit -n to use the default namespace

Modifiez la configuration, puis enregistrez et fermez le fichier. Les modifications sont appliquées automatiquement.

Appliquer la configuration mise à jour à partir d'un fichier

Modifiez svc.yaml, puis exécutez :

saectl apply -f svc.yaml

Détacher une instance SLB

saectl delete service <service-name> -n <namespace>  # Omit -n to use the default namespace

Gérer les ConfigMaps

saectl prend en charge la création, la consultation, la mise à jour et la suppression de ConfigMaps. Un ConfigMap stocke la configuration sous forme de paires clé-valeur, que vous pouvez référencer en tant que variables d'environnement ou monter en tant que fichier à l'intérieur d'un conteneur.

Créer un ConfigMap

Créez un fichier nommé cm.yaml avec le contenu suivant :

apiVersion: v1
kind: ConfigMap
metadata:
  name: database-configmap   # ConfigMap name
  namespace: default         # Namespace where the ConfigMap is created
data:                        # Key-value pairs
  database: mysql
  database_uri: mysql://localhost:2309

Appliquez le fichier pour créer le ConfigMap :
```
saectl apply -f cm.yaml
```

Consulter les ConfigMaps

Lister les ConfigMaps dans tous les namespaces

saectl get configmap -A

Exemple de sortie :

NAMESPACE   NAME            DATA   AGE
default     nacos           1      69d
test        test-config     2      10d

Champ	Description
NAMESPACE	Namespace où se trouve le ConfigMap.
NAME	Nom du ConfigMap.
DATA	Nombre de paires clé-valeur dans le ConfigMap.
AGE	Durée d'existence du ConfigMap.

Lister les ConfigMaps dans un namespace

saectl get configmap -n <namespace>  # Omit -n to use the default namespace

Afficher les détails d'un ConfigMap

saectl get cm <cm-name> -o yaml -n <namespace>  # Omit -n to use the default namespace

Utiliser un ConfigMap dans un conteneur

Référencer en tant que variables d'environnement

Montez des paires clé-valeur individuelles ou toutes les paires en tant que variables d'environnement :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test-configmap
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      sae.aliyun.com/app-name: test-configmap
  template:
    metadata:
      creationTimestamp: null
      labels:
        sae.aliyun.com/app-name: test-configmap
    spec:
      containers:
      - args:
        - /home/admin/start.sh
        command:
        - /bin/bash
        env:                             # Reference individual key-value pairs
        - name: database                 # Environment variable name in the container
          valueFrom:
            configMapKeyRef:             # Value comes from the "database" key in database-configmap
              key: database
              name: database-configmap
        envFrom:                         # Reference all key-value pairs
        - configMapRef:                  # All pairs in other-configmap become environment variables
            name: other-configmap
        name: main
        image: registry.cn-shenzhen.aliyuncs.com/sae-serverless-demo/sae-demo:microservice-java-provider-v1.0
        imagePullPolicy: Always
        resources:
          limits:
            cpu: "2"
            memory: 4Gi
          requests:
            cpu: "2"
            memory: 4Gi
      restartPolicy: Always
      terminationGracePeriodSeconds: 10

Monter en tant que fichier

Montez un ConfigMap en tant que fichier à un chemin spécifié à l'intérieur du conteneur :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test-configmap
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      sae.aliyun.com/app-name: test-configmap
  template:
    metadata:
      labels:
        sae.aliyun.com/app-name: test-configmap
    spec:
      containers:
      - args:
        - /home/admin/start.sh
        command:
        - /bin/bash
        name: main
        image: registry.cn-shenzhen.aliyuncs.com/sae-serverless-demo/sae-demo:microservice-java-provider-v1.0
        imagePullPolicy: Always
        resources:
          limits:
            cpu: "2"
            memory: 4Gi
          requests:
            cpu: "2"
            memory: 4Gi
        volumeMounts:
        - mountPath: /tmp/nacos          # Path where the ConfigMap file is mounted
          name: my-volume
      volumes:
      - configMap:
          name: nacos-configmap          # ConfigMap to mount as my-volume
        name: my-volume
      restartPolicy: Always
      terminationGracePeriodSeconds: 10

Mettre à jour un ConfigMap

Utilisez edit pour mettre à jour en ligne ou apply pour mettre à jour à partir d'un fichier.

Modifier un ConfigMap en ligne

Ouvrez le ConfigMap dans un éditeur :

saectl edit cm <cm-name> -n <namespace>  # Omit -n to use the default namespace

Modifiez la configuration, puis enregistrez et fermez le fichier. Les modifications sont appliquées automatiquement.

Appliquer la configuration mise à jour à partir d'un fichier

Modifiez cm.yaml, puis exécutez :

saectl apply -f cm.yaml

Supprimer un ConfigMap

saectl delete cm <cm-name> -n <namespace>  # Omit -n to use the default namespace

Étapes suivantes

Installer et configurer l'outil saectl
Explorez les autres rubriques de ce répertoire pour connaître les champs YAML pris en charge et les exigences de format des fichiers YAML SAE.