RockyLinux9.３で自宅サーバーを再構築V07・WordPress のバックアップとリストア

引越しするには、旧環境のデータをバックアップし、新環境へリストアします。 WordPress のバックアップとリストアの方法を説明し、自動バックアップするスクリプトを作成します。 バックアップ・リストアができると、引越しだけでなく、トラブル時にも以前の状態まで戻せます。

www.kazuban.com

2024.01.08

新しいBASH

前回のスクリプトは、2020年に紹介したコマンド操作をネット情報を参考にスクリプト化しましたが、今回はこのスクリプトをAIに投げて、最新のBASH構文への変換を教えてもらいながら作成しました。
投稿のスクリプト類はちょっと長くなりましたが、全てコピペできるようにしました。
また、開発途中ではBASHで一行づつのデバッグもやってみました。

デバッグ

編集はVSCodeを利用したので、デバッグプラグインもインストールしてみましたが、あまり思ったように動いてくれませんでした。
AIに聞いてみると、BASH自体にも、構文チェックやステップデバッグができる機能があるようです

shellcheck

shellcheck [スクリプト名.sh]のようにコマンド実行するだけで、スクリプトのバグや構文エラーを簡単にチェックできます。
パッケージ名は、キャメルケース的書き方「ShellCheck」になるので注意が必要です

sudo dnf install ShellCheck

もしパッケージが見つからない場合には、EPELリポジトリが有効になっていない可能性があるのでEPELを有効化した上で再度インストール

sudo dnf install epel-release
sudo dnf install ShellCheck

shellcheck は、スクリプトのバグや構文エラーを検出してエラーコードと共に表示してくれます。
標準では致命的でない場合でも警告を出してくるのでちょっとうるさく感じる事もありますが、
エラーコードをAIに聞くことでより安全なコードの書き方の学習にもなります

set コマンド

Bashの set コマンドは、シェルの動作やオプションを設定・変更するためのコマンドです。
主にスクリプトの安全運転モードやデバッグのために、シェルの冒頭でオプションと組み合わせて使用されます
・set -euo pipefail
実務でよく使われる定番のオプション
これにより、スクリプト実行時のバグや予期せぬトラブルを大幅に減らせます

・set -x: デバッグ開始
実行されるコマンドや変数の展開結果をすべて画面（標準エラー出力）に表示

・set +x: デバッグ開始
実行トレース出力を停止

・trap ‘read -p “STEP> ” < /dev/tty’ DEBUG
実行中、すべてのコマンドを実行する直前で指定文字（STEP>）プロンプトで一時停止

・export PS4=’+ ${LINENO}: ‘
デバッグモード（set -x）で実行されるコマンドを表示する際、そのコマンドのスクリプトでの行番号を出力に含める設定

これらコードをスクリプト上部で実行しておくことで、シェルスクリプトのバグの原因特定が早くなります。
サンプルコードを書いてみました。

#!/bin/bash

set -euo pipefail
# --- debug mode: DEBUGGING=1 で有効 ---
DEBUGGING=1

if [[ $DEBUGGING == "1" ]]; then
  echo "Debug mode is 'true' !! "
  export PS4='+ ${LINENO}: '
  set -x
  trap 'read -p "STEP> " < /dev/tty' DEBUG
else
  echo "Debug mode is 'false' !! "
fi

# テスト用コード
echo "最初の処理"
x=10
y=20
result=$((x + y))
echo "結果は $result"

このコードを実行すると、デバッグの状況が体験できます

次に今回作成したWordPressのバックアップ＆リストアのスクリプトを紹介します
デバッグコードは、Header.sh に別スクリプトにして、呼び出す形式にしました。

スクリプト構成

WordPressのバックアップは、大きく分けて「ファイル（サーバー内のデータ）」と「データベース（MySQL/MariaDB）」の2つが必要になります。
前回スクリプトは、昔の経験とネット検索を参考に、自分で作成しましたが
今回は、BASHもかなり進化しているみたいなので、AIのサポートで最新の構文で書き直しました。
バックアップファイルやスクリプトの構成は
・「ユーザーホーム」内に、「Backup」ディレクトリを作成
・「Backup」内に、「WordPress」と「bin」ディレクトリを作成
・「WordPress」内にWordPress パッケージをインストールしたディレクトリ名（筆者環境では「blog」）を作成します
・「blog」内に、データベースとサーバー内データのバックアップを保存します
・「bin」内に実行スクリプトを保存します

.[ユーザーホームディレクトリ]
├── Backup #「バックアップデータを保存する」
│   ├── WordPress #「WordPerss関連データ」
│   │   └── blog #「blog内のバックアップデータ」
│   │       ├── 20260530-MariaDB.bak       # データベースバックアップ
│   │       ├── 20260530-Wp-content.tar.gz # WordPressコンテンツ
│   │       ├── mariadb_backup.log
│   │       └── wp_backup.log
│   ├── bin #「スクリプト」
│   │   ├── Header.sh                #「デバッグ用のスクリプト」
│   │   ├── MariaDB_Backup.sh        #「データベースのバックアップ」
│   │   ├── MariaDB_Restore.sh       #「データベースのリストア」
│   │   ├── Tidyup_backfile.sh       #「バックアップデータの整理」
│   │   ├── WordPress_Config_Data.sh #「バックアップ環境の設定」
│   │   ├── Wp-Backup.sh             #「バックアップ用メインスクリプト」
│   │   ├── Wp-Content_Backup.sh     #「WordPressデータのバックアップ」
│   │   ├── Wp-Content_Restore.sh    #「WordPressデータのリストア」
│   │   └── Wp-Restore.sh            #「リストア用メインスクリプト」

WordPress_Config_Data.sh : 変数設定

#!/bin/bash
#  WoredPressバックアップ設定ファイル
#    WordPress_Config_Data.sh    2026/05 by Kazuban
#------------------------------------
export USER="kazuban"
export USER_DIR="/home/${USER}"
export SUB_DIR="blog"
export DOCUMEN_ROOT="/home/www/html"
#----- MariaDB ----------------------
export MYSQL_ROOT_PASSWD="hogehoge_passwd"
export DATABASE="WpDb"
export MYSQL_USER="WpAdmin"
export MYSQL_USER_PASSWD="WpPasswd"
#----- WordPress --------------------
export WP_CONTENT_DIR="wp-content"
export WP_CONTENT_FILENAME="Wp-content"
export WP_CONTENT_PATH="/home/www/html/${SUB_DIR}/${WP_CONTENT_DIR}"
export WP_CONTENT_OWNER="apache:apache"

Wp-Backup.sh : データベース＆WordPressコンテンツのバックアップ

#!/bin/bash
#  WoredPress のバックアップ
#    データベース(Mysql)とサーバーデータ(wp-content)
#  Wp-Backup.sh    2026/05 by Kazuban
#------------------------------------
#--- debug mode, set "DEBUG=1". -----
export DEBUG=
#------------------------------------
export CALLER_SCRIPT="$0"
#export SCRIPT_DIR=$(dirname "$(realpath "$0")")
#shellscriptで警告でたので、AIに聞くとこの書き方が安全らしい
SCRIPT_DIR=$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")
export SCRIPT_DIR
#------------------------------------
source "${SCRIPT_DIR}/Header.sh"
source "${SCRIPT_DIR}/WordPress_Config_Data.sh"
export BACKUP_DIR="${USER_DIR}/Backup/WordPress/${SUB_DIR}"
#---- MariaDB -----------------------
export MYSQL_BACKUP_SCRIPT="${SCRIPT_DIR}/MariaDB_Backup.sh"
export MYSQL_LOG="${BACKUP_DIR}/mariadb_backup.log"
#---- WordPress ---------------------
#export BACKUP_SOURCE_DIR="${DOCUMEN_ROOT}/${SUB_DIR}/wp-content"
export WP_BACKUP_SCRIPT="${SCRIPT_DIR}/Wp-Content_Backup.sh"
export BACKUP_SOURCE_DIR="${DOCUMEN_ROOT}/${SUB_DIR}/${WP_CONTENT_DIR}"
export WP_LOG="${BACKUP_DIR}/wp_backup.log"
#------------------------------------
export TIDY_UP_SCRIPT="${SCRIPT_DIR}/Tidyup_backfile.sh"
export DAYS_AGO="5"
#-----　関数定義 -----------------------
user_dir=$(pwd)
echo $user_dir
# スクリプト終了時に実行させたい場合はここで再定義
cleanup() {
#  echo "Wp-Backup 終了処理"
  :
}
check_backup_dir(){
  #$BACKUP_DIRが存在しない場合には作成
  mkdir -p $BACKUP_DIR 
}
cmd_mariadb()   { check_backup_dir; $MYSQL_BACKUP_SCRIPT; }
cmd_wordpress() { check_backup_dir; $WP_BACKUP_SCRIPT; }
cmd_all()       { cmd_mariadb; cmd_wordpress; }
cmd_help() {
  echo "--- WordPress Backup Script ---"
  echo "Directory: ${SCRIPT_DIR}"
  echo "Usage: $0 {db|wp|all|help}"
  echo "  db   = データベース(MariaDB)"
  echo "  wp   = Word Press (Wp-Content)"
  echo "  all  = db + wp"
  echo "  help = オプション"
}

#-----　メインプログラム　-------------
#------------------------------------
case "${1:-}" in
  db)        cmd_mariadb   ;;
  wp)        cmd_wordpress ;;
  all)       cmd_all       ;;
  help|"")   cmd_help      ;;
  *)
    echo "Unknown command: $1"
    cmd_help
    exit 1
    ;;
esac

MariaDB_Backup.sh : データベースバックアップ（Wp-Backup.shから呼ばれる）

#!/bin/bash
#  WoredPress のデータベースバックアップ
#    MariaDB_Backup.sh    2026/05 by Kazuban
#------------------------------------
# 直接実行ガード（呼び出し元スクリプトからのみ実行可）
if [[ -z "${CALLER_SCRIPT:-}" ]]; then
  echo "直接実行はできません。"
  echo "[WP-Backup.sh db] から呼び出してください。"
  exit 1
fi
#------------------------------------
source "${SCRIPT_DIR}/Header.sh"
#------------------------------------
# --- 関数定義 ---
usage() {
  echo "使用方法: ${SCRIPT_NAME:-$(basename "$0")}"
  echo "  データベース(MariaDB)をバックアップし、古いファイルを整理します。"
  exit 0
}

log() {
  local message="$1"
  echo "$(date '+%Y-%m-%d %H:%M:%S') ${message}" | tee -a "${MYSQL_LOG}"
}

failed() {
  echo "エラー: $1" >&2
  log "ERROR: $1"
  exit 1
}

# バックアップファイル名を生成する（同名ファイルがあれば連番を付加）
make_filename() {
  local date_str
  date_str=$(date '+%Y%m%d')
  local basename="-MariaDB.bak"
  local filename="${date_str}${basename}"
  local i=1
  while [[ -e "${BACKUP_DIR}/${filename}" ]]; do
    filename="${date_str}-${i}${basename}"
    (( i++ )) || true
  done
  echo "${filename}"
}

# --- ヘルプ ---
if [[ "${1:-}" == "-?" || "${1:-}" == "-h" || "${1:-}" == "--help" ]]; then
  usage
fi

# --- 事前チェック ---
[[ -d "${BACKUP_DIR}" ]]      || failed "バックアップ先が見つかりません: ${BACKUP_DIR}"
[[ -x "${TIDY_UP_SCRIPT}" ]]  || failed "整理スクリプトが見つかりません: ${TIDY_UP_SCRIPT}"

# --- ファイル名決定 ---
FILENAME=$(make_filename)
BACKUP_PATH="${BACKUP_DIR}/${FILENAME}"

# --- バックアップ実行 ---
log "MariaDB バックアップ開始: ${FILENAME}"
echo "MariaDB を ${FILENAME} にバックアップします。"

if mariadb-dump \
    --user="${MYSQL_USER}" \
    --password="${MYSQL_USER_PASSWD}" \
    --host=localhost \
    --all-databases \
    --single-transaction \
    --quick \
    > "${BACKUP_PATH}" \
    2>> "${MYSQL_LOG}"; then
  log "バックアップ成功: ${FILENAME} ($(du -sh "${BACKUP_PATH}" | cut -f1))"
else
  failed "mariadb-dump コマンドが失敗しました"
fi

# --- 古いファイルの整理 ---
log "古いバックアップを整理します（${DAYS_AGO} 日以前）"
"${TIDY_UP_SCRIPT}" "${BACKUP_DIR}" "${DAYS_AGO}"

log "MariaDB バックアップ完了"
echo "MariaDB Backup Complete."

Wp-Content_Backup.sh : WordPressコンテンツバックアップ（Wp-Backup.shから呼ばれる）

#!/bin/bash
#  wp-content ディレクトリのバックアップスクリプト
#    WP-content_Backup.sh    2026/05 by Kazuban
#------------------------------------
# 直接実行ガード（呼び出し元スクリプトからのみ実行可）
if [[ -z "${CALLER_SCRIPT:-}" ]]; then
  echo "直接実行はできません。"
  echo "[WP-Backup.sh wp] から呼び出してください。"
  exit 1
fi
#------------------------------------
readonly SCRIPT_NAME="$(basename "$0")"
#------------------------------------
source "${SCRIPT_DIR}/Header.sh"
#------------------------------------
# スクリプト終了時に実行させたい場合はここで再定義
cleanup() {
#  echo "Wp-Backup 終了処理"
  :
}
#------------------------------------
# --- 関数定義 ---
usage() {
  echo "使用方法: ${SCRIPT_NAME}"
  echo "  wp-content ディレクトリをバックアップし、古いファイルを整理します。"
  exit 0
}

log() {
  local message="$1"
  echo "$(date '+%Y-%m-%d %H:%M:%S') ${message}" | tee -a "${WP_LOG}"
}

failed() {
  echo "エラー: $1" >&2
  log "ERROR: $1"
  exit 1
}

# バックアップファイル名を生成する（同名ファイルがあれば連番を付加）
make_filename() {
  local date_str
  date_str=$(date '+%Y%m%d')
  local basename="-Wp-content.tar.gz"
  local filename="${date_str}${basename}"
  local i=1
  while [[ -e "${BACKUP_DIR}/${filename}" ]]; do
    filename="${date_str}-${i}${basename}"
    (( i++ )) || true
  done
  echo "${filename}"
}

# --- ヘルプ ---
if [[ "${1:-}" == "-?" || "${1:-}" == "-h" || "${1:-}" == "--help" ]]; then
  usage
fi

# --- 事前チェック ---
[[ -d "${BACKUP_DIR}" ]]   || failed "バックアップ先が見つかりません: ${BACKUP_DIR}"
[[ -d "${BACKUP_SOURCE_DIR}" ]]  || failed "バックアップ元が見つかりません: ${BACKUP_SOURCE_DIR}"
[[ -x "${TIDY_UP_SCRIPT}" ]]  || failed "整理スクリプトが見つかりません: ${TIDY_UP_SCRIPT}"

# --- ファイル名決定 ---
FILENAME=$(make_filename)
DEST="${BACKUP_DIR}/${FILENAME}"

# --- バックアップ実行 ---
log "WordPress バックアップ開始:"
log "${BACKUP_SOURCE_DIR} → ${DEST}"
echo "WordPress Backup Starting..."

#echo "バックアップファイル：${DEST}"
#echo "sudo chown ${USER}: ${DEST}"
#exit 1
if sudo tar \
    --create \
    --gzip \
    --file="${DEST}" \
    "${BACKUP_SOURCE_DIR}"; then # \
    #2>> "${WP_LOG}"; then
  echo "バックアップファイル：${DEST}"
  echo "sudo chown ${USER}: ${DEST}"
  sudo chown ${USER}: ${DEST}
  log "バックアップ成功: ${FILENAME} ($(du -sh "${DEST}" | cut -f1))"
else
  failed "tar コマンドが失敗しました"
fi

# --- 古いファイルの整理 ---
log "古いバックアップを整理します（${DAYS_AGO} 日以前）"
"${TIDY_UP_SCRIPT}" "${BACKUP_DIR}" "${DAYS_AGO}"

log "WordPress バックアップ完了"
echo "WordPress Backup Complete."

Wp-Restore.sh : データベース＆WordPressコンテンツの復元

#!/bin/bash
#  WoredPress の復元
#    データベース(Mysql)とサーバーデータ(wp-content)
#  Wp-Restore.sh    2026/05 by Kazuban
#------------------------------------
#--- debug mode, set "DEBUG=1". -----
export DEBUG=
#------------------------------------
export CALLER_SCRIPT="$0"
#export SCRIPT_DIR=$(dirname "$(realpath "$0")")
SCRIPT_DIR=$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")
export SCRIPT_DIR
#------------------------------------
source "${SCRIPT_DIR}/Header.sh"
source "${SCRIPT_DIR}/WordPress_Config_Data.sh"
export BACKUP_DIR="${USER_DIR}/Backup/WordPress/${SUB_DIR}"
#---- MariaDB -----------------------
export MYSQL_RESTORE_SCRIPT="${SCRIPT_DIR}/MariaDB_Restore.sh"
export PRE_BACKUP_FILE="Pre-Backup.bak"
#---- WordPress ---------------------
export WP_RESTORE_SCRIPT="${SCRIPT_DIR}/Wp-Content_Restore.sh"
#------------------------------------
export PRE_BACKUP="Y"    # リストア前に現行 wp-content を退避するか Y/N
#-----　関数定義 -----------------------
#user_dir=$(pwd)
#echo $user_dir
# スクリプト終了時に実行させたい場合はここで再定義
cleanup() {
#  echo "Wp-Backup 終了処理"
  :
}
check_backup_dir(){
  if [ ! -d $BACKUP_DIR ]; then
    echo "バックアップディレクトリがありません！"
    exit 0 
  fi
}
cmd_mariadb()   { check_backup_dir; $MYSQL_RESTORE_SCRIPT; }
cmd_wordpress() { check_backup_dir; $WP_RESTORE_SCRIPT; }
cmd_all()       { cmd_mariadb; cmd_wordpress; }
cmd_help() {
  echo "--- WordPress Restor Script ---"
  echo "Directory: ${SCRIPT_DIR}"
  echo "Usage: $0 {db|wp|all|help}"
  echo "  db   = データベース(MariaDB)"
  echo "  wp   = Word Press (Wp-Content)"
  echo "  all  = db + wp"
  echo "  help = オプション"
}

#-----　メインプログラム　-------------
#------------------------------------
case "${1:-}" in
  db)        cmd_mariadb   ;;
  wp)        cmd_wordpress ;;
  all)       cmd_all       ;;
  help|"")   cmd_help      ;;
  *)
    echo "Unknown command: $1"
    cmd_help
    exit 1
    ;;
esac

MariaDB_Restore.sh データベース復元（Wp-Restore.shから呼ばれる）

#!/bin/bash
#  WoredPress のデータベース復元スクリプト
#    MariaDB_Restore.sh    2026/05 by Kazuban
#------------------------------------
# 直接実行ガード（呼び出し元スクリプトからのみ実行可）
if [[ -z "${CALLER_SCRIPT:-}" ]]; then
  echo "直接実行はできません。"
  echo "[WP-Backup.sh db] から呼び出してください。"
  exit 1
fi
# --- debug mode: DEBUG=1 で有効 ---
#DEBUG=
PRE_BACKUP="Y"   # リストア前にバックアップを取るか Y/N
PRE_BACKUP_FILE="Pre-Backup.bak"
#------------------------------------
export SCRIPT_DIR=$(dirname "$(realpath "$0")")
#------------------------------------
source "${SCRIPT_DIR}/Header.sh"
source "${SCRIPT_DIR}/WordPress_Config_Data.sh"
#export BACKUP_DIR="${USER_DIR}/Backup/WordPress/${SUB_DIR}"
#------------------------------------

# ---- 関数定義 ---------------------------------------
# バックアップファイルの一覧を配列に格納する
load_backup_files() {
  BACKUP_FILES=()
  while IFS= read -r f; do
    BACKUP_FILES+=("$(basename "$f")")
  #done < <(find "${BACKUP_DIR}" -maxdepth 1 -name "*.bak" | sort)
  done < <(find "${BACKUP_DIR}" -maxdepth 1 -name "*-MariaDB.bak" | sort)
}

# 番号付きリストを表示する
list_backups() {
  echo "--------------------"
  echo "バックアップディレクトリ: ${BACKUP_DIR}"
  echo "--------------------"

  # --- # は個数を表し、[@] は配列のすべての要素
  if [[ ${#BACKUP_FILES[@]} -eq 0 ]]; then
    echo "（バックアップファイルが見つかりません）"
  else
    local i=1
    for f in "${BACKUP_FILES[@]}"; do
      printf "  [%d] %s\n" "$i" "$f"
      (( i++ )) || true   # set -e 対策: (( )) は 0 になると終了コード 1 を返すため
    done
  fi
  echo "--------------------"
}

# 入力値（番号 or ファイル名）からファイル名を解決して返す
resolve_input() {
  local input="$1"

  # 数字のみ → 番号として解釈
  if [[ "$input" =~ ^[0-9]+$ ]]; then
    local idx=$(( input - 1 ))
    if (( idx < 0 || idx >= ${#BACKUP_FILES[@]} )); then
      echo "エラー: 番号 ${input} は範囲外です（1〜${#BACKUP_FILES[@]}）" >&2
      exit 1
    fi
    echo "${BACKUP_FILES[$idx]}"
  else
    # 文字列 → ファイル名として解釈（リスト内に存在するか確認）
    local f
    for f in "${BACKUP_FILES[@]}"; do
      if [[ "$f" == "$input" ]]; then
        echo "$f"
        return
      fi
    done
    echo "エラー: ファイルが見つかりません: ${input}" >&2
    exit 1
  fi
}

# 対話形式でファイルを選択させる
select_backup_file() {
  local selected=""
  while [[ -z "$selected" ]]; do
    read -r -p "番号またはファイル名を入力してください (q で終了): " INPUT
    case "$INPUT" in
      [qQ])
        kill -USR1 $$    # 親プロセス（スクリプト自身）にシグナルを送る
        exit 1;;
      "")   echo "入力してください" ;;
      *)    selected=$(resolve_input "$INPUT") ;;
    esac
  done
  echo "$selected"
}

usage() {
  echo "使い方: $(basename "$0") [バックアップファイル名 or 番号]"
  echo "  引数なしで起動すると対話形式で選択できます。"
  echo "--------------------"
  list_backups
  exit 1
}

run_pre_backup() {
  local date_str
  date_str=$(date '+%Y%m%d-%H%M')
  local pre_backup_path="${BACKUP_DIR}/${date_str}-${PRE_BACKUP_FILE}"

  echo "--------------------"
  echo "-- 事前バックアップを開始します... --"

  #mysqldump \
  mariadb-dump \
    --user="${MYSQL_USER}" \
    --password="${MYSQL_USER_PASSWD}" \
    --host=localhost \
    --all-databases \
    --single-transaction \
    --quick \
    > "${pre_backup_path}"

  echo "-- 事前バックアップ完了: ${pre_backup_path} --"
  echo "--------------------"
}

run_restore() {
  local backup_file="${BACKUP_DIR}/${1}"

  echo "--------------------"
  echo "-- リストア対象: ${1} --"
  echo "-- データベース: ${DATABASE} --"
  echo "--------------------"

  read -r -p "リストアを実行しますか？ (y/n): " YN
  case "${YN}" in
    [yY])
      echo "-- リストアを開始します... --"
      #mysql \
      mariadb \
        --user=root \
        --password="${MYSQL_ROOT_PASSWD}" \
        "${DATABASE}" \
        < "${backup_file}"
      echo "-- リストア完了 --"
      ;;
    [nN])
      kill -USR1 $$    # 親プロセス（スクリプト自身）にシグナルを送る
      exit 0
      echo "-- 中止しました --"
      exit 0
      ;;
    *)
      echo "エラー: y または n を入力してください" >&2
      exit 1
      ;;
  esac
}

