던전앤파이터 시세 예측[3]

목표 : 10분 마다 예측시세를 마리아db donpa_item1테이블 에 저장한다!!

 

1. 10분 후의 가격 정보 마리아db에 넣는 코드

import pymysql

# 연결 정보 설정
host = "10.109.90.46"
port = 3306
database = "donpa_item"
user = "root"
password = "1234"

# 연결
connection = pymysql.connect(
    host=host,
    port=port,
    user=user,
    password=password,
    database=database
)


# 연결 성공 여부 확인
if connection:
    print("마리아DB에 연결되었습니다.")

    
item_name = item_name  # 변수 값

# item_img, item_name, price 컬럼 값 설정
item_img = "https://img-api.neople.co.kr/df/items/8b998230ab012e695e9a53d67187cc3f"
price = predicted_unitPrice

# 쿼리 생성
update_query = f"""
    UPDATE donpa_item1
    SET price = {price}, item_img = '{item_img}'
    WHERE item_name = '{item_name}'
"""

insert_query = f"""
    INSERT INTO donpa_item1 (item_name, item_img, price)
    VALUES ('{item_name}', '{item_img}', {price})
"""

# 데이터베이스 작업 수행
try:
    with connection.cursor() as cursor:
        cursor.execute(update_query)  # item_name 값이 있는 경우 업데이트 시도
        if cursor.rowcount == 0:
            cursor.execute(insert_query)  # item_name 값이 없는 경우 새로운 행 추가
    connection.commit()  # 변경 내용을 커밋
    print("데이터베이스 작업 완료")
except Exception as e:
    print("데이터베이스 작업 중 에러 발생:", e)
    connection.rollback()  # 에러가 발생한 경우 롤백

# 연결 종료
connection.close()

 

2. 마리아db 데이터 확인하는 코드

import pymysql
import pandas as pd

# 연결 정보 설정
host = "10.109.90.46"
port = 3306
database = "donpa_item"
user = "root"
password = "1234"

# 연결
connection = pymysql.connect(
    host=host,
    port=port,
    user=user,
    password=password,
    database=database
)

# 연결 성공 여부 확인
if connection:
    print("마리아DB에 연결되었습니다.")

# SQL 쿼리
query = "SELECT * FROM donpa_item1"

# 데이터프레임으로 변환
try:
    df = pd.read_sql(query, connection)
except Exception as e:
    print("데이터베이스 작업 중 에러 발생:", e)

# 연결 종료
connection.close()
df

들어간 것을 확인

 

 

3. 여태 까지 해왔던 것을 토대로 나머지 9개의 데이터도 최종적으로 10분뒤 가격을 예측해 마리아db에 저장해보자

1. 균열의 단편 >>> donpa_data.csv

2. 무결점 라이언 코어 >>> donpa_data1.csv

3. 무결점 조화의 결정체 >>> donpa_data2.csv

4. 무색 큐브 조각 >>> donpa_data3.csv

5. 무결점 골든 베릴 >>> donpa_data4.csv

6. 힘의 정수 1개 상자 >>> donpa_data5.csv

7. 모순의 결정체 >>> donpa_data6.csv

8. 초전도 에너지 코어 상자[1회 교환가능] >>> donpa_data7.csv

9. 진정한 각성을 이룬 자 >>> donpa_data8.csv

10. 왜곡된 차원의 큐브[교환가능] >>> donpa_data9.csv

 

first_csv 틀

from pyspark.sql import SparkSession
from pyspark.sql.functions import col
from pyspark.sql.types import DoubleType
from pyspark.sql.functions import current_timestamp
from pyspark.sql.functions import year, month, dayofmonth, hour
from pyspark.sql.functions import concat_ws, lit, to_timestamp
import requests

# 스파크 세션 생성
spark = SparkSession.builder \
        .master("yarn") \
        .config("spark.sql.legacy.timeParserPolicy", "LEGACY") \
        .appName("DataProcessing") \
        .getOrCreate()

# API 엔드포인트 URL
api_url = "https://api.neople.co.kr/df/auction-sold"

# 파라미터 설정
params = {
    "itemName": "균열의 단편",
    "wordType": "match",
    "wordShort": "false",
    "limit": 10,
    "apikey": "JUG54ELPbKttanbis2VPFNqC9LJOM7v4"
}

# GET 요청 보내기
response = requests.get(api_url, params=params)

# 응답 데이터 확인
if response.status_code == 200:
    data = response.json()
    # 데이터 처리 및 출력
    #print(data)
