以前はMac上でDockerを動かす場合は、Docker for Macを使用していましたが、ある時点でマルウェア判定されてしまい、削除されてしまいました。

以下の記事によれば、最新版では解決しているようです。

Docker Desktop for Macがエラーで起動できない件(#7527)についての情報

そこで他の選択肢はないか調べてみるといくつか選択肢がありました。

その中でColimaというのがあり、設定してみました。

Colima で Docker と Docker Compose を使ってみた

設定も非常に簡単であり、実際のdockerやdocker composeの動かし方はほとんど変わりません。

一つColimaの方が良いと感じたのは、Docker for Macの場合、IRISのスクリプトの実行の結果として出力されるメッセージは、スクロールされて、Dockerコンテナの起動が終了すると、痕跡が残らないため途中でエラーが発生してもその場で確認できませんでしたが、Colimaの場合、ターミナル上で垂れ流されるだけなので、そのターミナルのスクリーンをロールバックすることで出力メッセージを確認できる点です。

説明

これは、ネイティブウェブアプリケーションとして IRIS にデプロイできる Django アプリケーションのテンプレートです。

インストール

1. リポジトリをクローンする
2. 仮想環境を作成する
3. 要件をインストールする
4. docker-compose ファイルを実行する

git clone
cd iris-django-template
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
docker-compose up

使用法

ベース URL は http://localhost:53795/django/ です。

エンドポイント

• /iris - IRISAPP ネームスペースに存在する上位 10 個のクラスを持つ JSON オブジェクトを返します。
• /interop - IRIS の相互運用性フレームワークをテストするための ping エンドポイント。
• /api/posts - Post オブジェクトの単純な CRUD エンドポイント。
• ``/api/comments` - Comment オブジェクトの単純な CRUD エンドポイント。

このテンプレートからの開発方法

WSGI 導入記事をご覧ください: wsgi-introduction。

概要: セキュリティポータルで DEBUG フラグをトグルすると、開発作業の過程で変更内容がアプリケーションに反映されるようになります。

コードの説明

Django アプリケーションは次のように構造化されています。

• app - Django プロジェクトフォルダ
  • app - 構成用の Django アプリフォルダ
    • settings.py - Django の設定ファイル
    • urls.py - ビューを URL に接続する Django URL 構成ファイル
    • wsgi.py - Django WSGI ファイル
    • asgi.py - Django ASGI ファイル
  • community - コミュニティアプリの Django アプリフォルダ、Post と Comment オブジェクトでの CRUD 操作
    • models.py - Post と Comment オブジェクトの Django モデルファイル
    • views.py - Post と Comment オブジェクトにアクセスするための Django ビューファイル
    • serializers.py - Post と Comment オブジェクトの Django シリアライザーファイル
    • admin.py - 管理インターフェースに CRUD 操作を追加する Django 管理ファイル
    • migrations - データベースを構築するための Django マイグレーションフォルダ
    • fixtures - Django fixtures フォルダデモデータ
  • sqloniris - IRIS アプリでの SQL に使用する Django アプリフォルダ
    • views.py - IRISAPP ネームスペースをクエリするための Django ビューファイル
    • apps.py - Django アプリ構成ファイル
  • interop - 相互運用性アプリ用の Django アプリフォルダ
    • views.py - 相互運用性フレームワークをテストするための Django ビューファイル
    • apps.py - Django アプリ構成ファイル
  • manage.py - Django 管理ファイル

app/settings.py

このファイルには、アプリケーションの Django 設定が含まれます。

...

# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'community',
    'sqloniris',
    'interop',
    'rest_framework'
]

...

REST_FRAMEWORK = {
    # Use Django's standard `django.contrib.auth` permissions,
    # or allow read-only access for unauthenticated users.
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.DjangoModelPermissionsOrAnonReadOnly'
    ],
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination',
    'PAGE_SIZE': 20
}

...

DATABASES = {
    "default": {
        "ENGINE": "django_iris",
        "EMBEDDED": True,
        "NAMESPACE": "IRISAPP",
        "USER":"SuperUser",
        "PASSWORD":"SYS",
    }
}

一部の重要な設定:

• INSTALLED_APPS - Django プロジェクトにインストール済みのアプリのリストが含まれます。
  • community - Post と Comment オブジェクトでの CRUD 操作用 Django アプリ。
  • sqloniris - IRIS での SQL 操作に使用する Django アプリ。
  • interop - 相互運用性操作用の Django アプリ。
  • rest_framework - REST API 用の Django REST フレームワーク。
• REST_FRAMEWORK - Django REST フレームワークの設定が含まれます。
  • DEFAULT_PERMISSION_CLASSES - 認証済みのユーザーのみが CRUD 操作を実行できます。
  • DEFAULT_PAGINATION_CLASS - REST API のページネーションクラス。
• DATABASES - IRIS データベース接続の設定が含まれます。
  • ここでは、django_iris エンジンを使って IRIS データベースに接続しています。

app/urls.py

このファイルには、Django アプリケーションの URL 構成が含まれます。

from django.contrib import admin
from django.urls import path,include
from rest_framework import routers
from community.views import PostViewSet, CommentViewSet
from sqloniris.views import index
from interop.views import index as interop_index

router = routers.DefaultRouter()
router.register(r'posts', PostViewSet)
router.register(r'comments', CommentViewSet)


urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include(router.urls)),
    path('iris/', index),
    path('interop/', interop_index)
]

• router - REST API のデフォルトのルーターが含まれます。
• routeer.register - Post と Comment ビューセットをルーターに登録します。
• urlpatterns - Django アプリケーションの URL パターンが含まれます。
  • /admin/ - Django 管理インターフェース。
  • /api/ - Post と Comment オブジェクトの REST API。
  • /iris/ - IRIS エンドポイントでの SQL。
  • /interop/ - 相互運用性エンドポイント。

app/wsgi.py

このファイルには、Django アプリケーションの WSGI 構成が含まれます。

これが、Django アプリケーションを実行するために IRIS に提供する必要のあるファイルです。

Security->Applications->Web Applications セクションで、このファイルへのパスを指定する必要があります。

• アプリケーション名
  • app.wsgi
• コーラブル名
  • application
• WSGI アプリディレクトリ
  • /irisdev/app/app

community/models.py

このファイルには、Post と Comment オブジェクトの Django モデルが含まれます。

from django.db import models

# Create your models here.
class Post(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()

class Comment(models.Model):
    content = models.TextField()
    post = models.ForeignKey(Post, on_delete=models.CASCADE, related_name='comments')

• Post - Post オブジェクトのモデル。
  • title - 投稿のタイトル。
  • content - 投稿のコンテンツ。
• Comment - Comment オブジェクトのモデル。
  • content - コメントのコンテンツ。
  • post - Post オブジェクトの外部キー。
  • related_name - コメントの関連名。

community/seializers.py

このファイルには、Post と Comment オブジェクトの Django シリアライザーが含まれます。

Django REST フレームワークでは、Django モデルを JSON オブジェクトにシリアル化できます。

from rest_framework import serializers
from community.models import Post, Comment

class PostSerializer(serializers.ModelSerializer):
    class Meta:
        model = Post
        fields = ('id', 'title', 'content', 'comments')

class CommentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Comment
        fields = ('id', 'content', 'post')

• PostSerializer - Post オブジェクトのシリアライザー。
• CommentSerializer - Comment オブジェクトのシリアライザー。
• fields - シリアル化されるフィールド。

community/views.py

このファイルには、Post と Comment オブジェクトの Django ビューが含まれます。

Django REST フレームワークを使て、Django モデルの CRUD 操作を作成できます。

from django.shortcuts import render
from rest_framework import viewsets

# Import the Post and Comment models
from community.models import Post, Comment

# Import the Post and Comment serializers
from community.serializers import PostSerializer, CommentSerializer

# Create your views here.
class PostViewSet(viewsets.ModelViewSet):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

class CommentViewSet(viewsets.ModelViewSet):
    queryset = Comment.objects.all()
    serializer_class = CommentSerializer

• PostViewSet - Post オブジェクトのビューセット。
• CommentViewSet - Comment オブジェクトのビューセット。
• queryset - ビューセットのクエリセット。
• serializer_class - ビューセットのシリアライザークラス。

sqloniris/views.py

このファイルには、IRIS 操作における SQL の Django ビューが含まれます。

from django.http import JsonResponse

import iris

def index(request):
    query = "SELECT top 10 * FROM %Dictionary.ClassDefinition"
    rs = iris.sql.exec(query)
    # Convert the result to a list of dictionaries
    result = []
    for row in rs:
        result.append(row)
    return JsonResponse(result, safe=False)

• index - IRIS 操作における SQL のビュー。
• query - IRIS データベースで実行される SQL クエリ。
• rs - クエリの結果セット。
• result - 結果セットからのリストのリスト。
• JsonResponse - ビューの JSON レスポンス。リストのリスト表示を許可するには safe を False に設定します。

interop/views.py

このファイルには、相互運用性操作における SQL の Django ビューが含まれます。

from django.http import HttpResponse

from grongier.pex import Director

bs = Director.create_python_business_service('BS')

def index(request):
    result = bs.on_process_input(request)
    return HttpResponse(result, safe=False)

• bs - Director クラスを使用して作成されるビジネスサービスオブジェクト。
• index - 相互運用性操作のビュー。
• result - ビジネスサービスの結果。

注: コードを単純化するために JsonResponse は使用しません。JSON オブジェクトを返す場合は使用できます。

トラブルシューティング

スタンドアロンモードで Django アプリケーションを実行する方法

スタンドアロンモードで Django アプリケーションを実行するには、以下のコマンドを使用できます。

cd /irisdev/app/app
python3 manage.py runserver 8001

これは、デフォルトのポート 8001 で Django アプリケーションを実行します。

注: このコマンドを実行するには、コンテナー内にいる必要があります。

docker exec -it iris-django-template-iris-1 bash

IRIS でアプリケーションを再起動する

DEBUG モードでアプリケーションに複数の呼び出しを行うと、変更はアプリケーションに反映されます。

IRIS 管理ポータルへのアクセス方法

http://localhost:53795/csp/sys/UtilHome.csp に移動すると、IRIS 管理ポータルにアクセスできます。

このテンプレートをローカルで実行する

これには、マシンに IRIS がインストールされている必要があります。

次に、IRISAPP というネームスペースを作成する必要があります。

要件をインストールします。

# Move to the app directory
cd /irisdev/app/app

# python manage.py flush --no-input
python3 manage.py migrate
# create superuser
export DJANGO_SUPERUSER_PASSWORD=SYS
python3 manage.py createsuperuser --no-input --username SuperUser --email admin@admin.fr

# load demo data
python3 manage.py loaddata community/fixtures/demo.json

# collect static files
python3 manage.py collectstatic --no-input --clear

# init iop
iop --init

# load production
iop -m /irisdev/app/app/interop/settings.py

# start production
iop --start Python.Production

静的ファイルの配信方法

Django アプリケーションで静的ファイルを配信するには、以下のコマンドを使用できます。

cd /irisdev/app
python3 manage.py collectstatic

これは、Django アプリケーションから静的ファイルを収集して、/irisdev/app/static ディレクトリに配信します。

IRIS で静的ファイルを公開するには、Security->Applications->Web Applications セクションを構成します。

説明

これは、ネイティブウェブアプリケーションとして IRIS にデプロイできる FastAPI アプリケーションのテンプレートです。

インストール

1. リポジトリをクローンする
2. 仮想環境を作成する
3. 要件をインストールする
4. docker-compose ファイルを実行する

git clone
cd iris-fastapi-template
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
docker-compose up

使用法

ベース URL は http://localhost:53795/fastapi/ です。

エンドポイント

• /iris - IRISAPP ネームスペースに存在する上位 10 個のクラスを持つ JSON オブジェクトを返します。
• /interop - IRIS の相互運用性フレームワークをテストするための ping エンドポイント。
• /posts - Post オブジェクトの単純な CRUD エンドポイント。
• /comments - Comment オブジェクトの単純な CRUD エンドポイント。

このテンプレートからの開発方法

WSGI 導入記事をご覧ください: wsgiサポートの概要。

概要: セキュリティポータルで DEBUG フラグをトグルすると、開発作業の過程で変更内容がアプリケーションに反映されるようになります。

コードの説明

app.py

これは FastAPI アプリケーションのメインのファイルです。 FastAPI アプリケーションとルートが含まれます。

from fastapi import FastAPI, Request

import iris

from grongier.pex import Director

# import models
from models import Post, Comment, init_db
from sqlmodel import Session,select

app = FastAPI()

# create a database engine
url = "iris+emb://IRISAPP"
engine = init_db(url)

• from fastapi import FastAPI, Request - FastAPI クラスト Request クラスをインポートします。
• import iris - IRIS モジュールをインポートします。
• from grongier.pex import Director: Flask アプリを IRIS 相互運用性フレームワークにバインドする Director クラスをインポートします。
• from models import Post, Comment, init_db - モデルと init_db 関数をインポートします。
• from sqlmodel import Session,select - Session クラスと sqlmodel モジュールの選択された関数をインポートします。
• app = FastAPI() - FastAPI アプリケーションを作成します。
• url = "iris+emb://IRISAPP" - IRIS ネームスペースの URL を定義します。
• engine = init_db(url) - sqlmodel ORM のデータベースエンジンを作成します。

models.py

このファイルには、アプリケーションのモデルが含まれます。

from sqlmodel import Field, SQLModel, Relationship, create_engine

class Comment(SQLModel, table=True):
    id: int = Field(default=None, primary_key=True)
    post_id: int = Field(foreign_key="post.id")
    content: str
    post: "Post" = Relationship(back_populates="comments")

class Post(SQLModel, table=True):
    id: int = Field(default=None, primary_key=True)
    title: str
    content: str
    comments: list["Comment"] = Relationship(back_populates="post")

説明することは特にありません。外部キーとリレーションによる単なるモデルの定義です。

init_db 関数は、データベースエンジンの作成に使用されます。

def init_db(url):

    engine = create_engine(url)

    # create the tables
    SQLModel.metadata.drop_all(engine)
    SQLModel.metadata.create_all(engine)

    # initialize database with fake data
    from sqlmodel import Session

    with Session(engine) as session:
        # Create fake data
        post1 = Post(title='Post The First', content='Content for the first post')
        ...
        session.add(post1)
        ...
        session.commit()

    return engine

• engine = create_engine(url) - データベースエンジンを作成します。
• SQLModel.metadata.drop_all(engine) - すべてのテーブルをドロップします。
• SQLModel.metadata.create_all(engine) - すべてのテーブルを作成します。
• with Session(engine) as session: - データベースを操作するためのセッションを作成します。
• post1 = Post(title='Post The First', content='Content for the first post') - Post オブジェクトを作成します。
• session.add(post1) - Post オブジェクトをセッションに追加します。
• session.commit() - 変更内容をデータベースにコミットします。
• return engine - データベースエンジンを返します。

/iris エンドポイント

######################
# IRIS Query example #
######################

@app.get("/iris")
def iris_query():
    query = "SELECT top 10 * FROM %Dictionary.ClassDefinition"
    rs = iris.sql.exec(query)
    # Convert the result to a list of dictionaries
    result = []
    for row in rs:
        result.append(row)
    return result

• @app.get("/iris") - /iris エンドポイントの GET ルートを定義します。
• query = "SELECT top 10 * FROM %Dictionary.ClassDefinition" - IRIS ネームスペースで上位 10 個のクラスを取得するクエリを定義します。
• rs = iris.sql.exec(query) - クエリを実行します。
• result = [] - 結果を保存する空のリストを作成します。
• for row in rs: - 結果セットを反復処理します。
• result.append(row) - 結果リストを行にアペンドします。
• return result - 結果リストを返します。

/interop エンドポイント

########################
# IRIS interop example #
########################
bs = Director.create_python_business_service('BS')

@app.get("/interop")
@app.post("/interop")
@app.put("/interop")
@app.delete("/interop")
def interop(request: Request):
    
    rsp = bs.on_process_input(request)

    return rsp

• bs = Director.create_python_business_service('BS') - Python ビジネスサービスを作成します。
  • ビジネスサービスの複数のインスタンスを防止するために、ルート定義の外に作成する必要があります。
• @app.get("/interop") - /interop エンドポイントの GET ルートを定義します。
• @app.post("/interop") - /interop エンドポイントの POST ルートを定義します。
• ...
• def interop(request: Request): - ルートハンドラーを定義します。
• rsp = bs.on_process_input(request) - ビジネスサービスの on_process_input メソッドを呼び出します。
• return rsp - レスポンスを返します。

/posts エンドポイント

############################
# CRUD operations posts    #
############################

@app.get("/posts")
def get_posts():
    with Session(engine) as session:
        posts = session.exec(select(Post)).all()
        return posts
    
@app.get("/posts/{post_id}")
def get_post(post_id: int):
    with Session(engine) as session:
        post = session.get(Post, post_id)
        return post
    
@app.post("/posts")
def create_post(post: Post):
    with Session(engine) as session:
        session.add(post)
        session.commit()
        return post

このエンドポイントは、Post オブジェクトで CRUD 操作を実行するために使用されます。

説明することは特にありません。すべての投稿を取得し、ID で投稿を取得し、投稿を作成するためのルートの定義です。

すべては sqlmodel ORM を使って行われます。

/comments エンドポイント

############################
# CRUD operations comments #
############################


@app.get("/comments")
def get_comments():
    with Session(engine) as session:
        comments = session.exec(select(Comment)).all()
        return comments
    
@app.get("/comments/{comment_id}")
def get_comment(comment_id: int):
    with Session(engine) as session:
        comment = session.get(Comment, comment_id)
        return comment
    
@app.post("/comments")
def create_comment(comment: Comment):
    with Session(engine) as session:
        session.add(comment)
        session.commit()
        return comment

このエンドポイントは、Comment オブジェクトで CRUD 操作を実行するために使用されます。

説明することは特にありません。すべてのコメントを取得し、ID でコメントを取得し、コメントを作成するためのルートの定義です。

すべては sqlmodel ORM を使って行われます。

トラブルシューティング

スタンドアロンモードで FastAPI アプリケーションを実行する方法

以下のコマンドを使用して、いつでもスタンドアロンの Flask アプリケーションを実行できます。

python3 /irisdev/app/community/app.py

注: このコマンドを実行するには、コンテナー内にいる必要があります。

docker exec -it iris-fastapi-template-iris-1 bash

IRIS でアプリケーションを再起動する

DEBUG モードでアプリケーションに複数の呼び出しを行うと、変更はアプリケーションに反映されます。

IRIS 管理ポータルへのアクセス方法

http://localhost:53795/csp/sys/UtilHome.csp に移動すると、IRIS 管理ポータルにアクセスできます。

このテンプレートをローカルで実行する

これには、マシンに IRIS がインストールされている必要があります。

次に、IRISAPP というネームスペースを作成する必要があります。

要件をインストールします。

IoP のインストール:

#init iop
iop --init

# load production
iop -m /irisdev/app/community/interop/settings.py

# start production
iop --start Python.Production

セキュリティポータルでアプリケーションを構成します。

説明

これは、ネイティブウェブアプリケーションとして IRIS にデプロイできる Flask アプリケーションのテンプレートです。

インストール

1. リポジトリをクローンする
2. 仮想環境を作成する
3. 要件をインストールする
4. docker-compose ファイルを実行する

git clone
cd iris-flask-template
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
docker-compose up

使用法

ベース URL は http://localhost:53795/flask/ です。

エンドポイント

• /iris - IRISAPP ネームスペースに存在する上位 10 個のクラスを持つ JSON オブジェクトを返します。
• /interop - IRIS の相互運用性フレームワークをテストするための ping エンドポイント。
• /posts - Post オブジェクトの単純な CRUD エンドポイント。
• /comments - Comment オブジェクトの単純な CRUD エンドポイント。

このテンプレートからの開発方法

WSGI 導入記事をご覧ください: wsgi-introduction。

概要: セキュリティポータルで DEBUG フラグをトグルすると、開発作業の過程で変更内容がアプリケーションに反映されるようになります。

コードの説明

app.py

これはアプリケーションのメインのファイルです。 Flask アプリケーションとエンドポイントが含まれます。

from flask import Flask, jsonify, request
from models import Comment, Post, init_db

from grongier.pex import Director

import iris

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'iris+emb://IRISAPP'

db = init_db(app)

• from flask import Flask, jsonify, request: Flask ライブラリをインポートします。
• from models import Comment, Post, init_db: モデルとデータベース初期化関数をインポートします。
• from grongier.pex import Director: Flask アプリを IRIS 相互運用性フレームワークにバインドする Director クラスをインポートします。
• import iris: IRIS ライブラリをインポートします。
• app = Flask(__name__): Flask アプリケーションを作成します。
• app.config['SQLALCHEMY_DATABASE_URI'] = 'iris+emb://IRISAPP': データベース URI を IRISAPP ネームスペースに設定します。
  • iris+emb URI スキームは、埋め込み接続として IRIS に接続するために使用されます（別の IRIS インスタンスの必要はありません）。
• db = init_db(app): Flask アプリケーションでデータベースを初期化します。

models.py

このファイルには、アプリケーションの SQLAlchemy モデルが含まれます。

from dataclasses import dataclass
from typing import List
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

@dataclass
class Comment(db.Model):
    id:int = db.Column(db.Integer, primary_key=True)
    content:str = db.Column(db.Text)
    post_id:int = db.Column(db.Integer, db.ForeignKey('post.id'))

@dataclass
class Post(db.Model):
    __allow_unmapped__ = True
    id:int = db.Column(db.Integer, primary_key=True)
    title:str = db.Column(db.String(100))
    content:str = db.Column(db.Text)
    comments:List[Comment] = db.relationship('Comment', backref='post')

説明することは特にありません。モデルはデータクラスとして定義されており、db.Model クラスのサブクラスです。

__allow_unmapped__ 属性は、comments 属性を使用せずに Post オブジェクトを作成できるようにするために使用する必要があります。

dataclasses はオブジェクトを JSON にシリアル化するのに使用されます。

init_db 関数は、Flask アプリケーションでデータベースを初期化します。

def init_db(app):
    db.init_app(app)

    with app.app_context():
        db.drop_all()
        db.create_all()
        # Create fake data
        post1 = Post(title='Post The First', content='Content for the first post')
        ...
        db.session.add(post1)
        ...
        db.session.commit()
    return db

• db.init_app(app): Flask アプリケーションでデータベースを初期化します。
• with app.app_context(): アプリケーションのコンテキストを作成します。
• db.drop_all(): データベースのすべてのテーブルをドロップします。
• db.create_all(): データベースのすべてのテーブルを作成します。
• アプリケーションの偽データを作成します。
• データベースオブジェクトを返します。

/iris エンドポイント

######################
# IRIS クエリ例 #
######################

@app.route('/iris', methods=['GET'])
def iris_query():
    query = "SELECT top 10 * FROM %Dictionary.ClassDefinition"
    rs = iris.sql.exec(query)
    # Convert the result to a list of dictionaries
    result = []
    for row in rs:
        result.append(row)
    return jsonify(result)

このエンドポイントは、IRIS データベースでクエリを実行し、IRISAPP ネームスペースに存在する上位 10 個のクラスを返します。

/interop エンドポイント

########################
# IRIS interop example #
########################
bs = Director.create_python_business_service('BS')

@app.route('/interop', methods=['GET', 'POST', 'PUT', 'DELETE'])
def interop():
    
    rsp = bs.on_process_input(request)

    return jsonify(rsp)

このエンドポイントは、IRIS の相互運用性フレームワークをテストするために使用されます。 ビジネスサービスオブジェクトを作成し、それを Flask アプリケーションにバインドします。

注: bs オブジェクトは有効な状態を維持するために、リクエストの範囲外にある必要があります。

• bs = Director.create_python_business_service('BS'): 'BS' というビジネスサービスオブジェクトを作成します。
• rsp = bs.on_process_input(request): リクエストオブジェクトを引数としてビジネスサービスオブジェクトの on_process_input メソッドを呼び出します。

/posts エンドポイント

############################
# CRUD operations posts    #
############################

@app.route('/posts', methods=['GET'])
def get_posts():
    posts = Post.query.all()
    return jsonify(posts)

@app.route('/posts', methods=['POST'])
def create_post():
    data = request.get_json()
    post = Post(title=data['title'], content=data['content'])
    db.session.add(post)
    db.session.commit()
    return jsonify(post)

@app.route('/posts/<int:id>', methods=['GET'])
def get_post(id):
    ...

このエンドポイントは、Post オブジェクトで CRUD 操作を実行するために使用されます。

dataclasses モジュールにより、Post オブジェクトは簡単に JSON にシリアル化できます。

以下では、すべての投稿を取得する sqlalchemy の query メソッドと、新しい投稿を作成するための add と commit メソッドを使用しています。

/comments エンドポイント

############################
# CRUD operations comments #
############################

@app.route('/comments', methods=['GET'])
def get_comments():
    comments = Comment.query.all()
    return jsonify(comments)

@app.route('/comments', methods=['POST'])
def create_comment():
    data = request.get_json()
    comment = Comment(content=data['content'], post_id=data['post_id'])
    db.session.add(comment)
    db.session.commit()
    return jsonify(comment)

@app.route('/comments/<int:id>', methods=['GET'])
def get_comment(id):
    ...

このエンドポイントは、Comment オブジェクトで CRUD 操作を実行するために使用されます。

Comment オブジェクトは外部キーによって Post オブジェクトにリンクされます。

トラブルシューティング

スタンドアロンモードで Flask アプリケーションを実行する方法

以下のコマンドを使用して、いつでもスタンドアロンの Flask アプリケーションを実行できます。

python3 /irisdev/app/community/app.py

注: このコマンドを実行するには、コンテナー内にいる必要があります。

docker exec -it iris-flask-template-iris-1 bash

IRIS でアプリケーションを再起動する

DEBUG モードでアプリケーションに複数の呼び出しを行うと、変更はアプリケーションに反映されます。

IRIS 管理ポータルへのアクセス方法

http://localhost:53795/csp/sys/UtilHome.csp に移動すると、IRIS 管理ポータルにアクセスできます。

このテンプレートをローカルで実行する

これには、マシンに IRIS がインストールされている必要があります。

次に、IRISAPP というネームスペースを作成する必要があります。

要件をインストールします。

IoP のインストール:

#init iop
iop --init

# load production
iop -m /irisdev/app/community/interop/settings.py

# start production
iop --start Python.Production

セキュリティポータルでアプリケーションを構成します。

インターシステムズは InterSystems IRIS data platform、InterSystems IRIS for Health、HealthShare Health Connect のバージョン 2024.3 をリリースしました。2024.3 は Continuous Delivery(CD)リリースです。

コミュニティの皆さん、こんにちは。
この記事では、iris-RAG-Gen という私のアプリケーションをご紹介します。

iris-RAG-Gen は、IRIS Vector Search の機能を使用して、Streamlit ウェブフレームワーク、LangChain、および OpenAI で ChatGPT をパーソナライズするジェネレーティブ AI 検索拡張生成（RAG: Retrieval-Augmented Generation）アプリケーションです。 このアプリケーションは IRIS をベクトルストアとして使用します。

アプリケーションの機能

• ドキュメント（PDF または TXT）を IRIS に取り込む
• 選択されたドキュメントの取り込みを使ってチャットする
• ドキュメントの取り込みを削除する
• OpenAI ChatGPT

ドキュメント（PDF または TXT）を IRIS に取り込む

以下の手順に従って、ドキュメントを取り込みます。

• OpenAI キーを入力します。
• ドキュメント（PDF または TXT）を選択します。
• ドキュメントの説明を入力します。
• 「Ingest Document」ボタンをクリックします。

ドキュメントの取り込み機能は、ドキュメントの詳細を rag_documents テーブルに挿入し、ベクトルデータを保存する 'rag_document + id'（rag_documents の ID）テーブルを作成します。

以下の Python コードは選択されたドキュメントをベクトルに保存します。

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import PyPDFLoader, TextLoader
from langchain_iris import IRISVector
from langchain_openai import OpenAIEmbeddings
from sqlalchemy import create_engine,text
classRagOpr:#Ingest document. Parametres contains file path, description and file type  defingestDoc(self,filePath,fileDesc,fileType):
embeddings = OpenAIEmbeddings()	
#Load the document based on the file typeif fileType == "text/plain":
loader = TextLoader(filePath)
elif fileType == "application/pdf":
loader = PyPDFLoader(filePath)
    <span class="hljs-comment">#load data into documents</span>
    documents = loader.load()        
    
    text_splitter = RecursiveCharacterTextSplitter(chunk_size=<span class="hljs-number">400</span>, chunk_overlap=<span class="hljs-number">0</span>)
    <span class="hljs-comment">#Split text into chunks</span>
    texts = text_splitter.split_documents(documents)
    
    <span class="hljs-comment">#Get collection Name from rag_doucments table. </span>
    COLLECTION_NAME = self.get_collection_name(fileDesc,fileType)
           
    <span class="hljs-comment"># function to create collection_name table and store vector data in it.</span>
    db = IRISVector.from_documents(
        embedding=embeddings,
        documents=texts,
        collection_name = COLLECTION_NAME,
        connection_string=self.CONNECTION_STRING,
    )

<span class="hljs-comment">#Get collection name</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_collection_name</span><span class="hljs-params">(self,fileDesc,fileType)</span>:</span>
    <span class="hljs-comment"># check if rag_documents table exists, if not then create it </span>
    <span class="hljs-keyword">with</span> self.engine.connect() <span class="hljs-keyword">as</span> conn:
        <span class="hljs-keyword">with</span> conn.begin():     
            sql = text(<span class="hljs-string">"""
                SELECT *
                FROM INFORMATION_SCHEMA.TABLES
                WHERE TABLE_SCHEMA = 'SQLUser'
                AND TABLE_NAME = 'rag_documents';
                """</span>)
            result = []
            <span class="hljs-keyword">try</span>:
                result = conn.execute(sql).fetchall()
            <span class="hljs-keyword">except</span> Exception <span class="hljs-keyword">as</span> err:
                print(<span class="hljs-string">"An exception occurred:"</span>, err)               
                <span class="hljs-keyword">return</span> <span class="hljs-string">''</span>
            <span class="hljs-comment">#if table is not created, then create rag_documents table first</span>
            <span class="hljs-keyword">if</span> len(result) == <span class="hljs-number">0</span>:
                sql = text(<span class="hljs-string">"""
                    CREATE TABLE rag_documents (
                    description VARCHAR(255),
                    docType VARCHAR(50) )
                    """</span>)
                <span class="hljs-keyword">try</span>:    
                    result = conn.execute(sql) 
                <span class="hljs-keyword">except</span> Exception <span class="hljs-keyword">as</span> err:
                    print(<span class="hljs-string">"An exception occurred:"</span>, err)                
                    <span class="hljs-keyword">return</span> <span class="hljs-string">''</span>
    <span class="hljs-comment">#Insert description value </span>
    <span class="hljs-keyword">with</span> self.engine.connect() <span class="hljs-keyword">as</span> conn:
        <span class="hljs-keyword">with</span> conn.begin():     
            sql = text(<span class="hljs-string">"""
                INSERT INTO rag_documents 
                (description,docType) 
                VALUES (:desc,:ftype)
                """</span>)
            <span class="hljs-keyword">try</span>:    
                result = conn.execute(sql, {<span class="hljs-string">'desc'</span>:fileDesc,<span class="hljs-string">'ftype'</span>:fileType})
            <span class="hljs-keyword">except</span> Exception <span class="hljs-keyword">as</span> err:
                print(<span class="hljs-string">"An exception occurred:"</span>, err)                
                <span class="hljs-keyword">return</span> <span class="hljs-string">''</span>
            <span class="hljs-comment">#select ID of last inserted record</span>
            sql = text(<span class="hljs-string">"""
                SELECT LAST_IDENTITY()
            """</span>)
            <span class="hljs-keyword">try</span>:
                result = conn.execute(sql).fetchall()
            <span class="hljs-keyword">except</span> Exception <span class="hljs-keyword">as</span> err:
                print(<span class="hljs-string">"An exception occurred:"</span>, err)
                <span class="hljs-keyword">return</span> <span class="hljs-string">''</span>
    <span class="hljs-keyword">return</span> <span class="hljs-string">"rag_document"</span>+str(result[<span class="hljs-number">0</span>][<span class="hljs-number">0</span>])</code></pre>
 
管理ポータルで以下の SQL コマンドを入力し、ベクトルデータを取得します。
SELECT top 5id, embedding, document, metadata
FROM SQLUser.rag_document2
 
選択されたドキュメントの取り込みを使ってチャットする
チャットオプションの選択セクションから「Document」を選択して質問を入力します。アプリケーションはベクトルデータを読み取り、関連する回答を返します。

以下の Python コードは、選択されたドキュメントをべく鳥に保存します。
from langchain_iris import IRISVector
from langchain_openai import OpenAIEmbeddings,ChatOpenAI
from langchain.chains import ConversationChain
from langchain.chains.conversation.memory import ConversationSummaryMemory
from langchain.chat_models import ChatOpenAI
classRagOpr:defragSearch(self,prompt,id):#Concat document id with rag_doucment to get the collection name
COLLECTION_NAME = "rag_document"+str(id)
embeddings = OpenAIEmbeddings()	
#Get vector store reference
db2 = IRISVector (
embedding_function=embeddings,

collection_name=COLLECTION_NAME,
connection_string=self.CONNECTION_STRING,
)
#Similarity search
docs_with_score = db2.similarity_search_with_score(prompt)
#Prepair the retrieved documents to pass to LLM
relevant_docs = ["".join(str(doc.page_content)) + " "for doc, _ in docs_with_score]
#init LLM
llm = ChatOpenAI(
temperature=0,

model_name="gpt-3.5-turbo"
)
#manage and handle LangChain multi-turn conversations
conversation_sum = ConversationChain(
llm=llm,
memory= ConversationSummaryMemory(llm=llm),
verbose=False
)
#Create prompt
template = f"""
Prompt: {prompt}
Relevant Docuemnts: {relevant_docs}
"""#Return the answer
resp = conversation_sum(template)
return resp['response']
</code></pre>

詳細については、iris-RAG-Gen の Open Exchange アプリケーションページをご覧ください。
よろしくお願いします。

開発者の皆さん、こんにちは。

突然ですが、2024年6月25日に開発者向けセミナー「FHIR 新機能のご紹介～2024.1～」が開催されました。
ご視聴になられた方も多数いらっしゃると思います。
まだご視聴になられていない方は是非一度、ご覧になってみてください。
YouTubeリンク

さて、こちらのセミナーにおいてご紹介された、IRIS for Health 2024.1からの新機能「FHIR Object Model」を用いて、リポジトリタイプのInteroperability開発の具体的なサンプルを作成してみました。
自身の備忘のため、すぐ開発環境を構築できるよう、コンテナ環境かつGitHubの公開もしております。
利用方法は、GitHub内のREADMEを参照ください。
GitHubリンク

目次

1. FHIR Object Modelとは？

2. メリット・デメリットを深堀り

3. GitHub公開ソースについて

4. 所感

1. FHIR Object Modelとは？

はじめに

InterSystems は先日、Visual Studio Code（VSC）IDE 用の拡張機能は InterSystems Studio に比べてより優れたエクスペリエンスを提供するという考えから、VSC IDE 用の拡張機能を独占的に開発するためにバージョン 2023.2 より InterSystems Studio のサポートを終了すると発表しました。それ以来、VSC に切り替えた開発者や、VSC を使用し始めた開発者が大勢います。 VSC には Studio のような出力パネルがなく、InterSystems が開発したプラグインをダウンロードする以外に IRIS ターミナルを開く統合機能もないため、多くの人は演算を実行する際にターミナルの開き方に迷ったことでしょう。

概要

• はじめに 
• 解決策
  • 少なくとも IRIS 2020.1 または IRIS 2021.1.2 を使用するユーザー: Web ターミナルを使用
  • 少なくとも least IRIS 2023.2 を使用するユーザー: WebSocket ターミナルを使用
  • Docker ベースの IRIS を使用するユーザー
  • ローカルマシンでバージョン 2023.2 より前の IRIS を使用するユーザー
  • SSH 接続を使ってリモートサーバーの IRIS でコーディングするユーザー

解決策

VSC でターミナルを開く方法は使用している特定の構成によって異なるため、以下に、状況に最適な解決策をまとめました。

少なくとも IRIS 2020.1.1 または IRIS 2021.1.2 を使用するユーザー: Web ターミナルを使用

少なくとも IRIS 2020.1.1 または IRIS 2021.1.2 を使用し、外部の拡張機能のインストールが許可されている（サードパーティアプリケーションに関する会社のポリシーにより許可されていない場合もあります）ユーザーの場合、VSC 用の Web ターミナル拡張機能が役立つ可能性があります。 ご存知ない方のために説明すると、Web ターミナルは、ObjectScript で制作された InterSystems 製品（IRIS、Caché、Ensemble、HealthShare、TrakCare など）用の Web ベースのターミナルで、ブラウザ内でより高度なバージョンのターミナルを使用することができます（プロジェクトページはこちらです）。 この VSC 拡張機能によって、直接 VSC からクリックするだけで Web ベースのターミナルを起動できます。

Web ターミナルを開くには、InterSystems ツール をクリックし、ネームスペースを選択して、いずれかのアイコン（ または ）をクリックします。それぞれ、VSC ターミナルパネルかブラウザで Web ターミナルが開きます（Alt を押すとデフォルトアイコンを変更できます）。

少なくとも least IRIS 2023.2 を使用するユーザー: WebSocket ターミナルを使用

少なくとも IRIS 2023.2 を使用するユーザーは、最新バージョンの VSC 拡張機能に含まれる新しい「WebSocket ターミナル」機能を利用できるため、他の回避策は必要ありません。

WebSocket ターミナルを開くには、InterSystems ツールをクリックし、ネームスペースを選択して、Web ターミナルの隣のアイコンをクリックします。

編集: 詳細については、これについて @Brett Saviano が書いたおもしろい記事をご覧ください！

How to run ObjectScript commands in the VS Code integrated terminal（VS Code の統合ターミナルで ObjectScript コマンドを実行する方法）

Docker ベースの IRIS を使用するユーザー

Docker 内の IRIS 環境で作業しており、VSC を使用しているユーザーは、Docker 環境から直背悦ターミナルセッションを開始できます。

ステータスバーで Docker voice をクリックし、Docker でターミナルを開くを選択します。

このポイントについて画像と説明を提供してくれた @Evgeny Shvarov に感謝しています。

ローカルマシンでバージョン 2023.2 より前の IRIS を使用するユーザー

ローカルマシンで実行するバージョンの IRIS で作業するユーザーの場合は、VSC 内に専用の IRIS ターミナルをセットアップすることができます。

1. 1. settings.json ファイルを開きます。 このファイルを見つけるには、表示 > コマンドパレットをクリックして「settings」と入力し、ユーザー設定を開く（JSON）を選択するなど、様々な方法があります。
   2. 「terminal.integrated.profiles.windows」の下に以下のコードを追加します。

"terminal.integrated.profiles.windows":{
<span class="hljs-string">"IRIS Terminal"</span>: {

&nbsp;&nbsp;&nbsp; <span class="hljs-string">"path"</span>: [

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <span class="hljs-string">"C:\\InterSystems\\IRISHealth\\bin\\irissession.exe"</span>
&nbsp;&nbsp;&nbsp; ],

&nbsp;&nbsp;&nbsp; <span class="hljs-string">"args"</span>: [<span class="hljs-string">"IRISHEALTH"</span>],

&nbsp;&nbsp;&nbsp; <span class="hljs-string">"icon"</span>: <span class="hljs-string">"terminal-cmd"</span>
} 
}

注意: 正しい irissession.exe のパスを挿入してください。

c. VSC からターミナルを開くには、ターミナル > 新しいターミナル > プロファイルを起動… > IRIS ターミナルに移動します。

d. ターミナルメニューに 'IRIS ターミナル' voice が表示されます。

SSH 接続を使ってりモードサーバーの IRIS でコーディングするユーザー 

SSH 接続（PuTTY の使用など）を使ってアクセスできるリモートサーバー（会社サーバーなど）の IRIS バージョンを使用するユーザーの場合、Remote - SSH VSC 拡張機能を使用して、VSC をサーバーに直接接続できます。 これを行うには、以下を実行します。

1. 1. VSC に Remote - SSH: Editing Configuration Files 拡張機能をインストールします。
   2. サイドバーの「リモートエクスプローラー」アイコンをクリックします。
   3. 「SSH 構成ファイルを開く」を選択します。

次のパスの構成ファイルを開きます: C:\Users\<username>\.ssh\config

1. 4. 構成ファイルに以下のコードを挿入します。 

Host my-putty-connection
    HostName < IP address or server name >
    User < username >
    IdentityFile < private key path on your local machine >
    Port < port > 

IP アドレスとポートは PuTTY に指定されたホスト名とポート、ユーザー名はリモートサーバーにアクセスする際に使用するユーザー認証情報、そして IdentityFile は PuTTY 秘密鍵へのファイルパスです。

注意:  PuTTY が生成した秘密鍵の元のフォーマット（.ppk）は VSC で読み取れません。 PuTTY 経由で VSC とリモートサーバーの接続を確立するには、元の秘密鍵を複製して .pem フォーマットに変換する必要があります。 この変換は、以下のように行います。

1. PuTTYgen アプリケーションを起動します。
2. File メニューから、Load private key をクリックします。
3. .ppk フォーマットの秘密鍵を選択して、Open を選択します。
4. Conversions メニューで Export OpenSSH Key (force new file format) をクリックします。
5. .pem 拡張子を使った新しい名前を設定し、Save ボタンをクリックします。
6. この新しい .pem ファイルへのパスを VSC の IdentifyFile パラメーターにリンクします。
   1. ファイルを保存します。 数秒ほどすると、Remote Explorer パネルに新しい接続が表示されます。
   2. 「Connect in New Window...」をクリックして新しい VSC ウィンドウに SSH 接続を開きます。
7. リモートマシンのオペレーティングシステムを選択します（初回アクセスのみ）。
8. 新しいウィンドウで、Terminal > New Terminal に移動します（または Ctrl + ò または Ctrl + Shift + ò を使用します）。
9. これで、リモートマシンに接続し、VSC 内で IRIS ターミナルを使用できるようになりました。

注意: この操作は、以前に PuTTY 経由でリモート接続を開始したことがあり、PuTTY が閉じられている場合またはリモートサーバーに接続していない場合にのみ機能します。 この操作では、PuTTY は起動せず、PuTTY が確立するトンネルに VSC が接続されるだけです。

VSC を通じて PuTTY 接続を開始するには、バッチファイルを使用できます（Windows）。 提供されている connect_remote.bat ファイルは、PuTTY に含まれる Plink コマンドを使用してセッションを開始します。

@echo off

set SESSION="<your saved session name>"

plink -load %SESSION%

セッションを開始するには、VSC ターミナルに .\connect_remote.bat と入力して、リモート接続を開き、認証情報を入力します。

注意: こちらの後のメソッドによって、すべての VSC ショートカットをサポートするターミナルバージョンにアクセスできるようになります！ Shift+Insert ではなく、Ctrl＋V を使用できるようになります 🎉

コミュニティの皆さん、こんにちは！！

Open Exchange に最新の「IRIS Api Tester」アプリケーションをアップロードしました。

InterSystems IRIS と Newman を使用した Docker プロジェクトで、素早く簡単に Postman コレクションをテストできます。

リポジトリをクローンするだけで、初期状態で使用できるようになっています: https://github.com/daniel-aguilar-garcia/irisapitester

docker-compose ファイルを実行します。

この URL をブラウザで開きます。

http://localhost:52773/csp/user/index.html

テストを Postman コレクションに追加します。

この例では、テストをコレクションの Test セクションに追加することでコレクションのすべてのエントリにグローバルテストを追加していますが、個別のテストを項目ごとに追加することもできます。

ここでは、リクエストのステータスコードが 200 になることをテストしています。ステータスコードが 200 でない場合には、レポートにエラーとして表示されます。

テストを追加したら、コレクションを JSON 形式でエクスポートします。

次に、JSON ファイルを IRIS Api Tester のホームページにドラッグし、「Run Test」ボタンを押します。

数秒後、レポートページにリダイレクトされます。

ここで、レポート内を移動して、すべてのテストを詳しく調べることができます。

ユーザーインターフェースを使わずにテストを起動したい場合は、このリクエストを使用できます。

テストを実行するための POST リクエスト:

localhost:52773/run_tests

Body の例:

{
"collection" : {
"info": {
"_postman_id": "79cfb5de-a2ab-4548-aa54-4a1712bf67a4",
"name": "TestNewman",
"schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
"_exporter_id": "838575"
},
"item": [
{
"name": "test_ok",
"event": [
{
"listen": "test",
"script": {
"exec": [
""
],
"type": "text/javascript"
}
}
],
"request": {
"method": "GET",
"header": [],
"url": {
"raw": "localhost:52773/test_ok",
"host": [
"localhost"
],
"port": "52773",
"path": [
"test_ok"
]
}
},
"response": []
},
{
"name": "test_ko",
"request": {
"method": "GET",
"header": [],
"url": {
"raw": "localhost:52773/test_ko",
"host": [
"localhost"
],
"port": "52773",
"path": [
"test_ko"
]
}
},
"response": []
}
],
"event": [
{
"listen": "prerequest",
"script": {
"type": "text/javascript",
"exec": [
""
]
}
},
{
"listen": "test",
"script": {
"type": "text/javascript",
"exec": [
"pm.test("Verificar código de cabecera", function () {",
"    pm.response.to.not.have.status(500);",
"});"
]
}
}
]
}
}

次に、HTML レポートを取得します。

HTML レポートを取得するための GET リクエスト:

localhost:52773/show_report

必要であれば、エクスポートしたサンプルコレクションの JSON ファイルを残しているので、ぜひお試しください。

このアプリがお役に立てれば幸いです。

お読みいただきありがとうございました！！

以下は、デモ動画です ;-)

<iframe allowfullscreen="" frameborder="0" height="360" src="https://www.youtube.com/embed/6JJJ0a6dSmY" width="640"></iframe>

この記事は、「プライベートWebサーバ（PWS）を使用しないバージョンの新規インストール／アップグレード：概要」の続きの記事で、コンテナ版IRISを利用する場合のWebサーバ設定例をご紹介します。（先に「概要」の記事をお読みいただくことをお勧めします。）

開発者の皆さん、こんにちは！

多くの方が、Open Exchange と GitHub で InterSystems ObjectScript ライブラリを公開しています。

でも、開発者がプロジェクトの使用とコラボレーションを簡単に行えるようにするにはどうしていますか？

この記事では、ファイルの標準セットをリポジトリにコピーするだけで、ObjectScript プロジェクトを簡単に起動して作業する方法をご紹介します。

では始めましょう！

概要 - 以下のファイルをこちらのリポジトリからお使いのリポジトリにコピーしてください。

Dockerfile

docker-compose.yml

Installer.cls

iris.script

settings.json{#9f423fcac90bf80939d78b509e9c2dd2-d165a4a3719c56158cd42a4899e791c99338ce73}

.dockerignore{#f7c5b4068637e2def526f9bbc7200c4e-c292b730421792d809e51f096c25eb859f53b637}
.gitattributes{#fc723d30b02a4cca7a534518111c1a66-051218936162e5338d54836895e0b651e57973e1}
.gitignore{#a084b794bc0759e7a6b77810e01874f2-e6aff5167df2097c253736b40468e7b21e577eeb}

すると、プロジェクトを起動して共同作業する標準的な方法が得られます。 以下は、この仕組みと動作する理由についての記事です。

注意: この記事では、InterSystems IRIS 2019.1 以降で実行可能なプロジェクトを対象としています。

InterSystems IRIS プロジェクトの起動環境の選択

通常、開発者には、プロジェクト/ライブラリを試して、素早く安全な方法であることを確認していただきたいと思っています。

私見としては、新しいものを素早く安全に起動するには、Docker コンテナが理想的だと考えています。起動、インポート、コンパイル、計算するあらゆるものがホストマシンにとって安全であり、いかなるシステムやコードも破壊されたり損なわれたりすることがないことを開発者に保証できるためです。 何らかの問題が発生した場合は、コンテナを止めて削除するだけで済みます。 アプリケーションが膨大なディスクスペースを占有するのであれば、コンテナを削除すれば、容量を解放できます。 アプリケーションがデータベース構成を破損するのであれば、破損した構成のあるコンテナを削除するだけです。 このように単純で安全なのです。

Docker コンテナでは、安全と標準化を得られます。

バニラ InterSystems IRIS Docker コンテナを実行するには、IRIS Community Edition イメージを実行するのが最も簡単です。

1. Docker デスクトップをインストールします。 

2. OS のターミナルで以下を実行します。

docker run --rm -p 52773:52773 --init --name my-iris store/intersystems/iris-community:2020.1.0.199.0

3. 次に、ホストブラウザで管理ポータルを開きます。

http://localhost:52773/csp/sys/UtilHome.csp

4. または IRIS へのターミナルを開きます。

   docker exec -it my-iris iris session IRIS

5. IRIS コンテナが不要になれば、それを停止します。

   docker stop my-iris

さて、 IRIS を Docker コンテナで実行しますが、 開発者にはコードを IRIS にインストールして、いくらかの設定を行ってほしいと考えているとします。 以下ではこれについて説明します。

ObjectScript ファイルのインポート

最も単純な InterSystems ObjectScript プロジェクトには、クラス、ルーチン、マクロ、グローバルなどの一連の ObjectScript ファイルが含めることができます。 命名規則とフォルダ構造の提案についての記事をご覧ください。

問題は、このコードをどのようにして IRIS コンテナにインポートするかです。

ここで役立つのが Dockerfile です。これを使用して、バニラ IRIS コンテナを取得し、リポジトリから IRIS にすべてのコードをインポートして、必要に応じて IRIS で設定を行います。 リポジトリに Dockerfile を追加する必要があります。

ObjectScript テンプレートリポジトリから取得した Dockerfile を調べてみましょう。

ARG IMAGE=store/intersystems/irishealth:2019.3.0.308.0-community
ARG IMAGE=store/intersystems/iris-community:2019.3.0.309.0
ARG IMAGE=store/intersystems/iris-community:2019.4.0.379.0
ARG IMAGE=store/intersystems/iris-community:2020.1.0.199.0
FROM $IMAGE

USER root

WORKDIR /opt/irisapp
RUN chown ${ISC_PACKAGE_MGRUSER}:${ISC_PACKAGE_IRISGROUP} /opt/irisapp

USER irisowner

COPY  Installer.cls .
COPY  src src
COPY iris.script /tmp/iris.script # run iris and initial 

RUN iris start IRIS \
    && iris session IRIS < /tmp/iris.script

最初の ARG の行は $IMAGE 変数を設定しており、それを FROM で使用します。 これは、$IMAGE 変数を変更するために FROM の前の最後の行が何であるかだけを切り替えて、さまざまな IRIS バージョンでコードをテスト/実行するのに適しています。 

以下のコードがあります。 

ARG IMAGE=store/intersystems/iris-community:2020.1.0.199.0

FROM $IMAGE

これは、IRIS 2020 Community Edition ビルド 199 を使用するということです。

リポジトリからコードをインポートするため、リポジトリのファイルを Docker コンテナにコピーする必要があります。 以下の行はそれを行います。

USER root

WORKDIR /opt/irisapp
RUN chown ${ISC_PACKAGE_MGRUSER}:${ISC_PACKAGE_IRISGROUP} /opt/irisapp

USER irisowner

COPY  Installer.cls .
COPY  src src

USER root - ここで、ユーザーをルートに切り替えて、フォルダを作成してファイルを Docker にコピーします。

WORKDIR /opt/irisapp - この行では、ファイルをコピーする workdir をセットアップしています。

RUN chown ${ISC_PACKAGE_MGRUSER}:${ISC_PACKAGE_IRISGROUP} /opt/irisapp   -  ここでは、irisowner ユーザーと IRIS を実行するグループに権限を付与しています。

USER irisowner - ユーザーを root から irisowner に切り替えます。

COPY Installer.cls .  - workdir のルートに Installer.cls をコピーしています。 このピリオドを忘れないでください。

COPY src src - ソースファイルをリポジトリの src フォルダから Docekr の workdir の src フォルダにコピーします。

次のブロックでは、初期スクリプトを実行し、インストーラーと ObjectScript コードを呼び出します。

COPY iris.script /tmp/iris.script # run iris and initial 
RUN iris start IRIS \
    && iris session IRIS < /tmp/iris.script

COPY iris.script / - iris.script をルートディレクトリにコピーします。 コンテナをセットアップするために呼び出す ObjectScript が含まれます。

RUN iris start IRIS</span>  - IRIS を起動します。

&& iris session IRIS < /tmp/iris.script - IRIS ターミナルを起動し、それに最初の ObjectScript を入力します。

以上です！ Docker にファイルをインポートする Dockerfile ができました。 installer.cls と iris.script の 2 つのファイルが残っています。ではそれらを詳しく見てみましょう。

Installer.cls

Class App.Installer
{

XData setup
{
<Manifest>
  <Default Name="SourceDir" Value="#{$system.Process.CurrentDirectory()}src"/>
  <Default Name="Namespace" Value="IRISAPP"/>
  <Default Name="app" Value="irisapp" />

  <Namespace Name="${Namespace}" Code="${Namespace}" Data="${Namespace}" Create="yes" Ensemble="no">

    <Configuration>
      <Database Name="${Namespace}" Dir="/opt/${app}/data" Create="yes" Resource="%DB_${Namespace}"/>

      <Import File="${SourceDir}" Flags="ck" Recurse="1"/>
    </Configuration>
    <CSPApplication Url="/csp/${app}" Directory="${cspdir}${app}"  ServeFiles="1" Recurse="1" MatchRoles=":%DB_${Namespace}" AuthenticationMethods="32"
       
    />
  </Namespace>

</Manifest>
}

ClassMethod setup(ByRef pVars, pLogLevel As %Integer = 3, pInstaller As %Installer.Installer, pLogger As %Installer.AbstractLogger) As %Status [ CodeMode = objectgenerator, Internal ]
{
  #; Let XGL document generate code for this method. 
  Quit ##class(%Installer.Manifest).%Generate(%compiledclass, %code, "setup")
}

}

率直に言って、ファイルのインポートに Installer.cls は必要ありません。 これは 1 行で実行可能です。 ただし、コードをインポートするほかに、CSP アプリのセットアップ、セキュリティ設定の追加、データベースとネームスペースの作成を行わなければなりません。

この Installer.cls では、 IRISAPP という名前で新しいデータベースとネームスペースを作成し、このネームスペースのデフォルトの /csp/irisapp アプリケーションを作成します。

すべては、<Namespace> 要素で行います。

<Namespace Name="${Namespace}" Code="${Namespace}" Data="${Namespace}" Create="yes" Ensemble="no">

    <Configuration>
      <Database Name="${Namespace}" Dir="/opt/${app}/data" Create="yes" Resource="%DB_${Namespace}"/>

      <Import File="${SourceDir}" Flags="ck" Recurse="1"/>
    </Configuration>
    <CSPApplication Url="/csp/${app}" Directory="${cspdir}${app}"  ServeFiles="1" Recurse="1" MatchRoles=":%DB_${Namespace}" AuthenticationMethods="32"
       
    />
  </Namespace>

そして、Import タグを使って、SourceDir からすべてのファイルをインポートします。

<Import File="${SourceDir}" Flags="ck" Recurse="1"/>

この SourceDir は変数であり、現在のディレクトリ/src フォルダに設定されています。

<Default Name="SourceDir" Value="#{$system.Process.CurrentDirectory()}src"/>

これらの設定を含む Installer.cls によって、src フォルダから任意の ObjectScript コードをインポートするわかりやすい新しいデータベース IRISAPP を作成できるという確信を持つことができます。

iris.script

ここに、IRIS コンテナを起動する初期の ObjectScript セットアップコードを挿入してください。

例: 開発にはパスワードのプロンプトは不要であるため、ここでは、installer.cls を読み込んで実行してから、パスワードの初回変更リクエストを回避するために、UserPasswords を永久にしています。

; run installer to create namespace
do $SYSTEM.OBJ.Load("/opt/irisapp/Installer.cls", "ck")
set sc = ##class(App.Installer).setup()  zn "%SYS"
Do ##class(Security.Users).UnExpireUserPasswords("*") ; call your initial methods here
halt

docker-compose.yml

docker-compose.yml はなぜ必要なのでしょうか。Dockerfile と同様に、イメージをただビルドして実行するだけではいけないのでしょうか。 もちろん、そうすることは可能です。 ただし、docker-compose.yml を使用すれば作業が単純になります。

通常、docker-compose.yml は、1 つのネットワークに接続された複数の Docker イメージを起動するために使用されます。

docker-compose.yml は、多数のパラメーターを処理する場合に、1 つの Docker イメージの起動をより簡単にするためにも使用できます。 これを使用すれは、ポートのマッピング、ボリューム、VSCode 接続パラメーターなどを Docker に渡すことができます。

version: '3.6' 
services:
  iris:
    build: 
      context: .
      dockerfile: Dockerfile
    restart: always
    ports: 
      - 51773
      - 52773
      - 53773
    volumes:
      - ~/iris.key:/usr/irissys/mgr/iris.key
      - ./:/irisdev/app

ここでは、サービス iris を宣言しています。これは Dockerfile を使用し、IRIS の 51773、52773、53773 ポートを公開するサービスです。 また、このサービスは、ホストマシンのホームディレクトリの iris.key と期待される IRIS フォルダ、およびソースコードのルートフォルダと /irisdev/app フォルダの 2 つのボリュームのマッピングも行います。

docker-compose によって、セットアップされるパラメーターに関係なく、イメージをビルドして実行するためのコマンドをより短く、統一することができます。

いずれの場合でも、以下のようにしてイメージをビルドします。

$ docker-compose up -d

 そして以下のようにして IRIS ターミナルを開きます。

$ docker-compose exec iris iris session iris

Node: 05a09e256d6b, Instance: IRIS

USER>

また、docker-compose.yml では、VSCode ObjectScript プラグインの接続もセットアップできます。

.vscode/settings.json

ObjectScript アドオン接続設定に関連しているのは、以下の部分です。

{
    "objectscript.conn" :{
      "ns": "IRISAPP",
      "active": true,
      "docker-compose": {
        "service": "iris",
        "internalPort": 52773
      }
    }     

}

ここにあるのは設定です。VSCode ObjectScript プラグインのデフォルトの設定とは異なります。

ここでは、IRISAPP ネームスペース（Installer.cls で作成）に接続すると述べています。

"ns": "IRISAPP",

そして、docker-compose の設定があります。これは、サービス「iris」内の docker-compose ファイルで、VSCode が 52773 がマッピングされているポートに接続すると書かれています。

"docker-compose": {
        "service": "iris",
        "internalPort": 52773
      }

52773 について調べたところ、これはマップされたポートが 52773 に対して定義されていないことがわかります。

ports: 
      - 51773
      - 52773
      - 53773

つまり、ホストマシンのポートで利用できるランダムなポートが取得され、VSCode は自動的にランダムなポートを介して、docker 上でこの IRIS に接続するということです。

これは非常に便利な機能です。IRIS を使用して任意の量の Docker イメージをランダムなポート上で実行し、VSCode をそれらのポートに自動的に接続するオプションが提供されるためです。

他のファイルはどうでしょうか？

以下のファイルもあります。

.dockerignore  - 作成した Docker ファイルにコピーしない不要なホストマシンのファイルをフィルターするために使用できるファイル。 通常、.git や .DS_Store は必須です。

.gitattributes - git の属性。ソース内の ObjectScript ファイルの行末を統一します。 Windows と Mac/Ubuntu オーナーがリポジトリで共同作業する場合に非常に便利です。

.gitignore - Git で変更履歴を追跡しないファイル。 通常、.DS_Store などの非表示の OS レベルのファイルです。

以上です！

リポジトリを Docker 実行可能にし、コラボレーションしやすくするにはどうすればよいでしょうか。

1. このリポジトリをクローンします。

2. 以下のファイルをすべてコピーします。

Dockerfile

docker-compose.yml

Installer.cls

iris.script

settings.json{#9f423fcac90bf80939d78b509e9c2dd2-d165a4a3719c56158cd42a4899e791c99338ce73}

.dockerignore{#f7c5b4068637e2def526f9bbc7200c4e-c292b730421792d809e51f096c25eb859f53b637}
.gitattributes{#fc723d30b02a4cca7a534518111c1a66-051218936162e5338d54836895e0b651e57973e1}
.gitignore{#a084b794bc0759e7a6b77810e01874f2-e6aff5167df2097c253736b40468e7b21e577eeb}

上記をリポジトリにコピーしてください。

Dockerfile のこの行を IRIS にインポートする ObjectScript のあるリポジトリ内のディレクトリに一致するように変更します（in /src フォルダにある場合は変更しません）。

それだけです。 すべての人（あなた自身も含む）が、新しい IRISAPP ネームスペースでコードをインポートできるようになります。

プロジェクトの起動方法

IRIS で ObjectScript プロジェクトを実行するためのアルゴリズムは以下の通りです。

1. プロジェクトをローカルに Git clone します。

2. プロジェクトを実行します。

$ docker-compose up -d

$ docker-compose exec iris iris session iris

Node: 05a09e256d6b, Instance: IRIS

USER>zn "IRISAPP"

**開発者によるプロジェクトへの貢献方法 **

1. リポジトリをフォークして、フォークされたリポジトリをローカルに Git clone します。

2. VSCode でフォルダを開きます（Docker と ObjectScript の拡張機能が VSCode にインストールされている必要があります）。

3. docker-compose.yml を右クリックし、再起動します。VSCode ObjectScript が自動的に接続され、編集/コンパイル/デバッグできるうようになります。

4. リポジトリに変更をコミット、プッシュ、およびプルリクエストします。

以下は、この仕組みを説明する簡単な Gif です。

以上です！ それでは、コーディングをお楽しみください！

前の記事 - AI による臨床文書の保管、取得、検索の単純化

この記事では、AI を使用した文字起こしと要約によってヘルスケアに変革を起こす OpenAI の高度な言語モデルの可能性を探ります。 OpenAPI の最先端 API を活用して、録音データを文字起こしし、自然言語処理アルゴリズムを使って簡潔な要約を生成するための重要なインサイトを抽出するプロセスを掘り下げていきます。

似たような機能は Amazon Medical Transcibe や Medvoice などの既存のソリューションでも提供されていますが、この記事では、OpenAI テクノロジーを使用してこれらの強力な機能を InterSystems FHIR に実装することに焦点を当てています。

Vue.js の録音データ

Vue.js アプリのボイスレコーダーは、完全にネイティブであり、Mediarecorder インターフェースを使って JavaScript で記述されています。 これは、アプリケーションを軽量に維持しながら、録音オプションを完全に制御できるようにすることを目的としています。 以下は、録音入力の開始と停止を行うスニペットです。

// オーディオストリームをチャンクとして保存する録音開始メソッドasync startRecording() {
      try {
        const stream = await navigator.mediaDevices.getUserMedia({
          audio: true,
        });
        this.mediaRecorder = new MediaRecorder(stream);
        this.mediaRecorder.start();

        this.mediaRecorder.ondataavailable = (event) => {
          this.chunks.push(event.data);
        };
        this.isRecording = true;
      } catch (error) {
        console.error("Error starting recording:", error);
      }
}

// 停止後にブロブを作成する（そして転写メソッドを呼び出す）録画停止メソッド
stopRecording() {
      if (this.mediaRecorder) {
        this.isLoading = true;
        this.mediaRecorder.stop();
        this.mediaRecorder.onstop = async () => {
          const blob = new Blob(this.chunks, {
            type: "audio/webm;codecs=opus",
          });
          awaitthis.sendAudioToWhisper(
            new File([blob], `file${Date.now()}.m4a`)
          );

          this.getSummary(this.transcription);
        };
      }
}

文字起こしコンポーネント

OpenAI の Whisper モデルを使った音声データの文字起こしには、いくつかの基本コンポーネントが使用されます。 以下のコードスニペットは、文字起こしプロセスに関わるステップを示します。

const apiKey = process.env.OPENAI_API_KEY;

const formData = new FormData();
formData.append("file", blob);
formData.append("model", "whisper-1");
formData.append("response_format", "json");
formData.append("temperature", "0");
formData.append("language", "en");

try {
  const response = await fetch(
    "https://api.openai.com/v1/audio/transcriptions",
    {
      method: "POST",
      headers: {
        Accept: "application/json",
        Authorization: `Bearer ${apiKey}`,
      },
      body: formData,
      redirect: "follow",
    }
  );

  const data = await response.json();
  if (data.text) {
    this.transcription = data.text;
  }
} catch (error) {
  console.error("Error sending audio to Whisper API:", error);
}

returnthis.transcription;

1. API キー - OPENAI_API_KEY は、OpenAI API にアクセスするために必要な認証トークンです。
2. フォームデータ - 文字起こしされる音声ファイルは、FormData オブジェクトに追加されます。 選択されたモデル（whisper-1）、レスポンス形式（json）、体温（``）、および言語（en）などの追加パラメーターも含まれています。
3. API リクエスト - OpenAI API エンドポイント https://api.openai.com/v1/audio/transcriptions への POST リクエストには、ヘッダーとフォームデータを含むボディを指定して、fetch メソッドで送信されています。
4. レスポンス処理 - API からのレスポンスがキャプチャされ、文字起こしされたテキストが data オブジェクトから抽出されます。 文字起こしを変数 this.transcription に割り当てて、さらに処理するか使用することができます。

要約コンポーネント

以下のコードスニペットは、OpenAI の text-davinci-003 モデルを使用したテキスト要約プロセスに関わる基本コンポーネントを示しています。

response = openai.Completion.create(
    model="text-davinci-003",
    prompt="Summarize the following text and give title and summary in json format. \
            Sample output - {\"title\": \"some-title\", \"summary\": \"some-summary\"}.\
            Input - "
    + text,
    temperature=1,
    max_tokens=300,
    top_p=1,
    frequency_penalty=0,
    presence_penalty=1
)

return response["choices"][0]["text"].replace('\n', '')

1. モデルの選択 - model パラメーターは text-davinci-003 に設定されており、OpenAI のテキスト補完モデルが要約に使用されていることを示します。
2. プロンプト - モデルに提供されるプロンプトは、望ましい結果を指定しています。これは入力テキストを要約して JSON 形式でタイトルと要約を返します。 入力テキストは、プロンプトに連結して処理されます。 OpenAI を通じてレスポンス変換を処理できるところに興味深いポイントがあります。 受信側での検証のみで十分であり、将来的にはコンバーターがほとんど必要なくなる可能性があります。
3. 生成パラメーター - 生成された要約の動作と品質を制御するために、temperature、max_tokens、top_p、frequency_penalty、presence_penalty などのパラメーターが設定されます。
4. API リクエストとレスポンスの処理 - API リクエストを行うために、openai.Completion.create() メソッドが呼び出されます。 レスポンスがキャプチャされ、生成された要約テキストがレスポンスオブジェクトから抽出されます。 要約テキストに含まれる改行文字（\n）は、最終結果を返す前に取り除かれます。

FHIR のドキュメント参照

OpenAI テクノロジーを使用して医師と患者の会話の文字起こしと要約を実装する文脈においては、FHIR 規格内での診療記録の保管を考慮することが重要です。 FHIR は、診療記録などの医療情報を様々な医療システムやアプリケーション間で交換するための構造化された標準アプローチです。 FHIR の DocumentReference リソースは、診療記録や関連文書を保管するための専用のセクションとして機能します。

文字起こしと要約機能を医師と患者の会話ワークフローに統合する場合、生成される文字起こしと要約は、FHIR Documents リソース内の診療記録として保管できます。 これにより、生成されたインサイトへのアクセス、取得、およびヘルスケアプロバイダーやその他の承認機関の間での共有を簡単に行えます。

{
    "resourceType": "Bundle",
    "id": "1a3a6eac-182e-11ee-9901-0242ac170002",
    "type": "searchset",
    "timestamp": "2023-07-01T16:34:36Z",
    "total": 1,
    "link": [
        {
            "relation": "self",
            "url": "http://localhost:52773/fhir/r4/Patient/1/DocumentReference"
        }
    ],
    "entry": [
        {
            "fullUrl": "http://localhost:52773/fhir/r4/DocumentReference/1921",
            "resource": {
                "resourceType": "DocumentReference",
                "author": [
                    {
                        "reference": "Practitioner/3"
                    }
                ],
                "subject": {
                    "reference": "Patient/1"
                },
                "status": "current",
                "content": [
                    {
                        "attachment": {
                            "contentType": "application/json",
                            "data": ""
                        }
                    }
                ],
                "id": "1921",
                "meta": {
                    "lastUpdated": "2023-07-01T16:34:33Z",
                    "versionId": "1"
                }
            },
            "search": {
                "mode": "match"
            }
        }
    ]
}

試してみましょう

1. プロジェクトをクローン - 次の GitHub リンクからプロジェクトリポジトリをクローンします: https://github.com/ikram-shah/iris-fhir-transcribe-summarize-export。
2. ローカルでセットアップ - 提供された指示に従って、プロジェクトをローカルマシン上にセットアップします。 セットアップ中に問題が発生した場合は、お知らせください。
3. 患者を選択 - プロジェクト内の提供されたサンプルリストから患者を選択します。 この患者は、文字起こしと要約に使用される医師と患者の会話と関連付けられます。
4. 対話ページ - 患者が選択されたら、プロジェクト内の対話ページに移動します。 このページで、「Take Notes」オプションを見つけてクリックし、医師と患者の会話の文字起こしプロセスを開始します。
5. 文字起こしの表示と編集 - 文字起こしプロセスが完了したら、生成された文字起こしを表示するオプションが表示されます。 さらに整理してわかりやすくするために、文字起こしに関連付けられたタイトルと要約を編集することもできます。
6. FHIR DocumentReference に保存 - タイトルと要約の処理が完了し、変更を保存すると、FHIR DocumentReference 内に自動的に保管されます。 これにより、関連する診療記録がキャプチャされ、それぞれの患者の記録に確実に関連付けられます。 現時点では、このプロジェクトは文字起こしテキスト全体を保存しませんが、 完全な文字起こしの補完を含めるように変更することもできます。

デモ

アプリケーション全体のデモはこちらでご覧ください: https://youtu.be/3Th6bR4rw0w

今後の方向性

AI を活用した文字起こしと要約の応用を遠隔医療通信に拡大することには、計り知れない可能性が秘められています。 これらの機能を Zoom、Teams、Google Meet などの一般的な会議プラットフォームに統合することで、医師と患者のリモート対話を合理化できる可能性があります。 遠隔医療セッションの自動文字起こしと要約機能には、正確な文書作成や分析の強化といったメリットがあります。 ただし、データプライバシーが重大な課題として残されます。 これに対応するためには、外部サーバーにデータを送信する前に、個人を特定できる情報（PII）をフィルターまたは匿名化する対策を実装する必要があります。

今後の方向性としては、ローカルで処理するためのオンデバイス AI モデルの調査、多言語コミュニケーションのサポートの改善、プライバシー維持した手法の進歩が挙げられます。

有用な実装だと思われた方は、Grand Prix 2023 でこのアプリに投票してください。

問題

あわただしい臨床環境では迅速な意思決定が重要であるため、文書保管とシステムへのアクセスが合理化されていなければいくつもの障害を生み出します。 文書の保管ソリューションは存在しますが（FHIR など）、それらの文書内で特定の患者データに有意にアクセスして効果的に検索するのは、重大な課題となる可能性があります。

動機

AI により、文書の検索が非常に強力になりました。 Chroma や Langchain のようなオープンソースツールを使用して、ベクトル埋め込みを保存して使用し、生成 AI API 全体でクエリを実行することで、ドキュメント上での質疑応答がかつてないほど簡単になっています。 より献身的に取り組む組織は、既存のドキュメントにインデックスを作成し、エンタープライズ用に微調整されたバージョンの GPT を構築しています。 GPT の現状に関する Andrej Karpathy の講演では、このトピックに関する素晴らしい概要が提供されています。

このプロジェクトは、医療関係者が文書を操作するあらゆるタッチポイントにおいて発生する摩擦を緩和する試みです。 医療関係者が情報を保管し、必要な情報を難なく検索できるように、入力と処理から保管と検索まで、IRIS FHIR と AI を活用しました。

ソリューション

医療関係者が音声メモを記録できるフルスタックのウェブアプリを構築しました。 これらのメモは、Open AI を使って文字起こしされ、要約されてから FHIR サーバーに保管されます。 保管されたドキュメントは、インデックス作成されてから、セマンティック検索で使用できるようになります。  

デモ動画

主な機能

1. ウェブアプリ - 患者、観察、遭遇に関する診療情報を表示します。 これは Vue.js で構築されています。
2. 音声データの文字起こし - Open AI Whisper API を使って、録音を正確なテキストに文字起こしします。
3. テキストの要約 - 文字起こしされた内容を必要なフォーマットで要約してタイトルが付けられます。 症状、診断などの具体的なセクションなどです。 これは、text-da-vinci-003 を使った Open AI テキスト補完 API で行われます。
4. ドキュメントの保管 - 要約されたドキュメントは、DocumentReference アーティファクトを使って FHIR に保管されます。
5. セマンティックドキュメント検索 - 保管されたドキュメントはインデックス作成されて、チャンクとして Chroma に保管されます。 これは、Langchain を使用して検索スペースを制限してセマンティック検索に GPT トークンを控えめに使用するために使用されます。 現時点では、使用できるドキュメント数が少ないため、検索時にドキュメントを読み込んでいますが、 非同期的にバックグラウンドでインデックス作成するように変更することが可能です。
6. ドキュメントのエクスポート - 最後に、ドキュメントを Google Docs に、その他のデータを Google Sheets にエクスポートするオプションがあります。 ユーザーは他の医療関係者や患者とのコラボレーションとやり取りを簡単に行えるように、OAuth を使って特定のアカウントにログインし、ドキュメントをエクスポートすることができます。

試してみましょう

次の GitHub リンクからプロジェクトリポジトリをクローンします: https://github.com/ikram-shah/iris-fhir-transcribe-summarize-export。 提供された指示に従って、プロジェクトをローカルマシン上にセットアップしてください。 期待される動作が得られない場合は、お知らせください。

ご意見とフィードバック

現在使用できる高度言語モデルと大量のデータを合わせることで、ヘルスケア分野の特に文書管理の領域に革命を起こす大きな可能性があります。 以下に、ご意見やフィードバックをお寄せください。 このプロジェクトの背後にある技術的な情報について、さらに多くの記事を投稿する予定です。

このプロジェクトに期待できると思われる場合は、Grand Prix コンテストでこのアプリに投票してください！

こんにちは、皆さま。
業務でIRISを用いて開発を行っている者です。

技術文書ライティングコンテストという事で、私からはAWS環境を用いたCI/CDの仕組みについてご紹介します。

CI/CDとは「Continuous Integration（継続的インテグレーション）/ Continuous Delivery（継続的デリバリー）」の略称で、
詳細はネットをググると色々出てくると思いますが、私としてはリポジトリに格納されたものを自動で品質保証して、
問題なければ自動でデプロイしてくれる一連の仕組みだと理解しています。

という事で、その第一歩はIRISのソースコードをgitで管理することです。
pythonで作成したテストプログラムを用意しました。

この記事では、.Net/Java ゲートウェイを簡単にコンテナ化する方法を説明します。

この例では、Apache Kafka との統合を開発します。

Java/.Net と相互運用するために、PEX を使用しています。

アーキテクチャ

このソリューションは完全に docker で実行し、以下のように構成されます。

Java ゲートウェイ

まず、メッセージを Kafka に送信する Java オペレーションを開発しましょう。 このコードはお好きな IDE で書くことができ、こちらのようになります。

要約すると:

• 新しい PEX ビジネスオペレーションを開発するには、抽象型の com.intersystems.enslib.pex.BusinessOperation クラスを実装する必要があります。
• public プロパティはビジネスホスト設定です。
• OnInit メソッドは Kafka への接続を初期化し、InterSystems IRIS へのポインターを取得するために使用されます。
• OnTearDown は、（プロセスのシャットダウン時に）Kafka から切断するために使用されます。
• OnMessage は dc.KafkaRequest メッセージを受け取って、Kafka に送信します。

では、これを Docker にパックしましょう！

これがこの例の dockerfile です。

FROM eclipse-temurin:8-jre-alpine AS builder

ARG APP_HOME=/tmp/app

COPY src $APP_HOME/src

COPY --from=intersystemscommunity/jgw:latest /jgw/*.jar $APP_HOME/jgw/

WORKDIR $APP_HOME/jar/
ADD https://repo1.maven.org/maven2/org/apache/kafka/kafka-clients/2.5.0/kafka-clients-2.5.0.jar .
ADD https://repo1.maven.org/maven2/ch/qos/logback/logback-classic/1.2.3/logback-classic-1.2.3.jar .
ADD https://repo1.maven.org/maven2/ch/qos/logback/logback-core/1.2.3/logback-core-1.2.3.jar .
ADD https://repo1.maven.org/maven2/org/slf4j/slf4j-api/1.7.30/slf4j-api-1.7.30.jar .

WORKDIR $APP_HOME/src

RUN javac -classpath $APP_HOME/jar/*:$APP_HOME/jgw/* dc/rmq/KafkaOperation.java && \
    jar -cvf $APP_HOME/jar/KafkaOperation.jar dc/rmq/KafkaOperation.class

FROM intersystemscommunity/jgw:latest

COPY --from=builder /tmp/app/jar/*.jar $GWDIR/

1 行ずつ見ながら、ここに何が起きているのかを確認しましょう（マルチステージ docker ビルドを理解していることが前提です）。

FROM eclipse-temurin:8-jre-alpine AS builder

最初のイメージは JDK 8 です（openjdk:8 イメージは廃止されたことに注意してください。代わりに推奨されているものを使用します）。

ARG APP_HOME=/tmp/app
COPY src $APP_HOME/src

/src フォルダから /tmp/app フォルダにソースをコピーしています。

COPY --from=intersystemscommunity/jgw:latest /jgw/*.jar $APP_HOME/jgw/

Java ゲートウェイソースを /tmp/app/jgw フォルダにコピーしています。

WORKDIR $APP_HOME/jar/
ADD https://repo1.maven.org/maven2/org/apache/kafka/kafka-clients/2.5.0/kafka-clients-2.5.0.jar .
ADD https://repo1.maven.org/maven2/ch/qos/logback/logback-classic/1.2.3/logback-classic-1.2.3.jar .
ADD https://repo1.maven.org/maven2/ch/qos/logback/logback-core/1.2.3/logback-core-1.2.3.jar .
ADD https://repo1.maven.org/maven2/org/slf4j/slf4j-api/1.7.30/slf4j-api-1.7.30.jar .

WORKDIR $APP_HOME/src

RUN javac -classpath $APP_HOME/jar/*:$APP_HOME/jgw/* dc/rmq/KafkaOperation.java && \
    jar -cvf $APP_HOME/jar/KafkaOperation.jar dc/rmq/KafkaOperation.class

これですべての依存関係が追加され、jar ファイルのコンパイルに javac/jar が呼び出されます。 実際のプロジェクトでは、Maven または Gradle の使用をお勧めします。

FROM intersystemscommunity/jgw:latest

COPY --from=builder /tmp/app/jar/*.jar $GWDIR/

そして最後に、jar がベース jgw イメージにコピーされます（ベースイメージは、ゲートウェイと関連タスクの開始も処理します）。

.Net ゲートウェイ

次は、Kafka からメッセージを受け取る .Net サービスです。 このコードはお好きな IDE で書くことができ、こちらのようになります。

要約すると:

• 新しい PEX ビジネスサービスを開発するには、抽象型の InterSystems.EnsLib.PEX.BusinessService クラスを実装する必要があります。
• public プロパティはビジネスホスト設定です。
• OnInit メソッドは Kafka への接続を初期化し、トピックを購読し、InterSystems IRIS へのポインターを取得するために使用されます。
• OnTearDown は、（プロセスのシャットダウン時に）Kafka から切断するために使用されます。
• OnMessage は Kafka からのメッセージを入力として使用し、他の相互運用性ホストに Ens.StringContainer メッセージを送信します。

では、これを Docker にパックしましょう！

これがこの例の dockerfile です。

FROM mcr.microsoft.com/dotnet/core/sdk:2.1 AS build

ENV ISC_PACKAGE_INSTALLDIR /usr/irissys
ENV GWLIBDIR lib
ENV ISC_LIBDIR ${ISC_PACKAGE_INSTALLDIR}/dev/dotnet/bin/Core21

WORKDIR /source
COPY --from=store/intersystems/iris-community:2020.2.0.211.0 $ISC_LIBDIR/*.nupkg $GWLIBDIR/

# copy csproj and restore as distinct layers
COPY *.csproj ./
RUN dotnet restore

# copy and publish app and libraries
COPY . .
RUN dotnet publish -c release -o /app

# final stage/image
FROM mcr.microsoft.com/dotnet/core/runtime:2.1
WORKDIR /app
COPY --from=build /app ./

# Configs to start the Gateway Server
RUN cp KafkaConsumer.runtimeconfig.json IRISGatewayCore21.runtimeconfig.json && \
    cp KafkaConsumer.deps.json IRISGatewayCore21.deps.json

ENV PORT 55556

CMD dotnet IRISGatewayCore21.dll $PORT 0.0.0.0

1 行ずつ見ていきましょう。

FROM mcr.microsoft.com/dotnet/core/sdk:2.1 AS build

このアプリの構築には、完全な .Net Core 2.1 SDK を使用します。

ENV ISC_PACKAGE_INSTALLDIR /usr/irissys
ENV GWLIBDIR lib
ENV ISC_LIBDIR ${ISC_PACKAGE_INSTALLDIR}/dev/dotnet/bin/Core21

WORKDIR /source
COPY --from=store/intersystems/iris-community:2020.2.0.211.0 $ISC_LIBDIR/*.nupkg $GWLIBDIR/

正式な InterSystems Docker イメージから .Net Gateway NuGets をビルダーイメージにコピーします。

# copy csproj and restore as distinct layers
COPY *.csproj ./
RUN dotnet restore

# copy and publish app and libraries
COPY . .
RUN dotnet publish -c release -o /app

ライブラリを構築します。

# final stage/image
FROM mcr.microsoft.com/dotnet/core/runtime:2.1
WORKDIR /app
COPY --from=build /app ./

ライブラリ dll を、実際に実行する最終コンテナにコピーします。

# Configs to start the Gateway Server
RUN cp KafkaConsumer.runtimeconfig.json IRISGatewayCore21.runtimeconfig.json && \
    cp KafkaConsumer.deps.json IRISGatewayCore21.deps.json

現在、.Net ゲートウェイは起動時にすべての依存関係を読み込む必要があるため、考えられるすべての依存関係を認識するようにしています。

ENV PORT 55556

CMD dotnet IRISGatewayCore21.dll $PORT 0.0.0.0

すべてのインターフェースでリッスンするポート 55556 でゲートウェイを開始します。

以上です！

こちらは、すべてをまとめて実行する完全な docker-compose です（Kafka とメッセージを見るための Kafka UI も含まれています）。

このデモを実行するには、以下を行う必要があります。

1. インストール:
   • docker
   • docker-compose
   • git
2. 実行:

git clone https://github.com/intersystems-community/pex-demo.git cd pex-demo docker-compose pull docker-compose up -d

注意事項: Java ゲートウェイと .Net ゲートウェイライブラリは、InterSystems IRIS クライアントと同じバージョンのものである必要があります。

開発者の皆さん、こんにちは！

InterSystems IRIS 、InterSystems IRIS for Healthのコミュニティエディションは、WindowsやLinuxにインストールするキットの他にコンテナ版も公開されています。

コンテナ版はダウンロードページからではなく、InterSystemsコンテナレジストリ よりpullいただけます。

この記事では、InterSystemsコンテナレジストリ の使い方と、コンテナ開始までの流れをご紹介します。

この記事では、InterSystems IRIS の学習に関連したトピックについて、開発者コミュニティでの厳選された記事にアクセスすることができます。機械学習や Embedded Python、JSON、API と REST アプリ、InterSystems環境の構築と管理、DockerとCloud、VSCode、SQL、Analytics/BI、グローバル、セキュリティ、DevOps、インターオペラビリティNative API、それぞれでランク付けされたトップの記事を見ることができます。ぜひ、楽しみながら学んでください！  

機械学習

機械学習は、高度なデータ分析を構築し、優れた効率で手動活動を自動化するための必須技術です。既存のデータから学習する認知モデルを作成し、自己調整されたアルゴリズムに基づいて予測、確率計算、分類、識別、「非創造的」な人間の活動の自動化を実行します。

すべてのシナリオにおいて、InterSystems IRISは、これらのマシンラーニングモデルを作成、実行、利用可能にし、使用するためのデータプラットフォームおよび環境として機能します。IRISは、SQLコマンドからのML利用（IntegratedML）、Embedded PythonやPMML（Predictive Model Markup Language）による機械学習が可能です。以下の記事でその機能を確認することができます。

ObjectScript言語

ObjectScript は InterSystems のオフィシャルプログラミング言語です。簡単で柔軟性があり、バックエンド、統合、および分析アプリケーションの作成に非常に強力です。詳細については、以下の記事を参照してください。

Embedded Python

Python は、世界で最も人気があり、よく使われているプログラミング言語の 1 つです (https://www.tiobe.com/tiobe-index/)。InterSystems IRIS は、すべての主要なプログラミング言語に対して開かれたデータ・プラットフォームです。しかし、Python は、この素晴らしい言語とそのライブラリは、クラス、SQL、および統合/プロダクショ ンなど、IRIS のあらゆる場所で使用することができます。ObjectScript ( InterSystems のプログラミング言語 ) を知らない、または知りたくない人にとって、Python は素晴らしい選択肢となります。そのやり方については、以下の記事を参照してください。

JSON

JSON は、マーケットで最も広く使用されている、データの送受信のための相互運用性フォーマットの 1 つです。InterSystems IRIS は、いくつかの方法でこの形式をサポートしています。JSON (DocDB) でネイティブ・データベースを持ち、オブジェクトを直列化および非直列化し、特に REST サービスからの要求と応答を JSON で処理することが可能です。以下の記事を確認してください。

APIとRESTアプリ

バックグラウンドアプリケーションは現在、REST（Representational State Transfer）パラダイムで開発され、Web APIとして公開されています。以下の記事で、その仕組みを確認してください。

InterSystems 環境の管理と設定

IRIS環境を適切に管理・設定することは、ユーザーが使用するアプリケーションのパフォーマンス、セキュリティ、可用性、信頼性にとって不可欠です。これらの記事は、これを行うための優れたヒントを与えてくれるでしょう。

Docker と Cloud

新しいアプリケーション・アーキテクチャは、コンテナ Docker と Cloud において動作し、弾力的なスケーラビリティ、インストール、設定、プロビジョニング時間の短縮、インフラの複雑性とコストの削減を実現することを目的としています。これらの記事を読んで、IRISをクラウド化する方法を学んでください。

VSCode

VSCodeは世界で最も使われているIDEの1つです。IRISはこのIDEをフルサポートしています。以下の記事をご覧ください。

SQL

SQLは、リレーショナルデータベースを扱うのに最もよく使われる言語の1つです。これらの記事は、クエリの実行方法とデータの永続性を示しています。

アナリティクスとビジネスインテリジェンス(BI)

アナリティクスとBIは、グラフ、ダッシュボード、サマリー、詳細表などのデータ分析、およびアナリスト・ユーザーによるナビゲーションとデータ探索に基づいて意思決定を行うことを可能にします。ここでは、IRISを使った分析アプリケーションの構築方法を紹介します。

グローバル

IRIS では、SQL、クラス、JSON ドキュメント、BI キューブ、その他のカスタム形式など、データを柔軟に保存および取得するための重要なメカニズムとして、グローバルが使用されています。以下の記事で、その方法を垣間見てください：

セキュリティ

どのようなアプリケーションでも、セキュリティを確保することは非常に重要です。セキュリティは、アクセスや承認の管理、トランザクションの追跡と監査、保存および転送されるコンテンツの暗号化、感性的なリソースの保護を保証するための正しい設定パラメータに関連しています。これらの記事を読んで、セキュリティを確立する方法について理解を深めてください。

DevOps

DevOpsとは、ソースコードの開発（Dev）から本番運用（Ops）への高速かつ高品質な移行を自動化することを可能にするプラクティスやツールを採用する方法です。IRISでその方法をご覧ください。

インターオペラビリティ

IRISは、強力なデータおよびアプリケーションのインタラクティブなバスを備えています。以下の記事でその使い方をご覧ください。

Native API

IRISは、市場で最も使用されているプログラミング言語（Java、Javascript/NodeJS、.Net、C++、Python）を使用することに前向きです。これを実現するために、これらの言語ごとにNative APIを使用しています。以下の記事をご覧ください。

2023.2がリリースされると同時に、IRIS ならびに IRIS for Health コンテナのタグと配布に関して少し変更を行います。

IRIS コンテナはこれまで、例えば 2023.1.0.235.1 のように、ビルド番号を付与したタグづけを行っていました。しかしお客様から、新製品がリリースされるたびに dockerfiles や Kubernetes ファイルを変更しなくていいよう、より安定的なタグに関するご要望をいただいてきました。 それを踏まえ、コンテナ・イメージのタグについて、以下のように変更を行います。

メジャー.マイナー タグ:  コンテナのタグは、年とリリース番号でのみ記述され、ビルド番号は付きません。例えば、現在以下のように取得されるイメージは

containers.intersystems.com/intersystems/iris:2023.2.0.606.0

今後は以下のフォーマットに変わります。 

containers.intersystems.com/intersystems/iris:2023.2

皆さんこんにちは！

この記事でご紹介する「開発環境テンプレート」は、最近 医療 IT で注目を集めている 医療情報交換標準規格  FHIRを体験できるコンテナです。

一式は、こちら（https://github.com/Intersystems-jp/IRIS-FHIR-Oximeter-Template）で公開しています。

コンテナビルド時、InterSystems IRIS for Health コミュニティエディションを使用した FHIR R4 リソースリポジトリの用意と、REST 用エンドポイントが用意されます。

作成されるエンドポイントに対して、REST クライアントから直接 FHIR R4 リソースリポジトリへアクセスすることもできますし（使用例はこちら／ビデオの解説はこちら）、Patient リソースと Observation リソースの操作体験が行えるサンプル Web アプリケーション（使用例はこちら／ビデオの解説はこちら）もコンテナに含まれていますので、お好みの方法で操作を体験できます。

この開発環境テンプレートでは、さらに！ FHIR  サーバーサイドアプリケーション（＝プロダクション）のサンプルも用意しています（図例はこちら）。

プロダクションは、新生児につけたパルスオキシメーターの測定値が定期的に送信されてくることを仮定して作られています。

これは InterSystems FAQ サイトの記事です。
 

こちらでは、InterSystems Container Registry(ICR) より入手可能なDockerコンテナイメージを使用する方法をご案内します。

※WRCDirectのダウンロードサイト より入手可能なイメージを使用する場合も同じようにできます。
　その際、Name：Web でフィルタリングしていただくと、Web Gateway の Docker イメージが見つけやすくなります。
※インターシステムズが提供する webgateway コンテナイメージには、Web ゲートウェイと Apache Web サーバの両方が含まれています。

【手順】

1. ブラウザより https://containers.intersystems.com/ にアクセスし、インターシステムズWRC認証情報でログインします。

2. Dockerログイントークンかログインコマンドを取得します。

3. 取得した認証情報を使い、Dockerインターフェース(PowerShellウインドウやLinuxコマンドラインなど)でICRへの認証を行います。
    以下の例のように、表示されるDocker ログインコマンドをコピー、ペーストすることで認証できます。

開発者の皆さん、こんにちは。

先日のウェビナーでご紹介した「ワークフローコンポーネント」をお試しいただけるサンプルを公開しました。👉 https://github.com/Intersystems-jp/WorkFlow-DC

《サンプルのテーマ》

店舗で販売している商品に付けるPOPメッセージ候補を予めテーブルに登録できる仕組みが既にある、と仮定しています。

IRISの Interoperability を利用してPOPメッセージ候補が登録されるテーブルに対して一定間隔でSELECT文を実行し、未処理のメッセージを取得します。
新たなレコードが存在する場合、ワークフローコンポーネントを利用して担当者に審査を依頼します。

担当者は、ワークフローユーザポータルを使用して、POPメッセージ候補の承認／却下を指示できるようにしています。

コミュニティの皆さん、こんにちは！

最近では、誰もが Github、GitLab、bitbucket などのリポジトリにプロジェクトのソースコードを保管していると思います。 InterSystems IRIS プロジェクトについても同様で、Open Exchange にチェックされています。

InterSystems Data Platform で特定のリポジトリの操作を開始または継続するたびに、何をしているでしょうか？

ローカルの InterSystems IRIS マシン、プロジェクト用の環境のセットアップ、ソースコードのインポートが必要です。

つまり、すべての開発者は以下を実行しています。

1. リポジトリからコードをチェックアウトする。
2. ローカル IRIS インストールをインストール/実行する。
3. プロジェクト用の新しいネームスペース/データベースを作成する
4. コードをこの新しいネームスペースにインポートする。
5. すべての残りの環境をセットアップする。
6. プロジェクトのコーディングを開始/継続する。 

リポジトリを Docker 化すると、この手順は次の 3 つのステップに短縮できます。

1. リポジトリからコードをチェックアウトする。
2. docker-compose build を実行する。 
3. プロジェクトのコーディングを開始/継続する。 

メリット: 実行に数分かかる上、頭が痛くなるようなステップ 3、4、5 を行わなくて済みます。

次の数ステップで、（ほぼ）すべての InterSystems リポジトリを Dcoker 化できます。 では、やってみましょう！

**リポジトリを Docker 化する方法は？その意味は？ **

基本的に、マシンに Docker をインストールし、コードと環境をコンテナに構築し、そのコンテナを Docker で実行すれば、最初に開発者が導入した方法で動作するようにするという考えです。 「OS のバージョンは何？」や「この IRIS インストールには他に何かあった？」といった疑問はありません。

毎回、クリーンなページ（またはクリーンな IRIS コンテナ）を使用して環境（ネームスペース、データベース、ウェブアプリ、ユーザー/ロール）がセットアップされ、作成したばかりのクリーンなデータベースにコードがインポートされます。

この「Docker 化」手順によって、現在のリポジトリに大きな悪影響が及ぶでしょうか？ 

及びません。 リポジトリのルートに独自にセットアップできるいくつかのツールに従った 2～3 個の新しいファイルを追加する必要があります。

前提条件

docker をダウンロードしてインストールします。

IRIS docker イメージをダウンロードしてインストールします。 この例では、WRC-preview からダウンロードできる完全な InterSystems IRIS プレビュー（iris:2019.1.0S.111.0）を使用します。詳細をご覧ください。

キーを必要とするインスタンスを操作する場合は、常に使用する場所に iris.key を配置します。  私の場合は、Mac の Home ディレクトリに置きました。

リポジトリの Docker 化

リポジトリを Docker 化するには、リポジトリのルートフォルダに 3 つのファイルを追加する必要があります。

こちらは、ISC-DEV プロジェクトの Docker 化されたレポジトリの例です。これは、IRIS データベースからソースコードをインポート/エクスポートするのに役立ちます。  このリポジトリには、以下に説明する追加の Dockerfile、docker-compose.yml、および installer.cls が含まれています。

まず、Dockerfile です。これは、docker-compose build コマンドで使用されます。

<p>
</p>

<p>
  WORKDIR /opt/app
</p>

<p>
  COPY ./Installer.cls ./
</p>

<p>
  COPY ./cls/ ./src/
</p>

<p>
  RUN iris start $ISC_PACKAGE_INSTANCENAME quietly EmergencyId=sys,sys && \
</p>

<p>
      /bin/echo -e "sys\nsys\n" \
</p>

<p>
              # ユーザー管理者に %ALL を付与
</p>

<p>
              " Do ##class(Security.Users).UnExpireUserPasswords(\"*\")\n" \
</p>

<p>
              " Do ##class(Security.Users).AddRoles(\"admin\", \"%ALL\")\n" \
</p>

<p>
              # インストーラのインポートと実行
</p>

<p>
              " Do \$system.OBJ.Load(\"/opt/app/Installer.cls\",\"ck\")\n" \
</p>

<p>
              " Set sc = ##class(App.Installer).setup(, 3)\n" \
</p>

<p>
              " If 'sc do \$zu(4, \$JOB, 1)\n" \
</p>

<p>
              # OS レベルの認証を導入（コンテナのログイン/パス プロンプトを削除するため）
</p>

<p>
              " Do ##class(Security.System).Get(,.p)\n" \
</p>

<p>
              " Set p(\"AutheEnabled\")=p(\"AutheEnabled\")+16\n" \
</p>

<p>
              " Do ##class(Security.System).Modify(,.p)\n" \
</p>

<p>
              " halt" \
</p>

<p>
      | iris session $ISC_PACKAGE_INSTANCENAME && \
</p>

<p>
      /bin/echo -e "sys\nsys\n" \
</p>

<p>
      | iris stop $ISC_PACKAGE_INSTANCENAME quietly
</p>

<p>
  CMD [ "-l", "/usr/irissys/mgr/messages.log" ]
</p>   

<p>
   
</p>

この Dockerfile は installer.cls とソースコードをリポジトリの /cls フォルダから /src フォルダ、そしてコンテナにコピーします。

また、いくつかの構成設定も実行します。これにより、管理者ユーザーに %All ロールと無期限のパスワード「SYS」が付与され、OS レベルの認証が導入され、%Installer が実行されます。 

%Installer とは何でしょうか？

Class App.Installer
{
XData MyInstall [ XMLNamespace = INSTALLER ]
{
<Manifest>
  <Default Name="NAMESPACE" Value="ISCDEV"/>
  <Default Name="DBNAME" Value="ISCDEV"/>
  <Default Name="APPPATH" Dir="/opt/app/" />
  <Default Name="SOURCESPATH" Dir="${APPPATH}src" />
  <Default Name="RESOURCE" Value="%DB_${DBNAME}" /> 

  <Namespace Name="${NAMESPACE}" Code="${DBNAME}-CODE" Data="${DBNAME}-DATA" Create="yes" Ensemble="0">
    <Configuration>
      <Database Name="${DBNAME}-CODE" Dir="${APPPATH}${DBNAME}-CODE" Create="yes" Resource="${RESOURCE}"/>
      <Database Name="${DBNAME}-DATA" Dir="${APPPATH}${DBNAME}-DATA" Create="yes" Resource="${RESOURCE}"/>
    </Configuration>
    <Import File="${SOURCESPATH}" Recurse="1"/>
  </Namespace>

</Manifest>
}

ClassMethod setup(ByRef pVars, pLogLevel As %Integer = 3, pInstaller As %Installer.Installer, pLogger As %Installer.AbstractLogger) As %Status [ CodeMode = objectgenerator, Internal ]
{
  Return ##class(%Installer.Manifest).%Generate(%compiledclass, %code, "MyInstall")
}

}

これは、ネームスペース/データベース ISCDEV を作成し、ソースフォルダである -/src からコードをインポートします。

次は、docker-compose.yml ファイルです。これは、docker-compose up コマンドでコンテナを実行するときに使用されます。

version: '2.4'
services:
  iris:
    build: .
    restart: always
    ports:
      - 52773:52773
    volumes:
      - ~/iris.key:/usr/irissys/mgr/iris.key

この構成によって、Docker に対し、ホストのどのポートで IRIS の動作が期待されるかを指示します。 最初（52773）はホスト、2 つ目はコンテナのコンテナ内部ポート（52773）です。

volumes セクションでは、docker-compose.yml は、IRIS が検索するコンテナ内でマシン上の iris キーへのアクセスを提供します。

- ~/iris.key:/usr/irissys/mgr/iris.key

このリポジトリでコーディングを始めるには、以下を実行します。

1. 任意のローカルディレクトリにリポジトリを Clone/git pull します。

 2. このディレクトリでターミナルを開き、以下を実行します。

user# docker-compose build

これによりコンテナがビルドされます。

3. プロジェクトで IRIS コンテナを実行します。

user# docker-compose up -d

お好きな IDE を開いて、localhost://52773 のサーバーに接続し、InterSystems IRIS Data Platform で作業を始めましょう！;)

この 3 つのファイルを使用して、リポジトリを Docker 化できます。 Dockerfile のソースコードに適切な名前、Installer.cls に適切なネームスペースを付けて、docker-compose.yml に iris.key を配置するだけで、InterSystems IRIS を使った日常の開発で、Docker コンテナを活用することができます。

InterSystemsコンテナレジストリ Webユーザインターフェースのお知らせ
 

InterSystemsはこの度、InterSystems コンテナレジストリ (ICR) Web ユーザインターフェースをリリースしました。このツールはICR上に多くあるコンテナイメージを見つけやすく、使いやすくできるようデザインされたものです。

InterSystems コンテナレジストリUIは以下のサイトです。

 https://containers.intersystems.com/contents

コミュニティエディションコンテナ

When you visit the ICR ユーザインターフェース,を訪問すると、コミュニティエディションといったパブリックに利用可能なコンテナにアクセスできます。画面左のナビゲーションで必要なプロダクトファミリを選択し、コンテナを選択、最終的に特定のバージョンを指定します。

エンタープライズエディションコンテナ

IRISエンタープライズエディションといったプライベートコンテナを観るにはログインボタンをクリックしてください。一度ログインいただくと、画面左のナビゲーションにはアクセスできるすべてのコンテナが表示されます。

ぜひ、ご利用ください！

FaaS（Function as a Service）は、アプリケーションの機能を開発、実行、および管理するプラットフォームを提供するクラウドコンピューティングサービスのカテゴリです。アプリの開発と起動に一般的に関連するインフラストラクチャの複雑な構築や保守がありません。 このモデルに従ったアプリケーションの構築は、「サーバーレス」アーキテクチャを実現する方法の 1 つであり、通常、マイクロサービスアプリケーションを構築する際に使用されています。

Wikipedia

FaaS は、クラウドでワークロードを実行するための非常に一般的なアプローチで、開発者はコードを書くことに専念することができます。

この記事では、InterSystems IRIS のメソッドを FaaS 方式でデプロイする方法を説明します。

Kubernetes をインストール

まず、Kubernetes 1.16 をインストールします。 多数のガイドが用意されているため、ここには書き写しませんが、私は minicube を使用しています。 Kubernetes の実行に minicube を使用する場合、以下のコマンドを実行するだけです。

minikube start --kubernetes-version=v1.16.1

Kubeless をインストール

次に、Kubeless をインストールします。 Kubeless は Kubernetes ネイティブのサーバーレスフレームワークで、基盤のインフラストラクチャの構築を気にすることなく、小さなコードをデプロイできます。 Kubernetes リソースを利用して、自動スケール、API ルーティング、監視、トラブルシューティングなどの機能を提供します。

kubectl create ns kubeless
kubectl create -f https://github.com/kubeless/kubeless/releases/download/v1.0.8/kubeless-v1.0.8.yaml
kubectl get pods -n kubeless

出力は以下のようになります。

NAME                                          READY   STATUS    RESTARTS   AGE
kubeless-controller-manager-666ffb749-26vhh   3/3     Running   0          83s

また、Kubeless クライアントをインストールする必要もあります（kubectl のあるインスタンスにインストール）。 これはこちらで入手できます。 Linux でのインストールは、以下のように単純です。

sudo install kubeless /usr/local/bin/kubeless

Kubeless をテスト

まず、単純な Python 関数をデプロイして、Kubeless が動作することを確認しましょう。

test.py を作成します。

def hello(event, context):
  return event['data']

関数環境についての詳細は、こちらのドキュメントをお読みください。一般的に関数は、以下のデータを伴うイベントとコンテキストの 2 つの引数を受け入れます。

event:data:# Event datafoo:"bar"# The data is parsed as JSON when requiredevent-id:"2ebb072eb24264f55b3fff"# Event IDevent-type:"application/json"# Event content typeevent-time:"2009-11-10 23:00:00 +0000 UTC"# Timestamp of the event sourceevent-namespace:"kafkatriggers.kubeless.io"# Event emitterextensions:# Optional parametersrequest:...# Reference to the request received response:...# Reference to the response to send # (specific properties will depend on the function language)context:function-name:"pubsub-nodejs"timeout:"180"runtime:"nodejs6"memory-limit:"128M"

   次に、関数とランタイムを含むファイルを指定して、hello 関数をデプロイします。

kubeless function deploy hello --runtime python3.7 --from-file test.py --handler test.hello
kubeless function ls hello

では、テストしましょう。

kubeless function call hello --data 'Hello world!'

答えとして Hello World! を受け取るはずです。

IRIS 構成を追加

次に、InterSystems IRIS 関数ハンドラーを追加する必要があります。編集する kubeless 構成を開きましょう。

kubeless get-server-config
kubectl get -n kubeless configmaps -o yaml > configmaps.yaml
kubectl edit -n kubeless configmaps

以下のエントリを runtime-images 配列に追加して保存します。

{"ID": "iris","depName": "","fileNameSuffix": ".cls","versions": [{"images": [{"image": "eduard93/kubeless-iris-runtime:latest","phase": "runtime"}],"name": "iris2022.1","version": "2022.1"}]}

変更が適用されるように、Kubeless コントローラーを再起動します。

kubectl delete pod -n kubeless -l kubeless=controller

IRIS 関数 CRD を構築して公開

では、InterSystems IRIS に最初の関数を書き込みましょう。

Class User.Test {

ClassMethod hi(event, context) As %Status
{
    if $isObject(event) {
        write event.Text + event.Text
    } else {
        write "HELLO FROM IRIS"
    }
    quit $$$OK
}
}

次に、関数 CRD を構築する必要があります。

以下は、テンプレートです。

apiVersion: kubeless.io/v1beta1
kind: Function
metadata:
  name: !name!
  namespace: default
spec:
  runtime: iris2022.1
  timeout: "180"
  handler: !handler!
  deps: ""
  function-content-type: text
  deployment:
    spec:
      template:
        spec:
          securityContext:
            runAsUser: 51773
            runAsGroup: 51773
  function: |

そして、以下の内容を入力します。

• name: 関数名（kubeless）
• handler: class.name_method（InterSystems IRIS）
• function の本体: 最後に追加します（タブを忘れずに！）

すると、CRD は以下のようになります。

apiVersion: kubeless.io/v1beta1
kind: Function
metadata:
  name: iris-demo
  namespace: default
spec:
  runtime: iris2022.1
  timeout: "180"
  handler: User_Test.hi
  deps: ""
  function-content-type: text
  deployment:
    spec:
      template:
        spec:
          securityContext:
            runAsUser: 51773
            runAsGroup: 51773
  function: |
    Class User.Test {
ClassMethod hi(event, context) As %Status
{
    if $isObject(event) {
        write event.Text + event.Text
    } else {
        write "HELLO FROM IRIS"
    }
    quit $$$OK
}
}</pre>

これは簡単に自動化できます。 Linux では以下を実行します。

sed 's/!name!/iris-demo/; s/!handler!/User_Test.hi/' function.yaml > function_demo.yaml
sed  's/^/     /'  User.Test.cls >> function_demo.yaml

Windows では以下は実行します（PowerShell）。

Get-Content function.yaml | ForEach-Object { $_ -replace "!handler!", "User_Test.hi" -replace "!name!", "iris-demo" } | Set-Content function_demo.yaml
"    " + [string]((Get-Content User.Test.cls)  -join "`r`n    ") | Add-Content function_demo.yaml

Kubeless にこの CRD を公開する必要があります。

kubectl apply -f function_demo.yaml

IRIS 関数をテスト

まず、関数がデプロイされて準備が完了していることを確認しましょう（初回時は、準備に数分かかることがあります）。

kubeless function ls

次にこれを呼び出します。

kubeless function call iris-demo --data '{"Text":123}'

Windows を使用している場合は、以下のように関数を呼び出します（エスケープ付きの二重引用符を使ったその他すべての呼び出しでも共通です）。

kubeless function call iris-demo --data '{\"Text\":123}'

どちらで操作しているかに関わらず、123 が数値であるため、レスポンスは 456 になります。

HTTP アクセス

Kubeless には HTTP アクセスも提供されています。 これをテストするには、以下の kubectl proxy コマンドを使用します。

kubectl proxy -p 8081

次に、このリクエストを任意の REST API クライアントを使って送信します。

GET http://localhost:8081/api/v1/namespaces/default/services/iris-demo:http-function-port/proxy/

{"Text":111}

Postman では以下のように表示されます。

次に、これをインターネットに公開しましょう。

これには 2 つのアプローチがあります。 イングレスをこちらに説明されているとおりに構成するのがお勧めです。

また、関数サービスをパッチすることができます。

kubectl get svc
kubectl patch svc iris-demo -p '{"spec": {"type": "LoadBalancer"}}'
kubectl get svc

クリーンアップ

デプロイした関数呼び出しを削除するには、以下のようにします。

kubectl delete -f function_demo.yaml

まとめ

これは紛れもなくコンセプトの証明であり、本番級のソリューションではありませんが、このアプローチでは、サーバーレスの FaaS アプローチを使って、InterSystems IRIS ワークロードを実行できることが分かりました。

リンク

• Minicube
• Kubeless
• InterSystems IRIS ランタイム

これは InterSystems FAQ サイトの記事です。

コンテナログイン時、-u オプションで root を指定することでログインできます。

docker exec -it -u root コンテナ名 bash

皆さん、こんにちは！

職場で持ち上がった単純なリクエストで始めた個人プロジェクトを紹介したいと思います。 

使用している Caché ライセンス数を調べることはできますか？ 

コミュニティに掲載されている他の記事を読んでみたところ、David Loveluck が投稿したぴったりの記事が見つかりました。 

APM - Using the Caché History Monitor（APM - Caché 履歴モニターを使用する）
https://community.intersystems.com/post/apm-using-cach%C3%A9-history-monitor

そこで、David の記事を参考に、Caché 履歴モニターを使って、リクエストされた情報を表示して見ました。 

「どのテクノロジーを使用するのか」という疑問に対し 

私は CSP に決定しました。単純で強力なテクノロジーであるため、私が担当するお客様は Caché が単なる MUMPS/ターミナルではないことに気づくでしょう。

ライセンス、データベース増加状況、CSP セッションの履歴を表示するページを作成した後、「システムダッシュボードとプロセス」ページのデザインを新装することにしました。

私の Caché インスタンスではすべてうまく機能します。

でも、IRIS はどうでしょうか？ 

Evgeny Shvarov が投稿した以下の記事に従って、

Using Docker with your InterSystems IRIS development repository（InterSystems IRIS 開発リポジトリで Docker を使用する）
https://community.intersystems.com/post/using-docker-your-intersystems-iris-development-repository

コードを Docker 化して GitHub に配置しました。いくつかの手順を踏めば、どなたでも利用できます。

実行方法

このリポジトリでコーディングを始めるには、以下を実行します。

1. 任意のローカルディレクトリにリポジトリを Clone/git pull します。
   $ git clone https://github.com/diashenrique/iris-history-monitor.git

2. このディレクトリでターミナルを開き、以下を実行します。
   $ docker-compose build

3. プロジェクトで IRIS コンテナを実行します。
   $ docker-compose up -d

テスト方法

ブラウザを開いて、以下のアドレスに移動します。

例: http://localhost:52773/csp/irismonitor/dashboard.csp

ユーザー名 _SYSTEM を使用して、ダッシュボードとその他の機能を実行できます。

システムダッシュボード

システムダッシュボードには、以下の項目が表示されます。

• ライセンス
• システム時間
• アプリケーションエラー
• Cache プロセス
• CSP セッション
• ロックテーブル
• ジャーナル空間
• ジャーナルのステータス
• ECP AppServer
• ECP DataServer
• Write デーモン
• Cache の効率
• 重大なアラート

線グラフウィジェットには、5 秒ごとにポイントがプロットされます。

 システムメニュー

システムプロセス

プロセスフィルター

さまざまなフィルターを使用して、必要な結果を得ることができます。 また、列のヘッダーを Shift + クリックすると、複数の項目で並べ替えることもできます。データグリッドを Excel にエクスポートすることも可能です！

履歴モニター

CSP セッションとライセンスの履歴モニターでは、情報が以下の 3 つのセクションに分かれて表示されます。

• 5 分毎
• 毎日
• 毎時間

データベースの増加が表示できるのは、毎日の情報のみです。

履歴ページでは以下の機能を共通して使用できます。

日付範囲の選択ツール

_デフォルト_値は、「過去 7 日間」です。

グラフ/データテーブル

各セクションの右上に、2 つのボタン（チャート/データテーブル）があります。

データテーブルには、グラフを作成する情報が表示されます。Excel 形式でダウンロード可能です。

Excel には、CSP で定義されたのと同じフォーマット、コンテンツ、およびグループが表示浚えます。

ズーム機能

すべてのグラフにはズームオプションがあるため、情報をより詳細に可視化することができます。

平均と最大

毎時間と毎日のセクションのグラフには、平均値と最大値が表示されます。

平均

最大

どうぞお楽しみください！

@Yuri Marx のお陰で、非常に優れた Postgres から IRIS へのデータベース移行の例を確認できました。
私の個人的な問題は、DBeaver を移行ツールとして使用することです。
特に、以前の IRIS（それから Caché）の強みの 1 つは、JBDC または ODBC でアクセスできる限り任意の外部 Db にアクセスできる SQLgateways を利用できることであったためです。 そこで、これを実演するために、パッケージを拡張しました。

完全な Docker を含む従来型の OEX パッケージです。
SQLgateway は Docker ビルド中にインストールされ、必要な Linux 用の jdvcdriver はこのリポジトリに含まれています。このデモを高速化するために、移行するテーブルのサイズは少しばかり縮小されています。 

テスト方法

すべての移行アクションは、SMP から直接実行可能です。

1.   
以下の場所でゲートウェイ接続を確認します。 SMP > 管理 > 構成 > 接続 > SqlGateway_Configuration

接続をテストするには［編集］をクリックします。

そして［接続テスト］をクリックします。

• 「接続成功」を確認します。
• ここでは、しばらくお待ちください。 Postgres コンテナが応答するまでに、かなり時間がかかることがあります。    
  • しばらくしてから、ブラウザのページを再読み込みし、もう一度テストしてください。     

2. ソーステーブルを識別します。 SMP でネームスペースを USER に変更し、 SMP > エクスプローラー > SQL > ウィザード > データ移行 に進みます。

3.     
必要なインポートパラメーターを設定します。
 

• 指定ネームスペース
  • Type = TABLE
  • Gateway = postgres >>> 最初の接続が確定されたら、以下のように選択します。
  • Schema = public
  • Tables to migrate = all         

4.      
ターゲットを特定しますが、スキーマが OEX 互換となるように、public から dc_public に変更します。
- すべて変更を忘れずにクリックしてください。

• 両サイドが選択されるように Definitions と Data を移行します。       

5.        
特殊設定を省略し、デフォルトを使用します。タスクをバックグラウンドで起動します。
    

6.     
結果を確認し、エラーなくすべてが機能していることを確認します。

• テーブルが、まだ移行されていないコンテンツに依存している場合は、エラーが表示される場合があります。       
  • ステータスに完了が表示されるまで待ちます。     

7.     
移行ウィザードを終了し、*dc **でフィルタリングした通常のテーブルビューに戻ります。
- 全 8 つのテーブルが表示され、意味のある列が表示されます。  

8.             
テーブルを選択して OpenTable をクリックすると、合理的なコンテンツが表示されます。

       

9.    
生成された関連する Class Definitions を見ると、結果と、正常に完了したことを確認できます。          

開発者のみなさん、こんにちは！

2022年3月9日開催「InterSystems Japan Virtual Summit 2022」のセッション「オープンソースだけで IRIS on Kubernetes を動かそう」のアーカイブを YouTube に公開いたしました。

（プレイリストはこちら）

Docker は使いこなせるようになってきたけど、Kubernetes はなかなか手を出すチャンスがないな、という方々を対象に手持ちの Windows/PC 上に K8s 環境を構築して色々試すことを最終目標としたセッションです。

開発者コミュニティの記事「microk8sでKubernetesをお手軽に試す」との紙面連動です。

ぜひご参照ください。

<iframe width="521" height="293" src="https://www.youtube.com/embed/zMhPuBFl6l4" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

【目次】

01:43 Kubernetes について
　参考動画：KubernetesでのIRISの運用とそれを支える仕組み

05:48 Microk8S 利用の動機付け

09:50 デモ
　記事：microk8sでKubernetesをお手軽に試す の内容に沿ってデモを動かしています。

14:00 デモ - IRIS起動の確認

15:35 デモ - MicroK8S 環境をクラスタ構成にする

17:32 デモ - Longhorn をデプロイする

19:28 デモ - Longhorn を Persistent Volume としてIRISが使用するように構成する

20:58 デモ - ノード障害発生時の動作を確認

23:15 まとめ
　↓参考となるオンラインラーニング（英語）↓
　https://learning.intersystems.com/course/view.php?name=KubernetesExercise

はじめに

前の記事では、ObjectScript Package Manager を使用してユニットテストを実行するためのパターンについて説明しました。 この記事では、さらに一歩踏み込み、GitHub Actions を使用してテストの実行とレポート作成を行います。 私の Open Exchange プロジェクトの 1 つである AppS.REST に CI を実行するのが、やる気の出るユースケースでしょう（この導入編の記事は、こちらにあります）。 この記事のスニペットが使用されている完全な実装は、GitHub でご覧ください。ObjectScript Package Manager を使って他のプロジェクトで CI を実行するためのテンプレートとして簡単に利用できます。

紹介する実装の機能は以下のとおりです。

• ObjectScript パッケージの構築とテスト
• codecov.io によるテストカバレッジ測定のレポート（TestCoverage パッケージを使用）
• テスト結果に関するレポートのビルドアーティファクトとしてのアップロード

ビルド環境

GitHub Actions に関する完全なドキュメントはこちらにあります。この記事の目的に準じ、この例で紹介される側面だけを詳しく確認します。

GitHub Actions のワークフローは、構成可能な一連のイベントによってトリガーされ、順番に、または並行して実行できる多数のジョブで構成されています。 それぞれのジョブには一連のステップがあります。このサンプルアクションのステップは、少し後の方で詳しく説明します。 これらのステップは、GitHub で提供されているアクションへの参照で構成されているか、単にシェルコマンドである場合があります。 この例での最初のボイラープレートのスニペットは、以下のようになります。

# Continuous integration workflow
name: CI

# Controls when the action will run. Triggers the workflow on push or pull request
# events in all branches
on: [push, pull_request]

# A workflow run is made up of one or more jobs that can run sequentially or in parallel
jobs:
  # This workflow contains a single job called "build"
  build:
    # The type of runner that the job will run on
    runs-on: ubuntu-latest
    
    env:
      # Environment variables usable throughout the "build" job, e.g. in OS-level commands
      package: apps.rest
      container_image: intersystemsdc/iris-community:2019.4.0.383.0-zpm
      # More of these will be discussed later...
    
    # Steps represent a sequence of tasks that will be executed as part of the job
    steps:
      # These will be shown later...

この例では、多数の環境変数が使用されています。 この例を ObjectScript Package Manager を使用して他のパッケージに適用する場合、ほとんどの変数を変更する必要はありませんが、一部には変更が必要です。

    env:
      # ** FOR GENERAL USE, LIKELY NEED TO CHANGE: **
      package: apps.rest
      container_image: intersystemsdc/iris-community:2019.4.0.383.0-zpm
      
      # ** FOR GENERAL USE, MAY NEED TO CHANGE: **
      build_flags: -dev -verbose # Load in -dev mode to get unit test code preloaded
      test_package: UnitTest
      
      # ** FOR GENERAL USE, SHOULD NOT NEED TO CHANGE: **
      instance: iris
      # Note: test_reports value is duplicated in test_flags environment variable
      test_reports: test-reports
      test_flags: >-
       -verbose -DUnitTest.ManagerClass=TestCoverage.Manager -DUnitTest.JUnitOutput=/test-reports/junit.xml
       -DUnitTest.FailuresAreFatal=1 -DUnitTest.Manager=TestCoverage.Manager
       -DUnitTest.UserParam.CoverageReportClass=TestCoverage.Report.Cobertura.ReportGenerator
       -DUnitTest.UserParam.CoverageReportFile=/source/coverage.xml

これを独自のパッケージに適応させるには、独自のパッケージ名と優先するコンテナイメージをドロップしてください（zpm を含める必要があります。https://hub.docker.com/r/intersystemsdc/iris-community をご覧ください）。 また、ユニットテストパッケージが独自のパッケージの規則に一致するように変更することもお勧めします（ユニットテストを実行する前に、読み込みとコンパイルを行ってして依存関係の読み込み/コンパイルを処理する必要がある場合。私自身、このパッケージではユニットテストに特有の奇妙な問題に遭遇したためですが、他のケースでは関連性がないかもしれません）。

インスタンス名と test_reports ディレクトリは、他の使用では変更する必要はありませんし、test_flags には有効なデフォルトセットが備わっています。これらは、ユニットテストが失敗すると、ビルドを失敗としてフラグする機能をサポートしており、jUnit 形式のテスト結果とコードカバレッジレポートのエクスポートも処理できます。

ビルドのステップ

GitHub リポジトリの確認

この例では、テストされているリポジトリと、Forgery のフォーク（ユニットテストで必要であるため）の2 つのリポジトリを確認する必要があります。

    # Checks out this repository under $GITHUB_WORKSPACE, so your job can access it
    - uses: actions/checkout@v2
    
    # Also need to check out timleavitt/forgery until the official version installable via ZPM
    - uses: actions/checkout@v2
      with:
        repository: timleavitt/forgery
        path: forgery

$GITHUB_WORKSPACE は非常に重要な環境変数で、このすべてが実行するルートディレクトリを表します。 権限の観点では、そのディレクトリ内ではほぼあらゆる操作を実行できますが、他の場所では問題に遭遇するかもしれません。

InterSystems IRIS コンテナの実行

最終的にテスト結果レポートを配置するディレクトリをセットアップしたら、ビルドの InterSystems IRIS Community Edition（+ZPM）コンテナを実行します。

    - name: Run Container
      run: |
        # Create test_reports directory to share test results before running container
        mkdir $test_reports
        chmod 777 $test_reports
        # Run InterSystems IRIS instance
        docker pull $container_image
        docker run -d -h $instance --name $instance -v $GITHUB_WORKSPACE:/source -v $GITHUB_WORKSPACE/$test_reports:/$test_reports --init $container_image
        echo halt > wait
        # Wait for instance to be ready
        until docker exec --interactive $instance iris session $instance < wait; do sleep 1; done

コンテナに共有されている GitHub ワークスペース（コードを読み込めるようにするため。ここにはテストカバレッジ情報もレポートします）と jUnit テスト結果を配置する別のディレクトリの 2 つのボリュームがあります。

「docker run」が終了しても、インスタンスが完全に開始され、コマンドを処理する準備が整っているわけではありません。 インスタンスの準備が整うまで、iris セッションを通じて「halt」コマンドを実行し続けます。これは失敗となりますが、（最終的に）成功になるまで、1 秒に 1 回ずつ試行し続けます。成功になれば、インスタンスの準備は完了です。

テスト関連ライブラリのインストール

このユースケースでは、他に TestCoverage と Forgery という 2 つのライブラリを使用してテストします。 TestCoverage は、Community Package Manager を介して直接インストールできますが、Forgery については、（現時点では）zpm「load」を介して読み込む必要があります。いずれのアプローチも有効です。

    - name: Install TestCoverage
      run: |
        echo "zpm \"install testcoverage\":1:1" > install-testcoverage
        docker exec --interactive $instance iris session $instance -B < install-testcoverage
        # Workaround for permissions issues in TestCoverage (creating directory for source export)
        chmod 777 $GITHUB_WORKSPACE
    
    - name: Install Forgery
      run: |
        echo "zpm \"load /source/forgery\":1:1" > load-forgery
        docker exec --interactive $instance iris session $instance -B < load-forgery

一般的には、ファイルにコマンドを記述して空、IRIS セッションで実行します。 ZPM コマンドに追加されている「:1:1」は、エラーが発生したらエラーコードとともにプロセスを終了し、エラーが発生しない場合は最後に停止することを示しています。つまり、エラーが発生した場合は、失敗したビルドステップとして報告されるため、ファイルの最後に「halt」コマンドを追加する必要はありません。

パッケージの構築とテスト

最後に、パッケージのテストを実際に構築して実行しましょう。 これはいたって単純です。始めの方で定義した $build_flags/$test_flags 環境変数が使用されていることに注目してください。

    # Runs a set of commands using the runners shell
    - name: Build and Test
      run: |
        # Run build
        echo "zpm \"load /source $build_flags\":1:1" > build
        # Test package is compiled first as a workaround for some dependency issues.
        echo "do \$System.OBJ.CompilePackage(\"$test_package\",\"ckd\") " > test
        # Run tests
        echo "zpm \"$package test -only $test_flags\":1:1" >> test
        docker exec --interactive $instance iris session $instance -B < build && docker exec --interactive $instance iris session $instance -B < test && bash <(curl -s https://codecov.io/bash)

これは、見たことのあるパターンに則っています。ファイルにコマンドを書き出してから、そのファイルを iris セッションの入力として使用しています。

最後の行の最後の部分は、コードカバレッジの結果を codecov.io にアップロードしています。 とても簡単です！

ユニットテスト結果のアップロード

ユニットテストが失敗したとしましょう。 ビルドログに戻って、どこで間違ってしまったのかを見つけ出すのは本当に面倒な作業ですが、有用なコンテキストが得られるかもしれません。 作業を楽にするために、jUnit 形式の結果をアップロードできるだけでなく、サードパーティのプログラムを実行して、見栄えの良い HTML レポートに変換することも可能です。

    # Generate and Upload HTML xUnit report
    - name: XUnit Viewer
      id: xunit-viewer
      uses: AutoModality/action-xunit-viewer@v1
      if: always()
      with:
        # With -DUnitTest.FailuresAreFatal=1 a failed unit test will fail the build before this point.
        # This action would otherwise misinterpret our xUnit style output and fail the build even if
        # all tests passed.
        fail: false
    - name: Attach the report
      uses: actions/upload-artifact@v1
      if: always()
      with:
        name: ${{ steps.xunit-viewer.outputs.report-name }}
        path: ${{ steps.xunit-viewer.outputs.report-dir }}

このほとんどは、https://github.com/AutoModality/action-xunit-viewer の Readme から拝借したものです。

最終結果

このワークフローの結果は、以下でご覧いただけます。

intersystems/apps-rest での CI ジョブのログ（ビルドアーティファクトを含む）: https://github.com/intersystems/apps-rest/actions?query=workflow%3ACI
テストカバレッジレポート: https://codecov.io/gh/intersystems/apps-rest

ご質問がございましたら、お知らせください！

これは、前回の「DockerマイクロサーバーとしてのIRIS Native APIを使用するWebSocketクライアントJS」のフォローアップです。

すべてのピースが1つのDockerイメージにまとめられたため、インストールがはるかに簡単になりました。
作業が楽になります。 ただしもちろん、マイクロサービスの原則はわかりにくくなくなっています。
オールインワンのバンドルパッケージであるため、 コンパクトになっています。

動作には変更がないため、 下位互換性のあるマイナーリリースと解釈されてしまう可能性があります。

これには、intersystems/iris-community:2020.2.0.204.0が含まれています。

実行するのは、以下の通りです。

• docker pull rcemper/rcc:iris-nodejs-compact（1回）
• docker run --rm --init -d \ --name=iris1 -p 52773:52773 -p 51773:51773 \ rcemper/rcc:iris-nodejs-compact （コンテナーを起動）
• docker exec -it iris1 bash wsgo.sh （マイクロサービスを起動）
• docker exec -it iris1 bash wsdemo.sh （テストデータを作成する制御を開始し、echoServerに送信して受信）
• docker exec -it iris1 bash wsstop.sh （制御から実行されない場合は、最終的にサービスを停止）
• docker stop iris1 （コンテナーを終了）

それだけです。

2021年7月7日:
正規化されたV2がリリースされました。

• git clone https://github.com/rcemper/IRIS-NativeAPI-Nodejs-compact.git
• docker-compose up -d
• docker-compose exec iris iris session iris %ZSocket
• docker-compose exec iris node WsockIris.js