Points de contrôle
Create your cluster
/ 20
Create your pod
/ 30
Create a Kubernetes Service
/ 30
Scale up your service
/ 20
Hello Node Kubernetes
GSP005
Présentation
L'objectif de cet atelier pratique est de transformer du code que vous avez développé en application dupliquée exécutée sur Kubernetes, lui-même exécuté sur Kubernetes Engine. Pour cet atelier, le code sera une simple application node.js Hello World.
Voici un schéma des différents éléments impliqués dans cet atelier afin de vous aider à comprendre comment ils interagissent. Utilisez ce schéma comme référence au fur et à mesure de votre progression. Il devrait prendre tout son sens lorsque vous aurez terminé l'atelier. (Vous pouvez choisir de l'ignorer pour le moment.)
Kubernetes est un projet Open Source (disponible sur kubernetes.io) qui peut être exécuté sur de nombreux environnements différents : ordinateurs portables, clusters multinœuds haute disponibilité, clouds publics, déploiements sur site, machines virtuelles, serveurs physiques, etc.
Dans cet atelier, l'utilisation d'un environnement géré comme Kubernetes Engine (une version de Kubernetes hébergée par Google et exécutée sur Compute Engine) vous permettra de bien vous familiariser avec Kubernetes plutôt que de passer du temps à configurer l'infrastructure sous-jacente.
Objectifs de l'atelier
-
Créer un serveur Node.js
-
Créer une image de conteneur Docker
-
Créer un cluster de conteneur
-
Créer un pod Kubernetes
-
Assurer le scaling de vos services
Prérequis
- Une bonne connaissance des éditeurs de texte Linux standards tels que
vim
,emacs
ounano
vous sera utile.
Nous vous invitons à éviter le copier-coller et à saisir directement les commandes, afin de mieux assimiler les concepts fondamentaux. De nombreux ateliers comportent cependant un bloc de code qui réunit les commandes à saisir. Vous pouvez facilement copier et coller les commandes de ce bloc aux emplacements appropriés dans le cadre de l'atelier.
Configuration
Avant de cliquer sur le bouton "Démarrer l'atelier"
Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur Démarrer l'atelier, indique combien de temps les ressources Google Cloud resteront accessibles.
Cet atelier pratique vous permet de suivre vous-même les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Nous vous fournissons des identifiants temporaires pour vous connecter à Google Cloud le temps de l'atelier.
Pour réaliser cet atelier :
- vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome) ;
- vous disposez d'un temps limité ; une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.
Démarrer l'atelier et se connecter à la console Google Cloud
-
Cliquez sur le bouton Démarrer l'atelier. Si l'atelier est payant, un pop-up s'affiche pour vous permettre de sélectionner un mode de paiement. Sur la gauche, vous trouverez le panneau Détails concernant l'atelier, qui contient les éléments suivants :
- Le bouton Ouvrir la console Google
- Le temps restant
- Les identifiants temporaires que vous devez utiliser pour cet atelier
- Des informations complémentaires vous permettant d'effectuer l'atelier
-
Cliquez sur Ouvrir la console Google. L'atelier lance les ressources, puis ouvre la page Se connecter dans un nouvel onglet.
Conseil : Réorganisez les onglets dans des fenêtres distinctes, placées côte à côte.
Remarque : Si la boîte de dialogue Sélectionner un compte s'affiche, cliquez sur Utiliser un autre compte. -
Si nécessaire, copiez le nom d'utilisateur inclus dans le panneau Détails concernant l'atelier et collez-le dans la boîte de dialogue Se connecter. Cliquez sur Suivant.
-
Copiez le mot de passe inclus dans le panneau Détails concernant l'atelier et collez-le dans la boîte de dialogue de bienvenue. Cliquez sur Suivant.
Important : Vous devez utiliser les identifiants fournis dans le panneau de gauche. Ne saisissez pas vos identifiants Google Cloud Skills Boost. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés. -
Accédez aux pages suivantes :
- Acceptez les conditions d'utilisation.
- N'ajoutez pas d'options de récupération ni d'authentification à deux facteurs (ce compte est temporaire).
- Ne vous inscrivez pas aux essais offerts.
Après quelques instants, la console Cloud s'ouvre dans cet onglet.
Activer Cloud Shell
Cloud Shell est une machine virtuelle qui contient de nombreux outils pour les développeurs. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud. Cloud Shell vous permet d'accéder via une ligne de commande à vos ressources Google Cloud.
- Cliquez sur Activer Cloud Shell en haut de la console Google Cloud.
Une fois connecté, vous êtes en principe authentifié et le projet est défini sur votre ID_PROJET. Le résultat contient une ligne qui déclare YOUR_PROJECT_ID (VOTRE_ID_PROJET) pour cette session :
gcloud
est l'outil de ligne de commande pour Google Cloud. Il est préinstallé sur Cloud Shell et permet la complétion par tabulation.
- (Facultatif) Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :
-
Cliquez sur Autoriser.
-
Vous devez à présent obtenir le résultat suivant :
Résultat :
- (Facultatif) Vous pouvez lister les ID de projet à l'aide de cette commande :
Résultat :
Exemple de résultat :
gcloud
, dans Google Cloud, accédez au guide de présentation de la gcloud CLI.
Créer votre application Node.js
À l'aide de Cloud Shell, créez un serveur Node.js simple que vous allez déployer sur Kubernetes Engine :
vi server.js
Lancez l'éditeur :
i
Ajoutez le contenu suivant au fichier :
var http = require('http');
var handleRequest = function(request, response) {
response.writeHead(200);
response.end("Hello World!");
}
var www = http.createServer(handleRequest);
www.listen(8080);
Enregistrez le fichier server.js
: Échap, puis saisissez :
:wq
L'exécutable node
étant installé sur Cloud Shell, exécutez la commande suivante (qui ne produit pas de résultat) pour démarrer le serveur nœud :
node server.js
Utilisez la fonctionnalité d'aperçu Web intégrée à Cloud Shell pour ouvrir un nouvel onglet dans le navigateur et transmettre une demande à l'instance que vous venez de démarrer sur le port 8080.
Un nouvel onglet de navigateur contenant les résultats s'ouvre :
Avant de continuer, retournez dans Cloud Shell et saisissez Ctrl+c pour arrêter le serveur nœud en cours d'exécution.
À présent, vous allez empaqueter cette application dans un conteneur Docker.
Créer une image de conteneur Docker
Créez maintenant un Dockerfile
qui décrit l'image que vous voulez créer. Les images de conteneurs Docker peuvent être basées sur des images existantes. Pour cette image, nous partirons donc d'une image de nœud existante.
vi Dockerfile
Lancez l'éditeur.
i
Ajoutez le contenu suivant :
FROM node:6.9.2
EXPOSE 8080
COPY server.js .
CMD node server.js
Cette "recette" pour l'image Docker :
- se basera sur l'image
node
trouvée sur Docker Hub. - exposera le port
8080
- copiera notre fichier
server.js
sur l'image. - démarrera le serveur nœud comme nous l'avons déjà fait manuellement.
Enregistrez ce fichier Dockerfile
en appuyant sur Échap, puis saisissez :
:wq
Créez l'image à l'aide de la commande ci-dessous, en remplaçant PROJECT_ID
par l'ID de votre projet GCP que vous trouverez dans la console et à la section Connection Details de l'atelier :
docker build -t gcr.io/PROJECT_ID/hello-node:v1 .
Le téléchargement et l'extraction de tous les éléments peuvent prendre un peu de temps, mais des barres de progression s'affichent pendant la création de l'image.
Une fois celle-ci terminée, testez l'image en local avec la commande suivante, qui exécutera un conteneur Docker comme daemon sur le port 8080 à partir de l'image de conteneur que vous venez de créer. (Remplacez PROJECT_ID
par l'ID de votre projet GCP que vous trouverez dans la console et à la section Connection Details de l'atelier.)
docker run -d -p 8080:8080 gcr.io/PROJECT_ID/hello-node:v1
Votre résultat doit se présenter comme suit :
325301e6b2bffd1d0049c621866831316d653c0b25a496d04ce0ec6854cb7998
Pour afficher les résultats, utilisez la fonction d'aperçu Web de Cloud Shell :
Vous pouvez également utiliser curl
à partir de votre invite Cloud Shell :
curl http://localhost:8080
Voici le résultat que vous devez obtenir :
Hello World!
Ensuite, arrêtez le conteneur en cours d'exécution.
Recherchez l'ID du conteneur Docker en exécutant cette commande :
docker ps
Votre résultat doit se présenter comme suit :
CONTAINER ID IMAGE COMMAND
2c66d0efcbd4 gcr.io/PROJECT_ID/hello-node:v1 "/bin/sh -c 'node
Arrêtez le conteneur avec la commande suivante, en remplaçant l'ID du conteneur (CONTAINER ID) obtenu à l'étape précédente :
docker stop [CONTAINER ID]
Le résultat de votre console doit se présenter comme suit (l'ID de votre conteneur) :
2c66d0efcbd4
Maintenant que l'image fonctionne comme prévu, transférez-la vers Google Container Registry, un dépôt privé pour vos images Docker accessible à partir de vos projets Google Cloud.
Exécutez la commande suivante en remplaçant PROJECT_ID
par l'ID de votre projet GCP que vous trouverez dans la console ou à la section Connection Details de l'atelier.
gcloud auth configure-docker
docker push gcr.io/PROJECT_ID/hello-node:v1
Le transfert initial peut prendre quelques minutes. Des barres de progression s'affichent pendant la création.
The push refers to a repository [gcr.io/qwiklabs-gcp-6h281a111f098/hello-node]
ba6ca48af64e: Pushed
381c97ba7dc3: Pushed
604c78617f34: Pushed
fa18e5ffd316: Pushed
0a5e2b2ddeaa: Pushed
53c779688d06: Pushed
60a0858edcd5: Pushed
b6ca02dfe5e6: Pushed
v1: digest: sha256:8a9349a355c8e06a48a1e8906652b9259bba6d594097f115060acca8e3e941a2 size: 2002
L'image de conteneur est répertoriée dans votre console. Cliquez sur le menu de navigation > Container Registry.
Vous disposez maintenant d'une image Docker disponible au niveau du projet, que Kubernetes peut consulter et orchestrer.
Créer votre cluster
Vous êtes désormais prêt à créer votre cluster Container Engine. Un cluster se compose d'un serveur d'API maître Kubernetes hébergé par Google et d'un ensemble de nœuds de calcul. Les nœuds de calcul correspondent à des machines virtuelles Compute Engine.
Assurez-vous d'avoir défini votre projet à l'aide de gcloud
(remplacez PROJECT_ID
par l'ID de votre projet GCP, que vous trouverez dans la console et à la section Connection Details de l'atelier) :
gcloud config set project PROJECT_ID
Créez un cluster avec deux nœuds n1-standard-1 (cette opération prend quelques minutes) :
gcloud container clusters create hello-world \
--num-nodes 2 \
--machine-type n1-standard-1 \
--zone us-central1-a
Vous pouvez ignorer en toute sécurité les avertissements qui se présentent lors de la création du cluster.
Le résultat de la console doit se présenter comme suit :
Creating cluster hello-world...done.
Created [https://container.googleapis.com/v1/projects/PROJECT_ID/zones/us-central1-a/clusters/hello-world].
kubeconfig entry generated for hello-world.
NAME ZONE MASTER_VERSION MASTER_IP MACHINE_TYPE STATUS
hello-world us-central1-a 1.5.7 146.148.46.124 n1-standard-1 RUNNING
Remarque : Vous pouvez également créer ce cluster via la console, comme dans l'image ci-dessus : Kubernetes Engine > Kubernetes clusters > Create cluster.
Cliquez sur le menu de navigation > Kubernetes Engine pour découvrir que vous disposez à présent d'un cluster Kubernetes entièrement fonctionnel, exécuté sur Kubernetes Engine :
Il est temps de déployer votre propre application en conteneur sur le cluster Kubernetes. À partir de maintenant, vous utiliserez la ligne de commande kubectl
(déjà configurée dans votre environnement Cloud Shell).
Cliquez sur Vérifier ma progression ci-dessous pour vérifier votre progression dans l'atelier.
Créer votre pod
Un pod Kubernetes est un groupe de conteneurs réunis à des fins d'administration et de mise en réseau. Il peut contenir un ou plusieurs conteneurs. Dans cet exemple, vous allez utiliser un seul conteneur créé avec votre image Node.js stockée dans le registre de conteneurs privé. Il diffusera du contenu sur le port 8080.
Créez un pod avec la commande kubectl run
(remplacez PROJECT_ID
par l'ID de votre projet GCP, que vous trouverez dans la console et à la section Connection Details de l'atelier) :
kubectl create deployment hello-node \
--image=gcr.io/PROJECT_ID/hello-node:v1
Voici le résultat que vous devez obtenir :
deployment.apps/hello-node created
Comme vous pouvez le voir, vous avez créé un objet déploiement. L'utilisation des déploiements est recommandée pour créer et faire évoluer des pods. Dans le cas présent, un nouveau déploiement gère un seul pod dupliqué qui exécute l'image hello-node:v1
.
Pour afficher le déploiement, exécutez la commande suivante :
kubectl get deployments
Voici le résultat que vous devez obtenir :
NAME READY UP-TO-DATE AVAILABLE AGE
hello-node 1/1 1 1 1m36s
Pour afficher le pod créé par le déploiement, exécutez cette commande :
kubectl get pods
Voici le résultat que vous devez obtenir :
NAME READY STATUS RESTARTS AGE
hello-node-714049816-ztzrb 1/1 Running 0 6m
Nous vous proposons à présent de passer en revue quelques commandes kubectl
intéressantes. Aucune d'entre elles ne modifiera l'état du cluster (la documentation complète est disponible sur cette page) :
kubectl cluster-info
kubectl config view
Pour le dépannage :
kubectl get events
kubectl logs <pod-name>
Vous devez maintenant rendre votre pod accessible depuis l'extérieur.
Cliquez sur Vérifier ma progression ci-dessous pour vérifier votre progression dans l'atelier.
Autoriser le trafic externe
Par défaut, le pod n'est accessible que par le biais de son adresse IP interne au sein du cluster. Pour rendre le conteneur hello-node
accessible en dehors du réseau virtuel Kubernetes, vous devez présenter le pod sous la forme d'un service Kubernetes.
Depuis Cloud Shell, vous pouvez présenter le pod au réseau Internet public avec la commande kubectl expose
associée à l'indicateur --type="LoadBalancer"
. Cet indicateur est obligatoire pour créer une adresse IP accessible depuis l'extérieur :
kubectl expose deployment hello-node --type="LoadBalancer" --port=8080
Voici le résultat que vous devez obtenir :
service/hello-node exposed
L'indicateur utilisé dans cette commande spécifie que vous allez utiliser l'équilibreur de charge fourni par l'infrastructure sous-jacente (dans ce cas, l'équilibreur de charge Compute Engine). Remarquez que vous présentez le déploiement, et non le pod directement. Par conséquent, le service obtenu va répartir le trafic sur tous les pods gérés par le déploiement (dans le cas présent, un seul pod, mais vous ajouterez des instances dupliquées par la suite).
Le Kubernetes maître crée l'équilibreur de charge et les règles de transfert Compute Engine associées, les pools cibles et les règles de pare-feu afin de rendre le service entièrement accessible en dehors de Google Cloud Platform.
Pour trouver l'adresse IP publiquement accessible du service, demandez à kubectl
de répertorier tous les services du cluster :
kubectl get services
Voici le résultat que vous devez obtenir :
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE
hello-node 10.3.250.149 104.154.90.147 8080/TCP 1m
kubernetes 10.3.240.1 <none> 443/TCP 5m
Deux adresses IP accessibles par le port 8080
sont répertoriées pour votre service hello-node. CLUSTER-IP est l'adresse IP interne visible uniquement au sein de votre réseau virtuel cloud. EXTERNAL-IP correspond à l'adresse IP externe avec équilibrage de charge.
Vous devez maintenant pouvoir accéder au service en utilisant l'adresse suivante dans votre navigateur : http://<EXTERNAL_IP>:8080
À ce stade, nous avons acquis plusieurs fonctionnalités en passant aux conteneurs et à Kubernetes : nous n'avons pas besoin de spécifier sur quel hôte exécuter notre charge de travail, et nous bénéficions également de la surveillance des services et du redémarrage. Voyons quels autres avantages nous pouvons tirer de notre nouvelle infrastructure Kubernetes.
Cliquez sur Vérifier ma progression ci-dessous pour vérifier votre progression dans l'atelier.
Assurer le scaling de votre service
L'une des puissantes fonctionnalités de Kubernetes est le scaling de votre application, qui se fait très simplement. Imaginons que vous ayez soudain besoin d'augmenter la capacité de votre application. Vous pouvez demander au contrôleur de réplication de gérer un certain nombre de nouvelles instances dupliquées pour votre pod :
kubectl scale deployment hello-node --replicas=4
Voici le résultat que vous devez obtenir :
deployment.extensions/hello-node scaled
Vous pouvez demander la description du déploiement mis à jour :
kubectl get deployment
Voici le résultat que vous devez obtenir :
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
hello-node 4 4 4 4 16m
Vous pouvez également répertorier tous les pods :
kubectl get pods
Voici le résultat que vous devez obtenir :
NAME READY STATUS RESTARTS AGE
hello-node-714049816-g4azy 1/1 Running 0 1m
hello-node-714049816-rk0u6 1/1 Running 0 1m
hello-node-714049816-sh812 1/1 Running 0 1m
hello-node-714049816-ztzrb 1/1 Running 0 16m
Une approche déclarative est utilisée ici. Plutôt que de démarrer ou d'arrêter de nouvelles instances, vous déclarez le nombre d'instances à exécuter en permanence. Les boucles de réconciliation de Kubernetes veillent à ce que la réalité corresponde à votre demande et prennent des mesures si nécessaire.
Voici un schéma qui résume l'état de votre cluster Kubernetes :
Cliquez sur Vérifier ma progression ci-dessous pour vérifier votre progression dans l'atelier.
Déployer une mise à niveau sur votre service
À un moment donné, des corrections de bugs ou de nouvelles fonctionnalités seront nécessaires sur l'application que vous avez déployée en production. Kubernetes vous aide à déployer une nouvelle version en production sans affecter les utilisateurs.
Premièrement, modifiez l'application. Modifiez server.js
:
vi server.js
i
Ensuite, mettez à jour le message de réponse :
response.end("Hello Kubernetes World!");
Enregistrez le fichier server.js
: appuyez sur Échap, puis saisissez :
:wq
Vous pouvez à présent créer et publier une nouvelle image de conteneur sur le registre avec une balise comportant un numéro (v2
dans cet exemple).
Exécutez la commande suivante en remplaçant PROJECT_ID
par l'ID de votre projet, que vous trouverez dans la console et à la section Connection Details de cet atelier :
docker build -t gcr.io/PROJECT_ID/hello-node:v2 .
docker push gcr.io/PROJECT_ID/hello-node:v2
Kubernetes met à jour votre contrôleur de réplication de manière fluide pour installer la nouvelle version de l'application. Afin de modifier le libellé de l'image pour votre conteneur en cours d'exécution, vous devez modifier le déploiement hello-node deployment
existant et remplacer l'image gcr.io/PROJECT_ID/hello-node:v1
par gcr.io/PROJECT_ID/hello-node:v2
.
Pour ce faire, utilisez la commande kubectl edit
. Elle permet d'ouvrir un éditeur de texte qui affiche la configuration yaml complète du déploiement. Vous n'avez pas besoin de comprendre la configuration yaml complète pour le moment. Sachez simplement qu'en mettant à jour le champ spec.template.spec.containers.image
de la configuration, vous demandez au déploiement de mettre à jour les pods avec la nouvelle image.
kubectl edit deployment hello-node
Recherchez Spec
> containers
> image
et remplacez le numéro de version par v2:
# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
annotations:
deployment.kubernetes.io/revision: "1"
creationTimestamp: 2016-03-24T17:55:28Z
generation: 3
labels:
run: hello-node
name: hello-node
namespace: default
resourceVersion: "151017"
selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/hello-node
uid: 981fe302-f1e9-11e5-9a78-42010af00005
spec:
replicas: 4
selector:
matchLabels:
run: hello-node
strategy:
rollingUpdate:
maxSurge: 1
maxUnavailable: 1
type: RollingUpdate
template:
metadata:
creationTimestamp: null
labels:
run: hello-node
spec:
containers:
- image: gcr.io/PROJECT_ID/hello-node:v1 ## Update this line ##
imagePullPolicy: IfNotPresent
name: hello-node
ports:
- containerPort: 8080
protocol: TCP
resources: {}
terminationMessagePath: /dev/termination-log
dnsPolicy: ClusterFirst
restartPolicy: Always
securityContext: {}
terminationGracePeriodSeconds: 30
Après avoir effectué la modification, enregistrez et fermez ce fichier : appuyez sur Échap, puis saisissez :
:wq
Voici le résultat que vous devez obtenir :
deployment.extensions/hello-node edited
Exécutez la commande suivante pour mettre à jour le déploiement avec la nouvelle image.
kubectl get deployments
De nouveaux pods seront créés avec la nouvelle image et les anciens pods seront supprimés.
Voici le résultat que vous devez obtenir (vous devrez peut-être réexécuter la commande ci-dessus pour voir ce qui suit):
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
hello-node 4 4 4 4 1h
Pendant cette opération, les utilisateurs de vos services ne devraient pas constater d'interruption. Au bout d'un moment, ils commenceront à accéder à la nouvelle version de votre application. Vous trouverez davantage d'informations sur le déploiement de mises à jour dans cette documentation.
Une fois votre cluster Kubernetes Engine configuré, nous espérons que ces fonctionnalités de déploiement, de scaling et de mise à jour offertes par Kubernetes vous aideront à vous concentrer sur l'application plutôt que sur l'infrastructure.
Tester vos connaissances
Testez vos connaissances sur Google Cloud Platform en répondant à notre quiz. (Sélectionnez plusieurs réponses.)
Félicitations !
Notre atelier pratique sur Kubernetes se termine ici. Nous n'avons fait qu'effleurer les possibilités offertes par cette technologie. Nous vous encourageons à l'explorer davantage avec vos propres pods, contrôleurs de réplication et services, mais également à vous renseigner sur les vérifications de vivacité (vérification de l'état) et à envisager d'utiliser directement l'API Kubernetes.
Suivre votre prochain atelier
Continuez sur votre lancée en suivant l'atelier Gérer des déploiements avec Kubernetes Engine ou consultez ces suggestions :
Étapes suivantes et informations supplémentaires
- Après cet atelier, découvrez Minikube, qui permet de configurer facilement d'un cluster Kubernetes à nœud unique à des fins de développement et de test : http://kubernetes.io/docs/getting-started-guides/minikube/.
- Kubernetes est un projet Open Source (http://kubernetes.io/) hébergé sur GitHub. Vos commentaires et contributions sont donc toujours utiles.
- Vous pouvez rester informé de l'actualité de Kubernetes sur Twitter et sur le blog de la communauté.
Formations et certifications Google Cloud
Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.
Dernière mise à jour du manuel : 4 décembre 2020
Dernier test de l'atelier : 4 décembre 2020
Copyright 2024 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.