# ----- メイン処理 --------------------------------------------

# バックアップディレクトリの存在確認
if [[ ! -d "${BACKUP_DIR}" ]]; then
  echo "エラー: バックアップディレクトリが存在しません: ${BACKUP_DIR}" >&2
  exit 1
fi

# ファイル一覧をグローバル配列に読み込む
# declare 変数の属性やタイプ -a 「配列(Array)」
declare -a BACKUP_FILES
load_backup_files

# ヘルプ
if [[ "${1:-}" == "-h" || "${1:-}" == "--help" ]]; then
  usage
fi

# ファイル選択：引数あり → 解決、なし → 対話形式
if [[ $# -gt 0 ]]; then
  list_backups
  SELECTED_FILE=$(resolve_input "$1")
else
  list_backups
  SELECTED_FILE=$(select_backup_file)
fi

echo "-- 選択されたファイル: ${SELECTED_FILE} --"

# 事前バックアップ
if [[ "${PRE_BACKUP}" =~ ^[Yy]$ ]]; then
  run_pre_backup
fi

# リストア実行
run_restore "${SELECTED_FILE}"

Wp-Content_Restore.sh: WordPressコンテンツ復元（Wp-Restore.shから呼ばれる）

#!/bin/bash
#  wp-content ディレクトリの復元スクリプト
#    WP-Content_Restore.sh    2026/05 by Kazuban
#------------------------------------
# 直接実行ガード（呼び出し元スクリプトからのみ実行可）
if [[ -z "${CALLER_SCRIPT:-}" ]]; then
  echo "直接実行はできません。"
  echo "[WP-Backup.sh db] から呼び出してください。"
  exit 1
fi
# --- debug mode: DEBUG=1 で有効 ---
#export DEBUG=
PRE_BACKUP="Y"    # リストア前に現行 wp-content を退避するか Y/N
#------------------------------------
export SCRIPT_DIR=$(dirname "$(realpath "$0")")
#------------------------------------
source "${SCRIPT_DIR}/Header.sh"
source "${SCRIPT_DIR}/WordPress_Config_Data.sh"
#------------------------------------

# --- 関数定義 ---
# バックアップファイルの一覧を配列に格納する
load_backup_files() {
  BACKUP_FILES=()
  cmd="find ${BACKUP_DIR} -maxdepth 1 -name *-${WP_CONTENT_DIR}.tar.gz"  #${WP_CONTENT_DIR}
  while IFS= read -r f; do
    BACKUP_FILES+=("$(basename "$f")")
  done < <(find "${BACKUP_DIR}" -maxdepth 1 -name "*-${WP_CONTENT_FILENAME}.tar.gz" | sort)
}

# 番号付きリストを表示する
list_backups() {
  echo "--------------------"
  echo "バックアップディレクトリ: ${BACKUP_DIR}"
  echo "--------------------"

  if [[ ${#BACKUP_FILES[@]} -eq 0 ]]; then
    echo "（バックアップファイルが見つかりません）" >&2
  else
    local i=1
    for f in "${BACKUP_FILES[@]}"; do
      printf "  [%d] %s\n" "$i" "$f"
      (( i++ )) || true   # set -e 対策: (( )) は 0 になると終了コード 1 を返すため
    done
  fi
  echo "--------------------"
}

# 入力値（番号 or ファイル名）からファイル名を解決して返す
resolve_input() {
  local input="$1"

  # 数字のみ → 番号として解釈
  if [[ "$input" =~ ^[0-9]+$ ]]; then
    local idx=$(( input - 1 ))
    if (( idx < 0 || idx >= ${#BACKUP_FILES[@]} )); then
      echo "エラー: 番号 ${input} は範囲外です（1〜${#BACKUP_FILES[@]}）" >&2
      exit 1
    fi
    echo "${BACKUP_FILES[$idx]}"
  else
    # 文字列 → ファイル名として解釈（リスト内に存在するか確認）
    local f
    for f in "${BACKUP_FILES[@]}"; do
      if [[ "$f" == "$input" ]]; then
        echo "$f"
        return
      fi
    done
    echo "エラー: ファイルが見つかりません: ${input}" >&2
    exit 1
  fi
}

# 対話形式でファイルを選択させる
select_backup_file() {
  local selected=""
  while [[ -z "$selected" ]]; do
    read -r -p "番号またはファイル名を入力してください (q で終了): " INPUT
    case "$INPUT" in
      [qQ])
        kill -USR1 $$
        exit 1 ;;
      "")   echo "入力してください" ;;
      *)    selected=$(resolve_input "$INPUT") ;;
    esac
  done
  echo "$selected"
}

# 使い方表示
usage() {
  echo "使い方: $(basename "$0") [バックアップファイル名 or 番号]"
  echo "  引数なしで起動すると対話形式で選択できます。"
  echo "--------------------"
  list_backups
  exit 1
}

# 既存 wp-content を日付付きディレクトリ名にリネームして退避する
run_pre_backup() {
  local date_str
  date_str=$(date '+%Y%m%d-%H%M')
  local backup_path="${WP_CONTENT_PATH}-${date_str}.bak"

  echo "--------------------"
  echo "-- 事前バックアップ（退避）を開始します... --"
  echo "-- ${WP_CONTENT_PATH} → ${backup_path} --"
  sudo mv "${WP_CONTENT_PATH}" "${backup_path}"
  echo "-- 事前バックアップ完了 --"
  echo "--------------------"
}

# リストア実行
run_restore() {
  local backup_file="${BACKUP_DIR}/$1"
  local work_dir
  #work_dir=$(mktemp -d) #添付ディレクトリの利用
  work_dir=$BACKUP_DIR

  echo "--------------------"
  echo "-- リストア対象: $1 --"
  echo "-- 展開先 (${WP_CONTENT_DIR}): ${WP_CONTENT_PATH} --"
  echo "--------------------"

  read -r -p "リストアを実行しますか？ (y/n): " YN
  case "${YN}" in
    [yY])
      echo "-- リストアを開始します... --"

      # 1. アーカイブ内の wp-content の階層数を確認
      echo "-- 展開中: ${backup_file} --"
      local wp_path strip_count

      list=$(tar tzf "${backup_file}")
      wp_path=$(echo "$list" | grep -m1 "${WP_CONTENT_DIR}/$" || true)
      echo "------ $wp_path --------"
      if [[ -z "${wp_path}" ]]; then
        echo "エラー: アーカイブ内に ${WP_CONTENT_DIR} ディレクトリが見つかりません" >&2
        exit 1
      fi
      # パスの / の数から除去する階層数を算出
      # 例: home/www/html/sweb01/wp-content/ → スラッシュ5個 → strip=4
      strip_count=$(echo "${wp_path}" | tr -cd '/' | wc -c)
      strip_count=$(( strip_count - 1 ))
      echo $strip_count
      #exit 1
      if [[ $strip_count < 0 ]]; then
        echo "エラー: 階層がありません" >&2
        #echo "エラー: アーカイブ内に wp-content ディレクトリが見つかりません"
        exit 1
      fi
      #DIR="${work_dir}/wp-content"
      DIR=${work_dir}
      echo "${DIR}がない場合には作成します"
      mkdir -p "$DIR"
      # --strip-components で wp-content/ を作業ディレクトリ直下に展開
      tar xvzf "${backup_file}" -C "${DIR}" \
        --strip-components="${strip_count}"
      ls -la $DIR

      # 所定の場所に配置してオーナーを設定
      echo sudo mv "${work_dir}/${WP_CONTENT_DIR}" "${WP_CONTENT_PATH}"
      echo sudo chown -R "${WP_CONTENT_OWNER}" "${WP_CONTENT_PATH}/"
      sudo mv "${work_dir}/${WP_CONTENT_DIR}" "${WP_CONTENT_PATH}"
      sudo chown -R "${WP_CONTENT_OWNER}" "${WP_CONTENT_PATH}/"

      echo "-- リストア完了 --"
      # スクリプト終了時に作業ディレクトリを削除
      #trap 'rm -rf "${work_dir}"' EXIT

      ;;
    [nN])
      kill -USR1 $$
      exit 0
      ;;
    *)
      echo "エラー: y または n を入力してください" >&2
      exit 1
      ;;
  esac
}
cleanup() {
  echo Clean up!!
  echo ${BACKUP_DIR}
  #read -r -p "${BACKUP_DIR}/${WP_CONTENT_DIR} 削除しますか？ (Y/N): " INPUT
  #  case "$INPUT" in
  #    [Yy])
  #      rm -rf "${BACKUP_DIR}/${WP_CONTENT_DIR}"  
  #  esac
}

# --- メイン処理 ---

# バックアップディレクトリの存在確認
if [[ ! -d "${BACKUP_DIR}" ]]; then
  echo "エラー: バックアップディレクトリが存在しません: ${BACKUP_DIR}" >&2
  exit 1
fi

# ファイル一覧をグローバル配列に読み込む
declare -a BACKUP_FILES
load_backup_files

# ヘルプ
if [[ "${1:-}" == "-h" || "${1:-}" == "--help" ]]; then
  usage
fi

# ファイル選択：引数あり → 解決、なし → 対話形式
if [[ $# -gt 0 ]]; then
  list_backups
  SELECTED_FILE=$(resolve_input "$1")
else
  list_backups
  SELECTED_FILE=$(select_backup_file)
fi

echo "-- 選択されたファイル: ${SELECTED_FILE} --"

# 事前バックアップ（現行 wp-content の退避）
if [[ "${PRE_BACKUP}" =~ ^[Yy]$ ]]; then
  run_pre_backup
fi

# リストア実行
run_restore "${SELECTED_FILE}"

Header.sh : デバッグモード仕様（変数 DEBUG=1 で有効）

#!/bin/bash
#
#  Header.sh    2026/05 by AI & Kazuban
#  共通ヘッダー: source で読み込んで使う
#  使い方: source "${SCRIPT_DIR}/Header.sh"
#
#------------------------------------
#-e：失敗で停止：#-u：未定義変数禁止:#pipefail：パイプの途中も検知
set -euo pipefail

# --- traps ---
trap 'echo "-- 中止しました --"; exit 0' USR1
trap 'echo "Error at line $LINENO"; exit 1' ERR
trap cleanup EXIT

# cleanup は呼び出し元スクリプトで上書き可能
cleanup() {
  :
}

# --- debug mode: DEBUG=1 で有効 ---
export DEBUG=${DEBUG:-0}
if [[ "$DEBUG" == "1" ]]; then
  echo "Debug mode is 'true' !! "
  export PS4='+ ${LINENO}: '
  set -x
  trap 'read -p "STEP> " < /dev/tty' DEBUG
else
  echo "Debug mode is 'false' !! "
fi

Tidyup_backfile.sh : バックアップファイルの整理（引数：対象ディレクトリ・保存日数）

#!/bin/bash
# Delete $DAY days ago from backup
#
#  Tidyup_backfile.sh  by AI & Kazuban 2026/05
#                default 10 days ago
#
#------------------------
# delete_backup - バックアップファイルを整理するスクリプト
# 使用方法: delete_backup [削除対象ディレクトリ] [何日前まで残すか]

#set -euo pipefail
#--- for debag ----------------------
#--- デバッグモード（DEBUG=1 で有効）---
#if [[ "${DEBUG:-0}" == "1" ]]; then
#  export PS4='+ ${LINENO}: '
#  set -x
#  trap 'read -p "STEP> " < /dev/tty' DEBUG
#fi

readonly SCRIPT_NAME="$(basename "$0")"

usage() {
    echo "使用方法: ${SCRIPT_NAME} <削除対象ディレクトリ> [保持日数]"
    echo "  削除対象ディレクトリ  : バックアップファイルのあるディレクトリ"
    echo "  保持日数              : 何日前までのファイルを残すか (デフォルト: 10)"
    exit 1
}

# --- 引数チェック ---
if [[ $# -lt 1 || "$1" == "-?" || "$1" == "-h" || "$1" == "--help" ]]; then
    usage
fi

TARGET_DIR="$1"
DAYS="${2:-10}"

# --- 数値チェック ---
if ! [[ "$DAYS" =~ ^[0-9]+$ ]]; then
    echo "エラー: 保持日数には正の整数を指定してください: ${DAYS}" >&2
    exit 1
fi

# --- ディレクトリ存在チェック ---
if [[ ! -d "$TARGET_DIR" ]]; then
    echo "エラー: ディレクトリが見つかりません: ${TARGET_DIR}" >&2
    exit 1
fi

# --- 削除基準日を算出 ---
DEL_DATE="$(date --date="${DAYS} days ago" +%Y%m%d)"
echo "削除基準日: ${DEL_DATE} より前のファイルを削除します (保持日数: ${DAYS}日)"

# --- 対象ファイルの処理 ---
# 数字始まりのファイル名から先頭8桁(YYYYMMDD)を取得して重複排除
while IFS= read -r file_date; do
    if [[ "$file_date" < "$DEL_DATE" ]]; then
        echo "削除: ${TARGET_DIR}/${file_date}*"
        rm -f -- "${TARGET_DIR}/${file_date}"*
    fi
done < <(
    ls -- "$TARGET_DIR" \
        | grep -E '^[0-9]' \
        | awk '{ print substr($0, 1, 8) }' \
        | sort -u
)

echo "完了"

自動バックアップ

こちらでも、紹介していますが、「crontab」に下記のように設定する事で、毎日２時に自動バックアップできるようになります

00 2 * * *        /home/kazuban/Backup/bin/Wp-Backup.sh all

正規表現

正規表現の情報は、ネット上に豊富にあると思うので、詳細は検索してみてください。
下記は「正規表現」の説明をAIに聞いてみた回答です

概要

本チャットログでは、「正規表現（Regular Expression）」の基本要素について、最小限かつ代表的な機能に絞って説明している。主な用途は文字列の検索・置換・抽出であり、「文字列パターンを表現する小さな言語」として位置付けている。

1. 文字列とリテラル

• abc
  • 文字列「abc」にそのままマッチするパターン。

2. メタ文字（特別な意味を持つ記号）

• . : 任意の1文字
• ^ : 行頭
• $ : 行末
• * : 直前要素の0回以上の繰り返し
• + : 直前要素の1回以上の繰り返し
• ? : 直前要素の0回または1回
• | : OR（または）
• () : グループ化・キャプチャ

具体例

• a.*b
  • 「a」で始まり「b」で終わる行全体にマッチ（間の文字列は任意長）
• colou?r
  • color または colour にマッチ（u がある/ない両方に対応）。

3. 繰り返し回数の指定（量指定子）

• {n} : ちょうど n 回
• {n,} : n 回以上
• {n,m} : n〜m 回

具体例

• \d{3}-\d{4}
  • 123-4567 のような「数字3桁-数字4桁」形式にマッチ。

4. 文字クラス

• [abc] : a か b か c のいずれか1文字
• [^abc] : a,b,c 以外の1文字
• [0-9] : 数字
• [A-Za-z] : 英字（大文字・小文字）

5. 代表的なエスケープシーケンス

多くの処理系で共通して使われるもの。

• \d : 数字 [0-9]
• \w : 単語構成文字（英数字 + _）
• \s : 空白文字（スペース・タブ・改行など）
• \D : 非数字（\d 以外）
• \W : 非単語構成文字（\w 以外）
• \S : 非空白文字（\s 以外）

6. エスケープが必要な記号

次の文字はメタ文字として特別な意味を持つため、そのままの記号として扱うにはバックスラッシュでエスケープする必要がある。

• 対象文字
  • . * + ? ^ $ ( ) [ ] { } | \
• 使用例
  • \. : ドットそのものにマッチ
  • \? : 疑問符そのものにマッチ

補足

ここまでが「基本の道具」としての正規表現の要素一式であり、今後はこれらを組み合わせて「メールアドレスの簡易チェック」など、実用的なパターン作成にも応用できると示唆している。

個別でみれば、なんとなくわかる気もしますが、これが組み合わさると、まったく呪文です
ただ、いろんなパターンの質問とAIの回答を照らし合わせると、なんとなく理解できてくるので、正規表現にかぎらず、AIは言語学習資料としても本当に役立ちます。

ファナック系、NCデータ構造

NCデータの分析ソフトを検討する場合、NCデータ構造の知識は必須です
NCデータの知識がないまま、AIの回答だけで進めると、間違いなく後々苦労します
ファナック系のプログラム構造は、下記記事でも紹介しています

NCプログラム／プログラム構造

最近の投稿は、覚書きとしても残しておきたかったので、素人ながらLinux系の投稿が連続していましたが、今回は気分を変えて、今まで携わってきたＮＣ関連の記事を書こうと思います。ＮＣプログラムとは？ＮＣ工作機械のコントローラへの指令の集まりです。プログラムとありますが、ファナック系は基本的には命令コード...

www.kazuban.com

2019.11.30

「ワード」＝「アドレス」+「数字・数値」
「ブロック」＝「ワード」の集まり
「NCデータ」＝「ブロック」の集まり

NCブロックからNCアドレスを抽出する課題なので、NCコードを少し復習しておきます

ブロックの末尾は制御器では「EOB」ですが、PC側では改行コードになります
改行コードはOSにより変わりますが、基本的にアスキー形式での転送で大丈夫だと思います
NCデータの最小単位は、「ワード」と呼ばれていて、
「アルファベット一文字」+「数字、符号、小数点」が一塊になっている要素です
例えば「G02」とか「X-12.345」の構成です。
先頭のアドレス文字で機械への指令の種類を表し、ワードで具体的な指令になります
この「ワード」が集まり、一行の構成になった文字列が「ブロック」と呼ばれます
さらに、「ブロック」が複数行あつまって、NCデータになります
CAM利用の場合、作成したNCデータファイルをNC機械へ転送し加工動作を制御します
分析ソフトを検討する場合、まずはNCデータをブロックに、ブロックをワードに分解したほうが整理しやすいです
今回の課題では、正規表現を利用して「ブロック」を「ワード」に分解するコードを作成します
やりたい事をAIに投げかけると、それなりの回答をもらえます。
ただ、ＮＣコードのように、機種依存や複雑な表現がある場合、AIへすべて完ぺきなコードを期待してもなかなか思うような回答は得られません。
また、最初は良くても開発を進めていくうちに、改造したくなる場合もあります
やはり、ある程度の理解は必要です。

ブロックから正規表現でワードに分解する

具体的に正規表現を書き、「ワード」に分解した結果と照らし合わせながら理解を進めようと思います
「ワード」＝「大文字アルファベット一文字」+「数字」なので、一番単純な正規表現のパターンは、”[A-Z]\d”になります
また、正規表現パターンで、文字列から部分文字列を抽出するのに、AIは「re.findall関数」を教えてくれました
（findall関数についての詳細は、ネット検索やAIに聞いてみてください）
サンプル文字列は複数のパターンを織り交ぜた、”G0G1G00 G03M3 T102M30″　でやってみます
（文字列並びのみのサンプルで、NCデータとしては意味ありません）

アドレスと数字抽出

import re

block = "G0G1G00 G03M3 T102M30" # サンプルNCブロック文字列
words = re.findall(r"[A-Z]\d", block)
print(f"{words}")

#---------- 結果 --------------
#['G0', 'G1', 'G0', 'G0', 'M3', 'T1', 'M3']

ちょっと期待とは違いますが、とりあえずは、アドレスと数字がリストで取り出せました
たった一行で分解された文字列リストが作成されました、すごいですね～
一文字づつ文字列操作で処理させたら、結構なコード量になっていると思います
ただ、「\d」としたため、「数字は一文字」しか抽出してくれませんでした
ここで「\d{2}」としてみると、「数字二文字」のみ取り出してくれます
今回の例ですべて取り出すには「\d{1,3}」とすればすべてヒットします
「\d+」でも同様の結果になりますが、こちらの方は文字数制限はなくなります
今回のサンプルでは、”[A-Z]\d+”で行こうと思います
ちなみに、「\d{0}」とすると、アドレスのみ取り出せます。

import re

block = "G0G1G00 G03M3 T102M30" # サンプルNCブロック文字列
words = re.findall(r"[A-Z]\d+", block)
print(f"{words}")

#---------- 結果 --------------
#['G0', 'G1', 'G00', 'G03', 'M3', 'T102', 'M30']

さらに、アドレスと数字を分けて抽出したい場合

グループ化と呼ばれる（丸括弧）でパターンを囲むと「tuple」として分離してくれます
抽出した後の処理内容によっては、こちらが便利かもしれません

import re

block = "G0G1G00 G03M3 T102M30" # サンプルNCブロック文字列
words = re.findall(r"([A-Z])(\d+)", block)
print(f"{words}")
for addr, val in words:
    print(f"addr={addr}:val={val}")

#---------- 結果 --------------
#[('G', '0'), ('G', '1'), ('G', '00'), ('G', '03'), ('M', '3'), ('T', '102'), ('M', '30')]
#addr=G:val=0
#addr=G:val=1
#addr=G:val=00
#addr=G:val=03
#addr=M:val=3
#addr=T:val=102
#addr=M:val=30

軸（X,Y,Z・・）の小数点にも対応させる

ここまでは、GやMコードでしたが、軸指令に対応するには、符号や小数点も考慮する必要があります
余談ですがプログラミング初心者の場合勘違いしやすいのが、数字と数値の違いです。
「12.23」の場合、数値としては「12 + 0.23」のように演算ができますが、
数字の場合は、「1」「2」「.」「2」「3」と途中に「.」があるだけのただの数字文字の連続です
正規表現の場合も、数字・符号・小数点の文字の集まりとして処理するので、数値で考えてしまうと期待と違う結果になり、悩む事になります
さて、文字を意識してサンプル文字列データに軸指令を追加して、上記のコードで実行してみます

import re

block = "G90G01 X12.5Y+20.3Z-5.63F1000" # サンプルNCブロック文字列
words = re.findall(r"[A-Z]\d+", block)
print(f"{words}")

#---------- 結果 --------------
#['G90', 'G01', 'X12', 'F1000']

やはりこのコードでは、±符号と小数点が入るとマッチしないので、省かれてしまいますね
まず符号に対応するためにはアドレス「A-Z」の後に[+-]を追加します

import re

block = "G90G01 X12.5Y+20.3Z-5.63F1000" # サンプルNCブロック文字列
words = re.findall(r"[A-Z][+-]\d+", block)
print(f"{words}")

#---------- 結果 --------------
#['Y+20', 'Z-5']

これでは、符号「+-」が必須に判断され符号付の文字列しかヒットしませんでした
符号文字は「無くてもいい」の意味で[+-]?としてみます

import re

block = "G90G01 X12.5Y+20.3Z-5.63F1000" # サンプルNCブロック文字列
words = re.findall(r"[A-Z][+-]?\d+", block)
print(f"{words}")

#---------- 結果 --------------
#['G90', 'G01', 'X12', 'Y+20', 'Z-5', 'F1000']

符号部分を[+-]? とすることで、符号がなくてもマッチするようになりました
次に小数点とそれ以下にも対応させてみましょう
NC制御器は、数値として扱いますが、文字としての小数点の扱いは結構面倒です。
小数点がある場合、ない場合、小数点から始まる場合、小数点で終わる場合・・など
まずは、小数点の有無に対応させるため、「\d+\.\d+」を考えましたが、
この場合、小数点がないとマッチしなくなります
そこで「？を付加」すれば「無くてもいい」にも対応できます

import re

block = "G90G01 X12.5Y+20.3Z-5.63F1000" # サンプルNCブロック文字列
words = re.findall(r"[A-Z][+-]?\d+\.?\d+", block)
print(f"{words}")

#---------- 結果 --------------
['G90', 'G01', 'X12.5', 'Y+20.3', 'Z-5.63', 'F1000']

だいぶ理想に近づいてきましたが、「X.124」や「23.」など、小数点での始まりや終わりには対応できません
サンプル文字列に追加して確かめてみましょう

import re

block = "G90G01 X12.50Y+20.3Z-5.63 I.5 J22.F1000" # サンプルNCブロック文字列
words = re.findall(r"[A-Z][+-]?\d+\.?\d+", block)
print(f"{words}")

#---------- 結果 --------------
#['G90', 'G01', 'X12.50', 'Y+20.3', 'Z-5.63', 'J22', 'F1000

やはり、「I.5」にはマッチせず「J22.」の「.」は省かれていますね
ここも余談ですが、NCで「22.」を「22」に変換してしまった場合、制御器によってはとんでもない事になりかねないので十分意識しておく必要があります。

整理してみると

• [A-Z]：NCコードのアドレス
• [+-]?：必須ではない、符号
• \d+：複数個の数字
  ここまでで、「Gコード」「Mコード」には対応できている
• \.?：小数点は必須でない
• \d+：複数個の数字

やはり、「小数点で終わる」場合「\.?」なので、省略されてしまいますね
ではどうすればいのか？
AIに聞いたところ、グループ化と言う方法があり、”( )”で囲む事で、一塊としてでマッチングのルール設定できるようです
ただし、”( )”では、囲みごとに分割されタプルのリストとして抽出されます
グループごとに分割させたくない場合には“(?: )“で囲む仕様があり非キャプチャグループと呼ばれマッチングのルールには使用するが分割はされないようです。
今回の例では、分割させたくないので、”(?: )“を使ってみます
最後の「\d+：複数個の数字」をグループ化して、必須ではない複数個の数字として設定します

import re

block = "G90G01 X12.50Y+20.3Z-5.63 I.5 J22.F1000" # サンプルNCブロック文字列
words = re.findall(r"[A-Z][+-]?\d+\.?(?:\d+)?", block)
print(f"{words}")

#---------- 結果 --------------
#['G90', 'G01', 'X12.50', 'Y+20.3', 'Z-5.63', 'J22.', 'F1000']

これで、「22.」には対応できました。次は、小数点で始まる「.5」の場合です。
ここまででも、結構な呪文になっているのに、さらに複雑になりそうです。
ここもAIに相談すると、グループの中で（A | B）の書式で「AまたはB」とマッチング範囲の選択ができるようで、この書式での書き方を教えてくました

import re

block = "G90G01 X12.50Y+20.3Z-5.63 I.5 J22.F1000" # サンプルNCブロック文字列
words = re.findall(r"[A-Z][+-]?(?:\d+\.\d+|\d+\.|\.\d+|\d+)", block)
print(f"{words}")

#---------- 結果 --------------
#['G90', 'G01', 'X12.50', 'Y+20.3', 'Z-5.63', 'I.5', 'J22.', 'F1000']

• [A-Z]：NCコードのアドレス
• [+-]?：必須ではない、符号
• — ここからグループ化 —
• \d+\.\d+：数字+小数点+数字
  または
• \d+\.：数字+小数点
  または
• \.\d+:小数点+数字
  または
• \d+：複数個の数字のみ

書き方は他にもあると思いますが、グループ化して、マッチさせたいパターンを一つ一つORで区切るこの方法は私には理解しやすかったです

複雑な正規表現の可読性を高める

いちおう動作はしましたが、ここまでくると、読みにくいですね～
可読性を高める方法として、さらにAIが「re.VERBOSE」を提案してくれました
具体的に、上記のコードを書き替えてみます
パターンを一行づつに分割できて、行ごとにコメントも追記できるので、複雑になってもわかりやすくなります

pattern = re.compile(
    r"""
    [A-Z]        # A-Zアドレス
    [+-]?         # 符号
    (?:           # 小数点処理、非キャプチャグループ
      \d+\.\d+      # 数字、小数点、数字
      |\d+\.        # または、数字、小数点
      |\.\d+        # または、小数点、数字
      |\d+          # または、数字のみ
    )
    """,
    re.VERBOSE,
)
words = pattern.findall(block)
print(f"{words}")

#---------- 結果 --------------
#['G90', 'G01', 'X12.50', 'Y+20.3', 'Z-5.63', 'I.5', 'J22.', 'F1000']

さらにちょっと特殊な、G や M　コードにも対応させてみます

通常、NCワードは「アドレス＋数字」ですが、拡張されたワーク座標系指令やサブプロ呼び出しなどちょっと特殊な構成のコードもあります
全てに対応は難しいと思いますが、「G54.1P1」や「M98P100」などにも対応してみようと思います。
これら対応するためには、上記のパターンでは処理できないのでパターンを追加します
やはり、可読性が上がる、re.VERBOSE を利用します

block = (
    "G05P10000 G90G01 X12.50Y+20.3Z-5.63 I.5 J22.F1000 G54 G54.1P12 M98P1100 M198 P2299"
)
pattern = re.compile(
    r"""
    # --- 特殊構成、G54.1P12 / M98P1234　など---
    [GM]          # G や M アドレス
    \d+(?:\.\d+)? # 54　や　54.1 
    \s*P\d+       # スペースとP文字と数字
    # --- 通常のアドレス+数字 ----
    |[A-Z]        # A-Zアドレス
    [+-]?         # 符号
    # --- 小数点対応 ----
    (?:           # 非キャプチャグループ
      \d+\.\d+      # 数字、小数点、数字
      |\d+\.        # または、数字、小数点
      |\.\d+        # または、小数点、数字
      |\d+          # または、数字のみ
    )
    """,
    re.VERBOSE,
)
words = pattern.findall(block)
print(f"{words}")

#---------- 結果 --------------
#['G05P10000', 'G90', 'G01', 'X12.50', 'Y+20.3', 'Z-5.63', 'I.5', 'J22.', 'F1000', 'G54', 'G54.1P12', 'M98P1100', 'M198 P2299']

どうにかできました。
次の課題は「G04X10.」とかにも対応したいと思っていますが、これ以上条件が増えると大変です
正規表現パターンを変数化できれば、もう少しわかりやすいと思います

正規表現のraw文字列の変数化

AIに聞いてみました。さすがAI、できますよ！との回答をもらいました
AIの回答を参考に上記コードを書き直してみました。

block = (
    "G05P10000 G90G01 X12.50Y+20.3Z-5.63 I.5 J22.F1000 G54 G54.1P12 M98P1100 M198 P2299"
)
num = r"[+-]?(?:\d+\.\d+|\d+\.|\.\d+|\d+)"  # +12.123|-24.|.56|30
g54_1 = r"[GM]\d+(?:\.\d+)?\s*P\d+\.?"      # G54.1P1 M98P1122
nomal = r"[A-Z]"  # 通常のアドレス
pattern = re.compile(
    rf"""     
    {g54_1}         # G54.1P1 , M98P1122
    #----------------------
    |{nomal}{num}   # G01 , X-12.356
    """,
    re.VERBOSE,
)
words = pattern.findall(block)
#---------- 結果 --------------
#['G05P10000', 'G90', 'G01', 'X12.50', 'Y+20.3', 'Z-5.63', 'I.5', 'J22.', 'F1000', 'G54', 'G54.1P12', 'M98P1100', 'M198 P2299']

なるほど、だいぶ見やすくなりました
今後の仕様変更にも対応しやすくなったと思います
興味ある方は是非、「G04X10.」への対応もやってみてください。

まとめ

これまでも単純な正規表現に触れる機会はありましたが、複雑な記述はまるで「呪文」のようで、敬遠していました。
しかし、正規表現は文字列操作において非常に強力な武器になります。
独学ではやる気なしでしたが、AIと対話する事で、ある程度は理解できてきました。
今後もAIと対話しながら一歩ずつ分析していくことで、正規表現だけでなく、プログラミング言語全体の理解力も深めていけると感じています。

Fusion360 Python API 再挑戦！AIの力を借りて、sketchなど基本ライブラリを作ってみた。

Aiと言う強い味方を得て、Fusion API に再挑戦しています。pythonの学習もかねて、skrtch関連の関数をライブラリ化しています。 筆者の環境では、正常に動作しています。コピペで利用可。 Aiに教えてもらわないと、作成できなかった実例をレポートしています。

www.kazuban.com

2025.07.09

この記事では、Fusionの標準APIの2D スケッチで頻繁に使うオブジェクトをカプセル化しライブラリとしてまとめてみました。
Fusion 360 はパラメトリックモデリングを前提としているため、まずラフに図形を描き、あとから寸法線や拘束を追加して形状を詰めていく、という作業フローが基本です。
試行錯誤しながら設計を煮詰めていく用途では非常に強力な手法ですが、CAM 作業のように、すでに図面や数値が確定している場合には、この手順がやや回りくどく感じることもあります。
またFusion 360 には原点の概念はありますが、原点を強く意識しないモデリング手法であるため、「図面ありき」の CAM 作業では、座標原点を通る中心線作図から始めるようにしています
ところが、この最初に描いた中心線も拘束や固定を忘れると、気づかないうちに移動させてしまい、後工程で大きなトラブルになることがあります。

固定された座標軸を、簡単かつ確実に作図したい
　　──まずこれが、スクリプト作成を始めたきっかけです。

また、スケッチ平面に対して高低差のある傾いた線を引きたい場合や、
平面からの異なる高さに円を描きたい場合なども、標準操作では少し手間がかかります。
前回作成したライブラリでは、直線や円といったシンプルな作図であれば、数値を引数として渡すだけで描画できるところまでは実現しています。
ただし、実用面を考えると、やはり GUI ダイアログ形式で数値入力できる仕様にしたいというのが今回の取り組みです。

Fusion API標準機能のコマンド UIでダイアログ仕様

Fusion API には、コマンドに付随する入力ダイアログ機能が標準で用意されており、テキストボックスやドロップダウンリスト、スライダーといった一般的な UI 要素を利用できます。
これらの UI 要素は Command Inputs オブジェクトを使って定義します。
コマンドが作成される際に呼び出される CommandCreated イベントハンドラ内で Command Inputs を作成し、コマンドの入力ダイアログに表示する入力フィールドを定義します。
その後、Execute イベントハンドラ内で、ユーザーがダイアログ上で入力した値を取得し、処理を実行します。
このように Fusion API のコマンドはイベント駆動で構成されており、各イベントハンドラを通して入力値を扱う必要があります。
とりあえずコード化してみましたが、初級者の私にとっては処理の流れを理解するのが難解でとりあえずネット情報やAIを参考に作成してみました
下記は、標準コマンドダイアログへの入力値を上記で紹介している「lib_2d.draw_center_line(x, y, z)スクリプトに取り込んでＸ，Ｙ，Ｚ座標軸線を作図させるスクリプトです

class CommonAddinFramework:
　”””
　Fusion 360 アドインの共通フレームワーククラス。
　ダイアログの表示、入力値の取得および指定された描画コールバック関数の実行を管理
　”””
　def __init__(
　　self,
　　command_id: str,
　　button_name: str,
　　description: str,
　　input_defaults: dict,
　　drawing_callback,
　):

・・・・
・・・・

コード全体を表示

単純入力フォームに、tkinter を使ってみる

上記でFusion標準のコマンドUIを使って、寸法入力で座標軸線を作画できるようになりましたが、今後機能を増やしていくには、やはりイベント処理ではわかり辛く煩わしく感じますし、ネット上の情報も少ないです
そこで、Python標準のtkinterを使ってみました
tkinterはpython標準ライブラリなので、さすがにこちらは、情報豊富です

中心線作図スクリプト

かなりAIに助けてもらいましたが
上記記事内で作成した中心線スクリプトに入力数値を渡すダイアログをtkinterを利用して作成してみました。
最初にメッセージ表示の「label」を配置して、「entry」で設定値入力ボックスを配置
さらに、固定とコンストラクション設定用の「Checkbutton」を配置して作成ボタンで、作図させる仕様です

# ——————————————————————
# ダイアログクラス
# ——————————————————————
class DialogPanel(tk.Tk):
　def __init__(
　　self,
　　input_defaults: Dict[str, float],
　　construction,
　　fixed,
　):

・・・・
・・・・

コード全体を表示

この「DialogPanel」クラスをアレンジして、直線や円などを作図する入力ダイアログも追加作成していきます。
このスクリプトをFuisonの「スクリプトとアドイン」に登録すれば、作図スクリプトをダイレクト数値入力仕様で実行できるようになります。
私的には、FusionAPIのCommand Inputsよりもわかりやすいです。

表示されたボタンをクリックして、関数を実行するスクリプト

いくつかコマンドダイアログを作成していくと、いちいち「スクリプトとアドイン」へ登録するのも面倒になってきます。
FusionAPIでもFusionタスクバーにコマンド実行プルダウンを追加できるようですが、これもまた敷居が高いです。
今回は、tkinterでメニュー用パネルを作成し、そのメニューボタンで作図スクリプトを起動できれば、メニューだけの登録で済みます。

ボタンクリックで起動させる、tk.Button　の　command　オプション

ボタンクリックで関数を実行させるには「command」オプションに関数名を渡すと実行できます

# 起動させたい関数
def cmd1():
    print("Function is cmd1().")
・・・
・・・
# ボタンクリックで、「def cmd1()」関数を起動する
tk.Button(
        root,
        text="Execute_command01",
        command=cmd1
)

ここで初心者の筆者が疑問に感じたのが、「command=cmd1」の書き方です
関数名は「cmd1()」なのに、「commandオプション」には”( )”が付かないようです
この関数名の”( )”の有無について、AIに聞いてみました

関数名の () の有無による違い

1. かっこがない場合 (cmd1)

かっこがない場合、それは関数そのもの（オブジェクト） を指します。これは「関数というデータ」として扱われます。

意味	関数そのものを指す（データ）
例	data = { "menu1": cmd1 }
目的	関数を変数に代入したり、tk.Button の command のように他の関数に引数として渡すとき。
動作	処理はまだ実行されない。ただ関数の場所を渡すだけ。

2. かっこがある場合 (cmd1())

かっこがある場合、それは関数の実行（呼び出し） を意味します。

意味	関数の処理を今すぐ実行する
例	cmd1()
目的	関数に書かれている処理をすぐに実行し、その戻り値（結果） を受け取るとき。
動作	すぐに処理が実行される。もし戻り値があれば、その結果が残る。

なるほど～
“( )”がない場合には、C言語でのポインタ渡しのようなイメージですかね
“( )”を付けると、「すぐに実行される」との事なので、
クリック後実行させたい、「tk.Button」の「command」オプションには、使えないですね
したがってTkinterのcommand は、引数なしで呼び出せるものを要求すると言うことになります
では、引数や戻り値を利用したい関数を実行するにはどうするか？

lambda（ラムダ式）を使う

lambda は、短い無名関数（名前のない一時的な関数）を簡単に作るためのPythonの機能ですが、デフォルト引数を設定できるけど、実行時には引数なしで呼び出されるようです
したがって、「tk.Button」の「command」に利用できます
具体的には、「lambda 引数1,引数2…：引数を使った処理」のように記述します

def exec(function, msg):
    function(msg)
・・・・・・
・・・・・・
command = lambda msg="button click!", func=cmd1: exec(func, msg)

このように、関数：execに、func, msg　の引数を渡せば
「func名」の関数に「引数msg」を渡して実行できます
簡単な、サンプルコードを書いてみました

"""Execute a function on button click."""

import traceback
import adsk.core
import adsk.fusion

# import adsk.cam

import tkinter as tk


def disp_message(msg: str):
    app = adsk.core.Application.get()
    ui = app.userInterface
    ui.messageBox(f"{msg}")


def print_cmd1():
    disp_message("lambda is not used.")


def print_cmd2(msg: str):
    disp_message(msg)


def exec(function, msg):
    function(msg)


def run(context):
# def run():
    root = tk.Tk()
    label1 = tk.Label(
        root,
        text="Click the button.",
        bg="light cyan",
    )
    label1.pack()
    # ---------------------------------
    tk.Button(
        root,
        text="Execute1",
        command=print_cmd1,
    ).pack(side=tk.LEFT, padx=10, pady=10)
    # ---------------------------------
    tk.Button(
        root,
        text="Execute2",
        command=lambda m="center button click!", f=print_cmd2: exec(f, m),
    ).pack(side=tk.LEFT, padx=10, pady=10)
    # ---------------------------------
    tk.Button(
        root,
        text="Execute3",
        command=lambda m="right button click!", f=print_cmd2: exec(f, m),
    ).pack(side=tk.LEFT, padx=10, pady=10)
    root.mainloop()

こんな感じで、「ボタン」を並べれば、ボタンクリック仕様のコマンド実行メニューが作成できそうです

Tkinterは、Autodesk 非公式

「tk.Button」と「lambda」で、メニューダイアログが作れそうです
上記で紹介した座標軸センターラインを作図するスクリプトを実行するダイアログを作成してみます
ところが、Tkinterの使用は、Autodeskは非公式のようなので注意が必要です

Fusion API で、tkinter を使用する場合の注意点

・Tkinterの使用は、Autodesk 非公式
・Tkinter が root.mainloop() で動作中は Fusion 本体の操作は一切できなくなる
・Mac + Tkinter は挙動が不安定なことがある
・Tkinterウィンドウを閉じた時に不安定になる場合がある
・最悪、タスクマネージャーでFusion 強制終了

やはり、Autodesk側としては、あまり推奨はしていないようです
常駐ツールやモーダルな本格的ダイアログはやめたほうがよさそうです
今回作成中も、閉じる時に「Script Error」が出たり、強制終了の必要に迫られたりしましたが、数値入力や条件入力の簡易パネルとして、開いたら閉じて、Fusionに制御を返すような単純な処理であれば利用できると思っています。

run(context) の context引数 は必須

python学習もかねて、いろいろ簡単なコードを書きました。
コードが悪いと、Fusionを強制終了させざるを得ない場合もありましたが、普通に問題なく動作しているのに、パネルの「×ボタン」で終了時に、Fusionのコマンドエリアに「SCRIPT ERROR」が出た事もありました。
これの原因究明には結構時間がかかりました。
上記のサンプルコードでも、run(context)の「context」は使っていないからと、
省略すると（「def run():」）「SCRIPT ERROR」になり、なにも動作しない状態になります
やはり、FusionAPIがどこかで使っていて、必須なようです
「×」での「SCRIPT ERROR」は終了時の警告のみなので、無視しようとも思いましたが、気味が悪いので、とりあえずAIにもいろいろも相談しましたが、的確な回答はもらえませんでした。
例えば下記コードで終了時に「SCRIPT ERROR」になります。
引数に「tk.Tk()型」を渡しました。結局、この引数が原因でした

def run1(root):
　    label1 = tk.Label(root , text=”Click the button.”)
　　・・・・
　　・・・・

master = tk.Tk()
run1(master)

Fusionの「スクリプトとアドイン」で、「スクリプトまたはアドインを作成」を選択すると、自動的にサンプルスクリプトが作成されるので、そちらを参考にしてみました。
Fusionで自動作成された、run関数の中身は下記のようになっています

def run(_context: str):
    """This function is called by Fusion when the script is run."""

    try:
        # Your code goes here.
        ui.messageBox(f'"{app.activeDocument.name}" is the active Document.')
    except:  #pylint:disable=bare-except
        # Write the error message to the TEXT COMMANDS window.
        app.log(f'Failed:\n{traceback.format_exc()}')

引数は「_context: str」となっています。
以前のサンプルコードには、「str」のような型ヒントはなかったように記憶していますが
「str」なので引数の型は「文字列型」を期待しているようです。
このサンプルでも「_context」はどこにも使われていないように見えますが、やはりFusionAPI側では必須なのでしょう
ちなみにデフォルトでは「_context: str」と、型ヒントでは「文字列型」となっていますが、下記コードを追加して調べてみました

    ui.messageBox(f"type={type(_context)}")
    ui.messageBox(f"{_context}")

そのタイプと内容を表示させてみると

type=<class ‘dict’>
{‘IsApplicationStartup’: False}

このように、「辞書型」になっていました。
詳細はわかりませんが、メイン関数の第一引数はFusionが使うので、別の引数を使いたい場合には、追加の形をとったほうがよさそうです
この部分を変更すると正常に終了するようになりました。
pythonのこういった型のあいまいな部分にも、まだまだ慣れないです

数値入力ダイアログで、座標軸を作図するスクリプトをボタンで起動

さて、上記で紹介した「中心線作図スクリプト」を、ボタンクリックで動作させるダイアログを作成してみようと思います。
ただし、このスクリプトは、以前紹介した記事内のライブラリ「lib_util.py」「lib_2d.py」を利用するので、もし試してみたい場合にはそちらも必要になります
下記に全部含まれたコードをダウンロードできるようにしておきますので、興味ある方がいらっしゃれば試してみてください。

"""Execute a function on button click."""

import adsk.core
import adsk.fusion
import os, sys, importlib, traceback
import tkinter as tk

import tkinter.font as tkFont
from typing import Optional, List, Dict, Any

current_dir = os.path.dirname(os.path.abspath(__file__))
script_dir = os.path.dirname(current_dir)  # C:\FusionAPI\Scripts
sys.path.append(script_dir)
# library import
"""
C:\FusionAPI\Scripts
│
├─library
│  ├─lib_util.py
│  ├─lib_2d.py
├─test
│  ├─menu.py (This script)
"""
from library import lib_util, lib_2d


##---------------------------
def disp_message(msg: str):
    lib_util.disp_message(msg)


# ------------------------------------------------------------------
# ダイアログクラス
# ------------------------------------------------------------------
class DialogPanel(tk.Tk):
    """センターライン作画ダイアログ"""

    def __init__(
        self,
        input_defaults: Dict[str, float],
        construction,
        fixed,
    ):
        super().__init__()
        # self.my_font = None
        self.input_defaults = input_defaults
        self.x_width: float = 0.0
        self.y_width: float = 0.0
        self.z_width: float = 0.0
        self.construction: bool = construction
        self.fixed: bool = fixed
        self.widths: dict[str, tk.DoubleVar] = {}
        self._create_widgets()

    def _simple_frame(self, **kwargs) -> tk.Frame:
        # Fontインスタンスを作成
        self.my_font = tkFont.Font(family="Arial", size=10, weight="normal")
        """単純フレームを作成し、ウィンドウ全体に展開"""
        master = self
        frame = tk.Frame(master, **kwargs)
        master.title("Center Line")
        frame.pack(fill="both", expand=True, padx=5, pady=5)
        return frame

    def _create_widgets(self):
        """全てのUI要素を作成"""
        # 全体を包む単一のフレーム
        self.main_frame = self._simple_frame(relief="ridge", bd=5)

        # ------------------
        # 0. トップメッセージ
        # ------------------
        row_idx = 0
        top_frame = tk.Frame(self.main_frame)
        top_frame.grid(row=row_idx, column=0, columnspan=3, pady=10)
        tk.Label(
            top_frame,
            text="各軸の長さを指定してください。\n作成したくない軸は「0.0」にしてください",
            bg="light cyan",
            font=self.my_font,
        ).pack()
        # ------------------
        # 1～3 各軸幅入力ボックス
        # ------------------

        row_idx += 1
        # 事前設定のラベルとデフォルト値
        for label, default in self.input_defaults.items():
            tk.Label(
                self.main_frame,
                text=label,
                font=self.my_font,
            ).grid(
                row=row_idx,
                column=0,
                sticky="e",
            )
            var = tk.DoubleVar(value=default)
            ent = tk.Entry(
                self.main_frame,
                font=self.my_font,
                textvariable=var,
                width=10,
                bg="lightyellow",
                # bg="ivory",
            )
            ent.grid(row=row_idx, column=1)
            self.widths[label] = var
            row_idx += 1
        # ------------------
        # 4. 要素固定チェック
        # ------------------
        row_idx += 1
        # self.fixed_check = tk.BooleanVar(value=True)
        self.fixed_check = tk.BooleanVar(value=self.fixed)
        check_button = tk.Checkbutton(
            self.main_frame,
            text="要素固定",
            variable=self.fixed_check,
            font=self.my_font,
        )
        check_button.grid(row=row_idx, column=0, padx=5, pady=5, sticky="w")
        # self.construction_check = tk.BooleanVar(value=True)
        self.construction_check = tk.BooleanVar(value=self.construction)
        check_button = tk.Checkbutton(
            self.main_frame,
            text="コンストラクション",
            variable=self.construction_check,
            font=self.my_font,
        )
        check_button.grid(row=row_idx, column=1, padx=5, pady=5, sticky="w")

        # ------------------
        # 5. 最終確定ボタン
        # ------------------
        row_idx += 1
        # ボタンを格納するボトムフレーム
        bottom_frame = tk.Frame(self.main_frame)
        bottom_frame.grid(row=row_idx, column=0, columnspan=3, pady=10)

        tk.Button(
            bottom_frame, text="作成実行", font=self.my_font, command=self.get_data
        ).pack(side=tk.LEFT, padx=10)
        tk.Button(
            bottom_frame, text="閉じる", font=self.my_font, command=self.destroy
        ).pack(side=tk.LEFT, padx=10)

    def get_data(self):
        """入力データを取り出す"""
        v: List = []
        for value in self.widths.values():
            v.append(value.get())
        self.x_width = float(v[0])
        self.y_width = float(v[1])
        self.z_width = float(v[2])
        self.fixed = self.fixed_check.get()
        self.construction = self.construction_check.get()
        self.destroy()


##--------------------------------------------------------------
##--------------------------------------------------------------
def diarog_test(master):
    """センターライン作画"""
    if master:
        master.quit()  # mainloop を終了させる
        master.destroy()
    input_defaults = {
        "X軸長さ": 50.0,
        "Y軸長さ": 50.0,
        "Z軸長さ": 10.0,
    }
    # 線種指定
    construction = True
    fixed = True

    app = DialogPanel(input_defaults, construction, fixed)
    app.mainloop()
    wx = app.x_width
    wy = app.y_width
    wz = app.z_width
    construction = app.construction
    fixed = app.fixed
    try:
        lib_2d.draw_center_line(wx, wy, wz, construction, fixed)
    except:
        disp_message("Failed:\n{}".format(traceback.format_exc()))


# ---- Action command after button click ----------


def print_cmd1():
    disp_message("lambda is not used.")


def print_cmd2(msg: str):
    disp_message(msg)


def exec(function, msg):
    function(msg)


def on_closing(root):
    """Processing when the window's 'x' button is pressed"""
    disp_message("I'll close now!")
    root.quit()  # Terminate the mainloop
    root.destroy()  # Releases window resources.


def button(root: tk.Tk):
    # Window close action
    root.protocol("WM_DELETE_WINDOW", lambda: on_closing(root))
    label1 = tk.Label(root, text="Click the button you like.", bg="light cyan")
    label1.pack()
    tk.Button(root, text="Message1", command=print_cmd1).pack(
        side=tk.LEFT, padx=10, pady=10
    )
    tk.Button(
        root,
        text="Message2",
        command=lambda m="Lambda specification!", f=print_cmd2: exec(f, m),
    ).pack(side=tk.LEFT, padx=10, pady=10)
    tk.Button(
        root,
        text="Draw center line",
        command=lambda tk=root, f=diarog_test: exec(f, tk),
    ).pack(side=tk.LEFT, padx=10, pady=10)
    root.mainloop()


def run(context: dict):  # {'IsApplicationStartup': False}
    root = tk.Tk()
    root.attributes("-topmost", True)  # Bring Window To Top
    button(root)

サンプルスクリプトのダウンロードと使い方

ダウンロードと使用方法は下記を参考にしてください
この例では、展開されたトップフォルダ「FusinAPI_kazuban」を「Cドライブ」の直下に、コピーする方法で説明していますが、任意の場所でかまいません
ただし、Fusionが立ち上がった状態では、キャッシュの影響で「library」内のスクリプトがうまく読み込めない事があります
コピー後に、Fusionを起動する方がトラブル少ないです。
そのトップフォルダ下の「Scripts」、その下の「library」「menyu01」内のスクリプトを使用します
全ての使用ライブラリも含めたZIPファイルは下記からのダウンロードできます

FusinAPI_kazubanダウンロード

C:\FusinAPI_kazuban
└─Scripts
    ├─library
        └─lib_2d.py
        └─lib_util.py
    └─menyu01
        └─menu.py

・ダウンロード後展開した「FusinAPI_kazuban」を適当なフォルダへコピー
・Fusionの「スクリプトとアドイン」から「menyu01」を選択する
・正常に登録されると、スクリプトが実行できます

第一弾、終了

とりあえず、Autodesk Fusion からtkinterオブジェクトのパネルを表示し、ボタンに割り当てられたスクリプト動作をさせる事ができました。
数値入力用ボタンでは、tkinterへの入力値をFusionAPIに渡し、作図させる事ができるようになりました
次回は、もう少し作図スクリプトとメニューを充実させていきたいと思います

RockyLinux9.３で自宅サーバーを再構築V08・postfix で送信専用メールサーバー構築

このサイトには「お問い合わせフォーム」を設定していますし、起動しているサーバーがエラーなどの連絡を発信する場合もあります。 重要なメールもあるので、メインのメールアドレスへ配信させる設定を行います。 今回は、サーバー側から、配信するのみの設定を行います

www.kazuban.com

2024.01.08

この設定により、このブログサイトへの、「お問い合わせ」も設置できているのですが、この不具合では、「お問い合わせ」もこちらに届きません
う～ん、困った。

こんな時ほど、Aiに相談だぁ！

最初は、ググってみましたが、なかなか的確なサイトにぶち当たりません。
Aiに聞いてみよう！
ChatGPT と Gemini 2.5Flash に同じ質問をしてみましたが、ほぼ同じ回答内容でしたが
ChatGPTのほうが、みやすく感じます
ただ、ChatGPTは次から次に、逆質問をしてくるのが、ちょっとウザいかも・・・

rocky linux9 で自宅サーバーを運用していますが、2025/10月からサーバーからのメールが送信できなくなりました sudo cat /var/log/maillog | grep -i error を実行してみると、下記エラーがでます。原因はなんでしょう？
sudo cat /var/log/maillog | grep -i error
（エラー内容）
・
・

それにしても、エラー内容をそのまま突っ込めるのは、今までの検索では考えられないですね。

Aiのエラー内容の整理

ログのエラー内容を整理すると：
Postfix が プロバイダ のメールサーバ (mx.hogehoge.com) に TCP ポート 25 で接続しようとしてタイムアウトしています。

主な原因候補

１０月からであれば、原因とは考えにくいですが・・・
Rocky Linux の firewalld やルーターで 25番ポートのアウトバウンドが塞がれた可能性。

プロバイダ側のポート25ブロック
2025年現在、多くの ISP（特に家庭向け回線）はスパム対策のため ポート25を塞いでいる ことが多いです。
それまでは通っていたけど、2025年10月から「送信ポリシー変更」でブロックされた可能性があります。

プロバイダ 側の受信制限
プロバイダ の受信サーバが外部からの直接SMTPを拒否するようになった可能性があります。

ファイアウォール / サーバ側の設定
個人宅サーバからの直接送信を受け付けない運用に切り替えた可能性。

確認方法

自宅サーバーからプロバイダメールサーバーへ直接接続できるか試す

telnet mx.hogehoge.com 25

もしタイムアウトするなら → 回線側（ISPやプロバイダ）で遮断。
もし「220〜」の応答があれば → Postfixの設定やファイアウォールの問題。

結果、telnet mx.hogehoge.com 25 が応答なし（タイムアウト）でした。
ということは、サーバー側(Postfix)の問題ではなく、回線側で25番ポートがブロックされている可能性が非常に高いと言うことのようです。

状況まとめ

• 以前は送れた → 2025年10月から送れなくなった
• ログでは「Connection timed out」
• telnet も通らない

👉 これは「ISP（プロバイダ 側）が 自宅回線からの直接25番SMTP送信を禁止 に切り替えた」ケースに一致します。
最近は迷惑メール対策で家庭向け回線ではほぼ標準でブロックされます。

解決方法

１．プロバイダのメールサーバ経由（SMTPリレー / smarthost）
　・Postfix の relayhost 設定でプロバイダの SMTP サーバ（587 or 465ポート）を使う
２．外部のメールリレーサービスを利用
　・SendGrid, Gmail SMTP relay, AWS SES など
３．自宅サーバではなく VPS 経由で送信
　・自宅サーバからVPSへ転送して、VPSから外へ送信。

解決策（おすすめ）

プロバイダのSMTPサーバを経由する（最も現実的）

Postfix で 「スマートホスト」設定をして、smtp.hogehoge.com:587 経由で送信するのがベストです。（25番ではなく 587 番（Submission ポート）がベスト）

まずは、 外部からの直接配送(mx) ではなく、 認証付きの送信サーバ(smtp) なら接続できるかの確認

telnet smtp.hogehoge.com 25
telnet smtp.hogehoge.com 587

結果、両方とも接続できました
telnet smtp.hogehoge.com 587
Trying 000.000.000.0… Connected to smtp.hogehoge.com. Escape character is ‘^]’.
220 hogehoge.com ESMTP server ready Sat, 4 Oct 2025 15:42:22 +0900

整理すると

mx.hogehoge.com:25 → タイムアウト（接続できない）
smtp.hogehoge.com:25 → 接続できる（220応答あり）
smtp.hogehoge.com:587 → 接続できる（220応答あり）
つまり：
プロバイダ は 外部からの直接配送(mx) を制限している
代わりに 認証付きの送信サーバ(smtp) なら 25 でも 587 でも受け付けている
じゃあどっちを使うべき？
587（submission ポート） が推奨です（標準仕様で「認証あり専用の送信ポート」）
25番で smtp.nifty.com に直接送ることもできますが、将来的にブロックされる可能性が高いです。
なので、Postfixの relayhost を smtp.hogehoge.com:587 にして、SMTP認証を通す設定がベストです。

設定方法

認証情報ファイルを作成

/etc/postfix/sasl_passwd　ファイルを作成し、アドレスとパスワードを追記：
「プロバイダのメールアドレス」：「アドレスパスワード」

[smtp.hogehoge.com]:587 myaddress@hogehoge.com:mypasswd

Postfix設定ファイルを修正

/etc/postfix/main.cf の末尾あたりに下記追記：

# hogehoge の SMTP サーバをリレーに指定
relayhost = [smtp.hogehoge.com]:587

# SMTP認証を有効化
smtp_sasl_auth_enable = yes
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
smtp_sasl_security_options = noanonymous

# TLS を使用
smtp_use_tls = yes
smtp_tls_security_level = may
smtp_tls_note_starttls_offer = yes

ハッシュ化して権限設定

sudo postmap /etc/postfix/sasl_passwd
sudo chmod 600 /etc/postfix/sasl_passwd*

Postfix再起動

sudo systemctl restart postfix

テスト送信

echo "This is a test mail" | mail -s "Postfix smtp test" myaddress@hogehoge.com

確認

/var/log/maillog を確認して、status=sent になれば成功

後日、Gmailへの転送がNGになった

後日、バックアップサーバーの立ち上げをやっていて、GmailへのテストメールがNGになった

 echo "This is a test mail to gmail" | mail -s "Postfix smtp test2" hogehoge@gmail.com

ここも、AIに聞いてみる

Gmailで該当メールを開いて 「︙」→「メッセージのソースを表示」 し、以下の行を確認してみてください：

Authentication-Results: mx.google.com;
   spf=pass  ← ここがfailだとアウト
   dkim=pass ← ここがfailだとアウト

その結果を教えてもらえれば、どこが問題か特定できます！

Authentication-Results: nifty.com;
    dmarc=none header.from=kazuban.com;
    dkim=none;
    spf=fail smtp.mailfrom=kazuban.com;
    sender-id=Fail (pra) header.From=kazuban.com

原因が明確になりました！

AIが問題点指摘

spf=fail → kazuban.com のDNSにSPFレコードがないか、Niftyのサーバーが許可されていないNiftyのSMTP経由で送っているのに、Fromアドレスが @kazuban.com なので、
「kazuban.comのSPF的にNiftyは許可されてないよ」とGmailに判断されています。

A. kazuban.com のDNSにSPFレコードを追加（推奨）

種別     ホスト名          内容
TXT      @ （または空欄）  v=spf1 include:nifty.com ~all

設定後、反映に数分〜数時間かかる場合があります。確認コマンドはこちら：

dig TXT kazuban.com | grep spf

v=spf1 include:nifty.com ~all が表示されれば成功です。

正常にもどった

いまさらですが、Aiはすごいですね
ちょっと前までは、プロンプトが重要とか言われていましたが、最近ではあまり感じません
普通に個人の言葉で、質問すれば、かなり理解してくれます
もしかすると、サポート会社などへ、電話質問するよりも簡単かもしれません
理解力と分析力は、はるかに人間を超えているように思います

カスタムマクロの欠点

Google で「カスタムマクロ欠点」で検索してみると、下記のAi概要が最上部に表示されました
話は変わりますが、最近では通常検索でもAi回答が出てくるようになりましたね。

AI による概要

カスタムマクロは、NCプログラムの効率化や自動化に役立つ一方で、いくつかの欠点も存在します。主な欠点としては、プログラミングの難易度、デバッグの複雑さ、互換性の問題、そして過度な依存によるリスクなどが挙げられます。

カスタムマクロの欠点

• プログラミングの難易度:カスタムマクロは、通常のNCプログラムよりも複雑なロジックを記述する必要があるため、習得に時間がかかり、プログラミングの難易度が高いです。特に、条件分岐やループ処理を多用する場合、複雑さが増し、エラーが発生しやすくなります。
• デバッグの複雑さ:カスタムマクロのデバッグは、通常のNCプログラムよりも難易度が高いです。変数の値の変化や処理の流れを追跡するのが難しく、エラーの原因特定に時間がかかることがあります。また、マクロプログラムが複雑になるほど、デバッグ作業はさらに困難になります。
• 互換性の問題:カスタムマクロは、使用するNC工作機械や制御装置の種類によって、互換性の問題が発生する可能性があります。同じマクロプログラムでも、機械が異なると正しく動作しない場合や、エラーが発生する場合があります。そのため、マクロプログラムを作成する際には、互換性を考慮する必要があります。
• 過度な依存によるリスク:カスタムマクロに過度に依存すると、マクロプログラムの変更や修正が必要になった場合に、他の作業に影響が出たり、生産性が低下する可能性があります。また、マクロプログラムの作成者が不在になった場合、保守や管理が困難になるというリスクもあります。

その他の考慮事項

• マクロプログラムの可読性:カスタムマクロは、可読性の高い書き方を心がける必要があります。コメントを適切に記述し、変数名や処理の流れを分かりやすくすることで、他の人がマクロプログラムを理解しやすくなります。
• マクロプログラムのバージョン管理:カスタムマクロは、バージョン管理を行うことで、変更履歴を把握し、必要に応じて以前のバージョンに戻すことができます。
• マクロプログラムのテスト:カスタムマクロは、実際に機械を動かす前に、シミュレーション環境などで十分にテストを行う必要があります。これにより、エラーの発生を未然に防ぎ、安全に運用することができます。

これらの欠点や考慮事項を踏まえ、カスタムマクロの導入を検討する必要があります。

なるほど・・ここのサイトでもいくつか取り上げていますが、まさに同意見です。

プログラミングの難易度

マクロは数多く作成してきましたが
機械の制御器に処理させる言語になるので、どうしても、一般的なプログラミング言語と比較すると、中途半端で可読性は悪くなってしまします。
ちなみに、レダース(Roeders）機は、独自開発されたプログラミング言語ライクな言語です。
加工動作のGコードのサブプロ部分と、その動作部分を管理するメインプロ部分を分離する事を基本で開発されているように感じています。
特にWindowsソフトウェアとして開発された言語なので、自動化や多数個など、複雑なメインプロを開発する場合でもかなり楽です。

デバッグの複雑さ

このサイトでも、何度か書いていますが、一番は変数の制限が可読性を悪くしているように思います。
筆者は通常のGコードだけであれば、TRYCUT と言うシミュレーションソフトを使っていますが、TRYCUTにはマクロ展開機能が付いていません。
シミュレートできないので、マクロのデバッグはエディタやプリントアウトして目視で追っかけ確認ますがかなかな面倒で、リスクもあります。
社内設備機械で、一台だけマクロも含めたシミュレート機能がある制御器があるので、確認のためだけに、その機械を起動させる場合もあります。
大人しく、マクロ機能付きのシミュレータを購入したら・・・の意見もあると思いますが、マクロ利用頻度から検討すると、どうしても費用対効果の面で無理があります。

そうだ、Aiに展開してもらおう！

前回、Fusion python API を、Aiに教わったらすごかった・・を記事にしました

Fusion360 Python API 再挑戦！AIの力を借りて、sketchなど基本ライブラリを作ってみた。

Aiと言う強い味方を得て、Fusion API に再挑戦しています。pythonの学習もかねて、skrtch関連の関数をライブラリ化しています。 筆者の環境では、正常に動作しています。コピペで利用可。 Aiに教えてもらわないと、作成できなかった実例をレポートしています。

www.kazuban.com

2025.07.09

Fusion API は、一般的なpython言語構文やライブラリだけでなく、独自のオブジェクトを絡み合わせて開発していくので、そのパッケージの理解だけでも大変です。
それを、Aiに聞いたら、サンプルコードを出してくれたり、自作したコードを添削してくれたりと、驚きでした。
そこで上の記事を書いてたら、ピ～ンときました。
「そうだ、Fusion APIのパッケージを瞬時に解読できるなら、カスタムマクロなら簡単に解読してくれるかも！」

課題データ

課題NCデータは、以前記事にした、下記ページのデータをそのまま使ってみようと思います

カスタムマクロ、G66モーダル呼び出しで固定サイクルを自作してみる。

前回、カスタムマクロプログラムの例として、ハイデンハインサイクルをマクロ化する例を紹介しました。ハイデンハインサイクルに比べると、ファナック固定サイクルの機能は非常に貧弱ですが、カスタムマクロを自作する事で、無限に拡張する事が可能です。今回は、カスタムマクロのモーダル呼び出し「G66」を利用して、穴...

www.kazuban.com

2022.05.30

穴の面取りを輪郭加工で行うマクロです。
メインプロ「O1000」に加工条件や面取り条件を変数で定義して、G66モーダル呼び出しで「O6000」の面取り加工マクロを呼び出し、指定位置「O6100」で面取りを行うプログラムです
若干変数での計算式もあります。

こちらのファナックマクロを展開してください
%
O1000
( Chamfering Program Ver1.0 By kazuban ) 
G90G00G17G40G80G49 
(++++++++++++++++++++) 
#1=54 (WORK ORIGIN)
#2=10 (Tool Number)
#3=#2 (H Number)
#4=0.5(Tool Diameter)
#5=2300 (Spindle Speed)
#6=200 (Feed)
#7=8 (Coolant)
#8=0.0(Surface Coordinat)
#9=50.0 (Initial Point) 
#10=5.0 (R Point)
(++++++++++++++++++++) 
#11=12.0 (Hole Diameter)
#12=1.0 (Chamfer)
#13=0.5 (Offset)
(++++++++++++++++++++) 
#30=6000 (Macro program No)
#31=6100 (Position program No)
(++++++++++++++++++++) 
N0001
G#1
T#2
M06
G90G00X0Y0 
G43Z[#8+#9]H#3
( Chamfer Process )
S#5M03 
M#7
(----------------------------)
(B:#2=#8 : Surface Coordinat) 
(C:#3=#9 : Initial Point) 
(I:#4=#10 : R Point) 
(J:#5=#12 : Chamfer) 
(K:#6=#13 : Offset)
(D:#7=#4 : Tool Dia)
(E:#8=#11 : Hole Dia)
(F:#9=#6 : Feed)
(++++++++++++++++++++) 
G66 P[#30] B[#8] C[#9] I[#10] J[#12] K[#13] D[#4] E[#11] F[#6]
M98P[#31]
G67
G90G00Z[#8+#9]
M09
M05
G91G28Z0 
G91G49Z0 
G90M05 
( End of Process )
M30
%
%
O6000
( Chamfering Macro Ver1.0 By kazuban ) 
(+++++++++++++++++++)
#1=[#8/2-[#6+#7/2]] (circle radius)
(+++++++++++++++++++)
(B:#2 : Surface Coordinat) 
(C:#3 : Initial Point) 
(I:#4 : R Point) 
(J:#5 : Chamfer) 
(K:#6 : Offset)
(D:#7 : Tool Dia)
(E:#8 : Hole Dia)
(F:#9 : Feed)
(+++++++++++++++++++)
G90G00G17
Z[#2+#3] 
Z[#2+#4] 
G01Z[#2-[#6+#5]]F[#9] 
G91X[#1]
G03X-[#1*2]I-[#1]J0. 
X[#1*2]I[#1]J0.
G01X-[#1] 
G90G00Z[#2+#3] 
M99
%
%
O6100
( Hole Position )
X-35.Y55.
X-50.Y55.
X10.Y10. 
M99
%

このデータをそのまま、「Gemini 2.5 Flash」に突っ込んで、展開をお願いしてみました。

Aiの回答

G66仕様で、G66への変数渡しが「#変数」そのままでないので、作者が見直す時も結構面倒ですが、Aiは瞬時に分析してくれました。

提供されたFANUCマクロプログラムを解析し、その内容を以下に解説します。

---

プログラム全体の概要

このマクロは、複数の穴の面取り加工を自動化するために設計されています。主プログラム (O1000) で加工条件を設定し、マクロプログラム (O6000) で実際の面取り動作を実行、そしてもう一つのプログラム (O6100) で穴の位置情報を呼び出す、という構成になっています。

O1000: 主プログラム

このプログラムは、加工に必要な初期設定と、マクロ呼び出しを行います。

• 初期設定:
  • #1=54 (WORK ORIGIN): ワーク原点の位置を#1に設定。
  • #2=10 (Tool Number): 工具番号を#2に設定。
  • #4=0.5(Tool Diameter): 工具径を#4に設定。
  • #5=2300 (Spindle Speed): 主軸回転速度を#5に設定。
  • #6=200 (Feed): 送り速度を#6に設定。
  • #11=12.0 (Hole Diameter): 穴の直径を#11に設定。
  • #12=1.0 (Chamfer): 面取り量を#12に設定。
  • #13=0.5 (Offset): 工具のオフセット量を#13に設定。
• マクロ呼び出し:
  • G66 P[#30] ...: ここで、面取りマクロプログラムO6000（#30）を呼び出しています。
  • B[#8] C[#9]...: マクロに渡す引数を設定しています。
    • B[#8]: 面取り加工の開始基準となるワーク表面座標。
    • C[#9]: 加工前の待機位置である初期点。
    • I[#10]: 加工開始前の退避点（R点）。
    • J[#12]: 面取り量。
    • K[#13]: オフセット量。
    • D[#4]: 工具径。
    • E[#11]: 穴径。
    • F[#6]: 送り速度。
  • M98 P[#31]: 穴の位置情報を記述したプログラムO6100（#31）を呼び出します。これにより、O6100に記述された各座標で、G66で指定されたマクロが繰り返して実行されます。

O6000: 面取りマクロプログラム

このプログラムは、O1000から渡された情報をもとに、実際の面取り加工を行います。

• 面取り加工の半径計算:
  • #1=[#8/2-[#6+#7/2]]: この式は、面取り加工を行う円弧の半径を計算しています。
    • #8/2: 穴の半径。
    • #6: 面取り量。
    • #7/2: 工具の半径。
    • 結果: 面取り加工する円弧の半径 = (穴の半径) – (面取り量) – (工具の半径)
• 加工シーケンス:
  1. G90G00G17: 絶対指令、早送り、XY平面選択。
  2. Z[#2+#3]、Z[#2+#4]: Z軸を初期点、R点へと移動。
  3. G01Z[#2-[#6+#5]]F[#9]: Z軸を面取り深さまで切り込みながら移動します。
  4. G91X[#1]: ワーク座標を基準に、計算された半径分だけX軸を移動。円弧加工の開始位置に移動します。
  5. G03X-[#1*2]I-[#1]J0.: 半径#1の円弧で、左回りに180度円弧切削。
  6. X[#1*2]I[#1]J0.: さらに、半径#1の円弧で、左回りに180度円弧切削。これにより、1周分の面取り加工が完了します。
  7. G01X-[#1]: 円弧加工の開始位置から中心に戻ります。
  8. G90G00Z[#2+#3]: Z軸を初期点に戻します。
  9. M99: マクロプログラムの終了。主プログラム（O1000）に戻ります。

O6100: 穴位置プログラム

このプログラムは、加工する穴のXY座標をリストアップしています。

• X-35.Y55.: 1つ目の穴の座標。
• X-50.Y55.: 2つ目の穴の座標。
• X10.Y10.: 3つ目の穴の座標。

これらの座標は、O1000のM98 P[#31]によって順番に読み込まれ、それぞれの位置でO6000の面取り加工が実行されます。

---

まとめ

このプログラムは、以下のような処理フローで動作します。

1. 主プログラムO1000がスタートします。
2. 工具交換、初期位置決め、主軸回転、クーラントONなど、準備が完了します。
3. O6100に記述された最初の座標（X-35.Y55.）に移動します。
4. G66によってO6000の面取りマクロが呼び出されます。
5. マクロ内で計算されたパスで、面取り加工が行われます。
6. 面取り加工が完了すると、O1000に戻ります。
7. O6100の次の座標（X-50.Y55.）に移動します。
8. 再びO6000が呼び出され、面取り加工が行われます。
9. この繰り返し処理がO6100の最後まで行われます。
10. 全ての加工が終了すると、クーラントOFF、主軸停止、安全位置への退避が行われ、プログラムが終了します。

この構成は、複数の同じ形状の加工を効率的に行うための、NCプログラミングの典型的な手法です。プログラムを分割することで、位置情報や加工条件の変更が容易になります。

丁寧な解説ですが、加工シーケンス:４．の「ワーク座標を基準」と言うのがちょっと間違っていますね・・
無料版だからでしょうか？
でも、きちんとGコードに展開してくれれば、問題ないですから
再度、一般的なGコードへの展開をお願いすると・・・

%
O1000_EXPANDED
( Chamfering Program Expanded Version )

G90 G00 G17 G40 G80 G49 

( Tool and Spindle Setup )
T10 M06 
G90 G00 X0 Y0 
G43 Z[0.0+50.0] H10
S2300 M03 
M08

( — Hole 1 at X-35. Y55. — )
G90 G00 X-35. Y55.
G00 Z[0.0+50.0]
G00 Z[0.0+5.0]
G01 Z[0.0-[1.0+0.5]] F200
G91 X[12.0/2-[1.0+0.5/2]]
G03 X-[[12.0/2-[1.0+0.5/2]]2] I-[12.0/2-[1.0+0.5/2]] J0. X[[12.0/2-[1.0+0.5/2]]2] I[12.0/2-[1.0+0.5/2]] J0.
G01 X-[12.0/2-[1.0+0.5/2]]
G90 G00 Z[0.0+50.0]

( — Hole 2 at X-50. Y55. — )
・
・
・以下省略

G66呼び出しの部分も、きちんと、展開してくれました。
さらに、[]内で、変数を数値に置き換えた計算式で表現してくれています。
おそらく、[]を認識できるコントローラであれば、このまま動作すると思いますが、トライカットは動作してくれないので、再度、[]内の計算式部分を、実数値に変換をお願いしました。

完成

以下が完成したデータです

%
O1000
( Chamfering Program Expanded Numeric Version )

G90 G00 G17 G40 G80 G49 

( Tool and Spindle Setup )
T10 M06 
G90 G00 X0 Y0 
G43 Z50.0 H10
S2300 M03 
M08

( Chamfering Path Calculation )
( Hole Diameter: 12.0 )
( Chamfer: 1.0 )
( Tool Diameter: 0.5 )
( Offset: 0.5 )
( Radius for cutting: 12.0/2 - 1.0 - 0.5/2 = 6.0 - 1.0 - 0.25 = 4.75 )
( Cutting Depth: 1.0 + 0.5 = 1.5 )

( --- Hole 1 at X-35. Y55. --- )
G90 G00 X-35. Y55.
G00 Z50.0
G00 Z5.0
G01 Z-1.5 F200
G91 X4.75
G03 X-9.5 I-4.75 J0.
X9.5 I4.75 J0.
G01 X-4.75
G90 G00 Z50.0

( --- Hole 2 at X-50. Y55. --- )
G90 G00 X-50. Y55.
G00 Z50.0
G00 Z5.0
G01 Z-1.5 F200
G91 X4.75
G03 X-9.5 I-4.75 J0.
X9.5 I4.75 J0.
G01 X-4.75
G90 G00 Z50.0

( --- Hole 3 at X10. Y10. --- )
G90 G00 X10. Y10.
G00 Z50.0
G00 Z5.0
G01 Z-1.5 F200
G91 X4.75
G03 X-9.5 I-4.75 J0.
X9.5 I4.75 J0.
G01 X-4.75
G90 G00 Z50.0

( End of Program )
M09
M05
G91 G28 Z0
G91 G49 Z0
G90 M05
M30
%

シミュレーション

さっそく、シミュレーションしてみましょう！

正常に動作しました。

まとめ

やっぱり、Aiはすごいです。
座標値を変数で置き換えている程度のマクロであれば、エクセルやスクリプト言語などで、比較的簡単に変換できるかもしれませんが、計算式が入ってくると格段に難易度が上がります。
さらに、G66などのマクロ呼出しになると、引数への変数渡しに癖があるので、PC上での目視確認においても結構面倒です。
以前、マクロの変換ソフトの作成も考えた事もありますが、難易度高くで止めました。
今回のように、Aiに展開してもらえれば、手持ちのシミュレータで動作確認できるので、かなり気軽にマクロに取り組めると思います
それに、今回使用したAiは、「Gemini 2.5flash」で基本無料で利用できます。
ちょっと、間違った回答もありましたが、Fusion API の質問も含めて、制限が出ることはなかったです。「chatGPT」無料版では、制限に引っかかりました。

ところが昨年、AI（生成AI）が大きく注目されるようになり、「これを使ってみるか？」と再び興味がわきました。
試しにFusion向けのコードをAIに聞いてみると、実際に動作するスクリプトを提案してくれて、少しやる気が復活…
しかしそれも一時的で、またもや放置状態に。

話題の『生成Ai』に、Fusion360のPythonスクリプトをきいてみた

最近『生成Ai』を触り始めました。今までの、検索に比べても、非常に便利です。 できる事の幅が広すぎて、ついていけませんが、プログラムコードも出力してくれるようです。 いままで手を付けていなかった、Fusion360のPythonスクリプトを質問してみました。

www.kazuban.com

2024.01.27

そして今回！
AIもさらに進化してきた今こそ、もう一度挑戦してみようと思い立ちました。
本記事では、Fusion360 Python API に再び取り組み始めた記録と、コーディングへのAIの活用事例をレポートしています。
例題として、Fusion APIの基本ライブラリを作成しましたので、利用できそうであれば、利用していただければ幸いです。

なお、より高度なスクリプトや実践的な例に興味がある方は、「Kantoku」さんのサイトに素晴らしい資料が公開されていますので、ぜひチェックしてみてください。

今回の目標：スケッチ関連の基本ライブラリを作る

Python言語は、ほとんど初心者ですが、ネット情報やAiを参考にコードをコピペするだけでは、なかなか覚えられないと思っています。
そこで、基本的なコードをライブラリ化する事で、少しは理解も深まるかと思い、まずはスケッチ周りの基本コードをライブラリ化してみようと思います

Aiの実力を試してみる

さっそく、何種類かのLLMに質問してみました。

fusionのpython API で直線を引くコード

ローカルLLM

ローカルの場合、私の環境では、レスポンス的に30bぐらいが実用できる限界です。
そこで、「gemma-3-27b」「qwen3-32b」で試してみます

「fusionのpython API で直線を引くコードをだして」

最初に、「import adsk.core, adsk.fusion, traceback」などFusion特有のパッケージをインポートしするコードを出してくれるので、なかなかいいな！と思っていましたが、実際にFusionで実行してみても正常動作しませんでした。
特に、CAD画面上にメッセージを出力する場合、「ui.messageBox」を利用しますが、一般的なpythonの「print」文を使ったりしています。
また、私の環境で30bクラスのLLMでは、回答に５分以上かかりました。
文章をまとめたり、翻訳したりの場合では、8bクラスでもいい回答をもらえますが、Fusion API のPython場合はちょっとマイナーなのかもしれません
参考にはなると思いますが、私の環境ではちょっとレスポンスが悪いです。

オンラインLLM

次に、オンラインの「chatGPT」と「gemini」で試してみました。
「chatGPT」も「gemini」も、正常に動作しました。
ただし、ログインしないと、会話履歴や共有できないので、ログインしたほうがいいと思います。
制限がある場合がありますが、そこそこ無料利用できます。
やはり、さすがです。回答レスポンスも早いです。
今回の質問では、一年前に、出してくれたコードとほとんど同じコードをだしてくれました。
一年前は、「bard(gemini)」のコードは、正常動作しないコードでしたが、現在の「gemini」は問題ないコードを出してくれます。
個人的は、ローカルLLMを使いたい気持ちがあるのですが、開発作業では、やはりレスポンスは重要なので、今後の学習はオンラインLLMを利用しようと思います。
まずは「Gemini 2.5Flash」を利用してみて、いい回答が出なかった場合には、「chatGPT」や「Gemini 2.5Pro」を使おうと思います

コンポネントやスケッチのアクティブな状態を把握

上記の直線を描くサンプルコードでは、ルートコンポネントに新しいスケッチを作成し、そのスケッチに直線を引いています。
もう少し、実践的な動作にしたいです。

• スケッチモードであれば、そのスケッチに・・
• スケッチモードでない場合、ルートにこだわらず、アクティブなコンポネントに新しいスケッチを作成しそのスケッチに・・

これを実現させるには、まず現状のアクティヴな状態を把握する必要があります
アクティブなコンポーネントを見つける関数はすぐ見つかりましたが、スケッチのモード判定方法はなかなか見つからずAiのお陰でどうにかなりそうです。
こういった汎用的だけど苦労した処理を、ライブラリ化しておくと、後々便利だと思います

現状がスケッチモードかどうかの判定

何度かgemini に聞いてみたところ、「activeEditObject」「activeEnvironment」を使用する方法があるとの回答をもらいました。
ただし、Ai としては、「activeEditObject」を推奨するとの事でした

import adsk.core
import adsk.fusion

def is_sketch_mode_active():
    """
    現在スケッチモード（いずれかのスケッチが編集中）かどうかを判定します。

    Returns:
        bool: スケッチモードであれば True、そうでなければ False。
        adsk.fusion.Sketch: アクティブなスケッチオブジェクト（スケッチモードの場合）。
    """
    try:
        app = adsk.core.Application.get()
        
        # 現在編集中のオブジェクトを取得
        active_object = app.activeEditObject

        # 編集中のオブジェクトがスケッチ（Sketch）であるかを確認
        if active_object and isinstance(active_object, adsk.fusion.Sketch):
            return True, active_object
        else:
            return False, None

    except:
        return False, None

# --- 実行例 ---
def run(context):
    ui = None
    try:
        app = adsk.core.Application.get()
        ui = app.userInterface

        is_active, active_sketch = is_sketch_mode_active()

        if is_active:
            ui.messageBox(f'はい、現在スケッチモードです。\nアクティブなスケッチ: {active_sketch.name}')
        else:
            ui.messageBox('いいえ、現在スケッチモードではありません。')

    except:
        if ui:
            ui.messageBox('エラーが発生しました。')

判定で、「isinstance()」関数を使っています。
これは、自力では、なかなか探せなかったと思います。恐るべし、Aiです。

python特有な構文

Aiが出してくれた、サンプルコードを見ると、C言語とは違う書き方が結構出てきます
例えば

return True , active_object

のように、複数変数を返す事ができて、取り出しは、下記のように「,」で区切って利用できるのですね

is_active , active_sketch = is_sketch_mode_active()

C++言語では、最近ではstd::tupleが利用できるみたいですが、それを知らない私は、classを使ったりしていますが、こちらのほうが、面倒ないですね。
「if文」も「三項演算子」と呼ばれている構文が結構使われていました。

design = get_design()
return design.activeComponent if design else None

C言語にも「三項演算子」はありますが、if文のほうが、分かりやすいかも・・
配列系も、多種類があるようで、Aiが出してくれたサンプルでも結構多用しています

plane = plane.lower()
planes_map = {
    "xy": component.xYConstructionPlane,
    "xz": component.xZConstructionPlane,
    "yz": component.yZConstructionPlane
}   
base_plane = planes_map.get(plane)

この「.get(plane)」はなんだ？
と思いましたが、これもAiに聞くと、すぐに説明してくれました。
planes_map[plane]でもアクセスできるようですが、get()を使うとplaneが存在しない場合安全にデフォルト値（Noneまたは指定した値）を返してくれるようです。
本当にすぐに教えてくれるので、私のような独学の場合、参考書などをめくるよりも、言語の理解は数段速くなるでしょうね～

Fusion スクリプトをライブラリ化する

Fusion では、「ユーティリティ」⇒「アドイン」⇒「スクリプトとアドイン」⇒「+」で新規にスクリプトを作成できます

このダイアログの「フォルダの場所」に「名前」に入力のフォルダを作成し、その中に「名前.py」で実行スクリプトが作成されます。
「フォルダの場所」はデフォルトでは、かなり深いので、私は「D:\Fusion360\Scripts」のようにシンプルな場所に変更しています。
また、この場所は、「基本設定」⇒「一般」⇒「API」でデフォルトを変更できます
ただし、ここでの設定箇所に「Scripts」は自動作成されるので、「D:\Fusion360」になります

Fusionスクリプトは、Fusionオブジェクトモデルを介して、利用したいオブジェクトのコマンドを記述します。
したがって、スクリプトを作成するには、各オブジェクトの情報が必要となり、かなり複雑です。

今回は、Pythonの学習も兼ねて、Fusionのスケッチ関連オブジェクトをカプセル化したライブラリを作成したいと思います。

ライブラリの登録場所とpythonでの実装方法

ライブラリフォルダは、Fusionが自動作成する、「Scripts」内の自作スクリプトと同じレベルに登録したいと思います

D:\Fusion360\Scripts
├── 新規スクリプト
├── CenterLine # 自作スクリプト
│ └── CenterLine.py # X,Y,Zの軸のセンターラインを作成する
│
├── library # 作成ライブラリ登録フォルダ
│ ├── _init_.py # 空ファイル（必要らしい）
│ ├── lib_util.py # Component & Sketch 関連関数
│ └── lib_2d.py # 点や直線を作成（今後、円、円弧なども追加予定）

私の環境では、このようなイメージです。
「library」フォルダ内に「lib_util.py」「lib_2d.py」スクリプトを作成
「lib_util.py」は、Component や sketch を提供する基本関数を記述します
「lib_2d.py」は、点や直線を扱う関数を作成しますが、「lib_util.py」の関数も利用します
今回はこの二つのライブラリを利用して、 X,Y,Zの軸のセンターラインを作成する「CenterLine /CenterLine.py」スクリプトを作成します

実行スクリプトと同じレベルのスクリプトをインポートするには？

インポートするコードもわからないので、さっそくAiに聞いてみました
上記の構造をAiに渡して、実行スクリプト「CenterLine.py」から「lib_util.py」の関数を利用するコードを聞いてみました
この場合、正確なディレクトリ構造を取得する事が必要だと言うことで下記コードを教えてもらいました。

current_dir = os.path.dirname(os.path.abspath(__file__))
script_dir = os.path.dirname(current_dir)

この構成はよくライブラリや設定ファイルを相対パスで読み込むときの定番のコードのようです
もう少し、詳しく説明してもらいました。

_file_：現在実行中のPythonスクリプトのファイルパス
os.path.abspath(__file__)：絶対パスに変換
os.path.dirname(…)：そのファイルが属するディレクトリを取得

D:/Fusion360/Scripts/
├── library/
│ └── __init__.py # モジュールの初期化用
│ └── lib_util.py
│ └── lib_2d.py
├── CenterLine/
│ └── CenterLine.py ← 実行スクリプト

__file__ → “./CenterLine/CenterLine.py”
abspath(__file__) → “D:/Fusion360/Scripts/library/CenterLine/CenterLine.py”
current_dir → “D:/Fusion360/Scripts/library/CenterLine”
script_dir → “D:/Fusion360/Scripts/library”

このコードで、ライブラリのディレクトリを取り出し、
「sys.path.append(script_dir)」でpythonが内部でモジュール検索時に、指定ディレクトリを追加するの意味のようです
この設定後に、「from library import lib_util」コードで「library」ディレクトリ内の「lib_util.py」内の関数を使用できるようになります
具体的には、下記になります

import os, sys

current_dir = os.path.dirname(os.path.abspath(__file__))
script_dir = os.path.dirname(current_dir)
sys.path.append(script_dir)
from library import lib_util

これで、新規作成したスクリプトに、このコードを追加すると、「lib_util」内の関数が使えます
さらに「lib_2d.py」ライブラリも、「lib_util.py」の関数も利用しますが、こちらは、「lib_util.py」と同じディレクトリ内なので、「script_dir = os.path.dirname(current_dir)」のコードは不要になりますね

import os, sys
current_dir = os.path.dirname(os.path.abspath(__file__))
# script_dir = os.path.dirname(current_dir)
sys.path.append(current_dir)
import lib_util

実際には結構時間がかかったのですが、これで、やっとライブラリが使えるようになりました。
本当、Ai様様です。
Aiの進歩で、コーディングの勉強は不要だとの意見もありますが、やっぱりコードの意味の理解は必要だと思います。
たぶん、Aiもそう思っているのでしょう！詳しいコメントを日本語で追記してくれます。
「あなたの言葉でコメントつけるから、覚えてね！」と言ってる気がします。
Ai利用でプログラミングの学習速度は、以前よりも圧倒的に速くなると思います

ライブラリ利用方法

./Scripts/
├── 新規スクリプト/ # <——– Fusion ダイアログで作成
│ └── 新規スクリプト.py
├── library/ #<——— Scripts/ 直下に作成
│ └── __init__.py # <—– 空ファイル追加作成、モジュールの初期化用
│ └── lib_util.py # <——- ライブラリファイル
│ └── lib_2d.py # <——- ライブラリファイル
└── CenterLine/ # <——- 自作スクリプト用
│ └── CenterLine.py # <——- 自作スクリプトファイル
└───────

イメージ的には、このようになります。
Fusionで「スクリプトまたはアドイン作成」を実行すると、設定ダイアログが表示され、設定した「フォルダの場所」へ設定した名前のフォルダが自動作成され、さらにその中に、設定した名前.py の実行ファイルが作成されます。

今回紹介のライブラリは、Fusionで設定した「フォルダの場所」の直下に「library」の名前でフォルダを作成し、さらに「library」の直下に、「__init__.py」「lib_util.py」「lib_2d.py」を作成します
「__init__.py」は、空ファイルですが、Aiが言うには、ライブラリを利用する際必要みたいです。
「lib_util.py」「lib_2d.py」も一旦空ファイルを作っておいて、下記コードをコピペして保存します

ライブラリを利用して、X,Y,Zの座標軸にセンターラインを描く

まずは、Fusion 「スクリプトとアドイン」で、新規スクリプトを作成します
ここでは「CenterLine」という名前にしました。
これで、「./Scripts」ディレクトリ内に、「CenterLine/CenterLine.py」が作成されています。
CenterLine.pyファイルの内容を、下記コードで上書きして保存します

CenterLine.py

"""This file acts as the main module for this script."""

import traceback
import adsk.core
import adsk.fusion
# import adsk.cam

import os, sys, importlib
#library import
current_dir = os.path.dirname(os.path.abspath(__file__))
script_dir = os.path.dirname(current_dir)
sys.path.append(script_dir)
from library import lib_util,lib_2d

def run(context):
    try:
        lib_2d.draw_center_line(100,100,100)
 
    except:
        lib_util.disp_message('Failed:\n{}'.format(traceback.format_exc()))

下記が、ライブラリ用スクリプトファイルです

lib_util.py

import adsk.core, adsk.fusion, adsk.cam, traceback
from typing import Tuple, Optional

#このライブラリは
#Fusionが作成するスクリプトと同じディレクトリに置かれる事を想定している
#使用する場合には、下記コードにより読み込みパスを追加する
"""
import os, sys, importlib
current_dir = os.path.dirname(os.path.abspath(__file__))
script_dir = os.path.dirname(current_dir)
sys.path.append(script_dir)
from library import lib_util
"""
# ---------------------
## Get Fusion object
# ---------------------
def get_app():
    return adsk.core.Application.get()
def get_design():
    app = get_app() 
    return adsk.fusion.Design.cast(app.activeProduct)
def get_ui():
    app = get_app() 
    return app.userInterface

# ---------------------
## メッセージ表示
# ---------------------
def disp_message(msg: str):
    """ユーザーにメッセージボックスを表示"""
    ui = get_ui()
    if ui:
        ui.messageBox(msg)

# ---------------------
## Component & Sketch Functions
# ---------------------
# /////////////////////////////////////////////////////////////
def get_root_component() -> Optional[adsk.fusion.Component]:
    """ルートコンポーネントを返す"""
    design = get_design()
    return design.rootComponent if design else None

# /////////////////////////////////////////////////////////////
def get_active_component() -> Optional[adsk.fusion.Component]:
    """現在アクティブなコンポーネントを返す"""
    design = get_design()
    return design.activeComponent if design else None

# /////////////////////////////////////////////////////////////
def create_new_component(name: str = 'New_Component') -> Optional[adsk.fusion.Component]:
    """新しいコンポーネントを作成し、アクティブなコンポーネントの配下に追加"""
    component = get_active_component()
    if not component:
        component = get_root_component()
    
    if not component:
        disp_message('コンポーネントが見つかりません。デザインがアクティブか確認してください。')
        return None
    
    try:
        occurrences = component.occurrences
        new_occurrence = occurrences.addNewComponent(adsk.core.Matrix3D.create())
        new_component = new_occurrence.component
        new_component.name = name
        return new_component
    except Exception:
        disp_message(f'新しいコンポーネントの作成に失敗しました:\n{traceback.format_exc()}')
        return None

# /////////////////////////////////////////////////////////////
def get_parent_sketch(obj: any) -> Optional[adsk.fusion.Sketch]:
    """指定されたオブジェクトの親スケッチを取得"""
    return obj.parentSketch if hasattr(obj, 'parentSketch') else None

# /////////////////////////////////////////////////////////////
def create_new_sketch(name: str = 'New_Sketch', plane: str = 'xy') -> Optional[adsk.fusion.Sketch]:
    """指定された平面に新しいスケッチを作成"""
    component = get_active_component()
    if not component:
        component = get_root_component()
    
    if not component:
        disp_message('スケッチを作成するコンポーネントが見つかりません。')
        return None
    
    plane = plane.lower()
    planes_map = {
        "xy": component.xYConstructionPlane,
        "xz": component.xZConstructionPlane,
        "yz": component.yZConstructionPlane
    }
    
    base_plane = planes_map.get(plane)
    if not base_plane:
        disp_message(f"サポートされていない平面: '{plane}' 'xy', 'xz', 'yz' のいずれかを選択してください。")
        return None
        
    try:
        sketches = component.sketches
        sketch = sketches.add(base_plane)
        sketch.name = name
        return sketch
    except Exception:
        disp_message(f'新しいスケッチの作成に失敗しました:\n{traceback.format_exc()}')
        return None

# /////////////////////////////////////////////////////////////
def is_sketch_mode_active() -> Tuple[bool, Optional[adsk.fusion.Sketch]]:
    """現在スケッチモードがアクティブであるかを確認し、スケッチオブジェクトを返す"""
    app = get_app()
    active_object = app.activeEditObject
    # is_instance() を使うことで、より安全に型チェックを行う
    if isinstance(active_object, adsk.fusion.Sketch):
        return True, active_object
    else:
        return False, None

# /////////////////////////////////////////////////////////////
def get_sketch() -> Optional[adsk.fusion.Sketch]:
    """アクティブなスケッチを返す、アクティブでない場合は新しいスケッチを作成"""
    is_active, sketch = is_sketch_mode_active()
    if not is_active:
        sketch = create_new_sketch()
    return sketch

lib_2d.py

import adsk.core, adsk.fusion, adsk.cam, traceback
from typing import Tuple, Optional

# 利用するlib_utilは、このライブラリと同じディレクトリ
import os, sys, importlib
current_dir = os.path.dirname(os.path.abspath(__file__))
sys.path.append(current_dir)
import lib_util

# ---------------------
## カスタム、点基本クラス
# ---------------------
# /////////////////////////////////////////////////////////////
class kPoint:
    """3D空間の点を表す基本クラス"""
    def __init__(self, x: float, y: float, z: float = 0.0):
        self.x = x
        self.y = y
        self.z = z

# ---------------------
## カスタム、スケッチ点クラス
# ---------------------
# /////////////////////////////////////////////////////////////
class kSketchPoint(kPoint):
    """Fusion 360 のスケッチ点として使用される座標を、単位とスケッチ平面に応じて変換するクラス"""
    def __init__(self, x: float = 0.0, y: float = 0.0, z: float = 0.0, sketch: Optional[adsk.fusion.Sketch] = None, unit: str = "mm"):
        unit = unit.lower()
        # 単位変換係数を辞書で管理
        scale_factors = {"mm": 0.1, "cm": 1.0, "m": 10.0}
        scale = scale_factors.get(unit, 1.0) # 存在しない単位は1.0 (cm) を使用

        if not sketch:
            sketch = lib_util.get_sketch() # スケッチが指定されていなければ、アクティブなスケッチを取得

        # スケッチ平面に応じて座標系を調整 (XZ平面はY軸が下向き)
        # 参照平面が'XZ'の場合は、y座標を反転させる
        # これはFusion 360の座標系の癖に対応
        direction_y = -1.0 if sketch and sketch.referencePlane.name == "XZ" else 1.0
        
        # 単位と座標系による方向を調整
        converted_x = x * scale
        converted_y = y * scale * direction_y
        converted_z = z * scale
        
        super().__init__(converted_x, converted_y, converted_z)
        self.sketch = sketch
        self.unit = unit
        
# ---------------------
## Sketch Geometry Creation Functions
# ---------------------
# /////////////////////////////////////////////////////////////
def is_equal_sketch_points(sp1: adsk.fusion.SketchPoint, sp2: adsk.fusion.SketchPoint, tolerance: float = 0.0001) -> bool:
    """2つのスケッチ点が指定された許容差内で同じ位置にあるかどうかを判断"""
    # ジオメトリオブジェクトの距離を比較
    distance = sp1.geometry.distanceTo(sp2.geometry)
    return distance < tolerance

# /////////////////////////////////////////////////////////////
def create_sketch_point(x: float = 0, y: float = 0, z: float = 0, sketch: Optional[adsk.fusion.Sketch] = None) -> Optional[adsk.fusion.SketchPoint]:
    """指定された座標にスケッチ点を作成"""
    if not sketch:
        sketch = lib_util.get_sketch()
    
    if not sketch:
        lib_util.disp_message('スケッチがアクティブでないか、新しいスケッチの作成に失敗しました。')
        return None
        
    try:
        # kSketchPoint を使用して単位と平面を考慮した座標を取得
        converted_point = kSketchPoint(x, y, z, sketch)
        # adsk.core.Point3D オブジェクトを作成
        point3d = adsk.core.Point3D.create(converted_point.x, converted_point.y, converted_point.z)
        # スケッチに点を追加
        sketchPoint = sketch.sketchPoints.add(point3d)
        return sketchPoint
    except Exception:
        lib_util.disp_message(f'スケッチ点の作成に失敗しました:\n{traceback.format_exc()}')
        return None

# /////////////////////////////////////////////////////////////
def create_line_from_sketchpoints(sp1: adsk.fusion.SketchPoint, sp2: adsk.fusion.SketchPoint, construction: bool = False, fixed: bool = False) -> Optional[adsk.fusion.SketchLine]:
    """2つの既存のスケッチ点から直線を作成"""
    # 同じスケッチに属しているかチェック
    if lib_util.get_parent_sketch(sp1) != lib_util.get_parent_sketch(sp2):
        lib_util.disp_message('2つの点は異なるスケッチに属しています。')
        return None
        
    # 2つの点が同じ位置にあるかチェック
    if is_equal_sketch_points(sp1, sp2):
        lib_util.disp_message('2つの点が同じ位置にあります。直線を作成できません。')
        return None
        
    sketch = lib_util.get_parent_sketch(sp1)
    if not sketch:
        lib_util.disp_message('親スケッチが見つかりません。')
        return None
        
    try:
        line = sketch.sketchCurves.sketchLines.addByTwoPoints(sp1, sp2)
        line.isConstruction = construction
        line.isFixed = fixed
        return line
    except Exception:
        lib_util.disp_message(f'直線（スケッチ点から）の作成に失敗しました:\n{traceback.format_exc()}')
        return None

# /////////////////////////////////////////////////////////////
def create_line_from_coordinate(x1: float, y1: float, z1: float, x2: float, y2: float, z2: float, sketch: Optional[adsk.fusion.Sketch] = None, construction: bool = False, fixed: bool = False) -> Optional[adsk.fusion.SketchLine]:
    """座標から直接、スケッチ直線を作成"""
    if not sketch:
        sketch = lib_util.get_sketch()

    if not sketch:
        return None

    # ヘルパー関数を利用して点を先に作成
    p1 = create_sketch_point(x1, y1, z1, sketch)
    p2 = create_sketch_point(x2, y2, z2, sketch)
    
    if p1 and p2:
        return create_line_from_sketchpoints(p1, p2, construction, fixed)
    else:
        lib_util.disp_message('直線を作成するための点の作成に失敗しました。')
        return None

# /////////////////////////////////////////////////////////////
def create_line_from_points(p1: kPoint, p2: kPoint, sketch: Optional[adsk.fusion.Sketch] = None, construction: bool = False, fixed: bool = False) -> Optional[adsk.fusion.SketchLine]:
    """カスタム `kPoint` オブジェクトからスケッチ直線を作成"""
    if not sketch:
        sketch = lib_util.get_sketch()
    
    if not sketch:
        return None
        
    return create_line_from_coordinate(p1.x, p1.y, p1.z, p2.x, p2.y, p2.z, sketch, construction, fixed)

# /////////////////////////////////////////////////////////////
def draw_center_line(widthX=100,widthY=100,widthZ=100):
    """センターライン作成"""
    widthX = 100 if widthX == 0 else widthX
    widthY = 100 if widthY == 0 else widthY
    widthZ = 100 if widthZ == 0 else widthZ
    wx=widthX/2
    wy=widthY/2
    wz=widthZ/2
    sketch = lib_util.get_sketch()
    xp1 = kPoint(-wx,0)
    xp2 = kPoint(wx,0)
    yp1 = kPoint(0,-wy)
    yp2 = kPoint(0,wy)
    zp1 = kPoint(0,0,-wz)
    zp2 = kPoint(0,0,wz)
    create_line_from_points(xp1,xp2,sketch,True,True) #X Axis
    create_line_from_points(yp1,yp2,sketch,True,True) #Y Axis
    create_line_from_points(zp1,zp2,sketch,True,True) #Z Axis

注意点

実は、まだ解決できていない注意点があります
通常のライブラリ使用では問題ないと思いますが、Fusionでライブラリを利用したスクリプトを実行後、ライブラリ内スクリプトを編集しても、編集内容が反映されません。
Aiに聞いてみると、Fusionの仕様でキャッシュが優先されているとの事です
キャッシュクリアのコードも教えてもらいましたが、現状では反映されません。
ライブラリの編集を反映させるには、Fusionを再起動させるとキャッシュがクリアされ反映されます
ライブラリを試行錯誤している場合でも、ちょっと面倒です。
いい方法は、ないのかなぁ～？？

まとめ

pythonはド素人なので、勉強もかねて、Ai にコーディングを教えてもらいながら、FusionのComponentやsketch、直線作成などの関数をライブラリ化してみました。
Fusionオブジェクトモデルは、広範囲で奥が深いので、探すのも大変です。
よく使いそうな関数を、まとめたので、少しは取り組みやすくなるのではないか？と思っています。
今後も進化させようと思っていますが、Aiがなかったら、ここまで完成できなかったと思います。
ここで紹介しているコードも、一旦自分なりに作成したスクリプトを、Aiに張り付けて、添削してもらったコードを再編集したものです。
関数名やコメントの書き方なども、pythonの慣習を教えてもらい参考にしています

Difyをクローン化

gitの確認

difyをクローン化するのに、「git」を利用するので、「git」のインストール状況を確認します。
windows ターミナルを開き、wsl を起動し、「git -v」で状況を確認します。

PS C:\Users\hogehoge2> wsl

$ git -v
git version 2.43.0
インストールされていない場合には、インストール
$ sudo apt update
$ sudo apt install git

Gitでdifyをクローン化する

「git clone ・・」でクローン化を実行すると、カレントディレクト下「dify」ディレクトリへソースコードがクローン化されます。
windowsターミナルで、「wsl」を実行し、ubuntu環境へ入ると、デフォルトでは、winndowsユーザーのディレクトリへセットされた状態で起動します。
好みの問題だと思いますが、この場所へ「dify」環境を作成してもいいと思いますが、筆者はubuntuのユーザーホームディレクトリ下に作成しようと思います。
wsl、ubuntuプロンプトで、「cd」を実行すると、ユーザーのホームディレクトリへ移動します。
その場所で「git clone・・」すると、そのディレクトリ直下に「dify」さらにその下に「docker」ディレクトリが作成されています。
「ls」コマンドで確認できます。
「dify/docker」ディレクトリへ「cd」コマンドで移動しておきます。
「pwd」コマンドで、現在のディレクトリが確認できます。

hogehoge2@hoge-PC:/mnt/c/Users/hogehoge2$
$ cd
$ git clone https://github.com/langgenius/dify.git
Cloning into 'dify'...
remote: Enumerating objects: 153846, done.
remote: Counting objects: 100% (536/536), done.
remote: Compressing objects: 100% (359/359), done.
remote: Total 153846 (delta 396), reused 178 (delta 177), pack-reused 153310 (from 3)
Receiving objects: 100% (153846/153846), 87.73 MiB | 5.07 MiB/s, done.
Resolving deltas: 100% (111131/111131), done.
$ ls
dify
$ cd dify/docker/
$ pwd
/home/hogehoge2/dify/docker

Difyコンテナ起動

「git clone」を実行したディレクトリに、「dify/docker」ディレクトリが作成されています。
その中に「.env.example」のサンプル環境変数ファイルが作成されています。
通常ファイルは「ls」コマンドで確認できますが。「.」で始まるファイルは表示されません。
その場合「ls -la」コマンドを実行すると、表示されます。
コピーは「cp <オリジナルファイル名>　<複写ファイル名>」で複写できます。
「.env.example」ファイルを、正式な環境変数「.env」としてコピーし、「docker compose」コマンドで、コンテナを起動させます。

$ pwd
/home/hogehoge2/dify/docker
$ cp .env.example .env
$ docker compose up -d
[+] Running 80/80    
✔ web Pulled             149.7s
✔ sandbox Pulled         221.1s
 ✔ ssrf_proxy Pulled      88.2s
 ✔ db Pulled             224.4s
 ✔ worker Pulled         402.2s
 ✔ plugin_daemon Pulled  404.6s
 ✔ nginx Pulled           36.4s
 ✔ weaviate Pulled       225.1s
 ✔ redis Pulled          221.2s
 ✔ api Pulled            402.2s
[+] Running 12/12
 ✔ Network docker_default             Created    0.1s
 ✔ Network docker_ssrf_proxy_network  Created    0.0s
 ✔ Container docker-web-1             Started    3.7s
 ✔ Container docker-ssrf_proxy-1      Started    4.0s
 ✔ Container docker-sandbox-1         Started    3.7s
 ✔ Container docker-redis-1           Started    3.7s
 ✔ Container docker-weaviate-1        Started    3.7s
 ✔ Container docker-db-1              Healthy    10.7s
 ✔ Container docker-worker-1          Started    9.3s
 ✔ Container docker-plugin_daemon-1   Started    9.3s
 ✔ Container docker-api-1             Started    9.5s
 ✔ Container docker-nginx-1           Started    10.0s

docker compose upでエラー発生！AIに聞いてみる。

上記は正常な例ですが、古いPCをテストマシンとして利用した時、「docker compose up」で下記エラーがでた事がありました。

dependency failed to start: container docker-db-1 is unhealthy

この時もgeminiに聞いてみたところ、「docker logs docker-db-1」でログを確認してくれとの事なので、ログを直接貼り付けると、

Ai

ログを見る限り、データベースの初期化自体は正常に完了しています (PostgreSQL init process complete; ready for start up.)。 その後の起動プロセスも進んでいますが、2025-04-29 00:02:07.998 UTC [557] FATAL: the database system is starting up という致命的なエラーが出力されています。

このエラーは、PostgreSQLサーバーが起動してリカバリなどの内部処理を行っている最中に、外部からの接続要求（この場合はおそらくDockerのヘルスチェックや、依存するDifyコンテナからの初期接続試行）があった場合に発生することがあります。

つまり、データベースサーバー自体は最終的に database system is ready to accept connections の状態になりますが、Dockerのヘルスチェックがサーバーの準備が完全に整う前に接続を試み、上記の FATAL エラーを受け取ってしまい、それが原因でコンテナが unhealthy と判定されている可能性が高いです。

解決策:

Dockerのヘルスチェック設定を調整し、データベースが完全に起動して接続可能になるまで、チェックを待つように設定を変更するのが最も有効な対策です。

データベースサービス (db または postgresql) の healthcheck 設定を見つける:
services のセクションにある、データベースコンテナに対応するサービス定義（通常は db という名前）を探します。その中に healthcheck というブロックがあるはずです。

YAML
services:

db: # ... その他の設定 ...
healthcheck: # ここに設定があります
　　・
test: ["CMD-EXEC", "pg_isready -U <db_user> -d <db_name>"] # 例
interval: 10s
timeout: 5s
retries: 5
start_period: 30s # <-- この値を調整します

docker-compose.yml を開く: Difyを起動するために使用している docker-compose.yml ファイルをテキストエディタで開きます。

じじぃ

docker-compose.yamlを確認した所、「start_period:」の設定がありません。

Ai

start_period が指定されていない場合、コンテナが起動を開始すると同時にヘルスチェックが始まります。今回のデータベースのログで見たように、起動直後の一時的な準備期間中に接続を試みると FATAL: the database system is starting up のようなエラーが発生することがあります。

interval: 1s と非常に短い間隔でチェックが実行されるため、データベースが完全に準備できる前に多くのチェックが走ってしまい、すぐにリトライ回数（retries: 60）を使い果たして unhealthy と判定されてしまう可能性が高いです。

解決策:

start_period を追加し、必要に応じて interval も調整しましょう。

1. healthcheck 設定に start_period を追加する: データベースが起動して準備ができるまでの猶予期間として、start_period を設定します。
   例えば 30s または 60s (30秒または60秒) を指定します。
   YAML
   services:
db: # ... その他の設定 ...

healthcheck:
test: [ 'CMD', 'pg_isready', '-h', 'db', '-U', '${PGUSER:-postgres}', '-d', '${POSTGRES_DB:-dify}' ]
interval: 5s # 例: 毎秒ではなく5秒ごとにチェックに緩和
timeout: 3s
retries: 10 # 例: リトライ回数を調整 (intervalを長くすればretriesは少なくても良い)
start_period: 60s # <- この行を追加 (例: 60秒待つ)
   
   ポイント: start_period の間は、ヘルスチェックが失敗してもコンテナは starting 状態のままとなり、unhealthy とは判定されません。start_period が経過した後に初めて、ヘルスチェックの失敗が unhealthy の判定に使われます。
2. interval も少し長めにすることをお勧めします: interval: 1s は開発時などに素早く確認したい場合には便利ですが、本番に近い環境や安定性を重視する場合は 5s や 10s に設定することが一般的です。これにより、データベースへの不要な負荷も軽減されます。
3. docker-compose.yml を保存する。
4. Docker Compose を再起動する: 変更を反映させるために、コンテナを再作成して起動します。

アドバイス通りに、編集して再度「docker compose up -d」を実行すると、正常になりました。
いやぁ～、AIさまさま、ですね～
おそらく、ネット検索では、解決できなかったと思います。
ただし、古いPCだったのが、一番の原因かもしれません。
５年ほど前のPCでは、このエラーはでなかったので、レアなケースかもしれませんが、AIの利用例として紹介しました。

Dify起動

初期画面

「docker compose up」が正常に終了すると、Webブラウザで「http://localhost/install」へアクセスすると「dify」の初期設定が開きます

Difyの動作と試用

とりあえず、起動しました。
以前このサイトでも説明していますが、簡単なチャットボットを作成し試してみます。
LLMモデルはオンラインの「gemini」を登録し、動作を確認できました。
オンラインであれば、「LM Studio」や「Ollama」など、ローカルLLMを利用するアプリは必要ないので、すぐに確認できます。

Difyを自動起動

Difyを動作させるには、Dockerが起動していなくてはいけません。
それには、WSL上で、ubuntuも起動している必要があります。
手動でやる場合、

・windowsターミナル起動
・wslコマンドで、ubuntuターミナル起動
・ubuntuターミナルでカレントディレクトリを、Difyのクローンディレクトリに移動
・「docker compose up -d」 コマンド実行

このような手順が必要ですが、問題なのは、ターミナルを閉じるとdockerも終了してしまうことです
Difyを使うには、dockerが起動していなくてはいけません。
windowsアプリの「docker desktop」であれば、標準で自動起動設定だったと思いますし、起動後もシステムトレイのアイコンで起動が確認できます。右ボタンで状態確認や終了も簡単です。
ubuntu経由の場合には、GUIでの確認ができないので、ここが面倒なところですね～。
自動起動方法をいろいろ調べると、windowsバッチファイルを作成し、スタートアップフォルダに登録する事で、windows起動時に、自動起動できそうです。
ただ、
「コマンドプロンプト　⇒　ubuntuターミナル　⇒　docker」
のタスクが必要で、ターミナルは開いた状態にしておく必要があります。
このようなバッチファイルを作りたいですが、どんなコードにすればいいのか・・？
うまいコードを考え付かなかったので、difyの試しもかねて起動しているチャットボットで設定しているgeminiに考えてもらいました。

@echo off
title Starting Dify via WSL

echo Starting WSL and navigating to ~/dify/docker...
echo Running 'docker compose up -d'...
echo WSL window will remain open after commands.

REM WSLを起動し、bashシェル内でコマンドを実行します。
REM cd ~          : ホームディレクトリに移動 (念のため)
REM cd ./dify/docker : dify/docker ディレクトリに移動
REM docker compose up -d : docker compose をバックグラウンドで起動
REM exec bash     : 上記コマンド実行後、インタラクティブなbashシェルを開始して終了させない
wsl.exe -e bash -c "cd ~/dify/docker && docker compose up -d && echo '--- Dify containers started (or attempted to start) ---' && exec bash"

echo WSL window launched. This batch window can be closed if desired.
REM pause REM Optionally uncomment this line to keep the batch window open until a key is pressed

すごいです。
ほとんど実際の起動には影響がない「REM」や「echo」文がほとんどですが、
「REM」文を使っての説明文や、「echo」での実行中のメッセージにも手抜きがないですね！
このコードをコピーしてエディターで、「start_dify.bat」というファイルで保存しました。
バッチファイルの単独実行では問題ありませんでした。
後はこのファイルのショートカットを、スタートアップフォルダへコピーするだけです。

・上記の作成したバッチファイルを、適当は場所へ保存します
　私は、ユーザーフォルダ「C:\Users\「ユーザー」」へ保存しました。
・次に、このファイルのショートカットを作成します。
・このショートカットを「スタートアップフォルダ」へ保存します。
　スタートアップフォルダは、エクスプローラーのアドレスバーへ「shell:startup」と入力すると開くことができます。

特に必須ではないですが、ターミナルは起動状態にさせるので邪魔になる場合、作成したショートカットファイルを、マウス右ボタンで「プロパティ」を開きます。
「プロパティ」の「ショートカット」タブの「実行時の大きさ」を「最小化」に設定すると、起動時にタスクバーに最小化状態で起動できます。

これで、再起動すると、自動起動したターミナルはタスクバーへ最小化状態ですが、環境によっては起動途中の場合があるので、すぐに使用したい場合には、一度開いてDockerの状態を確認したほうがいいと思います。
正常に起動できると、Webブラウザのアドレスバーに「http://localhost/install」でdifyが起動できます。
場合によっては、「http://localhost/signin」にリダイレクトされる場合もあります

この画面が開くと、ローカルPCでは、Difyを利用する事ができますが、今回はサーバーとして利用したいので、LAN上の別のPCからのアクセスも必要です。

Difyをサーバー化して、他のPCからもアクセスさせる

同じLAN上であっても、「localhost」では、他のPCではアクセスできません。
前回後半で少し話題にしましたが、「windowsホスト」「WSL(ubuntu)」「Docker」と複雑な通信環境なので面倒です。

DifyPCのIPアドレス調査

IPアドレスは、windowsターミナルでは「ipconfig」コマンド
WSLターミナルでは、「ip addr」で確認できます。
この情報を、Aiに添付して聞いてみました。

Ai

詳細な情報ありがとうございます！ipconfig と ip a の結果から状況がより明確になりました。
原因の特定
・Windows ホスト:
　あなたの Windows PC の Wi-Fi アダプターには 192.168.0.94 という IP アドレスが割り当てられています。
　これはご自宅などの LAN 内の IP アドレスです。
・WSL (Ubuntu):
　Windows Subsystem for Linux (WSL) 環境内の Ubuntu には、eth0 インターフェースに 172.31.226.6 という IP アドレスが割り当てられています。
　これは WSL が使用する仮想ネットワーク内の IP アドレスです。

Ai

WSL2 環境で Docker コンテナを動かしている場合、Windows ホストからそのコンテナ内のサービスにアクセスするには、通常以下のいずれかのアドレスを使用します。
１．localhost:
　Windows ホストのブラウザで http://localhost/chat/…と入力する。
　WSL2 は localhost 経由でのポートフォワーディングをサポートしています。
　（これが最も一般的な方法です）
２．WSL の IP アドレス: http://172.31.226.6/chat/…
　(今回アクセスできている方法)

・http://192.168.0.94/chat/… でアクセスできないのは、WSL2 と Docker のネットワークアーキテクチャ上、自然なことです。
サービスが Windows ホストの物理的な IP アドレスに直接公開されているわけではないためです。
・もし、LAN 内の他の PC (例: 192.168.0.100) からもこの Dify 環境にアクセスしたい場合は、追加の設定が必要になる可能性があります:

１．Windows ファイアウォールの設定: Windows のファイアウォールで、外部からのポート 80 (または Dify が使用しているポート) への着信接続を許可する必要があります。
２．ポートフォワーディング (状況による): WSL2 のネットワーク設定によっては、Windows ホストの 192.168.0.94 のポート 80 へのアクセスを、WSL の 172.31.226.6 のポート 80 へ転送する設定が必要になる場合があります。
これは 「netsh interface portproxy」 コマンドなどで設定できますが、まずは localhost や WSL の IP でアクセスできることを確認するのが先決です。

要約:
・Windows ホストからアクセスする場合: http://localhost/chat/… または http://172.31.226.6/chat/… を使用してください。
・http://192.168.0.94/chat/… でアクセスできないのは仕様であり、問題ではありません。

Windowsのアドレスからは、アクセスできない。

じじぃ

http://localhost や http://172.31.226.6 からはアクセスできています。
今回は、LAN上の別のPCからhttp://192.168.0.94 にアクセスしたいため、自分PCで試したら、アクセスできませんでした

Ai

なるほど、LAN上の他のPCからアクセスできるようにしたい、ということですね。承知いたしました。

ご自身のPC (192.168.0.94) から http://192.168.0.94/chat/... にアクセスできなかったのは、まさにその設定がまだされていないためです。Windowsホストのネットワーク(192.168.0.x) と WSL内部のネットワーク (172.31.x.x) は分離されており、外部（LANを含む）から直接WSL内のサービスにアクセスするには、「ポートフォワーディング（ポート転送）」という設定が必要になります。

設定手順

以下の手順を管理者権限で実行してください。

1. Difyが使用しているポートを確認 (重要):
   • まず、DifyがWSL内でどのポート番号で待ち受けているか確認します。HTTPなので通常は 80番 ですが、Dockerの設定によっては異なるポート（例: 3000番など）がホスト(WSL)に公開されている場合があります。
   • Docker Composeを使っている場合は docker-compose.yml ファイルの ports: セクションを確認してください。例えば ports: - "80:80" や ports: - "3000:80" のようになっています。左側の数字がWSL側で公開されているポート番号です。
   • docker ps コマンドを実行しても確認できます。PORTS 列に 0.0.0.0:80->80/tcp や 0.0.0.0:3000->80/tcp のように表示されます。0.0.0.0: の後の数字がWSL側で公開されているポート番号です。
   • 以降の説明では、Difyがポート 80 を使用していると仮定します。もし異なるポート（例: 3000）だった場合は、コマンド内の 80 をその番号に読み替えてください。
2. Windows ファイアウォールでポートを開放:
   • LAN内の他のPCからのアクセスを許可するために、WindowsのファイアウォールでDifyが使用するポート（ここでは80番）を開ける必要があります。
   • 管理者としてPowerShellを開き、以下のコマンドを実行します。
     powershell New-NetFirewallRule -DisplayName "Allow Dify Access from LAN" -Direction Inbound -LocalPort 80 -Protocol TCP -Action Allow
     (もしコマンドプロンプトを使いたい場合は、管理者として開き netsh advfirewall firewall add rule name="Allow Dify Access from LAN" dir=in action=allow protocol=TCP localport=80 を実行)
3. ポートフォワーディングの設定:
   • Windowsホスト (192.168.0.94) のポート80に来た通信を、WSL (172.31.226.6) のポート80に転送するように設定します。
   • 管理者としてPowerShell（またはコマンドプロンプト）を開き、以下のコマンドを実行します。 powershell netsh interface portproxy add v4tov4 listenport=80 listenaddress=0.0.0.0 connectport=80 connectaddress=172.31.226.6
     • listenport=80: Windows側で外部からの接続を待ち受けるポート番号。
     • listenaddress=0.0.0.0: Windowsの全てのIPアドレス（192.168.0.94 を含む）で待ち受ける設定。特定のIP (192.168.0.94) だけを指定することも可能です。
     • connectport=80: 転送先のWSL内でDifyが待ち受けているポート番号。
     • connectaddress=172.31.226.6: 転送先のWSLのIPアドレス。
4. 動作確認:
   • 設定後、まずご自身のPCのブラウザから http://192.168.0.94/chat/84aj9r6azPSYjXt8 にアクセスできるか試してください。 (ポートが80以外の場合は http://192.168.0.94:ポート番号/chat/... のように指定)
   • アクセスできれば、LAN内の他のPCからも同じアドレス (http://192.168.0.94/chat/...) でアクセスできるはずです。

注意点:

• WSLのIPアドレスの変動: WSLを再起動すると、WSLのIPアドレス (172.31.226.6) が変わる可能性があります。もしアクセスできなくなった場合は、ip a コマンドでWSLの新しいIPアドレスを確認し、手順3のポートフォワーディング設定を一度削除して再作成する必要があります。
  • 削除コマンド: netsh interface portproxy delete v4tov4 listenport=80 listenaddress=0.0.0.0
  • 再作成コマンド: (新しい connectaddress を指定して再度実行)
• 管理者権限: ファイアウォールとポートフォワーディングの設定には管理者権限が必要です。
• ポート番号: Difyが使用しているポート番号を正確に確認し、コマンド内の 80 を適宜修正してください。

この手順で、LAN内の他のPCからアクセスできるようになるはずです。試してみてください。

docker ps コマンドで実行中のコンテナーを提出

じじぃ

docker ps では下記になっています。
$ docker ps
・・
・
・

Ai

docker ps の出力結果、ありがとうございます。

コンテナ docker-nginx-1 の PORTS 列にご注目ください。

PORTS
0.0.0.0:80->80/tcp, [::]:80->80/tcp, 0.0.0.0:443->443/tcp, [::]:443->443/tcp

これは、以下のことを意味しています。

• 0.0.0.0:80->80/tcp: WSLホスト（172.31.226.6 など）の ポート 80 (HTTP) へのTCP接続を、docker-nginx-1 コンテナ内部のポート 80 に転送する。
• [::]:80->80/tcp: 上記のIPv6版。
• 0.0.0.0:443->443/tcp: WSLホストの ポート 443 (HTTPS) へのTCP接続を、docker-nginx-1 コンテナ内部のポート 443 に転送する。
• [::]:443->443/tcp: 上記のIPv6版。

docker-web-1 コンテナ自体は内部的にポート 3000 を使っていますが、外部（WSLホスト）からのアクセスは docker-nginx-1 コンテナがポート 80 (HTTP) と 443 (HTTPS) で受け付けています。Nginx がリバースプロキシとして動作し、リクエストを docker-web-1 や docker-api-1 などに振り分けている構成です。

結論

あなたが LAN 上の他の PC からアクセスしたい HTTP のポート番号は 80 です。

したがって、先ほどのポートフォワーディング設定のコマンドは、ポート番号 80 を使って実行してください。

1. ファイアウォール開放 (ポート 80): New-NetFirewallRule -DisplayName "Allow Dify Access from LAN (HTTP)" -Direction Inbound -LocalPort 80 -Protocol TCP -Action Allow
2. ポートフォワーディング設定 (ポート 80):
   powershell netsh interface portproxy add v4tov4 listenport=80 listenaddress=0.0.0.0 connectport=80 connectaddress=172.31.226.6

これで、 http://192.168.0.94 (ポート80は省略可能) でアクセスできるはずです。

もし将来的にHTTPS (https://192.168.0.94) でアクセスしたい場合は、同様にポート 443 用のファイアウォールルールとポートフォワーディング設定を追加する必要があります。

ファイヤーウォールとポートフォワーディング設定

ファイアウォールを開放し、ポートフォワーディング設定をしろ、のアドバイスです。
教わったコードを実行してみます。

１．ファイアウォール開放 (ポート 80):

PowerShell
PS C:\Users\hoge2>　New-NetFirewallRule -DisplayName "Allow Dify Access from LAN (HTTP)" -Direction Inbound -LocalPort 80 -Protocol TCP -Action Allow

コントロールパネル→システムとセキュリティ→windows Defender ファイアウォール→詳細設定
受信の規則で
コマンドで指定したAllow Dify Access from LAN(HTTP)が設定されているのが、確認できます。
コマンドではなく、この画面で、GUI設定する事もできます。

2．ポートフォワーディング設定 (ポート 80):

管理者権限のPowerShell の、「netsh」コマンドで設定します。

PowerShell（管理者）
PS C:\Users\hoge2> netsh interface portproxy add v4tov4 listenport=80 listenaddress=0.0.0.0 connectport=80 connectaddress=172.31.226.6

「netsh interface portproxy show v4tov4」で確認できます。

PS C:\Users\hoge2> netsh interface portproxy show v4tov4
ipv4 をリッスンする:         ipv4 に接続する:
Address         Port        Address         Port
--------------- ----------  --------------- ----------
0.0.0.0         80          172.31.226.6    80

アクセスできた～

これで無事に「http://192.168.0.94/instal」でアクセスできました。
LAN上の別のPCからも、アクセス確認できました。
おそらく、ネット検索では、ここまで的確なアドバイスを見つけるのは至難の業だと思います。
ちょっと前までは、言語生成AIをうまく使うには、プロンプトが重要だと言われていましたが、最近の言語生成AIはかなり言語の理解力が向上していると感じます。
上記のじじぃの質問でもわかりますが、ほとんど「プロンプト」など意識していません。
とにかくわからない事やPCからの出力を、自分の言葉で質問しているだけです。
それでもかなり的確な回答をくれます。
たまには、間違った回答もありますが、それでエラーが発生した場合、そのエラーやログをそのまま突っ込めば、新たな回答をくれます。
すごい時代になりました。

DifyにLLMを設定して、カスタムチャット環境を構築

やっとDifyサーバーが起動できました。

次に、このDifyにLLMモデルを設定することで、チャットボットをはじめカスタムLLMアプリを開発する事ができるようになります。
左図の例では、
一番上の「Gemini」はオンラインで公開されているLLMです。
二番目は、「LM Studio」でダウンロードしたローカルLLMです。
三番目は、「Ollama」で読み込んでいるローカルLLMです。
このように、「Dify」ではオンライン、ローカルあまり意識せず、使用するLLMを自由にカスタマイズできます。

DifyにLLMの設定方法

ネット上でも、多くの情報があると思いますが、このサイトでも以前の記事で紹介しています。

オンラインLLMの登録

ローカルでDifyとLM_Studio を連携させ、ローカルでチャットボットを作る。

LM StudioとDifyをローカルで連携させたのでレポートします。記事を書いている時に、Dify設定にLM Studioのプラグインを発見したので、そちらの設定も追加してます。

www.kazuban.com

2025.03.23

LM Studio モデルの登録

ローカルでDifyとLM_Studio を連携させ、ローカルでチャットボットを作る。

LM StudioとDifyをローカルで連携させたのでレポートします。記事を書いている時に、Dify設定にLM Studioのプラグインを発見したので、そちらの設定も追加してます。

www.kazuban.com

2025.03.23

Ollama　モデルの登録

DifyとOllamaを連携させ、ローカルチャットボット環境を作る

前回はLM StudioとDifyの連携でしたが、今回は、Ollamaと連携させてみました。どちらもそれぞれ特徴があるので、使い分けてもいいと思います。 私的には、スタンドアローンで使うならLM Studio。Difyとの連携であればOllama かな？と思っています。

www.kazuban.com

2025.03.30

あとがき

Windowsアプリ「Docker Desktop」を使わず、「Ubuntu」にインストールした「Docker Engine」で「Dify」をサーバー化する方法を紹介しました。
「Docker Desktop」はWindows環境向けのツールであり、構築の手間は比較的少ないですが、Ubuntuサーバー上で動作させる際は、仮想化環境の設定やネットワーク通信の複雑さが生じるため、トラブルシューティングがやや難しくなります。
今回は、AIのアシストにより、Difyサーバーを構築することができました。
設定プロセスだけでなく、AIを活用した実践例として、このやり取りもご参考にしていただければ幸いです。

インストール

OllamaをWindowsにインストールするには、下記サイトからインストール実行ファイル「OllamaSetup.exe」をダウンロード・実行でインストールできます。

インストール完了後、何事もなく終了ますが、スタートメニューには登録され、タスクバーの「隠れているインジケータ」にアイコンがあれば起動しています。
コマンドプロンプトなどを開いて、「ollama ーーhelp」コマンドで確認してみます。

PS C:\Users\hoge> ollama --help
Large language model runner

Usage:
  ollama [flags]
  ollama [command]

Available Commands:
  serve       Start ollama
  create      Create a model from a Modelfile
  show        Show information for a model
  run         Run a model
  stop        Stop a running model
  pull        Pull a model from a registry
  push        Push a model to a registry
  list        List models
  ps          List running models
  cp          Copy a model
  rm          Remove a model
  help        Help about any command

Flags:
  -h, --help      help for ollama
  -v, --version   Show version information

Use "ollama [command] --help" for more information about a command.
PS C:\Users\hoge>

エラーが出なければ、無事に動作しています。
「ollama ーーversion」でバージョンを確認できます。

PS C:\Users\hoge> ollama --version
ollama version is 0.6.2

モデルをダウンロードして起動

LLMを利用するにいは、公開されているモデルを下記から確認、ダウンロードできます。
https://ollama.com/search
一覧から、利用したいモデル名をクリックすると、さらに「1b」「4b」など、モデルサイズで数種類でてきます。
一般的に小さい方が、性能は低い傾向にありますが、レスポンスはよくなります。
自分の環境で、レスポンスと相談して、大きいモデルがいいと思います。
LM Studio の場合、自分のＰＣスペックとの相性をある程度アイコンで表示してくれますが、Ollamaでは、とりあえず試してみて・・になるのかな～？
LM Studioで体験しておくと、自分の環境でも大丈夫なモデルサイズは察しがつきます。

ターミナルで「ollama run [モデル名]」でダウンロード後実行できます。
モデル名は、ダウンロードサイトのコピーアイコンを利用するとモデル名をクリップボードへコピーできるので便利です。

PS C:\Users\hoge> ollama run gemma3:4b
pulling manifest
pulling aeda25e63ebd... 100% ▕███████████▏ 3.3 GB
pulling e0a42594d802... 100% ▕███████████▏  358 B
pulling dd084c7d92a3... 100% ▕███████████▏ 8.4 KB
pulling 3116c5225075... 100% ▕███████████▏   77 B
pulling b6ae5839783f... 100% ▕███████████▏  489 B
verifying sha256 digest
writing manifest
success
>>> 始めまして
はじめまして！こちらこそ、ご挨拶ありがとうございます。

何か私にできることはありますか？ 例えば、

*   何か質問に答える
*   文章を作成する
*   アイデアを出し合う
*   ただおしゃべりする

など、どんなことでも構いません。😊

>>> Send a message (/? for help)

「>>> Send a message (/? for help)」のプロンプトがでると、会話ができます。
会話の終了は「/bye」です。

Difyとの連携

前回、「LM Studio」との連携で、LM Studioプラグインの設定方法と、ほとんど同じです。

「設定」の「モデルプロバイダー」から「Ollama」プラグインをインストールします。
インストールが完了したら、再度「設定」の「モデルプロバイダー」「Ollamaモデル」に「モデルを追加」で上記でダウンロードしたモデルと「URL（ＩPアドレス）」を設定します。
ダウンローズ済みモデルは、ターミナルから「ollama list」コマンドで確認できます

PS C:\Users\hoge> ollama list
NAME           ID              SIZE      MODIFIED
llama3.2:1b    baf6a787fdff    1.3 GB    8 minutes ago
gemma3:4b      c0494fe00251    3.3 GB    26 minutes ago
PS C:\Users\hoge> ollama run llama3.2:1b
>>> /bye
PS C:\Users\hoge>

また、「Base URL」は「ollama」が動作している、PCの「IPアドレス」に「:11434」のポート番号を付加して設定します。
ただし、URLがLAN上の他のPCのIP（localhost以外の場合）でエラーが発生してしまう場合、下記の「環境変数の編集」を試してみてください。
正常に「保存」が終了すると、前回記事の「LM Studio」の場合と同様に、Difyで利用するモデルとして選択できるようになります。

Windows 環境変数の編集

「Ollama」の環境変数について、geminiに聞いて、下記回答をもらいました。

Ollamaの環境変数についてですね。Ollamaは、ローカルで大規模言語モデル（LLM）を実行するためのツールであり、いくつかの環境変数を使用してその動作をカスタマイズできます。主な環境変数は以下の通りです。

• OLLAMA_HOST:
  • Ollamaがリッスンするホストアドレスを指定します。デフォルトは127.0.0.1であり、ローカルマシンからの接続のみを受け付けます。ネットワーク上の他のマシンからOllamaにアクセスできるようにするには、この変数を0.0.0.0に設定します。
• OLLAMA_MODELS:
  • モデルの重みを保存するディレクトリのパスを指定します。デフォルトでは、Ollamaは特定のデフォルトディレクトリにモデルを保存しますが、この変数を使用して別の場所を指定できます。これにより、モデルファイルを別のドライブやディレクトリに保存することができます。
• OLLAMA_ORIGINS:
  • クロスオリジンリクエストを許可するオリジンを指定します。OLLAMA APIをWebアプリケーションから利用する場合に設定します。
• OLLAMA_DEBUG:
  • デバッグモードを有効にします。Ollamaのデバッグ情報を表示する場合に設定します。

これらの環境変数を設定することで、Ollamaの動作を柔軟に制御できます。環境変数の設定方法は、オペレーティングシステムによって異なります。

• Windows:
  • 「システム環境変数の編集」から設定します。
• macOS / Linux:
  • ターミナルからexportコマンドを使用して一時的に設定するか、.bashrcや.zshrcなどのファイルに記述して永続的に設定します。また、サービスとしてOllamaを実行している場合は、systemdの設定ファイルに環境変数を記述します。

より詳細な情報や具体的な設定方法については、Ollamaの公式ドキュメントや関連するオンラインリソースを参照することをおすすめします。

他のサイトをみると、環境変数を設定しないでも、正常に動作しているような記事も見かけましたし、「OLLAMA_HOST」だけ設定している記事もありました。
筆者の場合も、「OLLAMA_HOST」だけで正常に動作ましたが、「OLLAMA_ORIGINS」も設定しました。
また、「OLLAMA_MODELS」を設定すると、デフォルト（Cドライブ）以外にモデルを保存できます

Ollama用、環境変数の追加

環境変数を行う前には、「ollama」は終了しておきましょう。
タスクバー右の「^」ボタン「隠れているインジケーター」から、Ollamaアイコン右クリック「Quit Ollama」でも終了できます。
Windows検索バーに「環境変数」と入力すると「システム環境変数の編集」が見つかるので、「環境変数」ボタンをクリックして上段の「ユーザー環境変数」の「新規」で環境変数を追加します。

OLLAMA_HOST : 0.0.0.0
OLLAMA_ORIGINS : *
OLLAMA_MODELS : D:\Ollama_Models

ただし、「OLLAMA_MODELS」の設定は、注意が必要です。
環境変数追加前に、ダウンロードしたモデルは、自働的には移動してはくれません。
再度、ダウンロードするか、デフォルトでは
「C:\Users\[ユーザー]\.ollama\models」の下に登録されているので、環境変数変更前に指定フォルダへコピーしておくと、反映されると思いますが、試してはいません。
環境変数変更後でも、Ollamaを起動する前に、設定したフォルダへ移動してもいいかもしれません。
環境変数の編集が適応されているかは、下記で確認できます。
コマンドプロンプトとPowerShellで指令が違うので注意してください。

★コマンドプロンプト
C:\Users\hoge>echo %OLLAMA_HOST%
0.0.0.0

C:\Users\hoge>echo %OLLAMA_MODELS%
D:\Ollama_Models

C:\Users\hoge>echo %OLLAMA_ORIGINS%
*

★PowerShell
PS C:\Users\hoge> $env:OLLAMA_HOST
0.0.0.0

PS C:\Users\hoge> $env:OLLAMA_MODELS
D:\Ollama_Models

PS C:\Users\hoge> $env:OLLAMA_ORIGINS
*

Dify にもモデルを登録する

モデルフォルダを変更した場合には、「ollama list」コマンドで確認できます。
正常に変更されていれば、再度「Olama」を起動して、「Dify」の「Ollama」モデルのプラグイン設定で追加できるようになります。
追加方法は、LM Studio 編を参考にしてください。

追加したモデルは、Difyで作成するアプリから、ollamaを利用できるようになります。

あとがき

これで、完全ローカルで、DifyからOllamaも利用できるようになりました。
筆者の環境では、「Windows環境変数の編集」が必要だったので、少し戸惑いましたが、どうにか利用できるようになりました。
LM Studioがいいのか？Ollamaがいいのか？は、自分の環境や使い勝手で使い分けてください。
選択肢があるというのは、いいことだと思います。
さぁ、いよいよ、Difyの勉強を始められる環境は出来上がりましたが・・・・
ちょっと、Docker Desktop の環境なのが気になっています。
WSLでUbuntu24.04を起動させた環境か、現在稼働中のLinuxマシンか・・・
いずれにしても、linux環境で立ち上げてみたくなってきました。

Difyで簡単なチャットボット作る

まずは、Difyで一番簡単なチャットボットを作成する流れを説明します。
前回までで、Difyをインストールして「http://localhost/install」でアカウント作成を行いました。
ログインすると、「最初から作成」でアプリが作成できるようになります。

とりあえずチャットボットを選択し、「アプリのアイコンと名前」と「説明」は任意で入力します
「作成する」で、次の画面へ進みます。

ここで、右上の設定から、使用したいモデルを選択する事で、このモデルと会話するチャットアプリが作れますが、事前に使用するLLMモデルの登録が必要です。
ここでは、事前にオンラインのgeminiモデルを登録しておいたので、geminiの複数モデルが選択できるようになっています。
違うモデルで何種類か作成し公開すれば、簡単に違うモデルと会話できるアプリが作成できます。
ただしこれは、ローカルではなくオンライン環境になります。
ここで、LM_Studioで動作させてさせている、ローカルLLMを登録すれば、ローカルLLMと会話できるようになります。

モデルを登録する

Difyはとても機能が多く非常に興味的なアプリなので、筆者ももう少し取り組んでみたいと思っていますが、まずはローカル環境でいろいろ試せる環境を作ります。

オンラインLLM gemini の登録

まずは、ローカルではないですが、Googleのgeminiを利用してみます。
利用するには、geminiプラグインのインストールが必要です。
プラグインは、右上のユーザー名から出てくるプルダウンで「設定」を選択すると、
左サイドに「設定」の項目が表示されます。
その下段のモデルプロバイダーで登録します

インストールしたいモデル（今回は、Gemini）を探してインストールします。
インストールは私の環境では結構時間がかかりました。
インストール中でも画面にあまり変化がないので完了したタイミングを見逃しがちですが、
右上のプラグインアイコンがこの状態は、インストール中です
完了するとこのアイコンになりますので、待ちます。
次に、インストール後Geminiを使用するには、API-KEYのセットアップが必要です。

APIキーが正常に設定されると、「右上のユーザ」⇒「設定」⇒「モデルプロバイダー」で設定済みのモデルとして表示されます。

ただし、私の環境では、正常に設定できたとメッセージがでたのに、ここに表示されていない事がありました、その場合、もう一度モデルプロバイダー一覧から再度インストールすると表示されました。
この場合、インストール時間は殆どかかりません。
これで、上の例のように、使用モデルとして選択できるようになります。

ローカルLLM LM Studio の登録

Geminiはオンラインクラウド上のLLMですが、いよいよローカルLLMと連携させます。

LM Studio をサーバーモードにする

DifyとLM Studioを連携するには、まず、LM Studioをサーバーモードで動作させます。
まず左サイドバーのDeveloperアイコンで、開発者モードに入り、

その横のスイッチで「Static Running」状態に設定すれば、サーバーモードで動作しています。
次に、Difyに提供する、モデルを「Select a model load」でダウンロード済みのモデルから選択します。
２個のモデルをロードしてみました。

この状態であれば、Difyでロードしたモデルを使用できるようになります。
ただし、LM Studioをクローズすると、モデルも使用できなくなってしまいます。
右下の歯車マークで設定画面に入り

「Enable Local LLM Service」にチェックすれば、クローズしてもサーバー状態を維持します。

DifyでLM Studio のモデルを利用する

この記事を書いている時に自分でも再作業をしていたら、「LM Studio」用のプラグインが公開されているのに気が付きました。
これから説明する「OpneAI-API-compatible」よりも、わかりやすそうです。
たぶん公開は最近だと思うので、不具合がないとも言えませんが、もし、こだわりがなければ、「LM Studio」プラグインの方が簡単だと思います

ここでは、書き始めていた「OpneAI-API-compatible」の説明を行います。
geminiの時と同様に、「モデルプロバイダー」の「設定」で対応しているプラグインをインストールします。
LM Studioが利用するには「OpneAI-API-compatible」をインストールします。

インストールが完了したら、「モデルを追加」で、モデル名と
LM Studio サーバーの「URL」＋「/V1」を設定します。

モデル名とLM Studio のURL は、「LM Studio」の画面から、「コピー」アイコンで、クリップボードへコピーすれば、ペーストできます。
ただし、「API endpoint URL」は「URL」の後ろに「/V1」が必要です。
「/V1」がなくても、正常に保存できる場合がありますが、実際にチャットする時にエラーになりますので忘れないでください。
「LM Studio」に何種類がモデルがロードされている場合、ここでも複数設定しておくと、Dify側で複数のモデルを使分ける事ができます

LM Studio サーバーのモデル使用

ここまで完了すると、Dify側でのモデル選択で利用できるようになっています。
上記の「gemini」モデル一覧の下に、追加されているので、ここで選択する事でつかえるようになります。

LM Studio のモデルプロバイダーが追加されてる・・・

この記事を書いていて、Difyを触っていて気が付いたのですが、「モデルプロバイダー」一覧に「LM Studio」が入っていました。

筆者が見落としていただけなのか？ちょっと前にはなかったと思います。
そういう理由で、「OpneAI-API-compatible」を利用したのですが、「LM Studio」のほうが、名前からして分かりやすいですね。
試しに、インストールしてみたところ、問題なく使用できました。
ただ、「OpneAI-API-compatible」では、「API endpoint URL」で、「LM Studioサーバー」の「URL」とその後ろに「/V1」が必要でしたが、こちらは「Base URL」の設定項目で「URL」のみでOKです。
この設定も、わかりやすいです。

あとがき

ついに、ローカル上で、ローカル上のLLMモデルを利用した、チャットアプリ開発環境が完成しました。
企業で使うには、ライセンスの確認も必要ですし、動作させるPCのスペックは大きくなると思いますが、個人や少人数で使う場合、簡単に試しながら、気軽にDifyの学習ができるようになります。

LM Studio、ChatGPTのような大規模言語モデル（LLM）をローカルで簡単に動かせる時代が来た

LM Studio を体験してみました。 簡単に、ローカルPCでAiとチャットできます。 機密性の情報を扱う場合には、ローカルなので安全性は高まります 文章を要約したり、レポート作成してもらったり、正確な回答が必要でない場合には、使えそうです。 プログラムなど正確性が必要な場合には、オンラインのほうがよさそうです。

www.kazuban.com

2025.01.01

Difyは、チャットボットなど、AIアプリを比較的簡単に作成する事ができるアプリですが、LM Studioと連携する事で、ローカルでのチャットボットが作れそうです。
今回は、まずDifyを起動させてみました。
Difyの詳しい使用方法は、ネット上に沢山情報があるので、検索してみてください。
筆者もこれから触ってみて、記事にできそうであれば、レポートしたいと思います
Difyの立ち上げはそれほど難しくはないですが、ちょっと余計な事して、思うように動作せず、かなり悩んでしまったので、覚書かねて、レポートします。

Difyをローカルで立ち上げる

Difyは、クラウド上にも、Webアプリサービスが提供されており、サブスクで利用することもできますhttps://cloud.dify.ai/signin
ただ、オープンソースも公開されており、個人PCでクローン化すれば、無料で制限なく使用できますが、通常のwindowsインストールとは、ちょっと違う作業が必要です。

• 「WSL2」環境の構築
• 「Git」のインストール
• 「Docker　Desktop」のインストール
• 「Docker」で「Dify」をクローン化して利用可能にする

もともとは、Linux環境で開発されたソフトウェアなので、通常のWindowsアプリをインストールするよりも、コマンド作業も出てくるので、戸惑う事もありますが、一ステップずつやっていけば、意外と簡単です。

WSL2インストール

Linux 用 Windows サブシステム 機能の有効化

「Docker」は「Windows Subsystem for Linux」上で動作するので、WSLの環境が必要です。
最近のPCであれな、デフォルトで有効になっているのかもしれませんが、古い場合事前の設定が必要です。
WSLの環境ができていなくても、機能が有効になっていれば「Docker Desktop」のインストーラがやってくれますが、警告メッセージや更新作業などの要求がでる場合があるので、事前にWSL環境を作っておいたほうがいいと思います。

WSLの環境ですが、古いマシンの場合、場合よっては、BIOSでの仮想マシン有効設定が必要な場合もあるようです。
古いマシンを利用する場合には、事前に調査しておいたほうがいいと思います。
BIOS的に、仮想マシンが有効であれば、

コントロールパネル　⇒　プログラム　⇒
　　　　⇒　「プログラム機能：windowsの機能の有効化または無効化」

で、「Linux用Windiwsサブシステム」と「仮想マシンプラットフォーム」にチェックをいれます、

「OK」ボタンを押すと、自動的に必要なファイルを検索し、構築してくれます。
作業が終了したら、WIndowsを再起動します。

WSL更新

再起動後は、「コマンドプロンプト」でアップデートしておきます。

C:\Users\hogehoge>wsl --update
更新プログラムを確認しています。
Linux 用 Windows サブシステムをバージョンに更新しています: 2.4.12。

Git のインストール

「Git」は、Windowsのインストーラが用意されているので、比較的簡単にインストールできます。
こちらにアクセスし、「Click here to download 」でダウンロードして実行します。
いろいろ選択するダイアログが出てきますが、私はダウンロード先を「Dドライブ」に変更しただけで、すべてデフォルトでインストールしました。

Docker Desktopインストール

「Docker」は、複数の開発環境を、パッケージにしてアプリを実行できるアプリです。
環境ごとに、ハードウェアを用意する必要がないので、特に開発側ではよく使われているようです。
Difyを動かすには、「Dify」環境を「Docker」内でパッケージ化して、動作させます。
「Docker Desktop」は、Windowsインストーラも用意されているので、比較的簡単にインストールできます。
ただし、完全無料ではありません。
下記を超える規模の企業で利用する場合、利用回数制限やサブスク型有料になります。

個人・従業員250人未満かつ年間収益1,000万ドル以下の企業

実際の動作環境は、裏で「Docker Engine」が働いているようで、こちらだけであれば、オープンソースで公開されています。
ただし、こちらは、Linuxでのコマンド操作が必要になりそうです。
ちょっと興味もありますが、まずは「Docker Desktop」で進めます

インストール

こちらに、アクセスし、「Download Docker Desktop」から「Download for Windows-AMD64」をダウンロードし実行ます。
Windowsの警告などのメッセージがでる事もありすが、許可すると確認の画面が出てきます
「OK」でインストールが始まります。

終了すると、再起動要求がない場合には不要かもしれませんが、念のため再起動しておきましょう。
Windowsが再起動すると、上記の「Configuration」⇒「Add shortcut desktop」にチェックを入れておいた場合、デスクトップに「Docker」のショートカットが作られていると思います。
もし作られていない場合、PCの環境が管理者権限を必要としているかもしれません。
通常は、ショートカットのアイコンで起動できますが、作られていない場合、タスクメニューからでも起動できます。
ただし、ショートカットが作られなかった場合、管理者権限で実行しないと、正常に起動しない場合もあります。
管理者権限での起動の場合、下記の説明と違ってくるかもしれませんので、ご了承ください。

セットアップ

最初の起動では、タコやクジラのイラストの画面が立ち上げります。

これは、上記でも少し説明した、ライセンスに関しての注意事項です。
個人使用や指定規模未満の企業であれば「Accept」で次へ進みます。

「Welcom_to_Docker」と「Welcom Survey」は「Skip」でも大丈夫です。
無事に次に進むと、「Containers」の説明などへのリンクが表示されます。
これで、「Docker Desktop」のインストールは完了しています。
次にいよいよ、「Dify」をクローン化して使えるようにしていきます。
クローン化は、ターミナルでコマンドを入力して実行しますが、「コマンドプロンプト」や「PowerShell」を開いてもいいし、最後の画面右下の「>_Terminal」も利用できます。

Difyのインストール

「Docker」を使って「Dify」を起動させるには、次の操作を行います

• GitHub に公開されている dify プロジェクトのソースコードをダウンロードし、複製する。
• Docker Composeというツールを使って複製されたアプリの構築と起動する。

GitアプリでGithubで公開されている、difyのコードをクローン化する

「PowerShell」などのターミナルを開き、次のコマンドを実行します。

git clone https://github.com/langgenius/dify.git

このコマンドを実行すると、カレントディレクトリに、「dify」、さらにその下に「docker」ディレクトリが作成され、「docker」内に、difyがクローン化されます。

★ここで、失敗談

カレントディレクトリと言う考えが良くなかったようで、カレントに入るのであれば、カレントを変更すれば、Dドライブなどにもインストールできるな！
と、勝手に思ってしまいました。
通常のアプリのインストールでも、なるべくCドライブへは入れないようにしています。
試しに、クローン化前に、ターミナルから「ch」コマンドでカレントディレクトリを変更し、やってみたところ正常にクローン化され、その後の「Docker Compose」も「Dify」も正常に動作しているように見えました。
しかし、Difyを触っていて、LLMの「APIキー」の認証がうまくいきませんでした。
「Dify」の動作自体は正常だったので、「APIキー」の認証方法が悪いのか？と結構悩みましたが、デフォルトの設定がWindowsでログインしているユーザーのホームディレクトリを想定しるとすれば、「APIキー」がうまく書き込めない可能性も考えられます。
設定用のYAMLファイルや、環境変数を編集する事で、正常にできそうではありますが、慣れないうちは、ログインユーザーフォルダでの作業がよさそうです。

それでは、ターミナルを開いた状態で、クローン化していきます。

PS C:\Users\hoge> git clone https://github.com/langgenius/dify.git
Cloning into 'dify'...
remote: Enumerating objects: 146709, done.
remote: Counting objects: 100% (800/800), done.
remote: Compressing objects: 100% (440/440), done.
Receiving objects:  5% (7336/146709), 3.07 MiB | 6.10 MiB/s, done.
Receiving objects:  6% (8803/146709), 3.07 MiB | 6.10 MiB/s, done.
            ・ 
            ・ 

これで、「C:\Users\hoge」直下に「dify」、さらにその下に「docker」ディレクトリが作成され、その中に必要なファイル群が作成されてます。
作成されたファイル群には、環境ファイルのサンプルも入っているので、そのファイルをコピーし、必要あれば、編集して、アプリのパッケージ（コンテナ）を生成します。
まずディレクトリを「dify\docker」に移動し、その中に作成されている、サンプル環境変数を正式な環境変数としてコピーし、「docker compose」コマンドで、コンテナを起動させます。

環境ファイルサンプル「.env.example」を、「.env」の名前でコピーし
「docker compose」コマンドで、コンテナを操作します

PS C:\Users\hoge>cd dify\docker
PS C:\Users\hoge\dify\docker> copy .env.example .env
PS C:\Users\hoge\dify\docker> docker compose up -d

ちなみに、AIに「docker compose up」は何者なのか？聞いてみました。

docker compose up -d コマンドは、Docker Compose ファイルに従って、コンテナをデバッグモードで起動・実行するコマンドです。
解説:
docker-compose: Docker Compose を使うためのツール。複数のコンテナとそれらの依存関係を管理するためのファイル（docker-compose.yml）を読み込み、その定義に基づいてコンテナを操作します。
up: Docker Compose ファイルに従ってコンテナを起動するコマンドです。
-d: デバッグモードで実行することを意味します。このオプションを使えば、コンテナがバックグラウンドで動作し、ターミナルからは出力されなくなります。
docker compose up -d を実行すると:
docker-compose.yml ファイルを読み込みます。
定義されている各サービス (アプリケーション) のためのコンテナを起動します。
サービス間の依存関係を自動的に解決し、必要な順序でコンテナを立ち上げます。
バックグラウンドでコンテナが動作を開始します。
使用例:
docker-compose.yml ファイル内に複数のアプリケーションが定義されており、それらが互いに連携して動作する場合に便利です。例えば、ウェブサーバーとデータベースの連携などを設定する際に役立ちます。

らしいです。
さて、正常に完了すると、Webブラウザで下記アドレスにアクセスすると、Difyが起動します。

http://localhost/install

Difyが動き出した

やっと動き出しました。
いらん事しなけりゃ、簡単でしたが、結構悩んでしまいました。
Difyは、まだ触り始めですが、チャットだけでなく、AIを利用したいろいろなアプリを自分で作成きそうです。
次は、DifyとLM Studioを連携させて、ローカルLLMでのチャットボットを作ろうと思います。
ローカルであれば、セキュリティ的なリスクもかなり少なりますし、オンラインLLMを使用する場合の制限や課金も抑える事ができると思います。