3.3. Création d'applications à l'aide de l'interface de programmation
Vous pouvez créer une application OpenShift Container Platform à partir de composants qui incluent du code source ou binaire, des images et des modèles en utilisant la CLI d'OpenShift Container Platform.
L'ensemble des objets créés par new-app dépend des artefacts transmis en entrée : référentiels de sources, images ou modèles.
3.3.1. Créer une application à partir du code source
La commande new-app permet de créer des applications à partir du code source d'un dépôt Git local ou distant.
La commande new-app crée une configuration de construction, qui elle-même crée une nouvelle image d'application à partir de votre code source. La commande new-app crée également un objet Deployment pour déployer la nouvelle image et un service pour fournir un accès équilibré au déploiement de votre image.
OpenShift Container Platform détecte automatiquement si la stratégie de construction pipeline, source ou docker doit être utilisée, et dans le cas de la construction source, détecte une image de constructeur de langage appropriée.
3.3.1.1. Locale
Pour créer une application à partir d'un dépôt Git dans un répertoire local :
oc new-app /<chemin d'accès au code source>
Si vous utilisez un dépôt Git local, le dépôt doit avoir un remote nommé origin qui pointe vers une URL accessible par le cluster OpenShift Container Platform. S'il n'y a pas de remote reconnu, l'exécution de la commande new-app créera un build binaire.
3.3.1.2. A distance
Pour créer une application à partir d'un dépôt Git distant :
$ oc new-app https://github.com/sclorg/cakephp-ex
Pour créer une application à partir d'un dépôt Git privé et distant :
$ oc new-app https://github.com/youruser/yourprivaterepo --source-secret=yoursecret
Si vous utilisez un dépôt Git distant privé, vous pouvez utiliser l'option --source-secret pour spécifier un secret de clone source existant qui sera injecté dans votre configuration de construction pour accéder au dépôt.
Vous pouvez utiliser un sous-répertoire de votre dépôt de code source en spécifiant un drapeau --context-dir. Pour créer une application à partir d'un dépôt Git distant et d'un sous-répertoire contextuel :
$ oc new-app https://github.com/sclorg/s2i-ruby-container.git \
--context-dir=2.0/test/puma-test-app
De plus, lorsque vous spécifiez une URL distante, vous pouvez spécifier une branche Git à utiliser en ajoutant #<branch_name> à la fin de l'URL :
$ oc new-app https://github.com/openshift/ruby-hello-world.git#beta4
3.3.1.3. Détection de la stratégie de construction
OpenShift Container Platform détermine automatiquement la stratégie de construction à utiliser en détectant certains fichiers :
Si un fichier Jenkins existe dans le répertoire racine ou le répertoire contextuel spécifié du référentiel source lors de la création d'une nouvelle application, OpenShift Container Platform génère une stratégie de construction de pipeline.
NoteLa stratégie de construction
pipelineest obsolète ; envisagez d'utiliser Red Hat OpenShift Pipelines à la place.- Si un fichier Docker existe dans le répertoire racine ou le répertoire contextuel spécifié du référentiel source lors de la création d'une nouvelle application, OpenShift Container Platform génère une stratégie de construction Docker.
- Si aucun fichier Jenkins ou Docker n'est détecté, OpenShift Container Platform génère une stratégie de construction de source.
Ignorez la stratégie de construction détectée automatiquement en attribuant à l'indicateur --strategy la valeur docker, pipeline ou source.
$ oc new-app /home/user/code/myapp --strategy=docker
La commande oc nécessite que les fichiers contenant les sources de compilation soient disponibles dans un dépôt Git distant. Pour toutes les constructions de sources, vous devez utiliser git remote -v.
3.3.1.4. Détection des langues
Si vous utilisez la stratégie de construction des sources, new-app tente de déterminer le constructeur de langage à utiliser en fonction de la présence de certains fichiers dans le répertoire racine ou le répertoire contextuel spécifié du référentiel :
| Langue | Dossiers |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Après la détection d'une langue, new-app recherche sur le serveur OpenShift Container Platform des balises de flux d'images ayant une annotation supports correspondant à la langue détectée, ou un flux d'images correspondant au nom de la langue détectée. Si aucune correspondance n'est trouvée, new-app recherche dans le registre Docker Hub une image dont le nom correspond à la langue détectée.
Vous pouvez remplacer l'image que le constructeur utilise pour un référentiel source particulier en spécifiant l'image, soit un flux d'images ou une spécification de conteneur, et le référentiel avec un ~ comme séparateur. Notez que dans ce cas, la détection de la stratégie de construction et la détection de la langue ne sont pas effectuées.
Par exemple, pour utiliser le flux d'images myproject/my-ruby dont la source se trouve dans un dépôt distant :
$ oc new-app myproject/my-ruby~https://github.com/openshift/ruby-hello-world.git
Pour utiliser le flux d'images du conteneur openshift/ruby-20-centos7:latest avec la source dans un dépôt local :
$ oc new-app openshift/ruby-20-centos7:latest~/home/user/code/my-ruby-app
La détection de la langue nécessite que le client Git soit installé localement afin que votre dépôt puisse être cloné et inspecté. Si Git n'est pas disponible, vous pouvez éviter l'étape de détection de la langue en spécifiant l'image du constructeur à utiliser avec votre référentiel à l'aide de la syntaxe <image>~<repository>.
L'invocation de -i <image> <repository> nécessite que new-app tente de cloner repository afin de déterminer le type d'artefact, ce qui échouera si Git n'est pas disponible.
L'invocation -i <image> --code <repository> demande à new-app de cloner repository pour déterminer si image doit être utilisé comme constructeur du code source ou déployé séparément, comme dans le cas d'une image de base de données.
3.3.2. Créer une application à partir d'une image
Vous pouvez déployer une application à partir d'une image existante. Les images peuvent provenir de flux d'images dans le serveur OpenShift Container Platform, d'images dans un registre spécifique ou d'images dans le serveur Docker local.
La commande new-app tente de déterminer le type d'image spécifié dans les arguments qui lui sont transmis. Toutefois, vous pouvez indiquer explicitement à new-app s'il s'agit d'une image conteneur en utilisant l'argument --docker-image ou d'un flux d'images en utilisant l'argument -i|--image-stream.
Si vous spécifiez une image à partir de votre dépôt Docker local, vous devez vous assurer que la même image est disponible pour les nœuds du cluster OpenShift Container Platform.
3.3.2.1. Image Docker Hub MySQL
Créez une application à partir de l'image MySQL de Docker Hub, par exemple :
$ oc new-app mysql
3.3.2.2. Image dans un registre privé
Créer une application en utilisant une image dans un registre privé, spécifier la spécification complète de l'image du conteneur :
$ oc new-app myregistry:5000/example/myimage
3.3.2.3. Flux d'images existant et balise de flux d'images optionnelle
Créer une application à partir d'un flux d'images existant et d'une balise de flux d'images optionnelle :
$ oc new-app my-stream:v1
3.3.3. Créer une application à partir d'un modèle
Vous pouvez créer une application à partir d'un modèle précédemment stocké ou d'un fichier de modèle, en spécifiant le nom du modèle comme argument. Par exemple, vous pouvez stocker un modèle d'application et l'utiliser pour créer une application.
Téléchargez un modèle d'application dans la bibliothèque de modèles de votre projet actuel. L'exemple suivant télécharge un modèle d'application à partir d'un fichier appelé examples/sample-app/application-template-stibuild.json:
$ oc create -f examples/sample-app/application-template-stibuild.json
Créez ensuite une nouvelle application en faisant référence au modèle d'application. Dans cet exemple, le nom du modèle est ruby-helloworld-sample:
$ oc new-app ruby-helloworld-sample
Pour créer une nouvelle application en faisant référence à un fichier modèle dans votre système de fichiers local, sans le stocker au préalable dans OpenShift Container Platform, utilisez l'argument -f|--file. Par exemple :
$ oc new-app -f examples/sample-app/application-template-stibuild.json
3.3.3.1. Paramètres du modèle
Lors de la création d'une application basée sur un modèle, utilisez l'argument -p|--param pour définir les valeurs des paramètres définis par le modèle :
$ oc new-app ruby-helloworld-sample \
-p ADMIN_USERNAME=admin -p ADMIN_PASSWORD=mypassword
Vous pouvez stocker vos paramètres dans un fichier, puis utiliser ce fichier avec --param-file lors de l'instanciation d'un modèle. Si vous souhaitez lire les paramètres à partir de l'entrée standard, utilisez --param-file=-. Voici un exemple de fichier appelé helloworld.params:
ADMIN_USERNAME=admin ADMIN_PASSWORD=mypassword
Faire référence aux paramètres du fichier lors de l'instanciation d'un modèle :
$ oc new-app ruby-helloworld-sample --param-file=helloworld.params
3.3.4. Modifier la création d'une application
La commande new-app génère des objets OpenShift Container Platform qui construisent, déploient et exécutent l'application créée. Normalement, ces objets sont créés dans le projet en cours et reçoivent des noms dérivés des dépôts de sources d'entrée ou des images d'entrée. Cependant, avec new-app, vous pouvez modifier ce comportement.
| Objet | Description |
|---|---|
|
|
Un objet |
|
|
Pour l'objet |
|
|
Un objet |
|
|
La commande |
| Autres | D'autres objets peuvent être générés lors de l'instanciation de modèles, en fonction du modèle. |
3.3.4.1. Spécification des variables d'environnement
Lorsque vous générez des applications à partir d'un modèle, d'une source ou d'une image, vous pouvez utiliser l'argument -e|--env pour transmettre des variables d'environnement au conteneur d'application au moment de l'exécution :
$ oc new-app openshift/postgresql-92-centos7 \
-e POSTGRESQL_USER=user \
-e POSTGRESQL_DATABASE=db \
-e POSTGRESQL_PASSWORD=password
Les variables peuvent également être lues à partir d'un fichier en utilisant l'argument --env-file. Voici un exemple de fichier appelé postgresql.env:
POSTGRESQL_USER=user POSTGRESQL_DATABASE=db POSTGRESQL_PASSWORD=password
Lire les variables du fichier :
$ oc new-app openshift/postgresql-92-centos7 --env-file=postgresql.env
En outre, les variables d'environnement peuvent être fournies sur l'entrée standard en utilisant --env-file=-:
$ cat postgresql.env | oc new-app openshift/postgresql-92-centos7 --env-file=-
Les objets BuildConfig créés dans le cadre du traitement new-app ne sont pas mis à jour avec les variables d'environnement transmises avec l'argument -e|--env ou --env-file.
3.3.4.2. Spécifier les variables de l'environnement de construction
Lorsque vous générez des applications à partir d'un modèle, d'une source ou d'une image, vous pouvez utiliser l'argument --build-env pour transmettre des variables d'environnement au conteneur de compilation au moment de l'exécution :
$ oc new-app openshift/ruby-23-centos7 \
--build-env HTTP_PROXY=http://myproxy.net:1337/ \
--build-env GEM_HOME=~/.gem
Les variables peuvent également être lues à partir d'un fichier en utilisant l'argument --build-env-file. Voici un exemple de fichier appelé ruby.env:
HTTP_PROXY=http://myproxy.net:1337/ GEM_HOME=~/.gem
Lire les variables du fichier :
$ oc new-app openshift/ruby-23-centos7 --build-env-file=ruby.env
En outre, les variables d'environnement peuvent être fournies sur l'entrée standard en utilisant --build-env-file=-:
$ cat ruby.env | oc new-app openshift/ruby-23-centos7 --build-env-file=-
3.3.4.3. Spécification des étiquettes
Lorsque vous générez des applications à partir de sources, d'images ou de modèles, vous pouvez utiliser l'argument -l|--label pour ajouter des étiquettes aux objets créés. Les étiquettes facilitent la sélection collective, la configuration et la suppression des objets associés à l'application.
$ oc new-app https://github.com/openshift/ruby-hello-world -l name=hello-world
3.3.4.4. Visualisation de la sortie sans création
Pour voir une simulation de l'exécution de la commande new-app, vous pouvez utiliser l'argument -o|--output avec une valeur yaml ou json. Vous pouvez ensuite utiliser la sortie pour prévisualiser les objets créés ou la rediriger vers un fichier que vous pouvez modifier. Lorsque vous êtes satisfait, vous pouvez utiliser oc create pour créer les objets OpenShift Container Platform.
Pour enregistrer les artefacts de new-app dans un fichier, procédez comme suit :
$ oc new-app https://github.com/openshift/ruby-hello-world \
-o yaml > myapp.yamlModifier le fichier :
$ vi myapp.yaml
Créez une nouvelle application en faisant référence au fichier :
$ oc create -f myapp.yaml
3.3.4.5. Création d'objets avec des noms différents
Les objets créés par new-app sont normalement nommés d'après le référentiel source ou l'image utilisée pour les générer. Vous pouvez définir le nom des objets produits en ajoutant le drapeau --name à la commande :
$ oc new-app https://github.com/openshift/ruby-hello-world --name=myapp
3.3.4.6. Création d'objets dans un autre projet
Normalement, new-app crée des objets dans le projet en cours. Cependant, vous pouvez créer des objets dans un autre projet en utilisant l'argument -n|--namespace:
$ oc new-app https://github.com/openshift/ruby-hello-world -n myproject
3.3.4.7. Création d'objets multiples
La commande new-app permet de créer plusieurs applications en spécifiant plusieurs paramètres à new-app. Les étiquettes spécifiées dans la ligne de commande s'appliquent à tous les objets créés par la commande unique. Les variables d'environnement s'appliquent à tous les composants créés à partir de la source ou des images.
Pour créer une application à partir d'un référentiel source et d'une image Docker Hub :
$ oc new-app https://github.com/openshift/ruby-hello-world mysql
Si un dépôt de code source et une image de constructeur sont spécifiés en tant qu'arguments séparés, new-app utilise l'image de constructeur comme constructeur pour le dépôt de code source. Si ce n'est pas le cas, spécifiez l'image du constructeur requise pour la source en utilisant le séparateur ~.
3.3.4.8. Regroupement d'images et de sources dans un même module
La commande new-app permet de déployer plusieurs images ensemble dans un seul pod. Pour spécifier les images à regrouper, utilisez le séparateur . L'argument de ligne de commande --group peut également être utilisé pour spécifier les images à regrouper. Pour regrouper l'image construite à partir d'un référentiel source avec d'autres images, spécifiez son image de construction dans le groupe :
$ oc new-app ruby+mysql
Pour déployer une image construite à partir de la source et une image externe ensemble :
$ oc new-app \
ruby~https://github.com/openshift/ruby-hello-world \
mysql \
--group=ruby+mysql3.3.4.9. Recherche d'images, de modèles et d'autres données
Pour rechercher des images, des modèles et d'autres entrées pour la commande oc new-app, ajoutez les drapeaux --search et --list. Par exemple, pour trouver toutes les images ou tous les modèles qui incluent PHP :
$ oc new-app --search php