else:
    print("API 요청 실패:", response.status_code)

test1 = data.get("rows")
formatted_data = [{"soldDate": row["soldDate"], "itemName": row["itemName"], "unitPrice": row["unitPrice"]} for row in test1]

# 데이터프레임 생성
df = spark.createDataFrame(formatted_data)

# 불필요한 컬럼 제거
df = df.drop("soldDate")

# 수집한 시간 컬럼 추가
df = df.withColumn("now_time", current_timestamp())

# now_time 컬럼을 timestamp 형식으로 변환
df = df.withColumn("now_time", col("now_time").cast("timestamp"))

# unitPrice 컬럼을 숫자 형식으로 변환
df = df.withColumn("unitPrice", col("unitPrice").cast(DoubleType()))

# 시간이 같은 항목들의 unitPrice를 평균으로 합치기
grouped_df = df.groupBy(year("now_time").alias("year"),
                        month("now_time").alias("month"),
                        dayofmonth("now_time").alias("day"),
                        hour("now_time").alias("hour"),
                        "itemName").avg("unitPrice").withColumnRenamed("avg(unitPrice)", "unitPrice")

grouped_df = grouped_df.withColumn("now_datetime",
                                   to_timestamp(concat_ws("-", "year", "month", "day", "hour"), "yyyy-MM-dd-HH"))

grouped_df = grouped_df.drop("year", "month", "day", "hour")

# 원하는 순서로 컬럼 선택
grouped_df = grouped_df.select("now_datetime", "itemName", "unitPrice")

csv_path = "donpa_data.csv"
grouped_df.write.csv(csv_path, header=True, mode="overwrite")

# 스파크 세션 종료
spark.stop()

print("데이터를 CSV 파일로 저장했습니다.")

아이템 이름이랑 csv_path를 바꿔줘야됨

 

 

 

donpa_data_sava_csv틀

from pyspark.sql import SparkSession
from pyspark.sql.functions import col
from pyspark.sql.types import DoubleType
from pyspark.sql.functions import current_timestamp, year, month, dayofmonth, hour
from pyspark.sql.functions import concat_ws, lit, to_timestamp
import requests
import os

# 파이썬 스크립트 내에서 외부 명령어를 실행하고 그 결과를 처리하는 기능
import subprocess

# 스파크 세션 생성
spark = SparkSession.builder \
        .master("yarn") \
        .config("spark.sql.legacy.timeParserPolicy", "LEGACY") \
        .appName("DataProcessing") \
        .getOrCreate()

# API 엔드포인트 URL
api_url = "https://api.neople.co.kr/df/auction-sold"

# 파라미터 설정
params = {
    "itemName": "균열의 단편",
    "wordType": "match",
    "wordShort": "false",
    "limit": 10,
    "apikey": "JUG54ELPbKttanbis2VPFNqC9LJOM7v4"
}

# GET 요청 보내기
response = requests.get(api_url, params=params)

# 응답 데이터 확인
if response.status_code == 200:
    data = response.json()
else:
    print("API 요청 실패:", response.status_code)

test1 = data.get("rows")
formatted_data = [{"soldDate": row["soldDate"], "itemName": row["itemName"], "unitPrice": row["unitPrice"]} for row in test1]

# 데이터프레임 생성
df = spark.createDataFrame(formatted_data)

# 불필요한 컬럼 제거
df = df.drop("soldDate")

# 수집한 시간 컬럼 추가
df = df.withColumn("now_time", current_timestamp())

# now_time 컬럼을 timestamp 형식으로 변환
df = df.withColumn("now_time", col("now_time").cast("timestamp"))

# unitPrice 컬럼을 숫자 형식으로 변환
df = df.withColumn("unitPrice", col("unitPrice").cast(DoubleType()))

# 시간대 같은 항목들의 unitPrice를 평균으로 합치기
grouped_df = df.groupBy(year("now_time").alias("year"),
                        month("now_time").alias("month"),
                        dayofmonth("now_time").alias("day"),
                        hour("now_time").alias("hour"),
                        "itemName").avg("unitPrice").withColumnRenamed("avg(unitPrice)", "unitPrice")

grouped_df = grouped_df.withColumn("now_datetime",
                                   to_timestamp(concat_ws("-", "year", "month", "day", "hour"), "yyyy-MM-dd-HH"))

grouped_df = grouped_df.drop("year", "month", "day", "hour")

# 원하는 순서로 컬럼 선택
grouped_df = grouped_df.select("now_datetime", "itemName", "unitPrice")


try:
    previous_df = spark.read.option("header", "true").csv("hdfs:///user/ubuntu/donpa_data.csv/*.csv")
except:
    previous_df = None

if previous_df is not None:
    # now_time 컬럼을 timestamp 형식으로 변환
    previous_df = previous_df.withColumn("now_datetime", col("now_datetime").cast("timestamp"))

    # unitPrice 컬럼을 숫자 형식으로 변환
    previous_df = previous_df.withColumn("unitPrice", col("unitPrice").cast(DoubleType()))

    # 두 데이터프레임을 수직으로 합치기
    merged_df = previous_df.union(grouped_df)

    # 시간대 같은 항목들의 unitPrice를 평균으로 합치기
    merged_df = merged_df.groupBy("now_datetime", "itemName").avg("unitPrice").withColumnRenamed("avg(unitPrice)", "unitPrice")

    # 시간 순으로 정렬
    merged_df = merged_df.orderBy("now_datetime")
    
    # CSV 파일로 저장
    merged_df.write.csv("new_donpa.csv", header=True, mode="overwrite")

    # 기존 디렉토리 삭제
    os.system("hdfs dfs -rm -r donpa_data.csv")

    # 새로운 디렉터리 이름 변경
    os.system("hdfs dfs -mv new_donpa.csv donpa_data.csv")
else:
    # grouped_df로 바로 저장
    grouped_df.write.csv("donpa_data.csv", header=True, mode="overwrite")


print("성공")

# 스파크 세션 종료
spark.stop()

 

 

 

csv_push_mongo틀

from pyspark.sql import SparkSession
import pymongo

# 스파크 세션 생성
spark = SparkSession.builder \
    .master("yarn") \
    .appName("CSV to MongoDB") \
    .getOrCreate()

# HDFS에서 CSV 파일 읽어오기
csv_path = "hdfs:///user/ubuntu/donpa_data.csv/*.csv"
csv_df = spark.read.option("header", "true").csv(csv_path)


# MongoDB에 연결
client = pymongo.MongoClient("mongodb://172.31.13.233:27017/")
db = client["donpa"]
collection = db["donpa_data"]

# 데이터프레임을 MongoDB에 저장
csv_df.write.format("mongo").mode("overwrite").option("uri", "mongodb://172.31.13.233:27017/donpa.donpa_data").save()

print("성공")

# 스파크 세션 종료
spark.stop()

 

 

airflow.py틀

from airflow.operators.bash_operator import BashOperator
from airflow import DAG
from datetime import datetime, timedelta
import pytz

default_args = {
    'owner': 'airflow',
    'depends_on_past': False,
    'start_date': datetime(2023, 8, 29),
    'retries': 1,
    'retry_delay': timedelta(minutes=5),
    'timezone': 'Asia/seoul',
}

dag = DAG(
    'spark_submit_dag1',
    default_args=default_args,
    schedule_interval='0 * * * *',  # 정각 마다 실행
    catchup=False,  # 과거 작업은 실행하지 않음
)

# coin_union_csv.py 실행
spark_submit_task = BashOperator(
    task_id='airflow_load_csv',
    bash_command='/usr/local/spark/bin/spark-submit --master yarn --deploy-mode client /home/ubuntu/donpa_data_save_csv/donpa_data_save_csv.py',
    dag=dag,
)

# fullcoin_push_mongo.py 실행
push_mongo_task = BashOperator(
    task_id='airflow_push_mongo',
    bash_command='/usr/local/spark/bin/spark-submit --master yarn --deploy-mode client --packages org.mongodb.spark:mongo-spark-connector_2.12:3.0.0 /home/ubuntu/csv_push_mongo/mongo.py',  # 파이썬 >실>행
    dag=dag,
)

# Task 간 의존성 설정
spark_submit_task >> push_mongo_task

 

 

 

쿠버플로우 사건발생 : 페어링으로 이미지 레지스트리에 저장을 했는데 인스턴스 내렸다 다시키면 저장이안됨???

보니까  pv에 이미지 저장되는 마운트 경로가 없음.. 생성해줘야됨 아아아아

 

 

1. pvc yaml

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
        name: sybabo-pvc
spec:
        accessModes:
                - ReadWriteMany
        resources:
                requests:
                        storage: 50Gi

 

 

