InterSystems Caché est un SGBD multi-modèles et un serveur d'applications. Consultez plus de détails ici.
Ici, nous présenterons un exemple de code pour l'enregistrement et le référencement des plannings de tâches.
①Exemple d'enregistrement du calendrier des tâches
*Créez une tâche à exécuter do ^TEST tous les jours à 1h00.
Bonjour à tous,
Je cherche la syntaxe ou le moyen pour utiliser une classe créée dans le Namespace "BNA" (mon application) depuis le Namespace %SYS.
Voici le contexte :
Je dispose d'une application "BNA" contenue dans le NS "BNA", cette application met à disposition une fonctionnalité de création des utilisateurs. Cette fonctionnalité crée à la fois l'utilisateur dans une table de l'application et dans le système Iris.
Les mappages globaux peuvent être enregistrés à l'aide de la classe système Config.MapGlobals.
La méthode pour mapper globalement ^Sample.PersonD dans une base de données SAMPLES autre que la base de données par défaut de l'espace de noms USER est la suivante (exemple exécuté dans un terminal).
USER>zn"%SYS"%SYS>set ns="USER"%SYS>set glo="Sample.PersonD"%SYS>set vals("Database")="SAMPLES"%SYS>set st=##class (Config.MapGlobals).Create(ns,glo,.vals)La plupart des communications serveur-client sur le web sont basées sur une structure de demande et de réponse. Le client envoie une demande au serveur et le serveur répond à cette demande. Le protocole WebSocket fournit un canal de communication bidirectionnel entre un serveur et un client, permettant aux serveurs d'envoyer des messages aux clients sans recevoir de demande au préalable. Pour plus d'informations sur le protocole WebSocket et son implémentation dans InterSystems IRIS, voir les liens ci-dessous.
Ce tutoriel est une mise à jour de ["Asynchronous Websockets -- a quick tutorial"] (https://community.intersystems.com/post/asynchronous-websockets-quick-tutorial) pour Caché 2016.2+ et InterSystems IRIS 2018.1+.
Dans InterSystems IRIS, une connexion WebSocket peut être mise en œuvre de manière synchrone ou asynchrone. Le mode de fonctionnement de la connexion WebSocket entre le client et le serveur est déterminé par la propriété "SharedConnection" de la classe %CSP.WebSocket.
SharedConnection=1 : Fonctionnement asynchrone
SharedConnection=0: Fonctionnement synchrone
Une connexion WebSocket entre un client et un serveur hébergé sur une instance InterSystems IRIS comprend une connexion entre l'instance IRIS et la passerelle Web. En mode synchrone, la connexion utilise un canal privé. Dans le cas d'une opération WebSocket asynchrone, un groupe de clients WebSocket partage un pool de connexions entre l'instance IRIS et la passerelle Web. L'avantage d'une implémentation asynchrone des WebSockets est évident lorsque de nombreux clients se connectent au même serveur, car cette implémentation n'exige pas que chaque client soit traité par une connexion exclusive entre la passerelle Web et l'instance IRIS.
Dans ce tutoriel, nous mettrons en œuvre les WebSockets de manière asynchrone. Ainsi, toutes les fenêtres de chat ouvertes partagent un pool de connexions entre la passerelle Web et l'instance IRIS qui héberge la classe de serveur WebSocket.
Le "hello world" des WebSockets est une application de chat dans laquelle un utilisateur peut envoyer des messages qui sont diffusés à tous les utilisateurs connectés à l'application. Dans ce tutoriel, les composants de l'application de chat sont les suivants :
Serveur : implémenté dans une classe qui étend %CSP.WebSocket
Client: mis en œuvre par une page CSP
La mise en œuvre de cette application de chat permettra d'atteindre les objectifs suivants :
Les utilisateurs peuvent diffuser des messages à toutes les fenêtres de chat ouvertes
Les utilisateurs en ligne apparaissent dans la liste "Utilisateurs en ligne" de toutes les fenêtres de chat ouvertes.
Les utilisateurs peuvent changer leur nom d'utilisateur en composant un message commençant par le mot-clé "alias". Ce message ne sera pas diffusé mais mettra à jour la liste des "Utilisateurs en ligne".
Lorsque les utilisateurs ferment leur fenêtre de chat, ils sont retirés de la liste des "Utilisateurs en ligne".
Pour obtenir le code source de l'application de chat, veuillez consulter ce [dépôt GitHub] (https://github.com/intersystems/InterSystems-WebSockets).
Le côté client de notre application de chat est mis en œuvre par une page CSP contenant le style de la fenêtre de chat, la déclaration de la connexion WebSocket, les événements et méthodes WebSocket qui gèrent la communication vers et depuis le serveur, et les fonctions d'aide qui regroupent les messages envoyés au serveur et traitent les messages entrants.
Tout d'abord, nous verrons comment l'application initie la connexion WebSocket à l'aide d'une bibliothèque Javascript WebSocket.
ws = new WebSocket(((window.location.protocol === "https:")? "wss:":"ws:")
+ "//"+ window.location.host + "/csp/user/Chat.Server.cls");
new crée une nouvelle instance de la classe WebSocket. Celle-ci ouvre une connexion WebSocket au serveur en utilisant le protocole "wss" (indique l'utilisation de TLS pour le canal de communication WebSocket) ou "ws". Le serveur est spécifié par le numéro de port du serveur web et le nom de l'hôte de l'instance qui définit la classe Chat.Server (cette information est contenue dans la variable window.location.host). Le nom de notre classe de serveur (Chat.Server.cls) est inclus dans l'URI d'ouverture de la WebSocket en tant que requête GET pour la ressource sur le serveur.
L'événement ws.onopen se déclenche lorsque la connexion WebSocket est établie avec succès, passant d'un état connecting à un état open.
ws.onopen = function(event){
document.getElementById("headline").innerHTML = "CHAT - CONNECTED";
};
Cet événement met à jour l'en-tête de la fenêtre de chat pour indiquer que le client et le serveur sont connectés.
L'action d'un utilisateur qui envoie un message déclenche la fonction send. Cette fonction sert d'enveloppe à la méthode ws.send, qui contient les mécanismes d'envoi du message du client au serveur via la connexion WebSocket.
function send() {
var line=$("#inputline").val();
if (line.substr(0,5)=="alias"){
alias=line.split(" ")[1];
if (alias==""){
alias="default";
}
var data = {}
data.User = alias
ws.send(JSON.stringify(data));
} else {
var msg=btoa(line);
var data={};
data.Message=msg;
data.Author=alias;
if (ws && msg!="") {
ws.send(JSON.stringify(data));
}
}
$("#inputline").val("");
}
send compile les informations à envoyer au serveur dans un objet JSON, en définissant des paires clé/valeur en fonction du type d'information envoyée (mise à jour d'alias ou message général). btoa traduit le contenu d'un message général en une chaîne ASCII encodée en base 64.
Lorsque le client reçoit un message du serveur, l'événement ws.onmessage est déclenché.
ws.onmessage = function(event) {
var d=JSON.parse(event.data);
if (d.Type=="Chat") {
$("#chat").append(wrapmessage(d));
$("#chatdiv").animate({ scrollTop: $('#chatdiv').prop("scrollHeight")}, 1000);
} else if(d.Type=="userlist") {
var ul = document.getElementById("userlist");
while(ul.firstChild){ul.removeChild(ul.firstChild)};
$("#userlist").append(wrapuser(d.Users));
} else if(d.Type=="Status"){
document.getElementById("headline").innerHTML = "CHAT - connected - "+d.WSID;
}
};
Selon le type de message reçu par le client ("Chat", "userlist" ou "status"), l'événement onmessage appelle wrapmessage ou wrapuser pour remplir les sections appropriées de la fenêtre de chat avec les données entrantes. Si le message entrant est une mise à jour d'état, l'en-tête d'état de la fenêtre de discussion est mis à jour avec l'ID WebSocket, qui identifie la connexion WebSocket bidirectionnelle associée à la fenêtre de discussion.
Une erreur dans la communication entre le client et le serveur déclenche la méthode WebSocket onerror, qui émet une alerte nous informant de l'erreur et mettant à jour l'en-tête d'état de la page.
ws.onerror = function(event) {
document.GetElementById("headline").innerHTML = "CHAT - error";
alert("Received error");
};
The onclose method is triggered when the WebSocket connection between the client and server is closed and updates the status header.
ws.onclose = function(event) {
ws = null;
document.getElementById("headline").innerHTML = "CHAT - disconnected";
}
Le côté serveur de l'application de chat est implémenté par la classe Chat.Server, qui étend %CSP.WebSocket. Notre classe serveur hérite de diverses propriétés et méthodes de %CSP.WebSocket, dont certaines seront discutées ci-dessous. Chat.Server implémente également des méthodes personnalisées pour traiter les messages provenant du ou des client(s) et pour les diffuser.
OnPreServer() est exécutée avant la création du serveur WebSocket et est héritée de la classe %CSP.WebSocket.
Method OnPreServer() As %Status
{
set ..SharedConnection=1
if (..WebSocketID '= ""){
set ^Chat.WebSocketConnections(..WebSocketID)=""
} else {
set ^Chat.Errors($INCREMENT(^Chat.Errors),"no websocketid defined")=$HOROLOG
}
Quit $$$OK
}
Cette méthode définit le paramètre de classe SharedConnection à 1, indiquant que notre connexion WebSocket sera asynchrone et supportée par plusieurs processus qui définissent les connexions entre l'instance InterSystems IRIS et la Web Gateway. Le paramètre SharedConnection ne peut être modifié que dans OnPreServer(). OnPreServer() stocke également l'identifiant WebSocket associé au client dans le global ^Chat.WebSocketConnections.
L'essentiel de la logique exécutée par le serveur est contenu dans la méthode Server().```
Method Server() As %Status
{
do ..StatusUpdate(..WebSocketID)
for {
set data=..Read(.size,.sc,1)
if ($$$ISERR(sc)){
if ($$$GETERRORCODE(sc)=$$$CSPWebSocketTimeout) {
//$$$DEBUG("no data")
}
if ($$$GETERRORCODE(sc)=$$$CSPWebSocketClosed){
kill ^Chat.WebSocketConnections(..WebSocketID)
do ..RemoveUser($g(^Chat.Users(..WebSocketID)))
kill ^Chat.Users(..WebSocketID)
quit // Client closed WebSocket
}
} else{
if data["User"{
do ..AddUser(data,..WebSocketID)
} else {
set mid=$INCREMENT(^Chat.Messages)
set ^Chat.Messages(mid)=data
do ..ProcessMessage(mid)
}
}
}
Quit $$$OK
}
Cette méthode lit les messages entrants du client (en utilisant la méthode `Read` de la classe `%CSP.WebSockets`), ajoute les objets JSON reçus au global `^Chat.Messages`, et appelle `ProcessMessage()` pour transmettre le message à tous les autres clients de chat connectés. Lorsqu'un utilisateur ferme sa fenêtre de chat (mettant ainsi fin à la connexion WebSocket avec le serveur), l'appel à `Read` de la méthode `Server()` renvoie un code d'erreur qui évalue la macro `$$CSPWebSocketClosed` et la méthode procède à la gestion de la fermeture en conséquence.
### *Traitement et distribution des messages*
`ProcessMessage()` ajoute des métadonnées au message de chat entrant et appelle `SendData()`, en passant le message en paramètre.
ClassMethod ProcessMessage(mid As %String) { set msg = ##class(%DynamicObject).%FromJSON($GET(^Chat.Messages(mid))) set msg.Type="Chat" set msg.Sent=$ZDATETIME($HOROLOG,3) do ..SendData(msg) }
`ProcessMessage()` récupère le message au format JSON dans le global `^Chat.Messages` et le convertit en un objet IRIS d'InterSystems en utilisant la méthode `%FromJSON` de la classe `%DynamicObject`. Cela nous permet d'éditer facilement les données avant de transmettre le message à tous les clients de chat connectés. Nous ajoutons un attribut `Type` avec la valeur "Chat", que le client utilise pour déterminer comment traiter le message entrant. `SendData()` envoie le message à tous les autres clients de chat connectés.```
ClassMethod SendData(data As %DynamicObject)
{
set c = ""
for {
set c = $order(^Chat.WebSocketConnections(c))
if c="" Quit
set ws = ..%New()
set sc = ws.OpenServer(c)
if $$$ISERR(sc) { do ..HandleError(c,"open") }
set sc = ws.Write(data.%ToJSON())
if $$$ISERR(sc) { do ..HandleError(c,"write") }
}
}
SendData() convertit l'objet InterSystems IRIS en une chaîne JSON (data.%ToJSON()) et envoie le message à tous les clients du chat. SendData() récupère l'ID WebSocket associé à chaque connexion client-serveur dans le global ^Chat.WebSocketConnections et utilise l'ID pour ouvrir une connexion WebSocket via la méthode OpenServer de la classe %CSP.WebSocket. Nous pouvons utiliser la méthode OpenServer car nos connexions WebSocket sont asynchrones - nous puisons dans le pool existant de processus IRIS-Web Gateway et attribuons à l'un d'entre eux l'ID WebSocket qui identifie la connexion du serveur à un client de chat spécifique. Enfin, la méthode Write()%CSP.WebSocket` envoie la représentation JSON du message au client.
Cette application de chat montre comment établir des connexions WebSocket entre un client et un serveur hébergés par InterSystems IRIS. Pour en savoir plus sur le protocole et son implémentation dans InterSystems IRIS, consultez les liens dans l'introduction.
Salut les gars,
Il y a quelques jours, un client m'a contacté avec le souhait d'améliorer son application existante, qui utilise les services SOAP afin de partager la même autorisation avec sa nouvelle API d'application basée sur REST. Comme leur nouvelle application utilise OAuth2, le défi était clair : comment transmettre le token d'accès avec la requête SOAP au serveur.
Après avoir passé du temps sur Google, il s'est avéré que l'un des moyens possibles d'y parvenir consistait à ajouter un élément d'en-tête supplémentaire à l'enveloppe SOAP, puis à s'assurer que l'implémentation du WebService fait ce qui est nécessaire pour valider le jeton d'accèsю
Pour supprimer les produits InterSystems installés sur votre système Windows, utilisez Ajouter ou supprimer des programmes dans le Panneau de configuration (dans Windows 10, sélectionnez Apps dans les Paramètres Windows).
Comme nous allons apporter des modifications au système, vous devrez vous connecter en tant qu'utilisateur disposant de privilèges d'administrateur.
1) Connectez-vous au système en tant qu'administrateur.
InterSystems annonce la version de maintenance (MR) de Caché, Ensemble et Health Connect HSAP 2018.1.9. Il s'agit d'une version de maintenance avec de nombreuses mises à jour dans une grande variété de domaines.
Les kits d'installation complets du produit peuvent être téléchargés à partir du site Web de WRC Software Distribution :
Sous Linux, utilisez la commande iris pour exécuter une routine ou une méthode à partir d'un shell et obtenir la valeur de retour.
Pour plus d'informations, veuillez consulter le document "About Instance Connections".
Voici un exemple de commande.
iris terminal instname [arguments]Un outil (l'utilitaire ^GLOBUFF) est disponible pour vérifier l'utilisation du cache de la base de données pour chaque variable globale.
Vous pouvez exécuter l'utilitaire directement ou par programme dans l'espace de noms %SYS.
Voici comment exécuter l'utilitaire directement :
La commande $ZF(-100) est utilisée suivant le format suivant.
$ZF(-100, flags, command name, command arguments)Le flag "/shell" est nécessaire pour exécuter les commandes du système d'exploitation.
Par exemple, utilisez mkdir comme suit :
// mkdir C:\temp\newdir
Write$ZF(-100, "/shell", "mkdir", "C:\temp\newdir")Si une commande a plusieurs arguments, mettez-les entre guillemets et séparez-les par des virgules, comme dans l'exemple ci-dessous.
Bonjour, j'ai besoin de faire un prompt de mots de passe sans afficher ce que l'utilisateur rentre avec le Terminal IRIS. Je veux utiliser la commande READ mais je ne suis pas sure si c'est possible avec.
Si le système ne s'arrête pas pendant 24 heures, les anciens fichiers journaux seront supprimés à 0h30 selon les « Paramètres de suppression des fichiers journaux ».
Une cause possible pour laquelle des fichiers journaux restants sont plus anciens que les « Paramètres de suppression des fichiers journaux » est que certaines transactions restent ouvertes.
Dans ce cas, vous pourrez supprimer le fichier journal en recherchant les processus exécutant les transactions et en finalisant les transactions.
Les définitions de classe créées par les utilisateurs sont stockées dans des classes de définition de classe. Ils peuvent être utilisés pour obtenir une liste de définitions de classe à partir d'un programme.
Remarque : Les classes de définition de classe font référence à toutes les classes contenues dans le package %Dictionary.
Dans l'exemple de code ci-dessous, une liste de définitions de classe est obtenue à l'aide de la commande query Summary de la classe %Dictionary.ClassDefinitionQuery.
Bonjour a tous,
Dans le cadre d'un projet, j'ai mis en place à l'aide de quelques classes objectscript une solution de tests d'integration.
Son principe est basique, les tests sont rassemblés dans des suites elles mêmes incluses dans un fichier par classe ou ensemble de classes testé.
Mon outil m'affiche à l'écran le bon passage des tests et utilise des séquences d'échappement terminal pour mettre en exergue les échecs (écriture en rouge) .
Mon souci est maintenant que j'aimerai obtenir les résultat dans un fichier tcommunicable à mon client.
Au hasard d'un post sur le terminal Iris j'ai découvert une syntaxe que je souhaite partager avec la communauté :
Dans le shel de la session Iris il est possible d'exécuter une commande "OS" (shell pour linux & mac, CMD pour windows ) en précédant la commande par !.
Par exemple :
USER> ! ls /tmp -lhToutes les commandes fonctionnent parfaitement même encapsulées dans un sudo. ci dessous queqlues exemples :
Bien sur si vous êtes sur un serveur distant, les commandes shell s'exécutent sur ce dernier et non en local
La famille InterSystems IRIS a un utilitaire intéressant : ^SystemPerformance (aussi connu comme ^pButtons pour Caché et Ensemble) qui génère les informations sur les performances de la base de données dans un fichier HTML lisible. Lorsque vous exécutez ^SystemPerformance sur IRIS pour Windows, un fichier HTML est créé dans lequel notre propre journal de performances mgstat et notre journal de performances Windows sont inclus.
Vous ne le réalisez peut-être pas, mais votre compte de connexion InterSystems peut être utilisé pour accéder à un très large éventail de services InterSystems pour vous aider à apprendre et à utiliser InterSystems IRIS et d'autres technologies InterSystems plus efficacement. Continuez à lire pour en savoir plus sur la façon de débloquer de nouvelles connaissances et outils techniques à l’aide de votre compte de connexion InterSystems. Aussi - après avoir lu, veuillez participer au sondage en bas, afin que nous puissions voir en quoi cet article vous a été utile ! (Ndt : accéder à la
Pour résoudre l'erreur <PROTECT>, supprimez l'attribut en lecture seule de la base de données de bibliothèque à l'échelle du système (IRISLIB pour InterSystems IRIS, CACHELIB pour Caché/Ensemble/HealthShare (basé sur Caché)).
Une fois que vous avez terminé d'importer la routine, n'oubliez pas de la remettre en lecture seule.
[Version 2013.1 and above]
[Management Portal] > [System Administration] > [Configuration] > [System Configuration] > [Local Database] Uncheck "Mount read-only" from the database name link.
Il n'est pas nécessaire de recompiler les routines après la mise à niveau de la version, mais comme la mise à jour de la version écrase %SYS, les routines au format INT et OBJ créées par l'utilisateur (*.INT,*.OBJ) dans %SYS seront supprimées. Par conséquent, vous devez être prudent.
Les routines MAC, INT et OBJ portant les noms suivants ne sont pas supprimées.
%Z*.INT, %z*.INT, Z*.INT,z*.INT
%Z*.OBJ, %z*.OBJ, Z*.OBJ,z*.OBJ
Veuillez noter que les classes/CSP doivent être compilées après la mise à niveau.
Si une relation est définie et qu'il existe un grand nombre de n dans un rapport 1:n, une grande quantité de mémoire peut être consommée en raison du traitement séquentiel de la relation.
Après avoir référencé un objet à plusieurs côtés dans un programme et l'avoir fait pivoter en interne, le simple fait de libérer la variable contenant l'OREF (en la supprimant, en définissant une autre valeur, etc.) ne libérera pas les objets liés ni l'objet de relation.
Exemples de mappage
De toute évidence, si vous avez un quatrième article dans une trilogie, vous devez tenter votre chance et écrire le cinquième, alors le voici !
Si plusieurs produits InterSystems sont installés sur le même système, la dernière version du pilote ODBC InterSystems parmi les produits installés restera enregistrée dans le gestionnaire de pilotes.
Vous pouvez passer à n'importe quel pilote en modifiant l'entrée de la registry ci-dessous.
Veuillez noter que l'exécution de RegFiles.bat ne modifie pas le pilote ODBC.
L'entrée de la registry est la suivante.
HKEY_LOCAL_MACHINE\SOFTWARE\ODBC\ODBCINST.INI\InterSystems ODBC35 key Driver
HKEY_LOCAL_MACHINE\SOFTWARE\ODBC\ODBCINST.INI\InterSystems ODBC35 key SetupJe souhaite créer des fichiers excel (xls) et des fichiers pdf pour la création de rapports.
Ces rapports étant complexes je souhaite programmer en objectscript leur création et non utiliser un système de report.
Je cherche les classes qui pourraient m'aider à réaliser cette tâche sachant que pour moi ces classes doivent exister puisqu'Iris propose la génération de fichiers xls.
J'avais demandé à chatGpt qui m'a "inventé" une classe inexistante : %Library.Excel.Workbook qui correspondait tout a fait à ce que je cherche.
Mes questions sont donc :
Pour suivre les bonnes pratiques, j'utilise maintenant VSCode en remplacement de studio, toutefois cela me pose quelques problèmes dans la remontée des erreurs de compilation.
Dans les copies d'écran suivantes, j'utilise par erreur un paramètre inexistant : ..#MessageFinessExisting (en fait le paramètre correct est ..#MessageCentreFinessExisting).
Lorsque je sauve mon fichier dans VSCode et donc provoque sa compilation, j'obtiens une erreur de compilation, mais sans précision : 
En revanche si je compile cette même classe sous studio, j'obtiens un message m'indiquant quelle est l'erreur :
Si Iris propose bien de créer des clés suivant une séquence, comment faire pour obtenir un n° séquentiel dans un autre contexte ?
Dans mon cas, je créé automatiquement des centres de soins, et je souhaite leur fixer une numéro du type :
APP-DD-999
Il est bien sur possible que des centres soient créés de manière concurrente, il faut donc gérer cette concurrence éventuelle.
Dans cette série d'articles, j'aimerais présenter et discuter de plusieurs approches possibles pour le développement de logiciels avec les technologies d'InterSystems et GitLab. J'aborderai des sujets tels que:
Dans le premier article, nous avons évoqué les notions de base de Git, les raisons pour lesquelles une compréhension approfondie des concepts de Git est importante pour le développement de logiciels modernes et la manière dont Git peut être utilisé pour développer des logiciels.
Dans le deuxième article, nous avons évoqué le flux de travail GitLab - un processus complet du cycle de vie du logiciel ainsi que Diffusion continue.
Dans le troisième article, nous avons évoqué l'installation et la configuration de GitLab et la connexion de vos environnements à GitLab
Dans le quatrième article, nous avons écrit une configuration de CD.
Dans le cinquième article, nous avons parlé des conteneurs et de la manière dont ils peuvent être utilisés (et pour quelles raisons).
Dans le sixème article nous abordons des principaux composants dont vous aurez besoin pour exécuter un pipeline de diffusion continue avec des conteneurs et de la façon dont ils fonctionnent tous ensemble.
Dans cet article, nous allons créer une configuration de diffusion continue décrite dans les articles précédents.
Dans cette série d'articles, j'aimerais présenter et discuter de plusieurs approches possibles pour le développement de logiciels avec les technologies d'InterSystems et GitLab. J'aborderai des sujets tels que:
Dans le premier article, nous avons évoqué les notions de base de Git, les raisons pour lesquelles une compréhension approfondie des concepts de Git est importante pour le développement de logiciels modernes et la manière dont Git peut être utilisé pour développer des logiciels.
Dans le deuxième article, nous avons évoqué le flux de travail GitLab - un processus complet du cycle de vie du logiciel ainsi que Diffusion continue.
Dans le troisième article, nous avons évoqué l'installation et la configuration de GitLab et la connexion de vos environnements à GitLab
Dans le quatrième article, nous avons écrit une configuration de CD.
Dans le cinquième article, nous avons parlé des conteneurs et de la manière dont ils peuvent être utilisés (et pour quelles raisons).
Dans cet article, nous allons discuter des principaux composants dont vous aurez besoin pour exécuter un pipeline de diffusion continue avec des conteneurs et de la façon dont ils fonctionnent tous ensemble.
Dans cette série d'articles, j'aimerais présenter et discuter de plusieurs approches possibles pour le développement de logiciels avec les technologies d'InterSystems et GitLab. J'aborderai des sujets tels que :
Dans le premier article, nous avons évoqué les notions de base de Git, les raisons pour lesquelles une compréhension approfondie des concepts de Git est importante pour le développement de logiciels modernes et la manière dont Git peut être utilisé pour développer des logiciels.
Dans le deuxième article, nous avons évoqué le flux de travail GitLab - un processus complet du cycle de vie du logiciel ainsi que Diffusion continue.
Dans le troisième article, nous avons évoqué l'installation et la configuration de GitLab et la connexion de vos environnements à GitLab
Dans le quatrième article, nous avons écrit une configuration de CD.
Dans cet article, nous parlerons des conteneurs et de la manière dont ils peuvent être utilisés (et pour quelles raisons).
Dans cette série d'articles, j'aimerais présenter et discuter de plusieurs approches possibles pour le développement de logiciels avec les technologies d'InterSystems et GitLab. J'aborderai des sujets tels que:
Dans cette série d'articles, j'aimerais présenter et discuter de plusieurs approches possibles pour le développement de logiciels avec les technologies d'InterSystems et GitLab. J'aborderai des sujets tels que:
Dans le premier article, nous avons évoqué les notions de base de Git, les raisons pour lesquelles une compréhension approfondie des concepts de Git est importante pour le développement de logiciels modernes et la manière dont Git peut être utilisé pour développer des logiciels.
Dans le deuxième article, nous avons évoqué le flux de travail GitLab - un processus complet du cycle de vie du logiciel ainsi que Diffusion continue.
Dans cet article, nous allons examiner: