던파 쿠버플로우, 쿠버네티스

마리아db 디플로이먼트 생성, pv생성

pvc

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

 

 

디플로이먼트

# Deployment 리소스의 API 버전
apiVersion: apps/v1

# Deployment 리소스를 생성
kind: Deployment

# 이 Deployment 리소스의 이름을 지정
metadata:
  name: mariadb-deployment
  
# Deployment의 세부사항을 정의
spec:
  # 파드를 하나만 복제
  replicas: 1
  
  # 파드를 선택하기 위한 라벨 셀렉터를 지정
  selector:
    matchLabels:
      # app: mariadb 라벨을 가진 파드를 선택
      app: mariadb
      
  # 파드의 템플릿을 정의
  template:
    metadata:
      labels:
        # app: mariadb 라벨이 파드에 적용
        app: mariadb
    # 파드 스펙을 정의
    spec:
      containers:
        - name: mariadb
          # 컨테이너에 사용할 이미지를 지정
          image: mariadb:latest
          # 컨테이너의 환경 변수를 지정
          env:
          	# MariDB의 루트 비밀번호를 1234로 지정
            - name: MYSQL_ROOT_PASSWORD
              value: "1234"
          # 컨테이너가 개방할 포트 정보를 정의
          ports:
            - containerPort: 3306
          volumeMounts:
            - name: db-volume
              mountPath: /usr/share/db
      volumes:
        - name: db-volume
          persistentVolumeClaim:
                  claimName: db-pvc

 

 

서비스

apiVersion: v1
kind: Service
metadata:
  name: mariadb-service
spec:
  selector:
    app: mariadb
  ports:
    - protocol: TCP
      port: 3306  # 서비스가 생성하는 엔드포인트의 포트
      targetPort: 3306  # 실제 MariaDB 파드의 포트

 

kubectl create로 3개 생성

 

서비스 확인

 

 

 

마리아db 접속해보기

kubectl run mysql-client -it --image=ghcr.io/c1t1d0s7/network-multitool --rm bash

mysql -h 10.233.18.183 -u root -p

 

create database donpa_item; >>> 데이터베이스 생성

use donpa_item >>> 데이터 베이스 사용

 

 

 donpa_item1 테이블 생성 명령어

CREATE TABLE donpa_item1 (     
	item_img TEXT,     
    item_name TEXT,     
    price FLOAT,     
    before_now FLOAT,     
    before_one FLOAT,     
    before_two FLOAT,     
    before_three FLOAT,     
    before_four FLOAT,     
    before_five FLOAT,     
    before_six FLOAT,     
    before_seven FLOAT,     
    before_eight FLOAT,     
    before_nine FLOAT,     
    before_ten FLOAT 
);

# TEXT 데이터 타입은 문자열을 무제한으로 저장할 수 있는 데이터 타입

 

연결확인

import pymysql

# 연결 정보 설정
host = "10.233.18.183"
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에 연결되었습니다.")

 

 

 

 

아침에 지하철타고오다가 신박한 피처가 생각이나서 추가를 해볼 예정이다!!

내가 생각한 피처는 던파100만 골드당 현금 시세 피처를 추가하면 좋은거 같아서 추가해볼것이다 왜냐면... 인플레이션, 디플레이션 처럼 각나라의 현금 가치에 따라 물가변동률이 큰것으로 알고있기 떄문에 현재 골드 시세 컬럼을 추가해주면 모델 성능에 효과적이지 안을까??? 생각해보았다.

 

마리아db에 골드 시세 테이블을 추가하고 거기에 골드시세 정보를 넣어보자

테이블 생성

CREATE TABLE goldprice (
    date TEXT,
    sell FLOAT,
    buy FLOAT
);

 

goldprice 이미지 만들기

dockerfile

# 작업 디렉토리 설정
WORKDIR /app

# main, requirements 두 파일 작업디렉토리로 복사
COPY main.py /app/main.py
COPY requirements.txt /app

# 필요한 종속성 설치
RUN pip install --no-cache-dir -r requirements.txt

CMD [ "python" , "main.py" ]

 

main.py

from bs4 import BeautifulSoup
import requests
import pymysql

# MySQL 연결 설정
conn = pymysql.connect(
    host='10.233.18.183',  # 호스트명
    user='root',    # 데이터베이스 사용자명
    password='1234',  # 데이터베이스 암호
    db='donpa_item',      # 데이터베이스 이름
    port=3306
)

# 커서 생성
cursor = conn.cursor()

date_list = []
sell_list = []
buy_list = []

# 검색 결과 페이지 URL
url = "http://dnfnow.xyz/invest"

headers = {
     'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36'
}

response = requests.get(url, headers=headers)

# 응답 데이터 파싱
soup = BeautifulSoup(response.text, "html.parser")

# 뉴스 타이틀, 링크 선택자
selector = "#week > script:nth-child(3)"
# 선택자에 해당하는 요소들을 모두 찾음
script_element = soup.select_one(selector)

# 원하는 JavaScript 코드 부분 추출
javascript_code = script_element.text
javascript_code = javascript_code.split('data')

date = javascript_code[1].split(' labels: [ ')[1].split(', ],\n ')[0].split(',')
# 공백 및 작은 따옴표 제거 후 출력
for i in date:
    cleaned_date = i.strip().strip("'")
    date_list.append(cleaned_date)

sell = javascript_code[3].split(': [ ')[1].split(', ]')[0].split(',')
# 공백 및 작은 따옴표 제거 후 출력
for i in sell:
    cleaned_sell = i.strip().strip("'")
    sell_list.append(float(cleaned_sell))

buy = javascript_code[4].split(': [ ')[1].split(', ]')[0].split(',')
# 공백 및 작은 따옴표 제거 후 출력
for i in buy:
    cleaned_buy = i.strip().strip("'")
    buy_list.append(float(cleaned_buy))

# 데이터베이스에 데이터 삽입 또는 업데이트
for i in range(len(date_list)):
    date = date_list[i]
    sell = sell_list[i]
    buy = buy_list[i]

    # 날짜가 이미 존재하는지 확인
    cursor.execute("SELECT COUNT(*) FROM goldprice WHERE date = %s", (date,))
    result = cursor.fetchone()

    if result[0] == 0:
        # 날짜가 존재하지 않으면 데이터 삽입
        sql = "INSERT INTO goldprice (date, sell, buy) VALUES (%s, %s, %s)"
        cursor.execute(sql, (date, sell, buy))
    else:
        # 날짜가 존재하면 데이터 업데이트 (오버라이팅)
        sql = "UPDATE goldprice SET sell = %s, buy = %s WHERE date = %s"
        cursor.execute(sql, (sell, buy, date))

# 변경사항 커밋
conn.commit()

# 연결 종료
conn.close()

 

requirements.txt

 

requests
beautifulsoup4
pymysql

 

sudo docker build -t kubeflow-registry.default.svc.cluster.local:30000/goldprice:latest . >>> 이미지 저장

sudo docker push kubeflow-registry.default.svc.cluster.local:30000/goldprice:latest >>> 레지스트리에 푸쉬

goldprice 크론잡

apiVersion: batch/v1
kind: CronJob
metadata:
  name: goldprice
spec:
  schedule: "15 * * * *"
  jobTemplate:
    spec:
      template:
        metadata:
          labels:
            app: goldprice
        spec:
          restartPolicy: OnFailure
          containers:
          - name: goldprice
            image: sy02229/goldprice:latest

 

던파 뉴스 이미지 만들기

뉴스 테이블 생성

create table donpa_news ( photo TEXT, title TEXT, link TEXT );

 

dockerfile

# 베이스 이미지 설정
FROM python:latest

# 작업 디렉토리 설정
WORKDIR /app

# main, requirements 두 파일 작업디렉토리로 복사
COPY main.py /app/main.py
COPY requirements.txt /app

# 필요한 종속성 설치
RUN pip install --no-cache-dir -r requirements.txt

CMD [ "python" , "main.py" ]

 

main.py

import requests
from bs4 import BeautifulSoup
import pymysql

# MySQL 연결 설정
conn = pymysql.connect(
    host='10.233.18.183',  # 호스트명
    user='root',    # 데이터베이스 사용자명
    password='1234',  # 데이터베이스 암호
    db='donpa_item',      # 데이터베이스 이름
    port = 3306
)

# 커서 생성
cursor = conn.cursor()

# 크롤링 코드 작성
photo_list = []
title_list = []
link_list = []

# 검색 결과 페이지 URL
url = "https://search.naver.com/search.naver?where=news&query=%EB%8D%98%ED%8C%8C&sm=tab_opt&sort=1&photo=1&field=0&pd=0&ds=&de=&docid=&related=0&mynews=0&office_type=0&office_section_code=0&news_office_checked=&nso=so%3Add%2Cp%3Aall&is_sug_officeid=0&office_category=0&service_area=0"

# HTTP GET 요청
response = requests.get(url)

# 응답 데이터 파싱
soup = BeautifulSoup(response.text, "html.parser")

select_num = 1
while select_num<=10:
    # 이미지 선택자
    selector = f"#sp_nws{select_num} > div > a > img"
    # 선택자에 해당하는 이미지 요소를 찾음
    image = soup.select_one(selector)
    # 각 링크의 href 속성값을 출력
    photo = image.get("data-lazysrc")
    photo_list.append(photo)
    select_num+=1

# 뉴스 타이틀, 링크 선택자
selector = "#main_pack > section.sc_new.sp_nnews._prs_nws > div > div.group_news > ul > li> div > div > a"
# 선택자에 해당하는 요소들을 모두 찾음
title_link = soup.select(selector)

# 각 타이틀,링크 속성값을 출력
for link in title_link:
    title = link.get("title")
    href = link.get("href")
    title_list.append(title)
    link_list.append(href)



# 테이블 초기화 (기존 데이터 삭제)
truncate_sql = "TRUNCATE TABLE donpa_news"
cursor.execute(truncate_sql)


# 데이터베이스에 데이터 삽입
for i in range(len(photo_list)):
    photo = photo_list[i]
    title = title_list[i]
    link = link_list[i]

    sql = "INSERT INTO donpa_news (photo, title, link) VALUES (%s, %s, %s)"
    cursor.execute(sql, (photo, title, link))

# 변경사항 커밋
conn.commit()

# 연결 종료
conn.close()

 

requirements.txt

requests
beautifulsoup4
pymysql

sudo docker build -t kubeflow-registry.default.svc.cluster.local:30000/donpa_news:latest . >>> 이미지 저장

sudo docker push kubeflow-registry.default.svc.cluster.local:30000/donpa_news:latest >>> 레지스트리에 푸쉬

 

 

 

 

던파 이벤트 이미지 만들기

이벤트 테이블 생성

create table donpa_event(
    img TEXT,
    text TEXT,
    date TEXT,
    herf TEXT
    );

 

 

dockerfile

FROM python:latest

# 작업 디렉토리 설정
WORKDIR /app

# main, requirements 두 파일 작업디렉토리로 복사
COPY main.py /app/main.py
COPY requirements.txt /app

# 필요한 종속성 설치
RUN pip install --no-cache-dir -r requirements.txt

CMD [ "python" , "main.py" ]

 

main.py

import requests
from bs4 import BeautifulSoup
import re
import pymysql

# MySQL 연결 설정
conn = pymysql.connect(
    host='10.233.18.183',  # 호스트명
    user='root',    # 데이터베이스 사용자명
    password='1234',  # 데이터베이스 암호
    db='donpa_item',      # 데이터베이스 이름
    port = 3306
)

# 커서 생성
cursor = conn.cursor()

eve_img = []
eve_text = []
eve_date = []
eve_herf = []

# 검색 결과 페이지 URL
url = "https://df.nexon.com/community/news/event/list"

# HTTP GET 요청
response = requests.get(url)

# 응답 데이터 파싱
soup = BeautifulSoup(response.text, "html.parser")

# 이벤트 img 셀렉터
selector_img = "#wrap > section.content.news > article.board_eventlist > ul > li > img"
# 이벤트 b 셀렉터
selector_text = "#wrap > section.content.news > article.board_eventlist > ul > li > b"
# 이벤트 날짜 span 셀렉터
selector_date = "#wrap > section.content.news > article.board_eventlist > ul > li > span"
# 이벤트 링크가 포함된 li 태그들 선택
selector_href = "#wrap > section.content.news > article.board_eventlist > ul > li"

# 선택자에 해당하는 요소들을 모두 찾음
event_img = soup.select(selector_img)
# URL에 프로토콜을 추가하여 출력
for img in event_img:
    src = img.get('src')
    if src.startswith('//'):
        src = 'https:' + src
    eve_img.append(src)
    
 # 선택자에 해당하는 요소들을 모두 찾음
event_text = soup.select(selector_text)
# 각 링크의 텍스트만 추출하여 리스트에 저장
event_text = [link.get_text(strip=True) for link in event_text]
# 결과 출력
for text in event_text:
    eve_text.append(text)



# 선택자에 해당하는 요소들을 모두 찾음
event_dates = soup.select(selector_date)
# 결과 출력
for span in event_dates:
    date_text = span.text.strip().replace('\n', '').strip().replace(' ','')  # span 태그 안의 텍스트>에서 공백 및 줄바꿈 제거
    eve_date.append(date_text)



event_href = soup.select(selector_href)

# 결과 출력
for li in event_href:
    if li.get("data-no"):
        event_url = f"http://df.nexon.com/community/news/event/{li.get('data-no')}?categoryType=0"
        eve_herf.append(event_url)

    else:
        li = li.get("onclick")

        if 'window.location.href' in li:
            # 정규 표현식을 사용하여 값을 추출합니다.
            li = re.findall(r"'(.*?)';", li)

            eve_herf.append("https://df.nexon.com"+''.join(li))
        elif 'neople.openCouponPop()' in li:
            li = "https://df.nexon.com/community/news/event/list"
            eve_herf.append(li)

        elif 'window.open' in li:
            # 정규 표현식을 사용하여 URL 추출
            li = re.search(r"https://[a-zA-Z0-9./-]+", li).group()
            eve_herf.append(li)
 
 # 테이블 초기화 (기존 데이터 삭제)
truncate_sql = "TRUNCATE TABLE donpa_event"
cursor.execute(truncate_sql)


# 데이터베이스에 데이터 삽입
for i in range(len(eve_img)):
    img = eve_img[i]
    text = eve_text[i]
    date = eve_date[i]
    herf = eve_herf[i]

    sql = "INSERT INTO donpa_event (img, text, date, herf) VALUES (%s, %s, %s, %s)"
    cursor.execute(sql, (img, text, date, herf))

# 변경사항 커밋
conn.commit()

# 연결 종료
conn.close()

 

requirements.txt

requests
beautifulsoup4
pymysql

 

sudo docker build -t kubeflow-registry.default.svc.cluster.local:30000/donpa_event:latest . >>> 이미지 저장

sudo docker push kubeflow-registry.default.svc.cluster.local:30000/donpa_event:latest >>> 레지스트리에 푸쉬

 

 

 

 

던파 뉴스 크론잡

apiVersion: batch/v1
kind: CronJob
metadata:
  name: donpa-news-cj
spec:
  schedule: "0 */3 * * *"
  jobTemplate:
    spec:
      template:
        metadata:
          labels:
            app: donpa-news-cj
        spec:
          restartPolicy: OnFailure
          containers:
          - name: donpa-news-cronjob
            image: sy02229/donpa_news:latest

 

던파 이벤트 크론잡

apiVersion: batch/v1
kind: CronJob
metadata:
  name: donpa-event-cj
spec:
  schedule: "10 10 * * *"
  jobTemplate:
    spec:
      template:
        metadata:
          labels:
            app: donpa-event-cj
        spec:
          restartPolicy: OnFailure
          containers:
          - name: donpa-event-cronjob
            image: kubeflow-registry.default.svc.cluster.local:30000/donpa_event:latest

 

 

goldprice는 매 15분마다

donpa_event는 10시10분 마다

donpa_news는 3시간 마다

마리아db 최신화 시켜주는 크론잡 돌려주기

 

 

이미지 확인하는 코드

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:{}

 

레지스트리 이미지 확인하는 코드

sudo ls -l /srv/nfs-volume/default-rigimg-pvc-pvc-c191aedc-7295-4844-821a-9e8a55a34344/docker/registry/v2/repositories

레지스트리 이미지 지워주는 코드

sudo rm -rf /srv/nfs-volume/default-rigimg-pvc-pvc-c191aedc-7295-4844-821a-9e8a55a34344/docker/registry/v2/repositories/fairing-job1

 

 

던파 아이템 1시간뒤 예측가격을 db에 넣어줄 이미지를 만들어보자

 

dockerfile

FROM sy02229/new_image:latest

# 작업 디렉토리 설정
WORKDIR /app

# main 파일 작업디렉토리로 복사
COPY main.py /app/main.py

CMD [ "python" , "main.py" ]

 

main.py

import pandas as pd
import pymysql
from pymongo import MongoClient
from sklearn.preprocessing import StandardScaler
import numpy as np

# 레이어를 선형으로 쌓아 순차적으로 연결하여 모델을 만드는 방식
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

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

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

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

date_df = pd.read_sql(query, connection)

# 연결 종료
connection.close()

# 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") 


# 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)

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

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

# 기존 데이터가 있다면 NaN에 이동평균선 값을 채워넣어주는 방법
# 기존 데이터가 없다면 NaN에 0 값을 채워줘야 함
df = df.fillna(0)

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

# sell, buy컬럼을 합쳐주기 위해 date컬럼 생성
df['date'] = pd.to_datetime(df['now_datetime']).dt.strftime('%Y%m%d')

# sell, buy컬럼 붙여주자!!
df = df.merge(date_df, left_on='date', right_on='date', how='left')

# sell, buy값이 널값이면 가장 최근의 sell, buy값으로 대체해주자
null_check = df['sell'].isnull().sum()
if null_check != 0:
    # date_df의 맨 마지막 값을 가져와서 NaN 값을 채우기
    last_date_df_row = date_df.iloc[-1]
    df['sell'].fillna(last_date_df_row['sell'], inplace=True)
    df['buy'].fillna(last_date_df_row['buy'], inplace=True)

# 붙여주고 date는 이제 필요없으므로 drop시켜줌
df.drop(columns = 'date', inplace=True)

# 이전가격 변수에 저장해 두기
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)

# standardscaler스케일링
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 날짜

# 직전 24개의 데이터를 기반으로 10분뒤 가격을 예측하는 것을 목표
# 데이터 구조를 lstm의 입력과 출력에 맞게 바꿔주자
pred_days = 1
seq_len = 24
input_dim = 4

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모델
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]))

# 모델 피팅
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.losses import Huber
from tensorflow.keras.callbacks import EarlyStopping

# specify your learning rate
learning_rate = 0.01
# 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=5)

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


# 마지막 데이터에 대한 예측을 위한 입력 데이터 준비
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]]))[0][0]

# 연결 정보 설정
host = "10.233.18.183"
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://img-api.neople.co.kr/df/items/8b998230ab012e695e9a53d67187cc3f"
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()  # 변경 내용을 커밋
except Exception as e:
    connection.rollback()  # 에러가 발생한 경우 롤백

# 연결 종료
connection.close()

sudo docker build -t kubeflow-registry.default.svc.cluster.local:30000/donpa_item1:latest .

sudo docker push kubeflow-registry.default.svc.cluster.local:30000/donpa_item1:latest

 

던파 아이템 1시간뒤 예측가격 크론잡

apiVersion: batch/v1
kind: CronJob
metadata:
  name: item-cj
spec:
  schedule: "*/2 * * * *"
  jobTemplate:
    spec:
      template:
        metadata:
          labels:
            app: item-cj
        spec:
          restartPolicy: OnFailure
          containers:
          - name: item-cronjob
            image: kubeflow-registry.default.svc.cluster.local:30000/donpa_item1:latest

 

매20분마다 10개의 아이템의 1시간뒤 가격을 예측한다