2. 도커 레지스트리 디플로이먼트 yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    deployment.kubernetes.io/revision: "1"
  generation: 1
  labels:
    run: kubeflow-registry
  name: kubeflow-registry
  namespace: default
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      run: kubeflow-registry
  strategy:
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        run: kubeflow-registry
    spec:
      containers:
      - image: registry:2
        imagePullPolicy: IfNotPresent
        name: kubeflow-registry
        resources: {}
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
        volumeMounts:
                - name: sy-volume
                  mountPath: /var/lib/registry
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30
      volumes:
              - name: sy-volume
                persistentVolumeClaim:
                        claimName: sybabo-pvc

 

kubectl create -f pvcyaml파일명

kubectl apply -f 도커레지스트리파일명

 

 

이제는 lstm코드 이미지를 만들어주자

1. 먼저 베이스 이미지를 생성해주자

FROM brightfly/kubeflow-jupyter-lab:tf2.0-cpu
RUN pip install --upgrade pip
# Install required Python packages
RUN pip install pymongo xgboost pymysql pandas scikit-learn

docker build -t sy02229/new_image:latest .

docker login >>> 도커허브에 업로드 하기위해 로그인

docker push sy02229/new_image >>> Docker 이미지를 Docker Hub 또는 기타 컨테이너 레지스트리에 푸시하여 공유하는 명령

 

2. 베이스 이미지를 기반으로 lstm코드 이미지를 만들어 주자

import tensorflow as tf
import os
from pymongo import MongoClient
import pandas as pd
from datetime import datetime
from sklearn.preprocessing import StandardScaler
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.losses import Huber
from tensorflow.keras.callbacks import EarlyStopping
import pymysql
from kubeflow import fairing
from kubeflow.fairing.builders.append.append import AppendBuilder
from kubeflow.fairing.preprocessors.converted_notebook import ConvertNotebookPreprocessor
from kubeflow.fairing.kubernetes import utils as k8s_utils
class MyFashionMnist(object):
    def train(self):
        # MongoDB 연결 설정
        client = MongoClient("mongodb://3.38.178.84:27017/")
        db = client["donpa"]  # 데이터베이스명
        collection = db["donpa_data"]  # 컬렉션명

        # 컬렉션 데이터 조회
        data = collection.find()

        # 데이터프레임으로 변환
        df = pd.DataFrame(data)

        # _id 컬럼은 제거해주자
        df = df.drop(columns="_id") 

        # 출력
        #print("데이터의 row수:",len(df))
        # object타입의 데이터 datetime타입으로 변경하는 코드
        df['now_datetime'] = pd.to_datetime(df['now_datetime'])
        # 시간까지만 잘라내기
        df['now_datetime'] = df['now_datetime'].dt.strftime("%Y-%m-%d %H:%M")
        # now_datetime 다시 datetime타입으로 변경하는 코드
        df['now_datetime'] = pd.to_datetime(df['now_datetime'])

        # unitPrice 컬럼 float타입으로 변경
        df['unitPrice'] = df['unitPrice'].astype('float')

        #soldDate 컬럼 인덱스로 변경
        df.set_index('now_datetime', inplace=True)
        #display(df.head())

        # itemName컬럼은 사용하지 안을거임
        item_name = df.iloc[0,0] # 지우기전 아이템 이름 저장해주자
        df = df.drop(columns= 'itemName')
        df = df.reset_index(drop=False)

        # 피처 엔지니어링
        # 3시간 이평선
        ma3 = df['unitPrice'].rolling(window=3).mean()
        df.insert(len(df.columns), 'ma3', ma3)

        # 기존 데이터가 있다면 NaN에 이동평균선 값을 채워넣어주는 방법
        # 기존 데이터가 없다면 NaN에 0 값을 채워줘야 함
        df = df.fillna(0)
        
        before_now = df.iloc[-1,1]
        before_one = df.iloc[-2,1]
        before_two = df.iloc[-3,1]
        before_three = df.iloc[-4,1]
        before_four = df.iloc[-5,1]
        before_five = df.iloc[-6,1]
        before_six = df.iloc[-7,1]
        before_seven = df.iloc[-8,1]
        before_eight = df.iloc[-9,1]
        before_nine = df.iloc[-10,1]
        before_ten = df.iloc[-11,1]

        # 실제 값
        original_open = df['unitPrice'].values
        # 날짜 값
        dates = pd.to_datetime(df['now_datetime'])

        # 사용할 컬럼만 가져오기
        cols = list(df)[1:]
        # 데이터타입 float로 변경
        df = df[cols].astype(float)

        # 데이터 정규화
        scaler = StandardScaler()
        scaler = scaler.fit(df)
        df_scaler = scaler.transform(df)

        # 학습용 테스트 데이터 9대1비율로 나눈다
        n_train = int(0.9*df_scaler.shape[0]) # 90퍼 비율
        train_data_scaled = df_scaler[:n_train] # train 데이터
        train_dates = dates[:n_train] # train 날짜

        test_data_scaled = df_scaler[n_train:] # test 데이터
        test_dates = dates[n_train:] # test 날짜


        # 데이터 구조를 lstm의 입력과 출력에 맞게 바꿔주자
        pred_days = 1
        seq_len = 2
        input_dim = 2

        X_train = []
        Y_train = []
        X_test = []
        Y_test = []

        for i in range(seq_len, n_train-pred_days +1):
            X_train.append(train_data_scaled[i - seq_len:i, 0:train_data_scaled.shape[1]])
            Y_train.append(train_data_scaled[i + pred_days - 1:i + pred_days, 0])

        for i in range(seq_len, len(test_data_scaled)-pred_days +1):
            X_test.append(test_data_scaled[i - seq_len:i, 0:test_data_scaled.shape[1]])
            Y_test.append(test_data_scaled[i + pred_days - 1:i + pred_days, 0])

        X_train, Y_train = np.array(X_train), np.array(Y_train)
        X_test, Y_test = np.array(X_test), np.array(Y_test)

        #lstm 모델
        # TensorFlow에서 Keras 모듈을 불러옵니다
        # 레이어를 선형으로 쌓아 순차적으로 연결하여 모델을 만드는 방식
        model = Sequential()
        model.add(LSTM(64, input_shape=(X_train.shape[1], X_train.shape[2]), # (seq length, input dimension)
                       return_sequences=True))
        model.add(LSTM(32, return_sequences=False))
        model.add(Dense(Y_train.shape[1]))


        # 모델 피팅
        # specify your learninte
        learning_rate = 0.0
        # create an Adam optimizer with the specified learning rate
        optimizer = Adam(learning_rate=learning_rate)
        # compile your model using the custom optimizer
        model.compile(optimizer=optimizer, loss=Huber(), metrics=['mse'])
        earlystopping = EarlyStopping(monitor='val_loss', patience=10)

        # 모델 피팅
        history = model.fit(X_train, Y_train, epochs=30, batch_size=32,
                            validation_split=0.1, verbose=1, callbacks = [earlystopping])


        # 1시간뒤 가격 예측
        # 마지막 데이터에 대한 예측을 위한 입력 데이터 준비
        last_input = df_scaler[-seq_len:]
        # 하나만 예측하므로 배치크기는 1
        last_input = last_input.reshape(1, seq_len, input_dim)
        # 10분 뒤의 unitPrice 예측
        predicted_unitPrice = model.predict(last_input)
        # 스케일링을 원래 데이터 범위로 되돌리기
        predicted_unitPrice = scaler.inverse_transform(np.array([[predicted_unitPrice[0][0], 0]]))[0][0]
        # 예측 결과 출력
        #print("1시간뒤 예측가격 unitPrice:", predicted_unitPrice)


        # 연결 정보 설정
        host = "10.109.90.46"
        port = 3306
        database = "donpa_item"
        user = "root"
        password = "1234"

        # 연결
        connection = pymysql.connect(
            host=host,
            port=port,
            user=user,
            password=password,
            database=database
        )


        # item_img, item_name, price 컬럼 값 설정
        item_name = item_name  # 변수 값
        item_img = "https://bbscdn.df.nexon.com/data6/commu/202305/190236_646c8f3c32617.png"
        price = predicted_unitPrice

        # 쿼리 생성
        update_query = f"""
            UPDATE donpa_item1
            SET price = {price}, item_img = '{item_img}', before_now = {before_now}, before_one = {before_one}, before_two = {before_two}, before_three = {before_three}, before_four = {before_four}, before_five = {before_five}, before_six = {before_six}, before_seven = {before_seven}, before_eight = {before_eight}, before_nine = {before_nine}, before_ten = {before_ten}
            WHERE item_name = '{item_name}'
        """

        insert_query = f"""
            INSERT INTO donpa_item1 (item_name, item_img, before_now, before_one, before_two, before_three, before_four, before_five, before_six, before_seven, before_eight, before_nine, before_ten, price)
            VALUES ('{item_name}', '{item_img}', {before_now}, {before_one}, {before_two}, {before_three}, {before_four}, {before_five}, {before_six}, {before_seven}, {before_eight}, {before_nine}, {before_ten}, {price})
        """

        # 데이터베이스 작업 수행
        try:
            with connection.cursor() as cursor:
                cursor.execute(update_query)  # item_name 값이 있는 경우 업데이트 시도
                if cursor.rowcount == 0:
                    cursor.execute(insert_query)  # item_name 값이 없는 경우 새로운 행 추가
            connection.commit()  # 변경 내용을 커밋
            #print("데이터베이스 작업 완료")
        except Exception as e:
            #print("데이터베이스 작업 중 에러 발생:", e)
            connection.rollback()  # 에러가 발생한 경우 롤백

        # 연결 종료
        connection.close()

if __name__ == '__main__':
    if os.getenv('FAIRING_RUNTIME', None) is None:
        # Kubeflow Fairing의 필요한 모듈을 가져옵니다.
        from kubeflow.fairing.builders.append.append import AppendBuilder
        from kubeflow.fairing.preprocessors.converted_notebook import ConvertNotebookPreprocessor
        
        # Docker 이미지 관련 설정
        DOCKER_REGISTRY = 'kubeflow-registry.default.svc.cluster.local:30000'
        base_image = 'sy02229/new_image:latest'
        image_name = 'fairing-job1'
        
        # Fairing 빌더 설정
        builder = AppendBuilder(
            registry=DOCKER_REGISTRY,
            image_name=image_name,
            base_image=base_image,
            push=True,
            preprocessor=ConvertNotebookPreprocessor(
                notebook_file="Untitled1.ipynb"  # 노트북 파일 지정
            )
        )
        builder.build()  # Docker 이미지 빌드 및 푸시
    else:
        # Kubeflow Fairing 런타임 환경에서 직접 실행되는 경우
        myModel = MyFashionMnist()
        myModel.train()  # 모델 훈련 실행

해당 코드를 사용해 이미지를 빌드해준다

 

3. 이미지를 주기적으로 돌려줄 크론잡 파드생성해주자

apiVersion: batch/v1beta1
kind: CronJob
metadata:
  name: item-cj
spec:
  schedule: "20 * * * *"
  jobTemplate:
    spec:
      template:
        metadata:
          labels:
            app: item-cj
        spec:
          restartPolicy: OnFailure
          containers:
          - name: item-cronjob
            image: kubeflow-registry.default.svc.cluster.local:30000/fairing-job1:F5B25F59

크론잡 파드 실행시키면

잘실행 되는것을 확인

 

다른 10개의 모델도 크론잡 파드로 돌리자!!! 매 시간 20분에 실행되게끔 돌리자

 

이미지 확인하는 코드

sudo docker login kubeflow-registry.default.svc.cluster.local:30000; sudo docker images

 

일단 잘못 생성한 이미지들은 다 내려주자

sudo docker images | grep "kubeflow-registry.default.svc.cluster.local:30000/fairing-job" | awk '{print $2}' | sudo xargs -I {} docker rmi kubeflow-registry.default.svc.cluster.local:30000/fairing-job:{}

 

레지스트리에 이미지도 지워줘야됨

1) 레지스트리 이미지 디렉토리 확인

sudo ls -l /mnt/sharedfolder/default-docker-pvc-pvc-81a2f30e-098f-4393-a91f-32c624e653a9/docker/registry/v2/repositories

2) 지워주기

sudo rm -rf /mnt/sharedfolder/default-docker-pvc-pvc-81a2f30e-098f-4393-a91f-32c624e653a9/docker/registry/v2/repositories/지워버릴디렉토리

 

최종 도커 이미지

1. 균열의 단편 >>> fairing-job1 >>> Untitled1.ipynb

2. 무결점 라이언 코어 >>> fairing-job2 >>> Untitled2.ipynb

3. 무결점 조화의 결정체 >>> fairing-job3 >>> Untitled3.ipynb

4. 무색 큐브 조각 >>> fairing-job4 >>> Untitled4.ipynb

5. 무결점 골든 베릴 >>> fairing-job5 >>> Untitled5.ipynb

6. 힘의 정수 1개 상자 >>> fairing-job6 >>> Untitled6.ipynb

7. 모순의 결정체 >>> fairing-job7 >>> Untitled7.ipynb

8. 초전도 에너지 코어 상자[1회 교환가능] >>> fairing-job8>>> Untitled8.ipynb

9. 진정한 각성을 이룬 자 >>> fairing-job9 >>> Untitled9.ipynb

10. 왜곡된 차원의 큐브[교환가능] >>> fairing-jo10>>> Untitled10.ipynb

 

과연 테이블이 업데이트 되는지 확인

오케이 성공성공