mirror of
https://hubproxy.babadafafafafa.cn/https://github.com/1Panel-dev/1Panel.git
synced 2026-09-20 08:03:55 +08:00
6348 lines
394 KiB
Go
6348 lines
394 KiB
Go
import { getFuLocaleMessage } from '@/lang/fu';
|
||
|
||
const message = {
|
||
commons: {
|
||
true: '참',
|
||
false: '거짓',
|
||
colon: ': ',
|
||
example: '예: ',
|
||
fit2cloud: 'FIT2CLOUD',
|
||
lingxia: 'LXware',
|
||
button: {
|
||
run: '실행',
|
||
add: '추가',
|
||
save: '저장',
|
||
set: '설정',
|
||
sync: '동기화',
|
||
delete: '삭제',
|
||
edit: '편집',
|
||
enable: '활성화',
|
||
disable: '비활성화',
|
||
confirm: '확인',
|
||
cancel: '취소',
|
||
reset: '재설정',
|
||
restart: '재시작',
|
||
conn: '연결',
|
||
disConn: '연결 해제',
|
||
clean: '지우기',
|
||
cleanAll: '모두 지우기',
|
||
selectAll: '전체 선택',
|
||
login: '로그인',
|
||
close: '닫기',
|
||
off: '꺼짐',
|
||
stop: '중지',
|
||
start: '시작',
|
||
view: '보기',
|
||
watch: '실시간 보기',
|
||
handle: '실행',
|
||
clone: '복제',
|
||
expand: '확장',
|
||
collapse: '축소',
|
||
log: '로그',
|
||
back: '뒤로',
|
||
backup: '백업',
|
||
recover: '복원',
|
||
retry: '재시도',
|
||
upload: '업로드',
|
||
download: '다운로드',
|
||
init: '초기화',
|
||
verify: '검증',
|
||
saveAndEnable: '저장 및 활성화',
|
||
import: '가져오기',
|
||
importAll: '모두 가져오기',
|
||
export: '내보내기',
|
||
power: '제출',
|
||
search: '검색',
|
||
refresh: '새로고침',
|
||
get: '가져오기',
|
||
upgrade: '업그레이드',
|
||
update: '업데이트',
|
||
ignore: '업그레이드 무시',
|
||
install: '설치',
|
||
copy: '복사',
|
||
random: '생성',
|
||
uninstall: '제거',
|
||
fullscreen: '전체 화면',
|
||
quitFullscreen: '전체 화면 종료',
|
||
showAll: '모두 표시',
|
||
hideSome: '일부 숨기기',
|
||
agree: '동의',
|
||
notAgree: '동의하지 않음',
|
||
preview: '미리 보기',
|
||
open: '열기',
|
||
notSave: '저장하지 않음',
|
||
createNewFolder: '새 폴더 생성',
|
||
createNewFile: '새 파일 생성',
|
||
helpDoc: '문서',
|
||
unbind: '연결 해제',
|
||
cover: '덮어쓰기',
|
||
skip: '건너뛰기',
|
||
fix: '수정',
|
||
down: '중지',
|
||
up: '시작',
|
||
sure: '확인',
|
||
show: '표시',
|
||
hide: '숨기기',
|
||
visit: '열기',
|
||
migrate: '마이그레이션',
|
||
prev: '이전',
|
||
next: '다음',
|
||
create: '생성',
|
||
setDefault: '기본값 복원',
|
||
bind: '연결',
|
||
tip: '팁',
|
||
},
|
||
operate: {
|
||
start: '시작',
|
||
stop: '중지',
|
||
restart: '재시작',
|
||
reload: '다시 로드',
|
||
rebuild: '재구축',
|
||
sync: '동기화',
|
||
up: '실행',
|
||
down: '중지',
|
||
delete: '삭제',
|
||
},
|
||
search: {
|
||
timeStart: '시작 시간',
|
||
timeEnd: '종료 시간',
|
||
timeRange: '부터',
|
||
dateStart: '시작 날짜',
|
||
dateEnd: '종료 날짜',
|
||
date: '날짜',
|
||
},
|
||
table: {
|
||
all: '전체',
|
||
total: '총 {0}',
|
||
name: '이름',
|
||
type: '유형',
|
||
card: '카드',
|
||
table: '표',
|
||
status: '상태',
|
||
records: '기록',
|
||
group: '그룹',
|
||
createdAt: '생성 시간',
|
||
publishedAt: '게시 시간',
|
||
date: '날짜',
|
||
updatedAt: '업데이트 시간',
|
||
operate: '작업',
|
||
message: '메시지',
|
||
description: '설명',
|
||
interval: '간격',
|
||
user: '소유자',
|
||
title: '제목',
|
||
port: '포트',
|
||
forward: '포워드',
|
||
protocol: '프로토콜',
|
||
tableSetting: '테이블 설정',
|
||
refreshRate: '새로 고침 속도',
|
||
selectColumn: '열 선택',
|
||
local: '로컬',
|
||
serialNumber: '일련 번호',
|
||
manageGroup: '그룹 관리',
|
||
backToList: '목록으로 돌아가기',
|
||
keepEdit: '계속 편집',
|
||
pin: '상단 고정',
|
||
unpin: '고정 해제',
|
||
default: '기본값',
|
||
noRefresh: '자동 새로고침 안 함',
|
||
creator: '생성자',
|
||
updater: '수정자',
|
||
},
|
||
loadingText: {
|
||
Upgrading: '시스템 업그레이드 중입니다. 잠시만 기다려 주십시오...',
|
||
Restarting: '시스템 재시작 중입니다. 잠시만 기다려 주십시오...',
|
||
Recovering: '스냅샷에서 복구 중입니다. 잠시만 기다려 주십시오...',
|
||
Rollbacking: '스냅샷에서 롤백 중입니다. 잠시만 기다려 주십시오...',
|
||
},
|
||
msg: {
|
||
noneData: '데이터가 없습니다',
|
||
delete: '이 작업은 되돌릴 수 없습니다. 계속하시겠습니까?',
|
||
clean: '이 작업은 되돌릴 수 없습니다. 계속하시겠습니까?',
|
||
closeDrawerHelper: '시스템에서 변경 사항을 저장하지 않을 수 있습니다. 계속하시겠습니까?',
|
||
deleteSuccess: '삭제 완료',
|
||
loginSuccess: '로그인 성공',
|
||
operationSuccess: '작업 완료',
|
||
copySuccess: '복사 완료',
|
||
notSupportOperation: '이 작업은 지원되지 않습니다',
|
||
requestTimeout: '요청이 시간 초과되었습니다. 나중에 다시 시도해 주십시오',
|
||
infoTitle: '안내',
|
||
notRecords: '현재 작업에 대한 실행 기록이 생성되지 않았습니다',
|
||
sureLogOut: '로그아웃하시겠습니까?',
|
||
createSuccess: '생성 완료',
|
||
updateSuccess: '업데이트 완료',
|
||
uploadSuccess: '업로드 성공',
|
||
operateConfirm: '작업을 확인하려면 수동으로 입력하십시오: ',
|
||
inputOrSelect: '선택하거나 입력해 주십시오',
|
||
selectOne: '{0}을(를) 하나 선택해 주십시오',
|
||
copyFailed: '복사 실패',
|
||
operatorHelper: '"{0}"에 대해 "{1}" 작업이 수행되며 이 작업은 되돌릴 수 없습니다. 계속하시겠습니까?',
|
||
notFound: '죄송합니다. 요청하신 페이지를 찾을 수 없습니다.',
|
||
unSupportType: '현재 파일 형식은 지원되지 않습니다.',
|
||
unSupportSize: '업로드된 파일이 {0}M을 초과했습니다. 확인해 주십시오!',
|
||
fileExist: '현재 폴더에 이미 동일한 파일이 존재합니다. 중복 업로드는 지원되지 않습니다.',
|
||
fileNameErr: '파일 이름은 1~256 자 사이의 영어, 중국어, 숫자, 또는 점(.-_)만 포함해야 합니다.',
|
||
confirmNoNull: '{0} 값이 비어 있지 않은지 확인하십시오.',
|
||
errPort: '포트 정보가 올바르지 않습니다. 확인해 주십시오!',
|
||
remove: '제거',
|
||
backupHelper: '현재 작업은 {0}을(를) 백업합니다. 계속하시겠습니까?',
|
||
recoverHelper: '{0} 파일에서 복원 중입니다. 이 작업은 되돌릴 수 없습니다. 계속하시겠습니까?',
|
||
refreshSuccess: '새로 고침 완료',
|
||
rootInfoErr: '이미 루트 디렉토리입니다',
|
||
resetSuccess: '초기화 완료',
|
||
creatingInfo: '생성 중입니다. 이 작업이 필요하지 않습니다',
|
||
offlineTips: '오프라인 버전은 이 작업을 지원하지 않습니다',
|
||
errImportFormat: '가져오기 데이터 또는 형식이 비정상입니다. 확인 후 다시 시도하세요!',
|
||
importHelper:
|
||
'충돌하거나 중복되는 데이터를 가져올 때 가져온 내용을 기준으로 원래 데이터베이스 데이터를 업데이트합니다.',
|
||
errImport: '파일 내용이 비정상입니다:',
|
||
backupSuccess: '백업 성공',
|
||
restoreSuccess: '복원 성공',
|
||
installSuccess: '설치 성공',
|
||
uninstallSuccess: '제거 성공',
|
||
},
|
||
login: {
|
||
username: '사용자 이름',
|
||
password: '비밀번호',
|
||
passkey: '패스키 로그인',
|
||
welcome: '다시 오신 것을 환영합니다. 사용자 이름과 비밀번호를 입력하여 로그인하세요!',
|
||
errorAuthInfo: '입력한 사용자 이름 또는 비밀번호가 잘못되었습니다. 다시 입력해주세요!',
|
||
errorMfaInfo: '인증 정보가 잘못되었습니다. 다시 시도해주세요!',
|
||
captchaHelper: '캡챠',
|
||
errorCaptcha: '캡챠 코드 오류!',
|
||
codeInput: 'MFA 인증기의 6자리 인증 코드를 입력하세요',
|
||
mfaTitle: 'MFA 인증',
|
||
mfaCode: 'MFA 인증 코드',
|
||
title: 'Linux 서버 관리 패널',
|
||
licenseHelper: '<커뮤니티 라이선스 계약>',
|
||
errorAgree: '커뮤니티 소프트웨어 라이선스에 동의하려면 클릭하세요',
|
||
logout: '로그아웃',
|
||
agreeTitle: '동의',
|
||
agreeContent:
|
||
'귀하의 합법적인 권리와 이익을 보다 잘 보호하기 위해, 다음 « <a href = "https://www.fit2cloud.com/legal/licenses.html" target = "_blank" >커뮤니티 라이선스 계약</a> »을 읽고 동의해주세요.',
|
||
passkeyFailed: '패스키 로그인에 실패했습니다. 다시 시도하세요',
|
||
passkeyNotSupported: '현재 브라우저 또는 환경에서 패스키를 지원하지 않습니다',
|
||
passkeyToPassword: '패스키 사용에 문제가 있나요? 비밀번호로 로그인하세요',
|
||
},
|
||
rule: {
|
||
username: '사용자 이름을 입력하세요',
|
||
password: '비밀번호를 입력하세요',
|
||
rePassword: '확인 비밀번호가 비밀번호와 일치하지 않습니다.',
|
||
requiredInput: '이 필드는 필수 항목입니다.',
|
||
requiredSelect: '목록에서 항목을 선택하세요',
|
||
illegalChar: '현재 & ; $ \' ` ( ) " > < ｜ 문자 주입은 지원되지 않습니다',
|
||
illegalInput: '이 필드에는 유효하지 않은 문자가 포함될 수 없습니다.',
|
||
duplicate: '이 값은 고유해야 합니다.',
|
||
commonName:
|
||
'이 필드는 특수 문자로 시작할 수 없으며, 영어, 한자, 숫자, ".", "-", "_" 문자로 구성되어야 하며 길이는 1-128자여야 합니다.',
|
||
userName: '특수 문자로 시작하지 않고, 영어, 한국어, 숫자 및 _, 길이 3-30 지원',
|
||
simpleName:
|
||
'이 필드는 "_"로 시작할 수 없으며, 영어, 숫자 및 "_" 문자로 구성되어야 하며 길이는 3-30 자여야 합니다.',
|
||
simplePassword:
|
||
'이 필드는 "_"로 시작할 수 없으며, 영어, 숫자 및 "_" 문자로 구성되어야 하며 길이는 1-30 자여야 합니다.',
|
||
dbName: '이 필드는 "_"로 시작할 수 없으며, 영어, 숫자 및 "_" 문자로 구성되어야 하며 길이는 1-64 자여야 합니다.',
|
||
imageName: '특수 문자로 시작하지 않고, 영어, 숫자, :@/.-_ 지원, 길이 1-256',
|
||
composeName: '특수 문자로 시작할 수 없으며, 소문자, 숫자, "-", "_"를 지원하며 길이는 1-256 자여야 합니다.',
|
||
volumeName: '이 필드는 영어, 숫자, ".", "-", "_" 문자로 구성되어야 하며 길이는 2-30 자여야 합니다.',
|
||
supervisorName:
|
||
'이 필드는 특수 문자로 시작할 수 없으며, 영어, 숫자, "-", "_" 문자로 구성되어야 하며 길이는 1-128 자여야 합니다.',
|
||
complexityPassword:
|
||
'길이 8-30 자이며 영문, 숫자, 특수 문자 중 최소 두 가지를 포함하는 비밀번호 조합을 지원합니다.',
|
||
commonPassword: '이 필드 길이는 6 자 이상이어야 합니다.',
|
||
linuxName: '이 필드 길이는 1-128 자 사이여야 하며, 다음 특수 문자를 포함할 수 없습니다: "{0}".',
|
||
email: '이 필드는 유효한 이메일 주소여야 합니다.',
|
||
number: '이 필드는 숫자여야 합니다.',
|
||
integer: '이 필드는 양의 정수여야 합니다.',
|
||
ip: '이 필드는 유효한 IP 주소여야 합니다.',
|
||
host: '이 필드는 유효한 IP 주소 또는 도메인 이름이어야 합니다.',
|
||
hostHelper: 'IP 주소 또는 도메인 이름 입력을 지원합니다',
|
||
port: '이 필드는 유효한 포트 번호여야 합니다.',
|
||
selectHelper: '올바른 {0} 파일을 선택하세요',
|
||
domain: '이 필드는 다음 형식이어야 합니다: example.com 또는 example.com:8080.',
|
||
databaseName: '이 필드는 영어, 숫자 및 "_" 문자로 구성되어야 하며 길이는 1-30 자여야 합니다.',
|
||
ipErr: '이 필드는 유효한 IP 주소여야 합니다.',
|
||
numberRange: '이 필드는 {0}에서 {1} 사이의 숫자여야 합니다.',
|
||
paramName: '이 필드는 영어, 숫자, ".", "-", "_" 문자로 구성되어야 하며 길이는 2-30 자여야 합니다.',
|
||
paramComplexity:
|
||
'이 필드는 특수 문자로 시작하거나 끝날 수 없으며, 영어, 숫자, "{0}" 문자로 구성되어야 하며 길이는 6-128 자여야 합니다.',
|
||
paramUrlAndPort: '이 필드는 "http(s)://(도메인 이름/IP):(포트)" 형식이어야 합니다.',
|
||
nginxDoc: '이 필드는 영어, 숫자 및 "." 문자로 구성되어야 합니다.',
|
||
appName:
|
||
'소문자, 숫자, "-", "_"를 지원하며 길이는 2-30 자이고, "-" 또는 "_"로 시작하거나 끝날 수 없습니다.',
|
||
containerName:
|
||
'영어, 숫자, "-", "_", "."를 지원하며, "-", "_", "."로 시작할 수 없고 길이는 2-128 자여야 합니다.',
|
||
mirror: '미러 가속 주소는 http(s)://로 시작해야 하며, 대소문자 영어, 숫자, ".", "/", "-"를 지원하고 공백을 포함할 수 없습니다.',
|
||
disableFunction: '영어 문자, 밑줄 및 ,만 지원합니다',
|
||
leechExts: '영어 문자, 숫자 및 ,만 지원합니다',
|
||
paramSimple: '소문자와 숫자를 지원하며 길이는 1-128 자여야 합니다',
|
||
filePermission: '파일 권한 오류',
|
||
formatErr: '형식 오류입니다. 확인 후 다시 시도하세요',
|
||
phpExtension: '소문자 영어와 숫자, "_"만 지원합니다',
|
||
paramHttp: 'http:// 또는 https:// 로 시작해야 합니다',
|
||
phone: '전화번호 형식이 올바르지 않습니다',
|
||
authBasicPassword: '알파벳, 숫자 및 일반 특수 문자 지원, 길이 1-72',
|
||
length128Err: '길이는 128자를 초과할 수 없습니다',
|
||
maxLength: '길이는 {0}자를 초과할 수 없습니다',
|
||
alias: '영어, 숫자, - 및 _ 지원, 길이 1-128, -_로 시작하거나 끝날 수 없습니다.',
|
||
},
|
||
res: {
|
||
paramError: '요청이 실패했습니다. 나중에 다시 시도하세요!',
|
||
forbidden: '현재 사용자는 권한이 없습니다',
|
||
serverError: '서비스 예외',
|
||
notFound: '리소스가 존재하지 않습니다',
|
||
commonError: '요청이 실패했습니다',
|
||
},
|
||
service: {
|
||
serviceNotStarted: '{0} 서비스가 시작되지 않았습니다.',
|
||
},
|
||
status: {
|
||
running: '실행 중',
|
||
done: '완료',
|
||
scanFailed: '불완전',
|
||
success: '성공',
|
||
waiting: '대기 중',
|
||
waitForUpgrade: '업그레이드 대기 중',
|
||
waiting1: '대기 중',
|
||
failed: '실패',
|
||
stopped: '중지됨',
|
||
error: '오류',
|
||
created: '생성됨',
|
||
restarting: '재시작 중',
|
||
uploading: '업로드 중',
|
||
unhealthy: '비정상',
|
||
removing: '제거 중',
|
||
paused: '일시 중지',
|
||
exited: '종료됨',
|
||
partial: '부분 실행',
|
||
dead: '중단됨',
|
||
installing: '설치 중',
|
||
enabled: '활성화됨',
|
||
disabled: '비활성화됨',
|
||
normal: '정상',
|
||
building: '빌드 중',
|
||
upgrading: '업그레이드 중',
|
||
pending: '편집 대기',
|
||
rebuilding: '재빌드 중',
|
||
deny: '거부됨',
|
||
accept: '수락됨',
|
||
used: '사용 중',
|
||
unUsed: '사용 안 함',
|
||
starting: '시작 중',
|
||
recreating: '재생성 중',
|
||
creating: '생성 중',
|
||
init: '애플리케이션 대기 중',
|
||
ready: '정상',
|
||
applying: '적용 중',
|
||
uninstalling: '제거 중',
|
||
lost: '연결 끊김',
|
||
bound: '바인딩됨',
|
||
unbind: '미바인드',
|
||
exceptional: '예외',
|
||
free: '여유',
|
||
enable: '활성화됨',
|
||
disable: '비활성화됨',
|
||
deleted: '삭제됨',
|
||
notfound: '찾을 수 없음',
|
||
inactive: '시작되지 않음',
|
||
degraded: '저하됨',
|
||
inaccessible: '접근 불가',
|
||
unknown: '알 수 없음',
|
||
downloading: '다운로드 중',
|
||
packing: '패키징 중',
|
||
sending: '전송 중',
|
||
healthy: '정상',
|
||
executing: '실행 중',
|
||
installerr: '설치 실패',
|
||
applyerror: '적용 실패',
|
||
systemrestart: '중단됨',
|
||
starterr: '시작 실패',
|
||
uperr: '실행 실패',
|
||
new: '신규',
|
||
conflict: '충돌',
|
||
duplicate: '중복',
|
||
unexecuted: '실행되지 않음',
|
||
canceled: '취소됨',
|
||
unused: '미사용',
|
||
},
|
||
units: {
|
||
second: '초 | 초 | 초',
|
||
minute: '분 | 분 | 분',
|
||
hour: '시간 | 시간 | 시간',
|
||
day: '일 | 일 | 일',
|
||
week: '주 | 주 | 주',
|
||
month: '월 | 월 | 월',
|
||
year: '년 | 년 | 년',
|
||
time: '시간',
|
||
core: '코어 | 코어 | 코어',
|
||
secondUnit: '초',
|
||
minuteUnit: '분',
|
||
hourUnit: '시간',
|
||
dayUnit: '일',
|
||
millisecond: '밀리초',
|
||
semicolon: ';',
|
||
},
|
||
log: {
|
||
noLog: '로그 없음',
|
||
},
|
||
},
|
||
menu: {
|
||
home: '대시보드',
|
||
apps: '앱 스토어',
|
||
website: '웹사이트 | 웹사이트들',
|
||
project: '프로젝트 | 프로젝트들',
|
||
config: '구성 | 구성들',
|
||
ssh: 'SSH 설정',
|
||
firewall: '방화벽',
|
||
ssl: '인증서 | 인증서들',
|
||
database: '데이터베이스 | 데이터베이스들',
|
||
aiTools: 'AI',
|
||
mcp: 'MCP',
|
||
container: '컨테이너 | 컨테이너들',
|
||
cronjob: '크론 작업 | 크론 작업들',
|
||
system: '시스템',
|
||
security: '보안',
|
||
files: '파일',
|
||
monitor: '모니터링',
|
||
terminal: '터미널',
|
||
settings: '설정',
|
||
toolbox: '툴박스',
|
||
logs: '로그 | 로그들',
|
||
runtime: '런타임 | 런타임들',
|
||
processManage: '프로세스 | 프로세스들',
|
||
process: '프로세스 | 프로세스들',
|
||
network: '네트워크 | 네트워크들',
|
||
supervisor: '슈퍼바이저',
|
||
tamper: '변조 방지',
|
||
app: '애플리케이션',
|
||
msgCenter: '작업',
|
||
disk: '디스크',
|
||
template: '템플릿',
|
||
filter: '필터',
|
||
},
|
||
home: {
|
||
recommend: '추천',
|
||
dir: '디렉토리',
|
||
alias: '별칭',
|
||
quickDir: '빠른 액세스',
|
||
minQuickJump: '최소 하나의 빠른 액세스 항목을 추가하세요',
|
||
maxQuickJump: '빠른 액세스를 최대 4개까지 추가할 수 있습니다',
|
||
database: '데이터베이스 - 전체',
|
||
restart_1panel: '패널 재시작',
|
||
restart_system: '서버 재시작',
|
||
operationSuccess: '완료되었습니다. 재시작 중입니다. 나중에 브라우저를 새로 고침하세요.',
|
||
entranceHelper: '보안 진입이 활성화되어 있지 않습니다. "설정 -> 보안"에서 활성화하여 보안을 강화하세요.',
|
||
appInstalled: '설치된 애플리케이션',
|
||
systemInfo: '시스템 정보',
|
||
hostname: '호스트 이름',
|
||
platformVersion: '운영 체제',
|
||
kernelVersion: '커널',
|
||
kernelArch: '아키텍처',
|
||
network: '네트워크',
|
||
io: '디스크 I/O',
|
||
ip: '로컬 IP',
|
||
proxy: '시스템 프록시',
|
||
baseInfo: '기본 정보',
|
||
totalSend: '총 송신',
|
||
totalRecv: '총 수신',
|
||
rwPerSecond: 'I/O 작업',
|
||
ioDelay: 'I/O 지연 시간',
|
||
uptime: '작동 시간',
|
||
runningTime: '가동 시간',
|
||
mem: '시스템 메모리',
|
||
swapMem: '스왑 파티션',
|
||
runSmoothly: '낮은 부하',
|
||
runNormal: '보통 부하',
|
||
runSlowly: '높은 부하',
|
||
runJam: '심한 부하',
|
||
core: '물리적 코어',
|
||
logicCore: '논리 코어',
|
||
corePercent: '코어 사용률',
|
||
cpuFrequency: 'CPU 주파수',
|
||
cpuDetailedPercent: 'CPU 사용률 상세',
|
||
cpuUser: '사용자',
|
||
cpuSystem: '시스템',
|
||
cpuIdle: '유휴',
|
||
cpuIrq: 'IRQ',
|
||
cpuSoftirq: 'Soft IRQ',
|
||
cpuSteal: 'Steal',
|
||
cpuTop: 'CPU 사용률 상위 5개 프로세스 정보',
|
||
memTop: '메모리 사용률 상위 5개 프로세스 정보',
|
||
loadAverage: '지난 1분의 평균 부하 | 지난 {n} 분의 평균 부하',
|
||
load: '부하',
|
||
mount: '마운트 지점',
|
||
fileSystem: '파일 시스템',
|
||
total: '전체',
|
||
used: '사용',
|
||
cache: '<27>시',
|
||
free: '여유',
|
||
shard: '샤딩',
|
||
available: '사용 가능',
|
||
percent: '사용률',
|
||
goInstall: 'Go 설치',
|
||
networkCard: '네트워크 카드',
|
||
disk: '디스크',
|
||
memo: '메모',
|
||
memoPlaceholder: '편집 버튼을 클릭하여 편집을 활성화하세요.',
|
||
carouselSetting: '캐러셀 설정',
|
||
tooltipSensitiveInfo: '민감한 정보 표시/숨기기',
|
||
},
|
||
tabs: {
|
||
more: '더 보기',
|
||
hide: '숨기기',
|
||
closeLeft: '왼쪽 닫기',
|
||
closeRight: '오른쪽 닫기',
|
||
closeCurrent: '현재 탭 닫기',
|
||
closeOther: '다른 탭 닫기',
|
||
closeAll: '모두 닫기',
|
||
},
|
||
header: {
|
||
logout: '로그아웃',
|
||
},
|
||
database: {
|
||
manage: '관리',
|
||
deleteBackupHelper: '데이터베이스 백업을 동시에 삭제',
|
||
delete: '삭제 작업은 되돌릴 수 없습니다. 삭제하려면 "',
|
||
deleteHelper: '"를 입력하세요.',
|
||
userBoundDatabases: '다음 데이터베이스에 대한 접근 권한이 있습니다:',
|
||
noMysql: '데이터베이스 서비스 (MySQL 또는 MariaDB)',
|
||
noPostgresql: '데이터베이스 서비스 PostgreSQL',
|
||
goUpgrade: '업그레이드로 이동',
|
||
goInstall: '설치로 이동',
|
||
isDelete: '삭제됨',
|
||
permission: '권한',
|
||
format: '문자 집합',
|
||
collation: '콜레이션',
|
||
collationHelper: '비어 있으면 {0} 문자 집합의 기본 콜레이션을 사용합니다',
|
||
permissionForIP: 'IP',
|
||
permissionAll: '모두(%)',
|
||
localhostHelper:
|
||
'컨테이너 배포 시 데이터베이스 권한을 "localhost"로 설정하면 컨테이너 외부에서 접근할 수 없게 됩니다. 신중하게 선택하세요!',
|
||
databaseConnInfo: '연결',
|
||
rootPassword: '루트 비밀번호',
|
||
serviceName: '서비스 이름',
|
||
serviceNameHelper: '같은 네트워크 내 컨테이너 간의 접근.',
|
||
backupList: '백업',
|
||
loadBackup: '불러오기',
|
||
localUpload: '로컬 업로드',
|
||
hostSelect: '서버 선택',
|
||
selectHelper: '백업 파일 {0}을(를) 가져오시겠습니까?',
|
||
remoteAccess: '원격 접근',
|
||
remoteHelper: '여러 IP 를 쉼표로 구분하여 입력, 예: 172.16.10.111,172.16.10.112',
|
||
remoteConnHelper:
|
||
'MySQL 의 root 사용자로 원격 접속은 보안 위험을 초래할 수 있습니다. 따라서 이 작업은 신중히 수행해야 합니다.',
|
||
changePassword: '비밀번호',
|
||
changeConnHelper: '이 작업은 현재 데이터베이스 {0}을(를) 수정합니다. 계속하시겠습니까?',
|
||
changePasswordHelper:
|
||
'데이터베이스가 애플리케이션과 연결되어 있습니다. 비밀번호를 변경하면 애플리케이션의 데이터베이스 비밀번호도 변경됩니다. 변경 사항은 애플리케이션이 재시작된 후에 적용됩니다.',
|
||
recoverTimeoutHelper: '-1은 제한 시간 제한 없음을 의미합니다',
|
||
confChange: '설정',
|
||
confNotFound:
|
||
'설정 파일을 찾을 수 없습니다. 앱 스토어에서 애플리케이션을 최신 버전으로 업그레이드하고 다시 시도해주세요!',
|
||
portHelper: '이 포트는 컨테이너의 노출된 포트입니다. 수정을 별도로 저장하고 컨테이너를 재시작해야 합니다!',
|
||
loadFromRemote: '동기화',
|
||
userBind: '사용자 바인딩',
|
||
userAuthorization: '사용자 권한',
|
||
noUserAuthorization: '권한 부여 안 함',
|
||
authorizedDatabaseCount: '데이터베이스 {0}개 권한 보유',
|
||
authorizationManagement: '권한 관리',
|
||
authorizedUsers: '권한이 부여된 사용자',
|
||
authorizedUserCount: '사용자 {0}명',
|
||
addUserAuthorization: '사용자 권한 추가',
|
||
revokeAuthorization: '권한 취소',
|
||
revokeAuthorizationHelper: '사용자 {0}의 데이터베이스 {1} 접근 권한을 취소하시겠습니까?',
|
||
supplementPassword: '비밀번호 추가',
|
||
supplementPasswordHelper: '기존 비밀번호를 1Panel에만 저장하며 MySQL 비밀번호는 변경하지 않습니다.',
|
||
pgBindHelper:
|
||
'이 작업은 새 사용자를 생성하여 대상 데이터베이스에 바인딩하는 데 사용됩니다. 현재 데이터베이스에 이미 존재하는 사용자 선택은 지원되지 않습니다.',
|
||
pgSuperUser: '슈퍼 사용자',
|
||
loadFromRemoteHelper: '서버의 데이터베이스, 사용자 및 권한 정보를 1Panel로 동기화합니다. 계속하시겠습니까?',
|
||
passwordHelper: '확인 불가, 수정하려면 클릭',
|
||
remote: '원격',
|
||
remoteDB: '원격 서버 | 원격 서버들',
|
||
createRemoteDB: '원격 DB 바인딩',
|
||
unBindRemoteDB: '원격 DB 바인딩 해제',
|
||
unBindForce: '강제 바인딩 해제',
|
||
unBindForceHelper: '바인딩 해제 중 발생하는 모든 오류를 무시하고 최종 작업을 성공적으로 완료합니다.',
|
||
unBindRemoteHelper:
|
||
'원격 데이터베이스 바인딩 해제는 바인딩 관계만 제거하며, 원격 데이터베이스 자체는 삭제되지 않습니다.',
|
||
editRemoteDB: '원격 서버 편집',
|
||
localDB: '로컬 데이터베이스',
|
||
address: '데이터베이스 주소',
|
||
version: '데이터베이스 버전',
|
||
userHelper: '루트 사용자 또는 루트 권한을 가진 데이터베이스 사용자가 원격 데이터베이스에 접근할 수 있습니다.',
|
||
mongodbPermissionDbOwner: '데이터베이스 소유자',
|
||
mongodbPermissionRead: '데이터 읽기',
|
||
mongodbPermissionReadWrite: '데이터 읽기 및 쓰기',
|
||
mongodbPermissionUserAdmin: '사용자 관리자',
|
||
pgUserHelper: '슈퍼 사용자 권한을 가진 데이터베이스 사용자.',
|
||
ssl: 'SSL 사용',
|
||
clientKey: '클라이언트 개인 키',
|
||
clientCert: '클라이언트 인증서',
|
||
caCert: 'CA 인증서',
|
||
hasCA: 'CA 인증서 있음',
|
||
skipVerify: '인증서 유효성 검사 무시',
|
||
initialDB: '초기 데이터베이스',
|
||
formatHelper: '현재 데이터베이스 문자셋은 {0} 입니다. 문자셋 불일치로 인해 복구에 실패할 수 있습니다.',
|
||
dropHelper: '여기에 업로드한 파일을 드래그 앤 드롭하거나',
|
||
clickHelper: '클릭하여 업로드',
|
||
supportUpType:
|
||
'sql, sql.gz, tar.gz, .zip 파일 형식만 지원합니다. 가져오는 압축 파일에는 하나의 .sql 파일만 있거나 test.sql이 포함되어 있어야 합니다',
|
||
currentStatus: '현재 상태',
|
||
baseParam: '기본 파라미터',
|
||
performanceParam: '성능 파라미터',
|
||
runTime: '시작 시간',
|
||
connections: '전체 연결',
|
||
bytesSent: '전송된 바이트',
|
||
bytesReceived: '수신된 바이트',
|
||
queryPerSecond: '초당 쿼리',
|
||
txPerSecond: '초당 전송',
|
||
connInfo: '활성/최대 연결',
|
||
connInfoHelper: '값이 너무 크면 "max_connections" 값을 증가시켜야 합니다.',
|
||
threadCacheHit: '스레드 캐시 적중',
|
||
threadCacheHitHelper: '값이 너무 낮으면 "thread_cache_size" 값을 증가시켜야 합니다.',
|
||
indexHit: '인덱스 적중',
|
||
indexHitHelper: '값이 너무 낮으면 "key_buffer_size" 값을 증가시켜야 합니다.',
|
||
innodbIndexHit: 'Innodb 인덱스 적중률',
|
||
innodbIndexHitHelper: '값이 너무 낮으면 "innodb_buffer_pool_size" 값을 증가시켜야 합니다.',
|
||
cacheHit: '쿼리 캐시 적중',
|
||
cacheHitHelper: '값이 너무 낮으면 "query_cache_size" 값을 증가시켜야 합니다.',
|
||
tmpTableToDB: '디스크로 임시 테이블',
|
||
tmpTableToDBHelper: '값이 너무 크면 "tmp_table_size" 값을 증가시켜야 합니다.',
|
||
openTables: '열린 테이블',
|
||
openTablesHelper: '"table_open_cache" 설정 값이 이 값 이상이어야 합니다.',
|
||
selectFullJoin: '전체 조인 선택',
|
||
selectFullJoinHelper: '값이 0이 아니면 데이터 테이블의 인덱스가 올바른지 확인하십시오.',
|
||
selectRangeCheck: '인덱스 없는 조인 수',
|
||
selectRangeCheckHelper: '값이 0이 아니면 데이터 테이블의 인덱스가 올바른지 확인하십시오.',
|
||
sortMergePasses: '정렬된 병합 횟수',
|
||
sortMergePassesHelper: '값이 너무 크면 "sort_buffer_size" 값을 증가시켜야 합니다.',
|
||
tableLocksWaited: '테이블 잠금 대기',
|
||
tableLocksWaitedHelper: '값이 너무 크면 데이터베이스 성능을 증가시키는 것을 고려해야 합니다.',
|
||
performanceTuning: '성능 튜닝',
|
||
optimizationScheme: '최적화 방안',
|
||
keyBufferSizeHelper: '인덱스용 버퍼 크기',
|
||
queryCacheSizeHelper: '쿼리 캐시. 이 기능이 비활성화된 경우 이 값을 0으로 설정하세요.',
|
||
tmpTableSizeHelper: '임시 테이블 캐시 크기',
|
||
innodbBufferPoolSizeHelper: 'Innodb 버퍼 크기',
|
||
innodbLogBufferSizeHelper: 'Innodb 로그 버퍼 크기',
|
||
sortBufferSizeHelper: '* 연결당, 스레드 정렬 버퍼 크기',
|
||
readBufferSizeHelper: '* 연결당, 읽기 버퍼 크기',
|
||
readRndBufferSizeHelper: '* 연결당, 임의 읽기 버퍼 크기',
|
||
joinBufferSizeHelper: '* 연결당, 조인 테이블 캐시 크기',
|
||
threadStackelper: '* 연결당, 스레드별 스택 크기',
|
||
binlogCacheSizeHelper: '* 연결당, 이진 로그 캐시 크기 (4096의 배수)',
|
||
threadCacheSizeHelper: '스레드 풀 크기',
|
||
tableOpenCacheHelper: '테이블 캐시',
|
||
maxConnectionsHelper: '최대 연결 수',
|
||
restart: '재시작',
|
||
slowLog: '느린 로그',
|
||
noData: '아직 느린 로그가 없습니다.',
|
||
isOn: '켜짐',
|
||
longQueryTime: '임계값(s)',
|
||
thresholdRangeHelper: '올바른 임계값을 입력하십시오 (1 - 600).',
|
||
timeout: '타임아웃(s)',
|
||
timeoutHelper: '유휴 연결의 타임아웃 기간. 0은 연결이 지속적으로 유지됨을 의미합니다.',
|
||
maxclients: '최대 클라이언트',
|
||
requirepassHelper:
|
||
'비밀번호가 설정되지 않은 경우 이 필드를 비워 두세요. 변경 사항은 별도로 저장하고 컨테이너를 재시작해야 합니다!',
|
||
databases: '데이터베이스 수',
|
||
maxmemory: '최대 메모리 사용량',
|
||
maxmemoryHelper: '0은 제한이 없음을 의미합니다.',
|
||
tcpPort: '현재 수신 포트.',
|
||
uptimeInDays: '운영 일수.',
|
||
connectedClients: '연결된 클라이언트 수.',
|
||
usedMemory: '현재 Redis 의 메모리 사용량.',
|
||
usedMemoryRss: '운영 체제에서 요청한 메모리 크기.',
|
||
usedMemoryPeak: 'Redis 의 최대 메모리 소비량.',
|
||
memFragmentationRatio: '메모리 단편화 비율.',
|
||
totalConnectionsReceived: '시작 이후 총 연결된 클라이언트 수.',
|
||
totalCommandsProcessed: '실행된 총 명령 수.',
|
||
instantaneousOpsPerSec: '초당 서버에서 실행된 명령 수.',
|
||
keyspaceHits: '데이터베이스 키가 성공적으로 발견된 횟수.',
|
||
keyspaceMisses: '데이터베이스 키를 찾지 못한 횟수.',
|
||
hit: '데이터베이스 키 발견 비율.',
|
||
latestForkUsec: '마지막 fork() 작업에 소요된 마이크로초 수.',
|
||
redisCliHelper: '"redis-cli" 서비스가 감지되지 않았습니다. 서비스를 먼저 활성화하십시오.',
|
||
redisQuickCmd: 'Redis 빠른 명령',
|
||
recoverHelper: '이 작업은 데이터를 [{0}]으로 덮어씁니다. 계속하시겠습니까?',
|
||
mongodbRecoverDropAllCollections: '복원 전에 현재 데이터베이스 비우기',
|
||
mongodbRecoverDropAllCollectionsHelper:
|
||
'기본적으로는 기존 컬렉션만 덮어쓰고 새로 추가된 컬렉션은 유지합니다. 활성화하면 현재 데이터베이스를 비운 뒤 백업 내용으로 복원합니다.',
|
||
submitIt: '데이터 덮어쓰기',
|
||
baseConf: '기본 설정',
|
||
allConf: '모든 설정',
|
||
restartNow: '지금 재시작',
|
||
restartNowHelper1:
|
||
'구성 변경 사항이 적용되려면 시스템을 재시작해야 합니다. 데이터가 지속되어야 하는 경우 먼저 저장 작업을 수행하십시오.',
|
||
restartNowHelper: '이 작업은 시스템이 재시작된 후에만 적용됩니다.',
|
||
persistence: '지속성',
|
||
rdbHelper1: '초 단위, 삽입',
|
||
rdbHelper2: '데이터 항목 수',
|
||
rdbHelper3: '조건을 충족하면 RDB 지속성이 트리거됩니다.',
|
||
rdbInfo: '규칙 목록의 값이 1에서 100000 사이여야 합니다.',
|
||
containerConn: '컨테이너 연결',
|
||
copyConnURL: '연결 URL 복사',
|
||
connAddress: '주소',
|
||
containerConnHelper:
|
||
'이 연결 주소는 웹사이트 런타임(PHP 등) 또는 컨테이너에서 실행 중인 애플리케이션에서 사용할 수 있습니다.',
|
||
remoteConn: '외부 연결',
|
||
remoteConnHelper2: '컨테이너 환경이 아닌 경우 또는 외부 연결에는 이 주소를 사용하십시오.',
|
||
remoteConnHelper3:
|
||
'기본 접근 주소는 호스트 IP입니다. 수정하려면 패널 설정 페이지의 "기본 접근 주소" 구성 항목으로 이동하세요.',
|
||
localIP: '로컬 IP',
|
||
},
|
||
aiTools: {
|
||
agents: {
|
||
agent: '에이전트',
|
||
account: '모델 계정',
|
||
batchOperation: '일괄 작업',
|
||
operationType: '작업 유형',
|
||
batchAction: '일괄 {0}',
|
||
installSkillAction: 'Skill 배포',
|
||
batchAgentTask: '에이전트 일괄 {0}',
|
||
dispatchAgentTask: '에이전트 {0} 작업 배포',
|
||
dispatchTask: '{0} 작업 배포',
|
||
taskSubmitted: '{0} 작업이 전송되었습니다',
|
||
allNodes: '모든 노드',
|
||
targetVersion: '대상 버전',
|
||
skillSource: 'Skill 소스',
|
||
skillKeyword: 'Skill 키워드',
|
||
clawHubSkillPlaceholder: '먼저 Skill을 검색하고 선택하세요',
|
||
noAccountHint: '기존 모델 계정을 선택하거나 새로 추가하세요.',
|
||
accountCount: '모델 계정 {0}개',
|
||
syncAgents: '관련 에이전트 동기화',
|
||
syncAgentsHelper: '이 모델 계정을 사용하는 에이전트의 openclaw.json 업데이트',
|
||
appVersion: '앱 버전',
|
||
webuiPort: 'WebUI 포트',
|
||
tokenOrAuth: 'Token/인증',
|
||
allowedOrigins: '접속 주소',
|
||
allowedOriginsRequired: '접속 주소를 하나 이상 입력하세요',
|
||
allowedOriginsInvalid: 'http(s)://host-or-ip[:port] 형식으로 입력하세요',
|
||
provider: '모델 제공자',
|
||
accountModelsHelper: '이 계정이 OpenClaw에 제공할 모델을 설정합니다. 모델 전환 및 설정에 사용됩니다.',
|
||
accountModelsRequired: '모델을 하나 이상 설정하세요.',
|
||
verifyModel: '검증 모델',
|
||
verifyModelHelper:
|
||
'이 계정으로 사용할 수 있는 모델을 선택하세요. 저장할 때 최소 요청을 보내 연결을 검증합니다.',
|
||
verifyModelRequired: '검증 모델을 선택하세요',
|
||
discoverModels: '모델 가져오기',
|
||
automaticModelDiscovery: '자동 가져오기',
|
||
manualModelConfiguration: '수동 설정',
|
||
discoverModelsHelper: '공급자의 /v1/models API에서 모델을 가져와 모두 모델 풀에 추가합니다.',
|
||
discoverModelsFailedFallback: '모델을 가져오지 못했습니다. 모델을 직접 설정하세요.',
|
||
discoverModelsFailedUseDefaults: '모델을 가져오지 못했습니다. 기본 모델을 사용합니다.',
|
||
accountModelsDuplicate: '카탈로그에 중복된 모델이 있습니다',
|
||
modelPool: '모델 풀',
|
||
fallbackModels: '폴백 모델',
|
||
addFallbackModel: '폴백 모델 추가',
|
||
fallbackModelsEmpty: '구성된 폴백 모델이 없습니다',
|
||
modelInputTypes: '입력 유형',
|
||
reasoning: '추론 모델',
|
||
verified: '검증됨',
|
||
verifySkipped: '검증 안 함',
|
||
skillsTab: '기술',
|
||
pluginsTab: '플러그인',
|
||
pluginsInstalled: '설치됨',
|
||
pluginsMarket: '플러그인 마켓',
|
||
pluginsMarketHint: '키워드를 입력하여 플러그인을 검색하세요',
|
||
pluginSearchPlaceholder: '플러그인 검색...',
|
||
pluginOrigin: '출처',
|
||
pluginOriginAll: '모든 출처',
|
||
pluginOriginBundled: '내장',
|
||
pluginOriginExternal: '외부',
|
||
pluginStatusAll: '모든 상태',
|
||
pluginEnabled: '활성화됨',
|
||
pluginDisabled: '비활성화됨',
|
||
pluginCategory: '분류',
|
||
pluginVerification: '검증',
|
||
pluginOfficial: '공식',
|
||
pluginCommunity: '커뮤니티',
|
||
pluginDownloads: '다운로드',
|
||
pluginEnable: '활성화',
|
||
pluginDisable: '비활성화',
|
||
pluginListEmpty: '플러그인이 없습니다',
|
||
pluginSearchEmpty: '일치하는 플러그인을 찾을 수 없습니다',
|
||
pluginInstallConfirm: '플러그인 {0}을(를) 설치하시겠습니까?',
|
||
pluginDisableConfirm: '플러그인 {0}을(를) 비활성화하시겠습니까?',
|
||
pluginUninstallConfirm: '플러그인 {0}을(를) 제거하시겠습니까?',
|
||
securityTab: '보안',
|
||
otherTab: '기타',
|
||
timeZone: '시간대',
|
||
browserEnabled: '브라우저 활성화',
|
||
npmRegistry: 'NPM 레지스트리',
|
||
npmRegistryHelper:
|
||
'OpenClaw 플러그인 설치에 사용됩니다. 사전 설정된 레지스트리를 선택하거나 사용자 지정 레지스트리를 입력할 수 있습니다.',
|
||
npmRegistryInvalid: 'http:// 또는 https:// 로 시작하는 올바른 NPM 레지스트리 URL을 입력하세요',
|
||
pluginInstallNPMRegistryHelper:
|
||
'설정 -> 기타에서 NPM 레지스트리를 설정하면 플러그인 설치 속도를 높일 수 있습니다',
|
||
skillsSearchPlaceholder: '기술 검색...',
|
||
skillsEmpty: '기술 없음',
|
||
skillsMarket: '기술 마켓',
|
||
skillsMarketHint: '소스를 선택하고 기술을 검색하세요',
|
||
skillsMarketEmpty: '관련 기술을 찾을 수 없습니다',
|
||
skillsMarketSourceClawhubGlobal: 'ClawHub (글로벌)',
|
||
skillsMarketSourceClawhubChina: 'ClawHub (중국)',
|
||
skillsMarketSourceSkillhub: 'SkillHub (Tencent)',
|
||
skillsMarketSourceLocalHub: '로컬 Skill 스토어',
|
||
skillsScore: '점수',
|
||
skillsMarketSourceOfficial: '공식',
|
||
versionUnsupportedTitle: '현재 버전에서는 이 기능을 지원하지 않습니다',
|
||
versionUnsupportedHelper: 'OpenClaw 를 버전 {0} 이상으로 업그레이드하세요.',
|
||
skillsGroupBuiltIn: '내장',
|
||
skillsGroupExternal: '외부',
|
||
skillsGroupWorkspace: '워크스페이스',
|
||
switchModelSuccess: '모델이 성공적으로 전환되었습니다',
|
||
channelsTab: '채널',
|
||
agentRoleTab: '에이전트',
|
||
agentRoleUnsupported: '역할 관리는 현재 OpenClaw 에서만 지원됩니다.',
|
||
workspace: '워크스페이스 디렉터리',
|
||
agentDir: '에이전트 디렉터리',
|
||
roleMarkdownDescriptions: {
|
||
'AGENTS.md': [
|
||
'에이전트의 운영 지침과 메모리를 어떻게 사용할지에 대한 설명입니다.',
|
||
'모든 세션 시작 시 로드됩니다.',
|
||
'규칙, 우선순위, 동작 방식의 세부 내용을 적기에 좋습니다.',
|
||
],
|
||
'SOUL.md': ['페르소나, 말투, 경계.', '매 세션마다 로드됩니다.'],
|
||
'USER.md': ['사용자가 누구인지, 어떻게 호칭할지.', '매 세션마다 로드됩니다.'],
|
||
'IDENTITY.md': ['에이전트의 이름, 분위기, 이모지.', '부트스트랩 절차 중 생성되거나 업데이트됩니다.'],
|
||
'TOOLS.md': [
|
||
'로컬 도구와 사용 규약에 대한 메모입니다.',
|
||
'도구 사용 가능 여부를 제어하지 않으며, 안내용 설명입니다.',
|
||
],
|
||
'HEARTBEAT.md': ['heartbeat 실행용 선택 체크리스트입니다.', '토큰 낭비를 막기 위해 짧게 유지하세요.'],
|
||
'BOOT.md': [
|
||
'내부 훅이 켜져 있을 때 gateway 재시작 시 실행되는 선택 시작 체크리스트입니다.',
|
||
'짧게 유지하고, 외부 발신은 message 도구를 사용하세요.',
|
||
],
|
||
'BOOTSTRAP.md': [
|
||
'최초 실행 시 한 번만 수행되는 절차입니다.',
|
||
'완전히 새로운 작업공간에서만 생성됩니다.',
|
||
'절차가 끝나면 삭제하세요.',
|
||
],
|
||
},
|
||
duplicateBinding: '채널과 계정 ID 조합은 중복될 수 없습니다',
|
||
accountIdOptional: '계정 ID (선택 사항)',
|
||
saveAllMd: '모두 저장',
|
||
roleMarkdownRestartHelper:
|
||
'현재 markdown 파일을 모두 저장하려면 적용을 위해 컨테이너를 재시작해야 합니다. 지금 재시작할지 나중에 재시작할지 선택하세요.',
|
||
configFileRestartHelper: '설정 파일을 저장하려면 즉시 컨테이너를 재시작해야 적용됩니다.',
|
||
overviewSnapshot: '개요',
|
||
primaryModel: '주 모델',
|
||
defaultModel: '기본 모델',
|
||
channelCount: '설정된 채널 수',
|
||
skillCount: '기술 수',
|
||
jobCount: '예약 작업 수',
|
||
sessionCount: '세션 수',
|
||
hermesChatAction: '대화',
|
||
hermesChatTitle: 'Hermes 대화',
|
||
hermesChatDialogTitle: 'Hermes 대화 - {0}',
|
||
hermesChatNewChat: '새 대화',
|
||
hermesChatNoSessions: '세션이 없습니다',
|
||
hermesChatMessageCount: '{0}개',
|
||
hermesChatEmptyHint: '왼쪽 세션을 선택하거나 새 대화를 클릭하세요',
|
||
hermesChatTitlePlaceholder: '세션 제목을 입력하세요',
|
||
hermesChatRenameSuccess: '세션 제목이 업데이트되었습니다',
|
||
hermesChatDeleteConfirm: '세션 {0}을(를) 삭제하시겠습니까?',
|
||
hermesChatDeleteSuccess: '세션이 삭제되었습니다',
|
||
weixin: 'Weixin',
|
||
wecom: 'WeCom',
|
||
dingtalk: 'DingTalk',
|
||
feishu: 'Feishu',
|
||
pluginNotInstalled: '플러그인이 설치되지 않았습니다. 먼저 설치해 주세요.',
|
||
dmPolicy: 'DM 정책',
|
||
threadSession: '스레드 세션',
|
||
replyMode: '응답 모드',
|
||
requireMention: '멘션 요구',
|
||
requireMentionTrue: "{'@'} 필요",
|
||
requireMentionFalse: "{'@'} 불필요",
|
||
requireMentionOpen: '그룹 설정 따름',
|
||
groupPolicy: '그룹 정책',
|
||
policyAllowlist: '허용 목록',
|
||
policyOpen: '열림',
|
||
policyDisabled: '비활성화',
|
||
bots: '봇',
|
||
addBot: '봇 추가',
|
||
accountId: '계정 ID',
|
||
accountIdPlaceholder: '봇을 구분하는 고유 ID이며 저장 후 설정과 라우팅 식별에 사용됩니다.',
|
||
setDefaultBot: '기본값으로 설정',
|
||
botDuplicateField: '{field}이(가) 이미 존재합니다',
|
||
botRequired: '봇을 하나 이상 추가하세요',
|
||
botId: '봇 ID',
|
||
allowFrom: 'DM 허용 목록',
|
||
allowFromPlaceholder: '한 줄에 하나의 발신자 ID',
|
||
allowlistPolicyHelper: '{0}. {1}이(가) 허용 목록일 때만 사용됩니다.',
|
||
systemPrompt: '시스템 프롬프트',
|
||
groupAllowFrom: '그룹 허용 목록',
|
||
groupAllowFromPlaceholder: '한 줄에 하나의 그룹 ID',
|
||
separateSessionByConversation: '대화별 세션 분리',
|
||
groupSessionScope: '그룹 세션 범위',
|
||
groupSessionScopeGroup: '그룹 공유',
|
||
groupSessionScopeGroupSender: '발신자별',
|
||
sharedMemoryAcrossConversations: '대화 간 메모리 공유',
|
||
asyncMode: '비동기 모드',
|
||
ackText: '확인 메시지',
|
||
ackTextDefault: '작업을 받았습니다. 처리 중입니다...',
|
||
streaming: '스트리밍',
|
||
streamingOff: '끄기',
|
||
streamingPartial: '부분 출력',
|
||
streamingBlock: '블로킹 출력',
|
||
streamingProgress: '진행 출력',
|
||
allowFromRequired: '허용 목록 항목을 하나 이상 입력하세요',
|
||
pairingCode: '페어링 코드',
|
||
pairingCodePlaceholder: '페어링 코드를 입력하세요',
|
||
approvePairing: '페어링 승인',
|
||
saveSuccess: '저장되었습니다',
|
||
successAndRestart: '{0}. 컨테이너를 자동으로 재시작하는 중입니다.',
|
||
pairingApproveSuccess: '페어링이 승인되었습니다',
|
||
scanConnect: '스캔하여 연결',
|
||
scanConnectHelper:
|
||
'클릭하여 QR 로그인 작업을 시작하세요. QR 코드는 작업 로그에 표시되며 스캔이 완료되면 컨테이너가 자동으로 재시작됩니다.',
|
||
channelAutoRestartHelper: '저장하면 설정 적용을 위해 컨테이너가 자동으로 재시작됩니다.',
|
||
dashboardAuthAutoRebuildHelper:
|
||
'사용자 이름 또는 비밀번호를 저장하면 변경 사항 적용을 위해 컨테이너가 자동으로 재생성됩니다.',
|
||
channelDeleteConfirm: '{0} 채널 구성을 삭제하시겠습니까?',
|
||
apiTypeBaseURLHelper: '이 유형은 최종적으로 {0}에 요청합니다. 권장 Base URL: {1}',
|
||
customImageURLHelper:
|
||
'Custom 계정에는 전체 이미지 생성 엔드포인트 URL을 입력하세요. 경로는 자동으로 추가되지 않습니다. 예: {0}',
|
||
apiTypeBaseURLMismatch: '현재 Base URL은 {0} 경로처럼 보이지만 {1}이 선택되었습니다. 권장 URL: {2}',
|
||
validateAvailability: '계정 가용성 확인',
|
||
validateAvailabilityHelper: '저장 전에 최소 메시지를 보내 API를 확인합니다',
|
||
validateImageAvailabilityHelper: '저장 전에 최소 이미지 한 장을 생성하며 비용이 발생할 수 있습니다',
|
||
},
|
||
model: {
|
||
model: '모델',
|
||
localModel: '로컬 모델',
|
||
create_helper: '가져오기 "{0}"',
|
||
ollama_doc: 'Ollama 공식 웹사이트를 방문하여 더 많은 모델을 검색하고 찾을 수 있습니다.',
|
||
container_conn_helper: '컨테이너 간 접근 또는 연결에 이 주소를 사용',
|
||
ollama_sync: 'Ollama 모델 동기화 중 다음 모델이 존재하지 않음을 발견했습니다. 삭제하시겠습니까?',
|
||
from_remote: '이 모델은 1Panel을 통해 다운로드되지 않았으며 관련 풀 로그가 없습니다.',
|
||
no_logs: '이 모델의 풀 로그가 삭제되어 관련 로그를 볼 수 없습니다.',
|
||
vllmVersionHelper: 'FusionXpark GB 10 서버는 -cu130 버전을 선택하세요.',
|
||
vllmCommandPortHelper: '시작 명령은 {0} 포트를 사용해야 하며, 그렇지 않으면 서비스에 접근할 수 없습니다.',
|
||
syncModelAccount: '모델 계정에 동기화',
|
||
modelAccountAddressHelper:
|
||
'컨테이너 주소는 에이전트 컨테이너 호출에 적합합니다. 127.0.0.1, 시스템 IP 또는 사용자 지정 주소는 AI Gateway 또는 외부 서비스 호출에 적합합니다.',
|
||
containerAddress: '컨테이너 주소',
|
||
customAddress: '사용자 지정 주소',
|
||
downloader: '다운로더',
|
||
modelDir: '모델 디렉토리',
|
||
manualDownload: '수동 다운로드',
|
||
modelSource: '모델 소스',
|
||
repoID: '저장소 ID',
|
||
endpointLabel: '{0} 엔드포인트',
|
||
acceleratedEndpointLabel: '{0} 가속 엔드포인트',
|
||
tokenOptionalLabel: '{0} Token (선택 사항)',
|
||
searchSource: '{0} 검색',
|
||
hfEndpointHelper:
|
||
'HuggingFace 접속이 불안정할 때 가속 엔드포인트를 설정하세요. 검색, 상세 정보, 다운로드에 사용됩니다.',
|
||
sortTrending: '인기 트렌드',
|
||
sortLikes: '좋아요 많은 순',
|
||
sortDownloads: '다운로드 많은 순',
|
||
sortUpdated: '최근 업데이트',
|
||
sortCreated: '최신 생성',
|
||
downloadsCount: '다운로드 수',
|
||
likes: '좋아요',
|
||
taskQueue: '다운로드 대기열',
|
||
progress: '진행률',
|
||
localDownloaded: '다운로드됨',
|
||
modelInfo: '모델 상세 정보',
|
||
downloading: '다운로드 중',
|
||
canceled: '취소됨',
|
||
downloadQueued: '다운로드 대기열에 추가되었습니다',
|
||
cancelTaskConfirm: '이 다운로드 작업을 취소하시겠습니까?',
|
||
deleteLocalModelConfirm: '로컬 모델 {0}을(를) 삭제하시겠습니까?',
|
||
},
|
||
proxy: {
|
||
proxy: 'AI 게이트웨이 강화',
|
||
proxyHelper1: '도메인을 바인딩하고 HTTPS를 활성화하여 전송 보안을 강화',
|
||
proxyHelper2: 'IP 접근을 제한하여 공용 인터넷에서의 노출을 방지',
|
||
proxyHelper3: '스트리밍을 활성화',
|
||
proxyHelper4: '생성 후, 웹사이트 목록에서 이를 보고 관리할 수 있습니다',
|
||
proxyHelper5:
|
||
'활성화한 후, 앱 스토어 - 설치됨 - Ollama - 매개변수에서 포트 외부 접근을 비활성화하여 보안을 강화할 수 있습니다.',
|
||
proxyHelper6: '프록시 구성을 비활성화하려면 웹사이트 목록에서 삭제할 수 있습니다.',
|
||
whiteListHelper: '화이트리스트에 있는 IP만 접근 허용',
|
||
},
|
||
aiProxy: {
|
||
title: 'AI 게이트웨이',
|
||
apiReference: 'API 안내',
|
||
notInstalled: '설치되지 않음',
|
||
usage: '사용량',
|
||
accountPool: '계정 풀',
|
||
importModelAccount: '모델 계정 가져오기',
|
||
editModelAccount: '모델 계정 편집',
|
||
selectModelAccount: '기존 모델 계정 선택',
|
||
upstreamApiAddress: '업스트림 API 주소',
|
||
priority: '우선순위',
|
||
healthStatus: '상태',
|
||
failureCount: '실패 횟수',
|
||
lastError: '최근 오류',
|
||
modelMap: '모델 매핑',
|
||
apiKeyKeepEmpty: 'API Key (비워 두면 변경하지 않음)',
|
||
apiKeyOnceHint: 'API Key는 생성 시 한 번만 표시됩니다. 지금 복사하여 저장하세요.',
|
||
apiKeyOnceSave: 'API Key는 한 번만 표시됩니다. 지금 저장하세요:',
|
||
qpsLimit: 'QPS 제한',
|
||
tokenLimit: 'Token 제한',
|
||
tokenUsed: '사용한 Token',
|
||
tokenRemaining: '남은 Token',
|
||
resetToken: 'Token 재설정',
|
||
resetTokenConfirm: '{0}의 Token 사용량을 재설정하시겠습니까?',
|
||
unlimited: '무제한',
|
||
unlimitedWithAuto: '무제한, auto 포함',
|
||
lastUsedAt: '최근 사용 시간',
|
||
validityPeriod: '유효 기간',
|
||
keepCurrentValidity: '현재 유효 기간 유지',
|
||
neverExpires: '만료 없음',
|
||
validForDays: '{0}일 동안 유효',
|
||
customDays: '사용자 지정 일수',
|
||
enterValidityDays: '유효 일수를 입력하세요',
|
||
currentExpiresAt: '현재 만료 시간: {0}',
|
||
currentNeverExpires: '현재 만료되지 않음',
|
||
expiresAt: '만료 시간',
|
||
expired: '만료됨',
|
||
reactivate: '다시 활성화',
|
||
settingTitle: 'AI 게이트웨이 설정',
|
||
basicSetting: '기본 설정',
|
||
performanceSetting: '성능 설정',
|
||
logSetting: '로그 설정',
|
||
lbPolicy: '부하 분산 정책',
|
||
protocolConversion: '프로토콜 변환',
|
||
protocolConversionDesc:
|
||
'Chat Completions, Responses 및 Anthropic Messages 간에 지원되는 직접 변환을 허용합니다. 네이티브 프로토콜이 항상 우선합니다.',
|
||
protocolConversionRisk:
|
||
'프로토콜 변환은 무손실을 보장하지 않습니다. 프로토콜 전용 필드, 도구 호출, 추론 또는 멀티모달 콘텐츠가 축소되거나 손실될 수 있으므로 위험을 고려한 후 사용하세요.',
|
||
lbPolicyRoundRobin: '라운드 로빈',
|
||
lbPolicyRoundRobinDesc:
|
||
'사용 가능한 모델 계정을 순서대로 선택합니다. 백엔드 성능이 비슷한 경우에 적합합니다.',
|
||
lbPolicyWeightedRoundRobin: '가중 라운드 로빈',
|
||
lbPolicyWeightedRoundRobinDesc:
|
||
'모델 계정의 가중치에 따라 요청을 분배합니다. 가중치가 높을수록 더 많은 트래픽을 받습니다.',
|
||
lbPolicyFailover: '장애 조치',
|
||
lbPolicyFailoverDesc:
|
||
'우선순위가 가장 높은 모델 계정을 먼저 사용하고, 실패 또는 쿨다운 후 다음 사용 가능한 계정으로 전환합니다.',
|
||
maxConcurrency: '최대 동시성',
|
||
queueSize: '대기열 크기',
|
||
queueTimeoutSeconds: '대기열 대기 시간 초과(초)',
|
||
requestTimeoutSeconds: '비스트리밍 요청 시간 초과(초)',
|
||
streamIdleTimeoutSeconds: '스트리밍 유휴 시간 초과(초)',
|
||
maxBodyMb: '최대 요청 본문(MB)',
|
||
runtimeRefreshSeconds: 'Runtime 새로고침 간격(초)',
|
||
logRetentionDays: 'AI 게이트웨이 로그 보관 일수',
|
||
clearLogs: '로그 비우기',
|
||
clearLogsConfirm:
|
||
'AI 게이트웨이 사용 통계, 콘텐츠 컴플라이언스 감사, 스마트 라우팅 결정, 요청 본문 로그 및 서비스 로그를 비웁니다. 계속하시겠습니까?',
|
||
usageRetentionDays: '사용 통계 보관 일수',
|
||
contentAuditRetentionDays: '콘텐츠 컴플라이언스 감사 로그 보관 일수',
|
||
logCleanupIntervalHours: '로그 정리 간격(시간)',
|
||
requestBodyLog: '요청 본문 로그',
|
||
requestBodyLogDesc:
|
||
'검색, 감사, 문제 해결을 위해 AI Gateway 요청 및 응답 본문을 Elasticsearch에 저장합니다.',
|
||
requestBodyLogIndexPrefix: '인덱스 접두사',
|
||
requestBodyLogRetentionDays: '요청 본문 로그 보관 일수',
|
||
requestBodyLogMaxBodyKb: '최대 요청 본문 크기(KB)',
|
||
requestBody: '요청 본문',
|
||
requestBodySize: '요청 본문 크기',
|
||
requestBodyTruncated: '잘림 여부',
|
||
responseBody: '응답 본문',
|
||
responseBodySize: '응답 본문 크기',
|
||
responseBodyTruncated: '응답 본문 잘림 여부',
|
||
readableContent: '읽기 쉬운 내용',
|
||
rawResponse: '원본 응답',
|
||
replyContent: '응답 내용',
|
||
reasoningContent: '추론 내용',
|
||
statusTitle: 'AI 게이트웨이 상태',
|
||
serviceEnabled: '서비스 자동 시작',
|
||
proxyEnabled: '게이트웨이 활성화',
|
||
statusMessage: '상태 메시지',
|
||
esLogDropped: '삭제된 ES 로그',
|
||
esLogLastSuccessAt: '마지막 ES 쓰기',
|
||
esLogCircuitOpen: '서킷 오픈',
|
||
esLogCircuitUntil: 'ES 서킷 종료 시간',
|
||
serviceOperateConfirm: 'AI 게이트웨이 서비스를 {0}하시겠습니까?',
|
||
deleteTargetConfirm: '{0} {1}을(를) 삭제하시겠습니까?',
|
||
deleteBackendTitle: '모델 계정 삭제',
|
||
userFallback: '삭제된 사용자 (ID: {0})',
|
||
requestModel: '요청 모델',
|
||
upstreamModel: '업스트림 모델',
|
||
upstreamDuration: '업스트림 시간',
|
||
requestModelPlaceholder: '예: qwen2.5-coder',
|
||
upstreamModelPlaceholder: '예: Qwen/Qwen2.5-Coder-32B-Instruct',
|
||
addMapping: '매핑 추가',
|
||
overview: '개요',
|
||
distribution: '분포',
|
||
usageTrend: '사용 추세',
|
||
distributionBy: '{0}별 분포',
|
||
unmatched: '미일치',
|
||
modelAccount: '모델 계정',
|
||
serviceProvider: '제공자',
|
||
tokenUsage: 'Token 사용량',
|
||
percent: '비율',
|
||
ranking: '순위',
|
||
rank: '순위',
|
||
promptToken: '입력 Token',
|
||
completionToken: '출력 Token',
|
||
totalToken: '총 Token',
|
||
cachedToken: '캐시 Token',
|
||
cacheHitRate: '캐시 적중률',
|
||
activeUsers: '활성 사용자',
|
||
activeModels: '활성 모델',
|
||
failedRequests: '실패한 요청',
|
||
averageTokenPerRequest: '평균 Token/요청',
|
||
callLogs: '호출 로그',
|
||
usageKeywordPlaceholder: 'Request ID / 모델 / 업스트림 모델 / 오류 메시지 검색',
|
||
attemptChain: '시도 체인',
|
||
attemptIndex: '호출 순서',
|
||
clientProtocol: '클라이언트 API',
|
||
upstreamProtocol: '업스트림 API',
|
||
conversionPath: '변환 경로',
|
||
noAttemptDetails: '호출 체인 기록이 없습니다',
|
||
input: '입력',
|
||
output: '출력',
|
||
total: '합계',
|
||
healthHealthy: '정상',
|
||
healthCooldown: '쿨다운',
|
||
healthUnhealthy: '비정상',
|
||
healthDeleted: '삭제됨',
|
||
healthUnknown: '알 수 없음',
|
||
validationModelMapEmpty: '모델 매핑의 모델 이름은 비워 둘 수 없습니다',
|
||
validationModelMapDuplicate: '요청 모델 {0}이(가) 중복되었습니다',
|
||
modelGroup: '모델 그룹',
|
||
modelCapability: '모델 기능',
|
||
textGeneration: '텍스트 생성',
|
||
imageGeneration: '이미지 생성',
|
||
textModels: '텍스트 모델',
|
||
textToImageModels: '텍스트-이미지 모델',
|
||
unauthorized: '권한 없음',
|
||
imageCount: '이미지 수',
|
||
availableModels: '사용 가능한 모델',
|
||
modelGroupModels: '요청 모델',
|
||
modelGroupModelsPlaceholder: '요청 모델 이름을 선택하거나 입력하세요',
|
||
modelGroupModelsHelper:
|
||
'클라이언트가 AI 게이트웨이를 호출할 때 사용하는 요청 모델 이름을 입력하세요. 스마트 라우팅은 순서대로 모델을 우선 선택하며 모델 간 부하 분산은 하지 않습니다.',
|
||
modelGroupGuide:
|
||
'모델 그룹에는 AI 게이트웨이가 노출하는 요청 모델 이름을 설정합니다. 업스트림 모델은 계정 풀의 모델 매핑에서 설정하세요. auto는 가상 모델 이름이므로 모델 그룹에 추가하지 않습니다.',
|
||
modelGroupModelCount: '{0}개 모델',
|
||
contentCompliance: 'Content Compliance',
|
||
contentAction: 'Action',
|
||
actionBlock: 'Block',
|
||
actionAuditOnly: 'Audit only',
|
||
actionDropHistory: '기록 삭제',
|
||
severity: 'Severity',
|
||
severityHigh: 'High',
|
||
severityMedium: 'Medium',
|
||
severityLow: 'Low',
|
||
sensitiveWord: 'Sensitive word',
|
||
sensitiveGroup: 'Sensitive word group',
|
||
sensitiveWordCount: 'Words',
|
||
normalizedWord: 'Normalized word',
|
||
matchedWords: 'Matched words',
|
||
matchedGroups: 'Matched groups',
|
||
importResult: 'Imported {0}, duplicated {1}, invalid {2}',
|
||
auditLogs: 'Audit Logs',
|
||
smartRoute: '스마트 라우팅',
|
||
smartRouteGuideTitle: '클라이언트에서 model=auto를 사용해 스마트 라우팅에 진입합니다',
|
||
smartRouteGuideReady:
|
||
'model=auto는 요청 복잡도에 따라 간단/복잡 모델 그룹에서 모델을 선택합니다. 다른 model은 일반 AI 게이트웨이로 전달됩니다.',
|
||
smartRouteGuideNotReady:
|
||
'먼저 설정에서 스마트 라우팅을 켜고 간단/복잡 모델 그룹을 설정하세요. 이후 클라이언트에서 model=auto를 사용합니다.',
|
||
copyAutoModel: 'auto 복사',
|
||
goSmartRouteSetting: '설정으로 이동',
|
||
smartRoutePolicy: '라우팅 정책',
|
||
routeConfig: '라우팅 설정',
|
||
embeddingConfig: 'Embedding 설정',
|
||
embeddingConfigDesc:
|
||
'스마트 라우팅과 콘텐츠 컴플라이언스 의미 샘플 매칭에 사용됩니다. 권장: llama.cpp + Qwen3-Embedding-0.6B. 샘플 벡터를 재생성하기 전에 설정하세요.',
|
||
decisionConfig: '판정 매개변수',
|
||
simpleModelGroup: '간단 모델 그룹',
|
||
complexModelGroup: '복잡 모델 그룹',
|
||
embeddingEndpoint: '엔드포인트',
|
||
embeddingModel: '모델',
|
||
embeddingApiKey: 'API Key',
|
||
routeThreshold: '라우팅 임계값',
|
||
routeThresholdHelper:
|
||
'스마트 라우팅용: 요청과 간단/복잡 샘플의 유사도가 이 값에 도달한 경우에만 샘플 매칭을 사용합니다.',
|
||
auditThreshold: '감사 임계값',
|
||
auditThresholdHelper:
|
||
'콘텐츠 준수용: 요청과 감사 샘플의 유사도가 이 값에 도달한 경우에만 일치로 판단합니다.',
|
||
topK: 'TopK',
|
||
topKHelper: '매번 비교할 가장 유사한 샘플 수입니다.',
|
||
members: '멤버',
|
||
samples: '샘플',
|
||
routeSamplesGuide:
|
||
'샘플은 간단/복잡 요청 예시이며 Embedding 유사도 매칭에 사용됩니다. 실제 사용자 요청을 작성하고 추가 후 벡터를 생성하거나 재생성하세요.',
|
||
rebuildVectors: '벡터 재생성',
|
||
rebuildVectorsConfirm:
|
||
'벡터를 재생성하면 Embedding 서비스가 스마트 라우팅 및 콘텐츠 컴플라이언스 샘플을 다시 처리합니다. 계속하시겠습니까?',
|
||
createVectorOnImport: '가져온 후 벡터 생성',
|
||
createVectorOnImportHelper:
|
||
'기본 선택입니다. Embedding이 설정되어 있으면 백그라운드 작업으로 벡터를 생성하고, 없으면 샘플만 생성합니다.',
|
||
route: '라우팅',
|
||
audit: '감사',
|
||
auditSamples: '감사 샘플',
|
||
sampleText: '텍스트',
|
||
sampleLabel: '라벨',
|
||
vectorModel: '벡터 모델',
|
||
vectorDim: '차원',
|
||
threshold: '임계값',
|
||
preview: '미리보기',
|
||
previewGuide:
|
||
'미리보기는 요청이 간단한지 복잡한지 테스트하며 업스트림 모델을 호출하지 않습니다. 소스는 샘플 매칭 또는 규칙 판단입니다.',
|
||
previewPlaceholder: '요청 텍스트 입력',
|
||
confidence: '신뢰도',
|
||
bestSampleSimilarity: '최고 샘플 유사도',
|
||
source: '소스',
|
||
sourceHeuristic: '규칙 판단',
|
||
sourceEmbedding: '샘플 매칭',
|
||
latency: '지연 시간',
|
||
decisionLogs: '결정 로그',
|
||
requestID: '요청 ID',
|
||
simple: '간단',
|
||
complex: '복잡',
|
||
sampleLabelSafe: '안전',
|
||
sampleLabelReview: '검토',
|
||
sampleLabelBlock: '차단',
|
||
latencyMs: '지연 시간(ms)',
|
||
smartRouteSettingGuide:
|
||
'활성화 후 model=auto 요청만 스마트 라우팅을 사용합니다. 간단 모델 그룹은 저비용 작업, 복잡 모델 그룹은 코드 분석, 아키텍처 설계, 장애 조사 등에 사용됩니다.',
|
||
sampleLabelPlaceholder: 'simple / complex / high',
|
||
sampleImportPlaceholder: '한 줄에 샘플 하나',
|
||
apiKeyCount: '数量',
|
||
},
|
||
skillsHub: {
|
||
title: 'Skills Hub',
|
||
upload: 'Skill 업로드',
|
||
importSkill: 'Skill 가져오기',
|
||
repositoryAddress: '저장소 주소',
|
||
repositoryGithubOnly: 'GitHub 저장소 주소만 지원됩니다',
|
||
repositoryRef: '브랜치 또는 Tag',
|
||
repositoryRefPlaceholder: '기본값은 main이며, 실패하면 master를 시도합니다',
|
||
repositoryDownloadPreview: '대상 다운로드 URL:',
|
||
packageURL: '패키지 URL',
|
||
packageURLPlaceholder: '.zip 패키지 주소를 입력하세요',
|
||
importSuccess: 'Skill을 성공적으로 가져왔으며 검토 대기 상태가 되었습니다.',
|
||
source: '출처',
|
||
applicableAgent: '적용 에이전트',
|
||
overview: '개요',
|
||
versionHistory: '버전 기록',
|
||
publishedAt: '게시 시간',
|
||
versionMarker: '표시',
|
||
currentVersion: '현재 보기',
|
||
latestVersion: '최신 버전',
|
||
latestPublished: '최신 게시',
|
||
riskLevel: '위험 수준',
|
||
riskReferenceHint:
|
||
'위험 수준은 Skill 패키지 내용을 기반으로 자동 감지되며 검토 참고용입니다.\n낮음: 명확한 위험 없음\n중간: 스크립트/의존성/외부 URL/환경 변수 포함\n높음: 원격 실행/민감 정보/위험 명령 포함',
|
||
riskCheckResult: '보안 검사 결과',
|
||
noRiskFound: '명확한 위험을 찾지 못했습니다.',
|
||
riskFilePath: '파일 경로',
|
||
riskKeyword: '일치한 키워드 또는 규칙',
|
||
riskDescription: '위험 설명',
|
||
publishHighRiskConfirm:
|
||
'이 Skill에는 스크립트 실행, 외부 다운로드 또는 민감한 정보 접근이 포함될 수 있는 고위험 항목이 있습니다. 그래도 게시하시겠습니까?',
|
||
approve: '승인',
|
||
reject: '거부',
|
||
publish: '게시',
|
||
disable: '게시 해제',
|
||
customTarget: '사용자 지정 에이전트',
|
||
addCustomTarget: '에이전트 추가',
|
||
installToTarget: '사용자 지정 에이전트에 설치',
|
||
hostSkillDir: 'Skill 디렉터리',
|
||
hostSkillDirHelper: '노드의 Skill 디렉터리 경로를 입력하세요.',
|
||
installMethod: '설치 방식',
|
||
copy: '복사',
|
||
extract: '압축 해제',
|
||
postInstallCommand: '설치 후 명령',
|
||
localSource: '로컬 업로드',
|
||
uploadDragTitle: 'Skill 패키지를 여기에 끌어다 놓거나 클릭하여 업로드',
|
||
uploadFormatLabel: '지원 형식:',
|
||
uploadFormatValue: '.zip, .7z, .tar, .tar.gz',
|
||
uploadSizeLabel: '파일 크기:',
|
||
uploadSizeValue: '파일 하나당 5 MB 이하',
|
||
uploadRequirementLabel: '패키지 요구 사항:',
|
||
uploadRequirementPrefix: 'Skill 패키지에는 다음이 포함되어야 합니다',
|
||
onlySupportedArchive: '.zip, .7z, .tar, .tar.gz 형식의 Skill 패키지만 업로드할 수 있습니다',
|
||
uploadSizeExceeded: '단일 Skill 패키지는 5 MB를 초과할 수 없습니다',
|
||
uploadSuccess: 'Skill이 성공적으로 업로드되었으며 검토 대기 상태가 되었습니다.',
|
||
versionAutoFillPlaceholder: '가능하면 파일명에서 자동 감지됩니다. 확인하거나 수동으로 입력하세요',
|
||
metadataOverwriteConfirm: 'Skill 패키지의 버전이 현재 입력과 다릅니다. 현재 입력값을 사용하시겠습니까?',
|
||
metadataOverwriteConfirmWithVersions:
|
||
'Skill 패키지의 버전이 현재 입력과 다릅니다. 패키지 버전: {packageVersion}; 입력 버전: {inputVersion}. 현재 입력값을 사용하시겠습니까?',
|
||
offlineNotice: '현재 환경은 오프라인입니다. 로컬 Skill 스토어에서만 Skill을 설치할 수 있습니다.',
|
||
publishConfirm: '이 Skill을 게시하시겠습니까? 게시 후 로컬 Skill 스토어에서 설치할 수 있습니다.',
|
||
disableConfirm: '이 Skill 게시를 해제하시겠습니까? 에이전트에 이미 설치된 Skill에는 영향이 없습니다.',
|
||
deleteConfirm:
|
||
'이 Skill을 삭제하시겠습니까? 삭제 후 복구할 수 없습니다. 에이전트에 이미 설치된 Skill에는 영향이 없습니다.',
|
||
rejectConfirm: '이 Skill 검토를 거부하시겠습니까? 거부 후 Skill은 거부 상태가 됩니다.',
|
||
downloadPublishedOnly: '게시된 Skill 패키지만 다운로드할 수 있습니다.',
|
||
deleteTargetConfirm:
|
||
'이 사용자 지정 에이전트를 삭제하시겠습니까? 삭제 후 사용자는 이 설치 대상을 선택할 수 없습니다.',
|
||
noInstallTarget: '사용 가능한 사용자 지정 에이전트가 없습니다. 먼저 설치 대상을 구성하세요.',
|
||
postInstallConfirm:
|
||
'이 대상에는 설치 후 명령이 구성되어 있습니다. 실행 전에 신뢰할 수 있는 명령인지 확인하세요.',
|
||
status: {
|
||
pending: '검토 대기',
|
||
approved: '승인됨',
|
||
published: '게시됨',
|
||
disabled: '게시 해제됨',
|
||
rejected: '거부됨',
|
||
deleted: '삭제됨',
|
||
},
|
||
agent: {
|
||
common: '공통',
|
||
},
|
||
risk: {
|
||
low: '낮음',
|
||
medium: '중간',
|
||
high: '높음',
|
||
},
|
||
riskType: {
|
||
script_file: '스크립트 파일',
|
||
dependency_manifest: '의존성 선언',
|
||
external_url: '외부 URL',
|
||
environment_variable: '환경 변수',
|
||
dockerfile: 'Dockerfile',
|
||
command_execution: '명령 실행',
|
||
remote_script_execution: '원격 스크립트 실행',
|
||
eval_execution: '동적 실행',
|
||
base64_execution: 'Base64 디코딩 실행',
|
||
privileged_command: '권한 상승 명령',
|
||
dangerous_delete: '위험한 삭제',
|
||
world_writable_permission: '고위험 권한',
|
||
credential: '의심스러운 인증 정보',
|
||
sensitive_path: '민감한 경로',
|
||
suspicious_download_execute: '의심스러운 다운로드 실행',
|
||
binary_content: '바이너리 콘텐츠',
|
||
scan_truncated: '검사 내용 잘림',
|
||
},
|
||
riskDescriptionText: {
|
||
script_file: '로컬 명령을 실행할 수 있는 스크립트 파일이 포함되어 있습니다.',
|
||
dependency_manifest: '설치 시 외부 의존성을 가져올 수 있는 의존성 선언 파일이 포함되어 있습니다.',
|
||
external_url: '외부 URL이 포함되어 있습니다. 외부 연결 주소를 신뢰할 수 있는지 확인하세요.',
|
||
environment_variable: '환경 변수를 선언합니다. 용도와 기본값을 확인하세요.',
|
||
dockerfile: '이미지 빌드 또는 실행 로직을 정의할 수 있는 Dockerfile이 포함되어 있습니다.',
|
||
command_execution: '명령 실행 관련 호출이 포함되어 있습니다. 실행 로직을 확인하세요.',
|
||
remote_script_execution: '원격 스크립트를 다운로드한 뒤 직접 실행하는 로직이 포함되어 있습니다.',
|
||
eval_execution: 'eval을 통한 동적 실행이 포함되어 있습니다.',
|
||
base64_execution: 'Base64 디코딩 후 내용을 실행하는 로직이 포함되어 있습니다.',
|
||
privileged_command: 'sudo 권한 상승 명령이 포함되어 있습니다.',
|
||
dangerous_delete: '위험한 삭제 명령이 포함되어 있습니다.',
|
||
world_writable_permission: 'chmod 777 권한 변경이 포함되어 있습니다.',
|
||
credential: 'API Key, Token, Secret 또는 Password로 의심되는 정보가 포함되어 있습니다.',
|
||
sensitive_path: '민감한 디렉터리 또는 파일에 접근하는 동작이 포함되어 있습니다.',
|
||
suspicious_download_execute: '의심스러운 외부 다운로드 또는 다운로드 후 실행 로직이 포함되어 있습니다.',
|
||
binary_content:
|
||
'파일에 NUL 바이트가 포함되어 실행 가능 콘텐츠 또는 바이너리 콘텐츠를 숨길 수 있습니다.',
|
||
scan_truncated: '파일이 검사 한도를 초과했습니다. 검사되지 않은 내용은 수동 확인이 필요합니다.',
|
||
},
|
||
},
|
||
benchmark: {
|
||
title: '벤치마크',
|
||
launchCommand: '시작 명령',
|
||
retest: '다시 테스트',
|
||
statusRunning: '실행 중',
|
||
statusWaiting: '대기 중',
|
||
base: '기본 정보',
|
||
backend: '백엔드',
|
||
baseUrl: 'Base URL',
|
||
endpoint: '엔드포인트',
|
||
tokenizer: '토크나이저',
|
||
tokenizerPlaceholder:
|
||
'로컬 토크나이저 디렉터리를 선택하거나 입력하세요. 예: /opt/1panel/tokenizers/DeepSeek-V3',
|
||
runConfig: '실행 구성',
|
||
rawResult: '원시 결과',
|
||
resultMetrics: '결과 지표',
|
||
contextTokens: '컨텍스트 길이',
|
||
contextTokensHelper: '이 벤치마크의 입력 Token 제한과 출력 Token 제한의 합계입니다.',
|
||
outputThroughput: '출력 처리량',
|
||
outputThroughputHelper: '초당 생성된 출력 Token 수입니다. 높을수록 생성 속도가 빠릅니다.',
|
||
totalThroughput: '총 처리량',
|
||
totalThroughputHelper: '초당 처리된 입력 및 출력 Token 수로 전체 처리 능력을 측정합니다.',
|
||
firstTokenLatency: '첫 Token 지연 시간',
|
||
firstTokenLatencyHelper: '요청 전송부터 첫 Token 수신까지의 시간입니다. 낮을수록 응답이 빠릅니다.',
|
||
tokenValueHelper: '양의 정수 또는 k 값을 입력하세요. 예: 512, 1k, 32k',
|
||
numPrompts: '프롬프트 수',
|
||
concurrency: '동시성',
|
||
mean: '평균값',
|
||
median: '중앙값',
|
||
requestRate: '요청 속도',
|
||
requestRateUnlimited: '무제한(최대 처리량)',
|
||
requestRateCustom: '사용자 지정 QPS',
|
||
requestRateCustomPlaceholder: '초당 요청 수, 예: 2.5',
|
||
successfulRequests: '성공한 요청',
|
||
requestThroughput: '요청 처리량',
|
||
timeout: '시간 초과(초)',
|
||
image: 'vLLM 이미지',
|
||
ignoreEos: 'EOS 무시',
|
||
extraHeaders: '추가 헤더',
|
||
},
|
||
gpu: {
|
||
gpu: 'GPU 모니터링',
|
||
gpuHelper: '시스템에서 NVIDIA-SMI 또는 XPU-SMI 명령을 감지하지 못했습니다. 확인하고 다시 시도하세요!',
|
||
process: '프로세스 정보',
|
||
type: '유형',
|
||
typeG: '그래픽',
|
||
typeC: '컴퓨팅',
|
||
typeCG: '컴퓨팅+그래픽',
|
||
processName: '프로세스 이름',
|
||
shr: '공유 메모리',
|
||
temperatureHelper: 'GPU 온도가 높으면 GPU 주파수가 감소할 수 있습니다',
|
||
gpuUtil: 'GPU 사용률',
|
||
temperature: '온도',
|
||
performanceState: '성능 상태',
|
||
powerUsage: '전력 소비',
|
||
memoryUsage: '메모리 사용률',
|
||
fanSpeed: '팬 속도',
|
||
power: '전력',
|
||
powerCurrent: '현재 전력',
|
||
powerLimit: '전력 제한',
|
||
memory: '메모리',
|
||
memoryUsed: '사용된 메모리',
|
||
memoryTotal: '전체 메모리',
|
||
percent: '사용률',
|
||
base: '기본 정보',
|
||
driverVersion: '드라이버 버전',
|
||
cudaVersion: 'CUDA 버전',
|
||
processMemoryUsage: '메모리 사용량',
|
||
performanceStateHelper: 'P0(최대 성능)부터 P12(최소 성능)까지',
|
||
busID: '버스 주소',
|
||
persistenceMode: '지속성 모드',
|
||
enabled: '활성화',
|
||
disabled: '비활성화',
|
||
persistenceModeHelper: '지속성 모드는 작업에 더 빠르게 응답하지만 대기 전력 소비도 그에 따라 증가합니다',
|
||
displayActive: 'GPU 초기화',
|
||
displayActiveT: '예',
|
||
displayActiveF: '아니오',
|
||
ecc: '오류 검사 및 수정 기술',
|
||
computeMode: '계산 모드',
|
||
default: '기본값',
|
||
exclusiveProcess: '배타적 프로세스',
|
||
exclusiveThread: '배타적 스레드',
|
||
prohibited: '금지됨',
|
||
defaultHelper: '기본값: 프로세스가 동시에 실행될 수 있음',
|
||
exclusiveProcessHelper:
|
||
'배타적 프로세스: 하나의 CUDA 컨텍스트만 GPU를 사용할 수 있지만 여러 스레드에서 공유 가능',
|
||
exclusiveThreadHelper: '배타적 스레드: CUDA 컨텍스트의 하나의 스레드만 GPU를 사용할 수 있음',
|
||
prohibitedHelper: '금지됨: 프로세스 동시 실행이 허용되지 않음',
|
||
migModeHelper: 'MIG 인스턴스를 생성하는 데 사용되며 사용자 레이어에서 GPU의 물리적 격리를 구현합니다.',
|
||
migModeNA: '지원되지 않음',
|
||
current: '실시간 모니터링',
|
||
history: '기록',
|
||
notSupport: '현재 버전 또는 드라이버는 이 매개변수 표시를 지원하지 않습니다.',
|
||
processCount: '프로세스 수',
|
||
},
|
||
mcp: {
|
||
server: 'MCP サーバー',
|
||
baseUrl: '外部アクセスパス',
|
||
baseUrlHelper: '例: http://192.168.1.2:8000',
|
||
ssePath: 'SSE パス',
|
||
ssePathHelper: '例: /sse, 他のサーバーと重複しないように注意してください',
|
||
environment: '環境変数',
|
||
envKey: '変数名',
|
||
envValue: '変数値',
|
||
externalUrl: '外部接続アドレス',
|
||
operatorHelper: '{0} に {1} 操作を実行します、続行しますか？',
|
||
domain: 'デフォルトアクセスアドレス',
|
||
domainHelper: '例: 192.168.1.1 または example.com',
|
||
bindDomain: 'ウェブサイトをバインド',
|
||
commandPlaceHolder: '현재 npx 및 바이너리 시작 명령만 지원합니다',
|
||
importMcpJson: 'MCP サーバー設定をインポート',
|
||
importMcpJsonError: 'mcpServers 構造が正しくありません',
|
||
bindDomainHelper:
|
||
'웹사이트를 바인딩한 후, 설치된 모든 MCP 서버의 접근 주소를 수정하고 포트의 외부 접근을 닫습니다',
|
||
outputTransport: '출력 유형',
|
||
streamableHttpPath: '스트리밍 경로',
|
||
streamableHttpPathHelper: '예: /mcp, 다른 서버와 중복되지 않도록 주의하세요',
|
||
npxHelper: 'npx 또는 바이너리로 시작하는 mcp에 적합',
|
||
uvxHelper: 'uvx로 시작하는 mcp에 적합',
|
||
protocolVersion: 'Protocol Version',
|
||
protocolVersionHelper:
|
||
'Only used by stateless Streamable HTTP to auto-initialize the downstream stdio MCP Server',
|
||
gatewayArgsHelper:
|
||
'인수는 supergateway 시작 명령에 추가됩니다. 1Panel에서 관리하는 전송, 포트, 경로 및 프로토콜 인수는 변경할 수 없습니다',
|
||
testConnection: 'Test Connection',
|
||
connectionSuccess: 'Connection succeeded',
|
||
connectionFailed: 'Connection failed',
|
||
},
|
||
tensorRT: {
|
||
llm: 'TensorRT LLM',
|
||
modelDir: '모델 디렉토리',
|
||
commandHelper: '외부 액세스가 필요한 경우 명령에서 포트를 애플리케이션 포트와 동일하게 설정하십시오',
|
||
imageAlert: '이미지 크기가 크므로 설치 전에 서버에 이미지를 수동으로 다운로드하는 것이 좋습니다',
|
||
modelSpeedup: '모델 가속 활성화',
|
||
modelType: '모델 유형',
|
||
},
|
||
},
|
||
container: {
|
||
createByCommand: '명령으로 생성',
|
||
importContainerBackupTip: '컨테이너 백업 파일 가져오기, .tar.gz 형식만 지원합니다',
|
||
importComposeBackupTip: 'Compose 백업 파일 가져오기, .tar.gz 형식만 지원합니다',
|
||
stopContainerBeforeBackup: '백업 전에 컨테이너 중지',
|
||
stopComposeBeforeBackup: '백업 전에 Compose 중지',
|
||
stopBeforeBackupHelper:
|
||
'활성화하면 백업 전에 컨테이너 또는 Compose 서비스를 중지하고, 완료 후 자동으로 복구하여 데이터 일관성을 보장합니다.',
|
||
commandInput: '명령 입력',
|
||
commandRule: '컨테이너 생성을 위한 올바른 docker run 명령을 입력하세요.',
|
||
commandHelper: '이 명령은 서버에서 실행되어 컨테이너를 생성합니다. 계속하시겠습니까?',
|
||
updateHelper1: '이 컨테이너가 앱 스토어에서 왔음을 감지했습니다. 다음 두 가지 사항을 유의하십시오:',
|
||
updateHelper2: '1. 현재 수정 사항은 앱 스토어에 설치된 애플리케이션에 동기화되지 않습니다.',
|
||
updateHelper3: '2. 설치된 페이지에서 애플리케이션을 수정하면 현재 편집된 내용이 무효화됩니다.',
|
||
updateHelper4: '컨테이너 편집에는 재빌드가 필요하며, 비지속적인 데이터는 손실됩니다. 계속하시겠습니까?',
|
||
containerList: '컨테이너 목록',
|
||
operatorHelper: '{0} 작업이 다음 컨테이너에서 수행됩니다. 계속하시겠습니까?',
|
||
operatorAppHelper:
|
||
'"{0}" 작업이 다음 컨테이너에서 수행되며, 실행 중인 서비스에 영향을 미칠 수 있습니다. 계속하시겠습니까?',
|
||
containerDeleteHelper:
|
||
"컨테이너가 앱 스토어에서 생성된 것으로 감지되었습니다. 컨테이너를 삭제해도 1Panel에서 완전히 제거되지 않습니다. 완전히 삭제하려면 앱 스토어 -> '설치됨' 또는 '런타임 환경' 메뉴로 이동하여 작업하십시오. 계속하시겠습니까?",
|
||
start: '시작',
|
||
stop: '중지',
|
||
restart: '재시작',
|
||
kill: '강제 종료',
|
||
pause: '일시 정지',
|
||
unpause: '재개',
|
||
rename: '이름 변경',
|
||
remove: '제거',
|
||
removeAll: '모두 제거',
|
||
containerPrune: '정리',
|
||
containerPruneHelper1: '이 작업은 중지된 모든 컨테이너를 삭제합니다.',
|
||
containerPruneHelper2:
|
||
"앱 스토어에서 가져온 컨테이너는 정리 후 '앱 스토어 -> 설치됨' 페이지로 이동하여 '재빌드' 버튼을 클릭하여 재설치해야 합니다.",
|
||
containerPruneHelper3: '이 작업은 취소할 수 없습니다. 계속하시겠습니까?',
|
||
imagePrune: '정리',
|
||
imagePruneSome: '라벨 없는 이미지 정리',
|
||
imagePruneSomeEmpty: "라벨이 'none'인 이미지가 정리되지 않았습니다.",
|
||
imagePruneSomeHelper: "컨테이너에서 사용되지 않는 'none' 태그가 붙은 이미지를 정리합니다.",
|
||
imagePruneAll: '사용되지 않는 이미지 정리',
|
||
imagePruneAllEmpty: '사용되지 않는 이미지가 정리되지 않았습니다.',
|
||
imagePruneAllHelper: '사용되지 않는 이미지를 정리합니다.',
|
||
networkPrune: '정리',
|
||
networkPruneHelper: '사용되지 않는 네트워크를 모두 제거합니다. 계속하시겠습니까?',
|
||
volumePrune: '정리',
|
||
volumePruneHelper: '사용되지 않는 로컬 볼륨을 모두 제거합니다. 계속하시겠습니까?',
|
||
cleanSuccess: '작업이 성공적으로 완료되었습니다. 이번 정리에서 {0}개의 항목이 정리되었습니다!',
|
||
cleanSuccessWithSpace:
|
||
'작업이 성공적으로 완료되었습니다. 이번 정리에서 {0}개의 디스크가 정리되었으며, 확보된 디스크 공간은 {1}입니다!',
|
||
unExposedPort: '현재 포트 매핑 주소는 127.0.0.1로 외부 액세스를 활성화할 수 없습니다.',
|
||
upTime: '업타임',
|
||
fetch: '가져오기',
|
||
lines: '라인',
|
||
linesHelper: '올바른 로그 수를 입력하세요!',
|
||
downloadLinesHelper: '다운로드할 로그 줄 수를 선택하거나 입력하세요.',
|
||
lastDay: '지난 하루',
|
||
last4Hour: '지난 4시간',
|
||
lastHour: '지난 1시간',
|
||
last10Min: '지난 10분',
|
||
cleanLog: '로그 정리',
|
||
downLogHelper1: '이 작업은 컨테이너 {0}의 모든 로그를 다운로드합니다. 계속하시겠습니까?',
|
||
downLogHelper2: '이 작업은 컨테이너 {0}의 최근 {0}개의 로그를 다운로드합니다. 계속하시겠습니까?',
|
||
cleanLogHelper: '이 작업은 컨테이너를 재시작해야 하며 취소할 수 없습니다. 계속하시겠습니까?',
|
||
newName: '새 이름',
|
||
source: '리소스 사용',
|
||
cpuUsage: 'CPU 사용',
|
||
cpuTotal: '전체 CPU',
|
||
core: '코어',
|
||
memUsage: '메모리 사용',
|
||
memTotal: '메모리 한도',
|
||
memCache: '메모리 캐시',
|
||
loadSize: '컨테이너 크기 가져오기',
|
||
ip: 'IP 주소',
|
||
cpuShare: 'CPU 공유',
|
||
cpuShareHelper:
|
||
'컨테이너 엔진은 기본값으로 1024를 사용합니다. 이를 늘리면 컨테이너에 더 많은 CPU 시간을 할당할 수 있습니다.',
|
||
inputIpv4: '예시: 192.168.1.1',
|
||
inputIpv6: '예시: 2001:0db8:85a3:0000:0000:8a2e:0370:7334',
|
||
diskUsage: '디스크 사용량',
|
||
localVolume: '로컬 스토리지 볼륨',
|
||
buildCache: '빌드 캐시',
|
||
usage: '사용됨: {0}, 해제 가능: {1}',
|
||
clean: '해제',
|
||
imageClean:
|
||
'이미지 정리를 수행하면 사용되지 않은 모든 이미지가 삭제됩니다. 이 작업은 되돌릴 수 없습니다. 계속하시겠습니까?',
|
||
containerClean:
|
||
'컨테이너 정리를 수행하면 중지된 모든 컨테이너(앱 스토어의 중지된 앱 포함)가 삭제됩니다. 이 작업은 되돌릴 수 없습니다. 계속하시겠습니까?',
|
||
sizeRw: '컨테이너 레이어 크기',
|
||
sizeRwHelper: '컨테이너에 고유한 쓰기 가능 레이어 크기',
|
||
sizeRootFs: '가상 크기',
|
||
sizeRootFsHelper: '컨테이너가 의존하는 모든 이미지 레이어 + 컨테이너 레이어의 총 크기',
|
||
containerFromAppHelper:
|
||
'이 컨테이너가 앱 스토어에서 왔음을 감지했습니다. 앱 작업으로 현재 편집이 무효화될 수 있습니다.',
|
||
containerFromAppHelper1:
|
||
'설치된 애플리케이션 목록에서 [매개변수] 버튼을 클릭하여 편집 페이지로 이동하고 컨테이너 이름을 수정하세요.',
|
||
command: '명령어',
|
||
console: '컨테이너 상호작용',
|
||
tty: '가상 TTY 할당 (-t)',
|
||
openStdin: 'STDIN 을 열어둡니다. 연결되지 않더라도 계속 열려있습니다 (-i)',
|
||
custom: '사용자 정의',
|
||
emptyUser: '비워두면 기본값으로 로그인합니다.',
|
||
privileged: '특권 모드',
|
||
privilegedHelper:
|
||
'컨테이너가 호스트에서 특정 특권 작업을 수행할 수 있도록 허용합니다. 이는 보안 위험을 초래할 수 있으므로 주의해서 사용하십시오.',
|
||
upgradeHelper: '레포지토리 이름/이미지 이름: 이미지 버전',
|
||
upgradeWarning2:
|
||
'업그레이드 작업은 컨테이너를 재빌드해야 하며, 비지속적인 데이터가 손실됩니다. 계속하시겠습니까?',
|
||
oldImage: '현재 이미지',
|
||
sameImageContainer: '동일 이미지 컨테이너',
|
||
sameImageHelper: '동일한 이미지를 사용하는 컨테이너는 선택 후 일괄 업그레이드 가능',
|
||
targetImage: '대상 이미지',
|
||
imageLoadErr: '컨테이너에 대한 이미지 이름이 감지되지 않았습니다.',
|
||
imageUpdateTagEmpty: '업데이트 가능한 이미지 태그를 찾지 못했습니다.',
|
||
appHelper: '이 컨테이너는 앱 스토어에서 왔으며 업그레이드 시 서비스가 중단될 수 있습니다.',
|
||
input: '수동 입력',
|
||
forcePull: '이미지 강제 풀',
|
||
forcePullHelper: '이 작업은 서버에 있는 기존 이미지를 무시하고 레지스트리에서 최신 이미지를 강제로 가져옵니다.',
|
||
imageUpdateHelper: '레지스트리의 동일 태그를 확인하고, 변경이 있으면 가져와 로컬 이미지를 업데이트합니다.',
|
||
server: '호스트',
|
||
serverExample: '80, 80-88, ip:80 또는 ip:80-88',
|
||
containerExample: '80 또는 80-88',
|
||
exposePort: '포트 노출',
|
||
exposeAll: '모든 포트 노출',
|
||
cmdHelper: '예시: nginx -g "daemon off;"',
|
||
entrypointHelper: '예시: docker-entrypoint.sh',
|
||
autoRemove: '자동 제거',
|
||
cpuQuota: 'CPU 코어 수',
|
||
memoryLimit: '메모리',
|
||
limitHelper: '0으로 설정하면 제한이 없으며, 최대값은 {0}입니다.',
|
||
mount: '마운트',
|
||
volumeOption: '볼륨',
|
||
hostOption: '호스트',
|
||
serverPath: '서버 경로',
|
||
containerDir: '컨테이너 경로',
|
||
volumeHelper: '저장소 볼륨의 내용이 올바른지 확인하십시오.',
|
||
networkEmptyHelper: '컨테이너 네트워크 선택이 올바른지 확인해 주세요',
|
||
modeRW: '읽기/쓰기',
|
||
modeR: '읽기 전용',
|
||
sharedLabel: '전파 모드',
|
||
private: '비공개',
|
||
privateHelper: '컨테이너와 호스트의 마운트 변경 사항이 서로 영향을 주지 않음',
|
||
rprivate: '재귀적 비공개',
|
||
rprivateHelper: '컨테이너 내 모든 마운트가 호스트와 완전히 격리됨',
|
||
shared: '공유',
|
||
sharedHelper: '호스트와 컨테이너의 마운트 변경 사항이 서로 보임',
|
||
rshared: '재귀적 공유',
|
||
rsharedHelper: '호스트와 컨테이너의 모든 마운트 변경 사항이 서로 보임',
|
||
slave: '슬레이브',
|
||
slaveHelper: '컨테이너는 호스트 마운트 변경 사항을 볼 수 있지만, 자신의 변경 사항은 호스트에 영향을 주지 않음',
|
||
rslave: '재귀적 슬레이브',
|
||
rslaveHelper: '컨테이너 내 모든 마운트가 호스트 변경 사항을 볼 수 있지만 호스트에 영향을 주지 않음',
|
||
mode: '모드',
|
||
env: '환경',
|
||
restartPolicy: '재시작 정책',
|
||
always: '항상',
|
||
unlessStopped: '중지되지 않는 한',
|
||
onFailure: '실패 시 (기본 5회)',
|
||
no: '절대',
|
||
refreshTime: '새로 고침 간격',
|
||
cache: '캐시',
|
||
image: '이미지 | 이미지들',
|
||
imagePull: '풀',
|
||
imagePullHelper: '여러 이미지 선택 풀링을 지원하며, 각 이미지 입력 후 Enter 키를 눌러 계속합니다',
|
||
imagePush: '푸시',
|
||
imagePushHelper:
|
||
'이 이미지에 여러 태그가 있는 것으로 감지되었습니다. 푸시 시 사용할 이미지 이름이 다음인지 확인하세요: {0}',
|
||
imageDelete: '이미지 삭제',
|
||
repoName: '컨테이너 저장소 이름',
|
||
imageName: '이미지 이름',
|
||
pull: '풀',
|
||
path: '경로',
|
||
importImage: '가져오기',
|
||
buildArgs: '빌드 인수',
|
||
imageBuild: '이미지 빌드',
|
||
pathSelect: '경로',
|
||
label: '레이블',
|
||
imageTag: '이미지 태그',
|
||
imageTagHelper: '여러 이미지 태그 설정을 지원하며, 각 태그 입력 후 Enter 키를 눌러 계속합니다',
|
||
push: '푸시',
|
||
fileName: '파일 이름',
|
||
export: '내보내기',
|
||
exportImage: '이미지 내보내기',
|
||
size: '크기',
|
||
tag: '태그',
|
||
tagHelper: '한 줄에 하나씩. 예시:\nkey1=value1\nkey2=value2',
|
||
imageNameHelper: '이미지 이름과 태그, 예시: nginx:latest',
|
||
cleanBuildCache: '빌드 캐시 정리',
|
||
delBuildCacheHelper:
|
||
'이 작업은 빌드 중 생성된 모든 캐시된 아티팩트를 삭제하며 되돌릴 수 없습니다. 계속 하시겠습니까?',
|
||
urlWarning: 'URL 접두어에 http:// 또는 https://를 포함할 필요는 없습니다. 수정해 주세요.',
|
||
network: '네트워크 | 네트워크들',
|
||
networkHelper: '이로 인해 일부 애플리케이션과 실행 환경이 제대로 작동하지 않을 수 있습니다. 계속 하시겠습니까?',
|
||
networkName: '이름',
|
||
driver: '드라이버',
|
||
option: '옵션',
|
||
attachable: '연결 가능',
|
||
parentNetworkCard: '부모 네트워크 카드',
|
||
subnet: '서브넷',
|
||
scope: 'IP 범위',
|
||
gateway: '게이트웨이',
|
||
auxAddress: '제외 IP',
|
||
volume: '볼륨 | 볼륨들',
|
||
volumeDir: '볼륨 디렉터리',
|
||
nfsEnable: 'NFS 스토리지 사용',
|
||
nfsAddress: '주소',
|
||
mountpoint: '마운트 지점',
|
||
mountpointNFSHelper: '예: /nfs, /nfs-share',
|
||
options: '옵션',
|
||
repo: '레지스트리',
|
||
httpRepoHelper: 'HTTP 타입 저장소 작업 시 Docker 서비스 재시작이 필요합니다.',
|
||
httpRepo: 'HTTP 프로토콜을 선택하면 Docker 서비스를 재시작하여 불안정한 레지스트리에 추가해야 합니다.',
|
||
delInsecure: '신뢰할 수 없는 항목 삭제',
|
||
delInsecureHelper:
|
||
'이 작업은 Docker 서비스를 재시작하여 불안정한 레지스트리에서 제거합니다. 계속 하시겠습니까?',
|
||
downloadUrl: '서버',
|
||
imageRepo: '이미지 레포지토리',
|
||
repoHelper: '거울 레포지토리/조직/프로젝트가 포함되어 있습니까?',
|
||
auth: '인증 필요',
|
||
mirrorHelper:
|
||
'거울이 여러 개 있을 경우 각 줄에 하나씩 표시해야 합니다. 예시:\nhttp://xxxxxx.m.daocloud.io \nhttps://xxxxxx.mirror.aliyuncs.com',
|
||
registrieHelper:
|
||
'개인 레지스트리가 여러 개 있을 경우 각 줄에 하나씩 표시해야 합니다. 예시:\n172.16.10.111:8081 \n172.16.10.112:8081',
|
||
compose: '컴포즈 | 컴포즈들',
|
||
composeFile: '컴포즈 파일',
|
||
fromChangeHelper: '소스를 변경하면 현재 편집한 내용이 삭제됩니다. 계속 하시겠습니까?',
|
||
composePathHelper: '구성 파일 저장 경로: {0}',
|
||
composeHelper: '1Panel 에디터나 템플릿을 통해 생성된 컴포지션은 {0}/docker/compose 디렉토리에 저장됩니다.',
|
||
deleteFile: '파일 삭제',
|
||
deleteComposeHelper:
|
||
'이 작업은 컴포즈와 관련된 모든 파일을 삭제합니다. 구성을 포함한 지속적인 파일도 포함됩니다. 신중히 진행해 주세요!',
|
||
deleteCompose: '" 이 컴포즈를 삭제하시겠습니까?',
|
||
composeDirectory: '디렉토리',
|
||
template: '템플릿',
|
||
composeTemplate: '컴포즈 템플릿 | 컴포즈 템플릿들',
|
||
content: '내용',
|
||
contentEmpty: '컴포즈 내용이 비어 있습니다. 입력 후 다시 시도해 주세요!',
|
||
containerNumber: '컨테이너 수',
|
||
containerStatus: '컨테이너 상태',
|
||
exited: '종료됨',
|
||
running: '실행 중 ( {0} / {1} )',
|
||
composeDetailHelper: '이 컴포즈는 1Panel 외부에서 생성되었습니다. 시작 및 중지 작업은 지원되지 않습니다.',
|
||
composeOperatorHelper: '{1} 작업이 {0}에서 수행됩니다. 계속 하시겠습니까?',
|
||
composeDownHelper:
|
||
'이 작업은 {0} 컴포즈 아래의 모든 컨테이너와 네트워크를 중지하고 제거합니다. 계속 하시겠습니까?',
|
||
composeEnvHelper2:
|
||
'이 오케스트레이션은 1Panel 앱 스토어에서 생성되었습니다. 설치된 애플리케이션에서 환경 변수를 수정하세요.',
|
||
composeContentPlaceholder: '여기에 docker-compose 파일 내용을 작성하거나 붙여넣으세요',
|
||
setting: '설정 | 설정들',
|
||
restartHelper: '구성 변경 사항을 적용하려면 Docker 서비스를 재시작해야 합니다',
|
||
operatorStatusHelper: '이 작업은 Docker 서비스를 "{0}" 합니다. 계속 하시겠습니까?',
|
||
dockerStatus: 'Docker 서비스',
|
||
daemonJsonPathHelper: '구성 경로가 docker.service 에 지정된 경로와 동일한지 확인하십시오.',
|
||
mirrors: '레지스트리 미러들',
|
||
mirrorsHelper: '',
|
||
mirrorsHelper2: '자세한 내용은 공식 문서를 참조하십시오.',
|
||
registries: '불안정한 레지스트리들',
|
||
ipv6Helper:
|
||
'IPv6를 활성화하려면 IPv6 컨테이너 네트워크를 추가해야 합니다. 구체적인 구성 단계를 공식 문서에서 참조하십시오.',
|
||
ipv6CidrHelper: '컨테이너를 위한 IPv6 주소 풀 범위',
|
||
ipv6TablesHelper: 'ip6tables 규칙에 대해 Docker IPv6 을 자동 구성합니다.',
|
||
experimentalHelper: 'ip6tables 를 활성화하려면 이 구성을 켜야 합니다. 그렇지 않으면 ip6tables가 무시됩니다.',
|
||
cutLog: '로그 옵션',
|
||
cutLogHelper1: '현재 구성은 새로 생성된 컨테이너에만 영향을 미칩니다.',
|
||
cutLogHelper2: '기존 컨테이너는 재생성해야 구성이 적용됩니다.',
|
||
cutLogHelper3:
|
||
'컨테이너를 재생성하면 데이터 손실이 발생할 수 있습니다. 중요한 데이터가 포함된 컨테이너는 재구성 전 백업을 꼭 해주세요.',
|
||
maxSize: '최대 크기',
|
||
maxFile: '최대 파일',
|
||
liveHelper:
|
||
'기본적으로 Docker 데몬이 종료되면 실행 중인 컨테이너도 종료됩니다. 데몬이 비활성화된 상태에서 컨테이너를 계속 실행하려면 데몬을 설정할 수 있습니다. 이 기능은 라이브 복구라고 불리며, 데몬 충돌, 예정된 중단 또는 업그레이드로 인한 컨테이너 다운타임을 줄이는 데 도움을 줍니다.',
|
||
liveWithSwarmHelper: 'live-restore 데몬 구성은 스웜 모드와 호환되지 않습니다.',
|
||
iptablesDisable: 'iptables 비활성화',
|
||
iptablesHelper1: 'Docker 에 대한 iptables 규칙을 자동으로 구성합니다.',
|
||
iptablesHelper2: 'iptables 를 비활성화하면 컨테이너가 외부 네트워크와 통신할 수 없습니다.',
|
||
daemonJsonPath: '구성 경로',
|
||
serviceUnavailable: '현재 Docker 서비스가 시작되지 않았습니다.',
|
||
startIn: '시작하려면',
|
||
sockPath: '유닉스 도메인 소켓',
|
||
sockPathHelper: 'Docker 데몬과 클라이언트 간의 통신 채널입니다.',
|
||
sockPathHelper1: '기본 경로: /var/run/docker-x.sock',
|
||
sockPathMsg: '소켓 경로 설정을 저장하면 Docker 서비스가 사용 불가능할 수 있습니다. 계속 하시겠습니까?',
|
||
sockPathErr: '올바른 Docker 소켓 파일 경로를 선택하거나 입력해 주세요.',
|
||
related: '관련',
|
||
includeAppstore: '앱 스토어에서 컨테이너 표시',
|
||
excludeAppstore: '앱스토어 컨테이너 숨기기',
|
||
cleanDockerDiskZone: 'Docker 에서 사용하는 디스크 공간 정리',
|
||
cleanImagesHelper: '(사용되지 않는 모든 이미지를 정리합니다.)',
|
||
cleanContainersHelper: '(정지된 모든 컨테이너를 정리합니다.)',
|
||
cleanVolumesHelper: '(사용되지 않는 모든 로컬 볼륨을 정리합니다.)',
|
||
makeImage: '이미지 생성',
|
||
newImageName: '새 이미지 이름',
|
||
commitMessage: '커밋 메시지',
|
||
author: '작성자',
|
||
ifPause: '생성 중 컨테이너 일시 정지',
|
||
ifMakeImageWithContainer: '이 컨테이너에서 새 이미지를 생성하시겠습니까?',
|
||
finishTime: '마지막 중지 시간',
|
||
workingDir: '작업 디렉토리',
|
||
composeFileMissing: 'Compose 파일이 감지되지 않았습니다',
|
||
resource: '리소스',
|
||
macAddr: 'MAC 주소',
|
||
exportHelper: '선택한 이미지를 하나의 tar 파일로 내보냅니다.',
|
||
goSetting: '설정으로 이동',
|
||
},
|
||
cronjob: {
|
||
importHelper:
|
||
'가져오기 시 동일한 이름의 예약 작업은 자동으로 건너뜁니다. 작업은 기본적으로 【비활성화】 상태로 설정되며, 데이터 연동 이상 시 【편집 대기】 상태로 설정됩니다.',
|
||
changeStatus: '상태 변경',
|
||
disableMsg: '이 작업은 예약된 작업이 자동으로 실행되지 않도록 멈춥니다. 계속하시겠습니까?',
|
||
enableMsg: '이 작업은 예약된 작업이 자동으로 실행되도록 허용합니다. 계속하시겠습니까?',
|
||
taskType: '작업 유형',
|
||
record: '레코드',
|
||
viewRecords: '레코드 보기',
|
||
shell: '셸',
|
||
stop: '수동 중지',
|
||
stopHelper: '이 작업은 현재 작업 실행을 강제로 중지합니다. 계속하시겠습니까?',
|
||
log: '백업 로그',
|
||
logHelper: '시스템 백업 로그',
|
||
ogHelper1: '1. 1Panel 시스템 로그',
|
||
logHelper2: '2. 서버 SSH 로그인 로그',
|
||
logHelper3: '3. 모든 사이트 로그',
|
||
containerCheckBox: '컨테이너 내 (컨테이너 명령어 입력 불필요)',
|
||
containerName: '컨테이너 이름',
|
||
ntp: '시간 동기화',
|
||
ntp_helper: 'Toolbox 의 빠른 설정 페이지에서 NTP 서버를 구성할 수 있습니다.',
|
||
app: '백업 앱',
|
||
website: '백업 웹사이트',
|
||
rulesHelper: '여러 개의 제외 규칙 지원, 영어 쉼표 , 로 구분. 예: *.log,*.sql',
|
||
lastRecordTime: '마지막 실행 시간',
|
||
all: '전체',
|
||
failedRecord: '실패한 레코드',
|
||
successRecord: '성공한 레코드',
|
||
database: '백업 데이터베이스',
|
||
backupArgs: '백업 인수',
|
||
backupArgsHelper:
|
||
'목록에 없는 백업 인수는 수동으로 입력하여 선택할 수 있습니다. 예: --no-data를 입력하고 드롭다운 목록의 첫 번째 옵션을 선택하세요.',
|
||
singleTransaction: '단일 트랜잭션을 사용하여 InnoDB 테이블을 백업하며, 대용량 데이터 백업에 적합합니다',
|
||
quick: '전체 테이블을 메모리에 로드하는 대신 데이터를 행별로 읽습니다. 대용량 데이터 및 저메모리 시스템 백업에 적합합니다',
|
||
skipLockTables: '모든 테이블을 잠그지 않고 백업합니다. 높은 동시성 데이터베이스에 적합합니다',
|
||
setGtidPurgedOff: '백업 시 GTID 정보를 내보내지 않으며 그룹 복제 환경에서 데이터베이스를 복구할 때 적합합니다',
|
||
missBackupAccount: '백업 계정을 찾을 수 없습니다',
|
||
syncDate: '동기화 시간',
|
||
clean: '캐시 정리',
|
||
curl: '접속 URL',
|
||
taskName: '작업 이름',
|
||
cronSpec: '트리거 주기',
|
||
cronSpecDoc:
|
||
'사용자 정의 실행 주기는 [분 시 일 월 요일] 형식만 지원합니다 (예: 0 0 * * *). 자세한 내용은 공식 문서를 참조하세요.',
|
||
cronSpecHelper: '올바른 실행 주기를 입력해 주세요',
|
||
cleanHelper: '이 작업은 모든 작업 실행 레코드, 백업 파일, 로그 파일을 기록합니다. 계속하시겠습니까?',
|
||
directory: '백업 디렉토리',
|
||
sourceDir: '백업 디렉토리',
|
||
snapshot: '시스템 스냅샷',
|
||
allOptionHelper:
|
||
'현재 작업 계획은 모든 [{0}]을 백업하는 것입니다. 현재 직접 다운로드는 지원되지 않습니다. [{0}] 메뉴에서 백업 목록을 확인하실 수 있습니다.',
|
||
exclusionRules: '배제 규칙',
|
||
exclusionRulesHelper:
|
||
'제외 규칙을 선택하거나 입력하고, 각 세트 입력 후 Enter 키를 눌러 계속합니다. 제외 규칙은 이 백업의 모든 압축 작업에 적용됩니다',
|
||
default_download_path: '기본 다운로드 링크',
|
||
saveLocal: '로컬 백업 보관 (클라우드 저장소 복사본 수와 동일)',
|
||
url: 'URL 주소',
|
||
urlHelper: '올바른 URL 주소를 입력해 주세요',
|
||
targetHelper: '백업 계정은 패널 설정에서 관리됩니다.',
|
||
withImageHelper: '앱 스토어 이미지를 백업하지만 스냅샷 파일 크기가 증가합니다.',
|
||
ignoreApp: '앱 제외',
|
||
withImage: '애플리케이션 이미지 백업',
|
||
retainCopies: '기록 보관',
|
||
retryTimes: '재시도 횟수',
|
||
timeout: '타임아웃',
|
||
ignoreErr: '오류 무시',
|
||
ignoreErrHelper: '백업 과정에서 발생하는 오류를 무시하여 모든 백업 작업이 실행되도록 합니다',
|
||
retryTimesHelper: '0은 실패 후 재시도 안 함을 의미합니다',
|
||
retainCopiesHelper: '실행 기록과 로그에 대해 보관할 복사본 수',
|
||
retainCopiesHelper1: '백업 파일에 대해 보관할 복사본 수',
|
||
retainCopiesUnit: '개 (보기)',
|
||
cronSpecRule: '라인 {0}의 실행 주기 형식이 잘못되었습니다. 확인 후 다시 시도해 주세요!',
|
||
perMonthHelper: '매월 {0}일 {1}:{2}에 실행',
|
||
perWeekHelper: '매주 {0}일 {1}:{2}에 실행',
|
||
perDayHelper: '매일 {0}:{1}에 실행',
|
||
perHourHelper: '매시간 {0}분에 실행',
|
||
perNDayHelper: '매 {0}일마다 {1}:{2}에 실행',
|
||
perNHourHelper: '매 {0}시간마다 {1}에 실행',
|
||
perNMinuteHelper: '매 {0}분마다 실행',
|
||
perNSecondHelper: '매 {0}초마다 실행',
|
||
perMonth: '매월',
|
||
perWeek: '매주',
|
||
perHour: '매시간',
|
||
perNDay: '매 N일',
|
||
perDay: '매일',
|
||
perNHour: '매 N시간',
|
||
perNMinute: '매 N분',
|
||
perNSecond: '매 N초',
|
||
day: '일',
|
||
dayUnit: 'd',
|
||
monday: '월요일',
|
||
tuesday: '화요일',
|
||
wednesday: '수요일',
|
||
thursday: '목요일',
|
||
friday: '금요일',
|
||
saturday: '토요일',
|
||
sunday: '일요일',
|
||
shellContent: '스크립트',
|
||
errRecord: '잘못된 로깅',
|
||
errHandle: '크론 작업 실행 실패',
|
||
noRecord: '크론 작업을 트리거하고 나면 여기에 레코드가 표시됩니다.',
|
||
cleanData: '데이터 정리',
|
||
cleanRemoteData: '원격 데이터 삭제',
|
||
cleanDataHelper: '이 작업에서 생성된 백업 파일을 삭제합니다.',
|
||
noLogs: '작업 출력이 아직 없습니다...',
|
||
errPath: '백업 경로 [{0}] 오류, 다운로드할 수 없습니다!',
|
||
cutWebsiteLog: '웹사이트 로그 회전',
|
||
cutWebsiteLogHelper: '회전된 로그 파일은 1Panel 의 백업 디렉토리로 백업됩니다.',
|
||
syncIpGroup: 'WAF IP 그룹 동기화',
|
||
syncIpGroupHelper: 'WAF 블랙/화이트리스트에서 사용하는 원격 IP 그룹을 동기화합니다',
|
||
requestExpirationTime: '업로드 요청 만료 시간(시간)',
|
||
unitHours: '단위: 시간',
|
||
alertTitle: '예정된 작업 - {0} 「{1}」 작업 실패 경고',
|
||
library: {
|
||
script: '스크립트',
|
||
syncNow: '지금 동기화',
|
||
turnOnSync: '자동 동기화 켜기',
|
||
turnOnSyncHelper: '자동 동기화를 켜면 매일 새벽 시간에 자동 동기화가 수행됩니다',
|
||
turnOffSync: '자동 동기화 끄기',
|
||
turnOffSyncHelper: '자동 동기화를 끄면 스크립트 동기화가 지연될 수 있습니다. 확인하시겠습니까?',
|
||
isInteractive: '대화형',
|
||
interactive: '대화형 스크립트',
|
||
interactiveHelper: '실행 중 사용자 입력이 필요하며 예약 작업에서는 사용할 수 없습니다.',
|
||
library: '스크립트 라이브러리',
|
||
remoteLibrary: 'リモートスクリプトライブラリ',
|
||
create: '스크립트 추가',
|
||
edit: '스크립트 수정',
|
||
groupHelper:
|
||
'스크립트 특성에 따라 다양한 그룹을 설정하여 스크립트 필터링 작업을 더 빠르게 수행할 수 있습니다.',
|
||
handleHelper: '{0} 에서 {1} 스크립트를 실행합니다. 계속하시겠습니까?',
|
||
noSuchApp: '{0} 서비스가 감지되지 않았습니다. 스크립트 라이브러리를 사용하여 먼저 빠르게 설치하세요!',
|
||
syncHelper:
|
||
'시스템 스크립트 라이브러리를 동기화합니다. 이 작업은 시스템 스크립트에만 적용됩니다. 계속하시겠습니까?',
|
||
},
|
||
nextTime: '다음 5회 실행',
|
||
logHelper1: '1. 1Panel 시스템 로그',
|
||
backupContent: '백업 내용',
|
||
cronSpecRule2: '실행 주기 형식이 올바르지 않습니다. 확인 후 다시 시도하세요.',
|
||
executor: '실행자',
|
||
cleanLog: '로그 자동 정리',
|
||
cleanLogscope: '로그 보관 기간',
|
||
},
|
||
monitor: {
|
||
globalFilter: '전역 필터',
|
||
enableMonitor: '모니터링 상태',
|
||
storeDays: '보관 일수',
|
||
defaultNetwork: '기본 네트워크 카드',
|
||
defaultNetworkHelper: '모니터링 및 개요 인터페이스에 표시되는 기본 네트워크 카드 옵션',
|
||
defaultIO: '기본 디스크',
|
||
defaultIOHelper: '모니터링 및 개요 인터페이스에 표시되는 기본 디스크 옵션',
|
||
cleanMonitor: '모니터링 기록 지우기',
|
||
cleanHelper: '이 작업은 GPU를 포함한 모든 모니터링 기록을 지웁니다. 계속하시겠습니까?',
|
||
avgLoad: '평균 부하',
|
||
loadDetail: '부하 세부사항',
|
||
resourceUsage: '자원 사용률',
|
||
networkCard: '네트워크 인터페이스',
|
||
read: '읽기',
|
||
write: '쓰기',
|
||
readWriteCount: 'I/O 작업',
|
||
readWriteTime: 'I/O 지연 시간',
|
||
today: '오늘',
|
||
yesterday: '어제',
|
||
lastNDay: '최근 {0}일',
|
||
lastNMonth: '최근 {0}개월',
|
||
lastHalfYear: '최근 반년',
|
||
memory: '메모리',
|
||
percent: '비율',
|
||
cache: '캐시',
|
||
disk: '디스크',
|
||
network: '네트워크',
|
||
up: '업',
|
||
down: '다운',
|
||
interval: '수집 간격',
|
||
intervalHelper: '적절한 모니터링 수집 간격을 입력하세요 (10초 - 12시간)',
|
||
runtimeDiagnostics: '런타임 진단',
|
||
runtimeRSS: '프로세스 메모리 (RSS)',
|
||
runtimeHeapAlloc: '힙 메모리',
|
||
runtimeHeapObjects: '힙 객체',
|
||
runtimeGoroutines: 'Goroutine 수',
|
||
goroutineSnapshot: 'Goroutine 스냅샷',
|
||
goroutineSummary: 'Goroutine {0}개를 호출 스택 {1}개로 그룹화',
|
||
goroutineTruncated: '스냅샷이 너무 커서 일부 호출 스택만 표시됩니다.',
|
||
captureSnapshot: '스냅샷 새로고침',
|
||
count: '수량',
|
||
topFunction: '최상위 함수',
|
||
manualCapture: '수동 캡처',
|
||
startCapture: '캡처 시작',
|
||
capturing: '캡처 중',
|
||
captureSuccess: '진단 파일이 생성되어 다운로드를 시작했습니다',
|
||
profileCPU: 'CPU',
|
||
profileHeap: '힙',
|
||
profileGoroutine: 'Goroutine',
|
||
profileMutex: '뮤텍스',
|
||
profileBlock: '블록',
|
||
runtimeRSSDesc: 'Go 힙, 스레드 스택 및 네이티브 메모리를 포함해 프로세스가 사용하는 실제 메모리입니다.',
|
||
runtimeHeapAllocDesc:
|
||
'Go 힙에 할당되어 아직 해제되지 않은 메모리입니다. 지속적인 증가는 객체가 유지되고 있음을 나타낼 수 있습니다.',
|
||
runtimeHeapObjectsDesc:
|
||
'Go 힙의 현재 활성 객체 수입니다. 지속적인 증가는 객체가 유지되고 있음을 나타낼 수 있습니다.',
|
||
runtimeGoroutineDesc: '현재 경량 동시 작업 수입니다. 지속적으로 증가하면 Goroutine 누수를 확인해야 합니다.',
|
||
profileCPUDesc: '선택한 시간 동안 CPU 호출 스택을 샘플링하여 CPU를 소비하는 함수를 찾습니다.',
|
||
profileHeapDesc: '사용 중인 Go 힙 객체와 할당 스택을 기록하여 지속적인 메모리 증가를 조사합니다.',
|
||
profileGoroutineDesc: '모든 Goroutine의 상태와 호출 스택을 저장하고 동일한 호출 경로를 그룹화합니다.',
|
||
profileMutexDesc: 'Mutex 경합으로 인한 대기 시간을 측정하여 잠금 경합 지점을 찾습니다.',
|
||
profileBlockDesc: 'Channel, Select 및 동기화 프리미티브의 차단 대기 시간을 측정합니다.',
|
||
},
|
||
terminal: {
|
||
local: '로컬',
|
||
defaultConn: '기본 연결',
|
||
defaultConnHelper: '이 작업은 【{0}】의 터미널을 연 후 자동으로 노드 터미널에 연결됩니다. 계속하시겠습니까?',
|
||
withReset: '연결 정보 재설정',
|
||
localConnJump: '기본 연결 정보는 [터미널 - 설정]에서 관리됩니다. 연결 실패 시 해당 위치에서 편집하세요!',
|
||
nodeAdminLocalOnly: '노드 관리자는 로컬 터미널만 사용할 수 있습니다.',
|
||
localHelper: '로컬 이름은 시스템 로컬 식별에만 사용됩니다.',
|
||
connLocalErr: '자동 인증에 실패했습니다. 로컬 서버 로그인 정보를 입력해주세요.',
|
||
testConn: '연결 테스트',
|
||
saveAndConn: '저장 후 연결',
|
||
connTestOk: '연결 정보가 유효합니다.',
|
||
connTestFailed: '연결할 수 없습니다. 연결 정보를 확인해주세요.',
|
||
host: '호스트 | 호스트들',
|
||
createConn: '새 연결',
|
||
manageGroup: '그룹 관리',
|
||
noHost: '호스트 없음',
|
||
groupChange: '그룹 변경',
|
||
expand: '모두 확장',
|
||
fold: '모두 축소',
|
||
batchInput: '배치 처리',
|
||
quickCommand: '빠른 명령 | 빠른 명령들',
|
||
noSuchCommand: '가져온 CSV 파일에서 빠른 명령어 데이터를 찾을 수 없습니다. 확인 후 다시 시도하세요!',
|
||
quickCommandHelper: '"터미널 -> 터미널" 하단에서 빠른 명령을 사용할 수 있습니다.',
|
||
groupDeleteHelper: '그룹을 제거하면 해당 그룹의 모든 연결이 기본 그룹으로 이동됩니다. 계속하시겠습니까?',
|
||
quickCommandBatchHelper: '한 줄에 하나의 빠른 명령을 이름---명령 형식으로 입력하세요. 예: 디스크 확인---df -h',
|
||
command: '명령',
|
||
quickCmd: '빠른 명령',
|
||
addHost: '추가',
|
||
localhost: '로컬호스트',
|
||
ip: '주소',
|
||
authMode: '인증 방식',
|
||
passwordMode: '비밀번호',
|
||
rememberPassword: '인증 정보 기억하기',
|
||
keyMode: '개인 키',
|
||
key: '개인 키',
|
||
keyPassword: '개인 키 비밀번호',
|
||
emptyTerminal: '현재 연결된 터미널이 없습니다.',
|
||
lineHeight: '줄 높이',
|
||
letterSpacing: '자간',
|
||
fontSize: '글꼴 크기',
|
||
fontFamily: '글꼴 세트',
|
||
fontFamilySupportHelper:
|
||
'글꼴을 선택하거나 직접 입력할 수 있습니다. 적용 여부는 브라우저가 실행 중인 시스템에 해당 글꼴이 설치되어 있는지에 따라 달라지며, 미설치 시 자동으로 폴백됩니다. 비어 있으면 기본 글꼴을 사용합니다.',
|
||
backgroundColor: '배경색',
|
||
foregroundColor: '전경색',
|
||
cursorBlink: '커서 깜박임',
|
||
cursorStyle: '커서 스타일',
|
||
cursorUnderline: '밑줄',
|
||
cursorBlock: '블록',
|
||
cursorBar: '막대',
|
||
scrollback: '스크롤백',
|
||
scrollSensitivity: '스크롤 감도',
|
||
aiAssistant: 'AI 도우미',
|
||
aiAccountHelper:
|
||
'선택한 모델 계정으로 명령을 생성하고 채웁니다. Ollama, vLLM 같은 로컬 모델은 사용자 지정 모델 계정을 사용하세요.',
|
||
aiPrefix: '트리거 접두사',
|
||
aiPrefixHelper:
|
||
'"접두사 + 공백"을 입력하고 Enter를 누르면 AI 명령 생성이 시작됩니다. 예: {0} 디스크 정보를 조회해줘.',
|
||
aiRiskCommands: '위험 명령 차단',
|
||
aiRiskCommandsHelper:
|
||
'차단할 위험 명령을 설정하세요(한 줄에 하나씩). 일치하면 생성이 차단되고 주석으로 다시 채워집니다.',
|
||
aiSummary: '{0} 접두사로 시작하는 줄에서 Enter를 누르면 AI 명령 생성이 트리거됩니다.',
|
||
aiPrefixAsciiVisible: 'ASCII 표시 가능 문자만 지원합니다. 공백, CJK 문자 및 전각 기호는 사용할 수 없습니다.',
|
||
saveHelper: '현재 터미널 설정을 저장하시겠습니까?',
|
||
},
|
||
toolbox: {
|
||
common: {
|
||
toolboxHelper: '일부 설치 및 사용 문제는 다음을 참고하세요',
|
||
},
|
||
swap: {
|
||
swap: '스왑 파티션',
|
||
swapHelper1: '스왑 크기는 물리적 메모리의 1~2배로 설정해야 하며, 특정 요구 사항에 따라 조정 가능합니다.',
|
||
swapHelper2:
|
||
'스왑 파일을 생성하기 전에 시스템 디스크에 충분한 가용 공간이 있는지 확인하세요. 스왑 파일 크기만큼 디스크 공간이 점유됩니다.',
|
||
swapHelper3:
|
||
'스왑은 메모리 압력을 완화하는 데 도움이 될 수 있지만, 단지 대안일 뿐입니다. 스왑에 과도하게 의존하면 시스템 성능이 저하될 수 있으므로 메모리를 추가하거나 애플리케이션 메모리 사용을 최적화하는 것을 우선적으로 고려해야 합니다.',
|
||
swapHelper4: '스왑 사용량을 정기적으로 모니터링하여 시스템이 정상적으로 작동하는지 확인하는 것이 좋습니다.',
|
||
swapDeleteHelper:
|
||
'이 작업은 스왑 파티션 {0}을 제거합니다. 시스템 보안상의 이유로 해당 파일은 자동으로 삭제되지 않습니다. 삭제가 필요한 경우 수동으로 진행하세요!',
|
||
saveHelper: '현재 설정을 먼저 저장해주세요!',
|
||
saveSwap: '현재 구성을 저장하면 스왑 파티션 {0}의 크기가 {1}(으)로 조정됩니다. 계속하시겠습니까?',
|
||
swapMin: '최소 파티션 크기는 40 KB입니다. 수정 후 다시 시도해주세요!',
|
||
swapMax: '파티션 크기의 최대값은 {0}입니다. 수정 후 다시 시도해주세요!',
|
||
swapOff: '최소 파티션 크기는 40 KB입니다. 0으로 설정하면 스왑 파티션이 비활성화됩니다.',
|
||
},
|
||
device: {
|
||
dnsHelper: 'DNS 서버',
|
||
dnsAlert: '/etc/resolv.conf 파일의 구성을 수정하면 시스템 재부팅 후 파일이 기본값으로 복원됩니다.',
|
||
dnsHelper1: 'DNS 항목이 여러 개인 경우 각 항목을 새 줄에 표시해야 합니다. 예:\n114.114.114.114\n8.8.8.8',
|
||
hostsHelper: '호스트 이름 해석',
|
||
hosts: '도메인',
|
||
hostAlert: '주석 처리된 기록은 숨겨져 있습니다. 모든 구성 버튼을 클릭하여 보거나 설정하세요.',
|
||
toolbox: '빠른 설정',
|
||
hostname: '호스트 이름',
|
||
passwd: '시스템 비밀번호',
|
||
passwdHelper: '입력 문자는 $ 및 &를 포함할 수 없습니다.',
|
||
timeZone: '시간대',
|
||
localTime: '서버 시간',
|
||
timeZoneChangeHelper: '시스템 시간대를 변경하려면 서비스를 재시작해야 합니다. 계속하시겠습니까?',
|
||
timeZoneHelper:
|
||
'"timedatectl" 명령이 설치되지 않은 경우 시간대를 변경할 수 없습니다. 시스템은 시간대 변경에 이 명령을 사용합니다.',
|
||
timeZoneCN: '베이징',
|
||
timeZoneAM: '로스앤젤레스',
|
||
timeZoneNY: '뉴욕',
|
||
ntpALi: '알리바바',
|
||
ntpGoogle: '구글',
|
||
syncSite: 'NTP 서버',
|
||
hostnameHelper:
|
||
'호스트 이름 수정은 "hostnamectl" 명령에 따라 달라집니다. 명령이 설치되지 않은 경우 수정이 실패할 수 있습니다.',
|
||
userHelper:
|
||
'사용자 이름은 "whoami" 명령을 사용하여 검색됩니다. 명령이 설치되지 않은 경우 검색이 실패할 수 있습니다.',
|
||
passwordHelper:
|
||
'비밀번호 수정은 "chpasswd" 명령에 따라 달라집니다. 명령이 설치되지 않은 경우 수정이 실패할 수 있습니다.',
|
||
hostHelper: '제공된 내용에 빈 값이 포함되어 있습니다. 확인 후 수정하여 다시 시도해주세요!',
|
||
dnsCheck: '가용성 테스트',
|
||
dnsOK: 'DNS 구성 정보가 유효합니다!',
|
||
dnsTestFailed: 'DNS 구성 정보가 유효하지 않습니다.',
|
||
syncSiteHelper: '{0}을(를) 기준으로 시스템 시간을 동기화하시겠습니까?',
|
||
},
|
||
fail2ban: {
|
||
sshPort: 'SSH 포트 청취',
|
||
sshPortHelper: '현재 Fail2ban 은 호스트의 SSH 연결 포트를 청취합니다.',
|
||
unActive: '현재 Fail2ban 서비스가 활성화되어 있지 않습니다.',
|
||
operation: 'Fail2ban 서비스에서 "{0}" 작업을 수행합니다. 계속하시겠습니까?',
|
||
fail2banChange: 'Fail2ban 구성 수정',
|
||
ignoreHelper: '허용 목록에 있는 IP는 차단되지 않습니다. 계속하시겠습니까?',
|
||
bannedHelper: '차단 목록에 있는 IP는 서버에 의해 차단됩니다. 계속하시겠습니까?',
|
||
maxRetry: '최대 재시도 횟수',
|
||
banTime: '차단 시간',
|
||
banTimeHelper: '기본 차단 시간은 10분이며, -1은 영구 차단을 나타냅니다.',
|
||
banTimeRule: '유효한 차단 시간 또는 -1을 입력하세요.',
|
||
banAllTime: '영구 차단',
|
||
findTime: '탐지 기간',
|
||
banAction: '차단 작업',
|
||
banActionOption: '{0}을(를) 사용하여 지정된 IP 주소 차단',
|
||
allPorts: ' (모든 포트)',
|
||
ignoreIP: 'IP 허용 목록',
|
||
bannedIP: 'IP 차단 목록',
|
||
logPath: '로그 경로',
|
||
logPathHelper: '기본값은 /var/log/secure 또는 /var/log/auth.log입니다.',
|
||
},
|
||
ftp: {
|
||
ftp: 'FTP 계정 | FTP 계정들',
|
||
notStart: 'FTP 서비스가 현재 실행 중이 아닙니다. 먼저 시작하세요!',
|
||
initHelper: 'FTP 사용자 ID가 초기화되지 않았습니다. 먼저 상단 상태 표시줄에서 초기화를 클릭하세요.',
|
||
operation: 'FTP 서비스에서 "{0}" 작업을 수행합니다. 계속하시겠습니까?',
|
||
noPasswdMsg: '현재 FTP 계정의 비밀번호를 가져올 수 없습니다. 비밀번호를 설정한 후 다시 시도하세요!',
|
||
enableHelper: '선택한 FTP 계정을 활성화하면 접근 권한이 복원됩니다. 계속하시겠습니까?',
|
||
disableHelper: '선택한 FTP 계정을 비활성화하면 접근 권한이 취소됩니다. 계속하시겠습니까?',
|
||
syncHelper: '서버와 데이터베이스 간의 FTP 계정 데이터를 동기화합니다. 계속하시겠습니까?',
|
||
dirSystem:
|
||
'이 디렉터리는 시스템 예약 디렉터리입니다. 수정 시 시스템 충돌이 발생할 수 있으니 수정 후 다시 시도하세요!',
|
||
dirHelper: 'FTP 활성화를 위해 디렉터리 권한 변경이 필요합니다. 신중하게 선택하세요',
|
||
dirMsg: 'FTP 활성화 시 {0} 디렉터리 전체의 권한이 변경됩니다. 계속하시겠습니까?',
|
||
},
|
||
clam: {
|
||
clam: '바이러스 검사',
|
||
cron: '예약 스캔',
|
||
cronHelper: '상용 버전에서 예약 스캔 기능을 지원합니다.',
|
||
specErr: '실행 일정 형식 오류입니다. 확인 후 다시 시도하세요!',
|
||
disableMsg: '예약 실행을 중지하면 이 스캔 작업이 자동으로 실행되지 않습니다. 계속하시겠습니까?',
|
||
enableMsg: '예약 실행을 활성화하면 이 스캔 작업이 정기적으로 자동 실행됩니다. 계속하시겠습니까?',
|
||
showFresh: '서명 업데이트 서비스 표시',
|
||
hideFresh: '서명 업데이트 서비스 숨기기',
|
||
clamHelper:
|
||
'ClamAV의 최소 권장 구성은 다음과 같습니다: RAM 3 GiB 이상, 2.0 GHz 이상의 단일 코어 CPU, 최소 5 GiB의 사용 가능한 하드 디스크 공간.',
|
||
notStart: 'ClamAV 서비스가 현재 실행 중이 아닙니다. 먼저 시작하세요!',
|
||
removeRecord: '보고서 파일 삭제',
|
||
noRecords: '"Trigger" 버튼을 클릭하여 스캔을 시작하면 이곳에서 기록을 확인할 수 있습니다.',
|
||
removeInfected: '바이러스 파일 삭제',
|
||
removeInfectedHelper: '작업 중 감지된 바이러스 파일을 삭제하여 서버 보안 및 정상 작동을 보장합니다.',
|
||
clamCreate: '스캔 규칙 생성',
|
||
infectedStrategy: '감염 파일 처리 전략',
|
||
removeHelper: '바이러스 파일을 삭제합니다. 신중히 선택하세요!',
|
||
move: '이동',
|
||
moveHelper: '바이러스 파일을 지정된 디렉토리로 이동합니다.',
|
||
copyHelper: '바이러스 파일을 지정된 디렉토리로 복사합니다.',
|
||
none: '조치 안 함',
|
||
noneHelper: '바이러스 파일에 대해 아무 조치도 취하지 않습니다.',
|
||
scanDir: '스캔 디렉토리',
|
||
infectedDir: '감염 파일 디렉토리',
|
||
scanDate: '스캔 날짜',
|
||
scanResult: '스캔 로그 출력',
|
||
tail: '라인',
|
||
infectedFiles: '감염된 파일',
|
||
log: '상세 내용',
|
||
clamConf: 'Clam AV 데몬',
|
||
clamLog: '@:toolbox.clam.clamConf 로그',
|
||
freshClam: 'FreshClam',
|
||
freshClamLog: '@:toolbox.clam.freshClam 로그',
|
||
alertHelper: '상용 버전에서 예약 스캔 및 SMS 알림을 지원합니다.',
|
||
alertTitle: '바이러스 스캔 작업 「{0}」에서 감염된 파일을 발견했습니다.',
|
||
},
|
||
},
|
||
logs: {
|
||
core: '패널 서비스',
|
||
agent: '노드 모니터링',
|
||
panelLog: '패널 로그',
|
||
operation: '작업 로그',
|
||
login: '로그인 로그',
|
||
loginIP: '로그인 IP',
|
||
loginAddress: '로그인 주소',
|
||
loginAgent: '로그인 에이전트',
|
||
loginStatus: '상태',
|
||
system: '시스템 로그',
|
||
hostSystem: '호스트 로그',
|
||
previousPage: '이전 페이지',
|
||
nextPage: '다음 페이지',
|
||
filter: '필터',
|
||
service: '서비스',
|
||
priority: '우선순위',
|
||
priorityEmergency: '긴급',
|
||
priorityAlert: '경보',
|
||
priorityCritical: '심각',
|
||
priorityError: '오류',
|
||
priorityWarning: '경고',
|
||
priorityNotice: '알림',
|
||
priorityInfo: '정보',
|
||
priorityDebug: '디버그',
|
||
message: '메시지',
|
||
deleteLogs: '로그 정리',
|
||
resource: '자원',
|
||
detail: {
|
||
dashboard: '개요',
|
||
ai: 'AI',
|
||
skills_hub: 'Skills Hub',
|
||
ai_proxy: 'AI 프록시',
|
||
ai_benchmark: '벤치마크',
|
||
groups: '그룹',
|
||
hosts: '호스트',
|
||
apps: '애플리케이션',
|
||
openresty: 'OpenResty',
|
||
websites: '웹사이트',
|
||
monitor: '웹사이트 모니터링',
|
||
containers: '컨테이너',
|
||
files: '파일 관리',
|
||
runtimes: '실행 환경',
|
||
process: '프로세스 관리',
|
||
toolbox: '도구 상자',
|
||
backups: '백업 / 복원',
|
||
tampers: '변조 방지',
|
||
xsetting: '인터페이스 설정',
|
||
logs: '로그 감사',
|
||
settings: '패널 설정',
|
||
cronjobs: '예약 작업',
|
||
waf: 'WAF',
|
||
databases: '데이터베이스',
|
||
licenses: '라이선스',
|
||
nodes: '노드',
|
||
commands: '빠른 명령',
|
||
opsReport: '운영 보고서',
|
||
users: '사용자 관리',
|
||
roles: '역할',
|
||
auth: '로그인 인증',
|
||
alert: '경고 알림',
|
||
sync: '리소스 동기화',
|
||
exchange: '리소스 동기화',
|
||
xapp: 'App',
|
||
vms: '가상 머신 관리',
|
||
},
|
||
websiteLog: '웹사이트 로그',
|
||
runLog: '실행 로그',
|
||
errLog: '에러 로그',
|
||
task: '작업 로그',
|
||
taskName: '작업 이름',
|
||
taskRunning: '실행 중',
|
||
},
|
||
file: {
|
||
fileDirNum: '총 {0}개 디렉터리, {1}개 파일,',
|
||
currentDir: '현재 디렉터리',
|
||
dir: '폴더',
|
||
upload: '업로드',
|
||
uploadFile: '@:file.upload @.lower:file.file',
|
||
uploadDirectory: '@:file.upload @.lower:file.dir',
|
||
download: '다운로드',
|
||
fileName: '파일 이름',
|
||
search: '검색',
|
||
mode: '권한',
|
||
editPermissions: '권한 편집',
|
||
owner: '소유자',
|
||
file: '파일',
|
||
remoteFile: '원격에서 다운로드',
|
||
share: '공유',
|
||
sync: '데이터 동기화',
|
||
size: '크기',
|
||
updateTime: '수정됨',
|
||
rename: '이름 바꾸기',
|
||
role: '권한',
|
||
info: '속성',
|
||
linkFile: '소프트 링크',
|
||
batchoperation: '일괄 작업',
|
||
shareList: '공유 목록',
|
||
fileTools: '파일 도구',
|
||
aiSearchHitLines: '일치하는 줄',
|
||
aiSearch: 'AI 검색',
|
||
aiSearchTitle: 'AI 검색',
|
||
aiSearchHint:
|
||
'파일 내용을 줄 단위로 검색합니다. 검색창 오른쪽 버튼과 아래의 "고급 조건"에서 검색 방식을 바꿀 수 있습니다. AI 계정을 활성화하고 저장하면 Markdown 요약도 생성할 수 있습니다.',
|
||
aiSearchAccountTitle: 'AI 계정',
|
||
aiSearchAccountIntro: '요약 생성을 위한 대형 모델 계정을 선택하세요. 변경 후 저장을 눌러주세요.',
|
||
aiSearchAccountEnable: '파일 AI 검색 활성화',
|
||
aiSearchSaveAccount: '계정 설정 저장',
|
||
aiSearchSectionQuery: '검색',
|
||
aiSearchSectionConditions: '검색 조건',
|
||
aiSearchResultsSection: '분석 결과',
|
||
aiSearchContentLabel: '검색 내용',
|
||
aiSearchDirLabel: '디렉터리',
|
||
aiSearchExtLabel: '파일 확장자',
|
||
aiSearchModifiedPreset: '수정 시간',
|
||
aiSearchSizePresetLabel: '파일 크기',
|
||
aiSearchTimeAny: '기간 없음',
|
||
aiSearchTime3h: '최근 3시간',
|
||
aiSearchTime1d: '최근 1일',
|
||
aiSearchTime7d: '최근 7일',
|
||
aiSearchTime30d: '최근 30일',
|
||
aiSearchTimeCustom: '사용자 지정',
|
||
aiSearchSizeAny: '크기 제한 없음',
|
||
aiSearchSize0_10mb: '0 ~ 10 MB',
|
||
aiSearchSize10_100mb: '10 MB ~ 100 MB',
|
||
aiSearchSize100_1gb: '100 MB ~ 1 GB',
|
||
aiSearchSizeGte1gb: '1 GB 이상',
|
||
aiSearchSizeCustom: '사용자 지정(바이트)',
|
||
aiSearchPlaceholder: '검색 내용을 입력하세요',
|
||
aiSearchContainSub: '하위 폴더',
|
||
aiSearchMaxItems: '검색 대상 경로/파일 수 상한(디렉터리 열람, 1–2000)',
|
||
aiSearchRun: '분석 시작',
|
||
aiSearchTruncated: '디렉터리 항목이 너무 많아 일부만 포함되었습니다. 결과가 완전하지 않을 수 있습니다.',
|
||
aiSearchPreFiltered: '키워드로 상대 경로를 미리 필터링하여 모델에 보낼 항목 수를 줄였습니다.',
|
||
aiSearchMeta: '분석 항목: {0} | 소요 시간 {1} | Token {2}',
|
||
aiSearchQueryRequired: '검색 내용이나 키워드를 입력하세요',
|
||
aiSearchContentHits: '내용 일치',
|
||
aiSearchContentScanMeta: '내용 스캔: {0}개의 텍스트 파일을 읽었습니다(현재 검색 조건, 크기/개수 제한 적용).',
|
||
aiSearchNoLineHits: '스캔한 텍스트 파일에서 일치하는 줄이 없습니다.',
|
||
aiSearchHitsTruncated: '일부 파일은 스캔되지 않았거나, 상한으로 인해 일치 목록이 잘렸습니다.',
|
||
aiSearchHitFiles: '일치한 파일',
|
||
aiSearchOpenFile: '편집기에서 열기',
|
||
aiSearchOpenAtLine: '이 줄로 열기',
|
||
aiSearchGrepOnlyHint:
|
||
'현재 파일 AI가 비활성화되어 있습니다. 결정적인 내용 검색만 수행되며 모델은 호출되지 않습니다. 위에서 AI 계정을 활성화하고 저장하면 요약을 사용할 수 있습니다. 검색 줄과 아래 옵션은 계속 적용됩니다.',
|
||
aiSearchMatchCase: '대소문자 구분',
|
||
aiSearchWholeWord: '단어 전체 일치(영문 단어 경계 \\b)',
|
||
aiSearchUseRegex: '정규식(Go RE2 문법)',
|
||
aiSearchExtensions: '파일 확장자(쉼표 구분, 예: go,ts,md)',
|
||
aiSearchMinSize: '최소 파일 크기(바이트, 0은 제한 없음)',
|
||
aiSearchMaxSize: '최대 파일 크기(바이트, 0은 제한 없음)',
|
||
aiSearchSectionAdvanced: '고급 조건',
|
||
aiSearchLimitMaxItems: '검색 총 파일 수',
|
||
aiSearchLimitMaxScan: '내용 스캔 파일 수',
|
||
aiSearchLimitMaxBytes: '단일 파일 읽기 상한',
|
||
aiSearchLimitHitsPerFile: '단일 파일 일치 줄 수',
|
||
aiSearchLimitTotalHits: '총 일치 줄 수',
|
||
aiSearchLimitUnitEntries: '개',
|
||
aiSearchLimitUnitFiles: '파일',
|
||
aiSearchLimitUnitBytes: 'B',
|
||
aiSearchLimitUnitLines: '줄',
|
||
aiSearchMaxScanFiles: '내용 스캔 최대 파일 수',
|
||
aiSearchMaxFileBytes:
|
||
'내용 스캔 시 각 파일에서 읽는 최대 바이트 수입니다. 위의 "파일 크기"와는 다르며, 이는 파일을 열어 비교할 때 실제 읽는 양을 제한합니다.',
|
||
aiSearchMaxHitsPerFile: '단일 파일 최대 일치 줄 수',
|
||
aiSearchMaxTotalHits: '총 일치 줄 수 상한',
|
||
aiSearchGrepMetaContent:
|
||
'내용 스캔: 검색 총 항목 {0}, 읽은 텍스트 파일 {1}개(현재 조건, 크기/개수 제한 적용). 소요 시간 {2}',
|
||
aiSearchAdvancedResetDefaults: '기본 상한으로 복원',
|
||
zip: '압축됨',
|
||
group: '그룹',
|
||
path: '경로',
|
||
public: '기타',
|
||
setRole: '권한 설정',
|
||
link: '파일 링크',
|
||
rRole: '읽기',
|
||
wRole: '쓰기',
|
||
xRole: '실행 가능',
|
||
name: '이름',
|
||
compress: '압축',
|
||
deCompress: '압축 해제',
|
||
compressType: '압축 형식',
|
||
compressDst: '압축 경로',
|
||
replace: '기존 파일 덮어쓰기',
|
||
compressSuccess: '압축 성공',
|
||
deCompressSuccess: '압축 해제 성공',
|
||
deCompressDst: '압축 해제 경로',
|
||
linkType: '링크 유형',
|
||
softLink: '소프트 링크',
|
||
hardLink: '하드 링크',
|
||
linkPath: '링크 경로',
|
||
selectFile: '파일 선택',
|
||
downloadUrl: '원격 URL',
|
||
downloadStart: '다운로드 시작됨',
|
||
wgetUrlInvalid: '유효한 http(s) 다운로드 주소를 입력하세요',
|
||
moveSuccess: '이동 성공',
|
||
copySuccess: '복사 성공',
|
||
pasteMsg: '대상 디렉토리의 오른쪽 상단에 있는 [붙여넣기] 버튼을 클릭하세요',
|
||
move: '이동',
|
||
calculate: '계산',
|
||
remark: '비고',
|
||
setRemark: '비고 설정',
|
||
remarkPrompt: '비고를 입력하세요',
|
||
remarkPlaceholder: '비고',
|
||
remarkToggle: '비고',
|
||
remarkToggleTip: '파일 비고 로드',
|
||
canNotDeCompress: '이 파일은 압축 해제할 수 없습니다',
|
||
uploadSuccess: '업로드 성공',
|
||
downloadProcess: '다운로드 진행률',
|
||
downloading: '다운로드 중...',
|
||
infoDetail: '파일 속성',
|
||
root: '루트 디렉터리',
|
||
list: '파일 목록',
|
||
sub: '하위 폴더',
|
||
downloadSuccess: '다운로드 성공',
|
||
theme: '테마',
|
||
language: '언어',
|
||
eol: '줄 끝',
|
||
history: '버전 기록',
|
||
historyTitle: '버전 기록',
|
||
historyHint:
|
||
'파일 변경 전 버전을 기록하여 파일 내용의 변경 이력을 확인하고 내용 수정 버전으로 되돌릴 수 있습니다.',
|
||
historySettingTitle: '버전 정책',
|
||
historyEnable: '버전 기록 활성화',
|
||
historyMaxPerPath: '파일당 보관 개수',
|
||
historyDiskQuota: '전체 디스크 할당량 (MB)',
|
||
historyCurrentScope: '현재 파일',
|
||
historyAllScope: '전체 파일',
|
||
historyDeleteConfirm: '선택한 변경 기록을 삭제하시겠습니까?',
|
||
historyNeedFile: '먼저 파일을 열어주세요',
|
||
historyRestore: '이 버전으로 복원',
|
||
historyOperationOnlyHint: '선택한 항목은 파일 작업이며 버전 복원을 지원하지 않습니다.',
|
||
historyCurrentFile: '현재 파일',
|
||
historyLatestVersion: '왼쪽에는 기록 버전의 내용, 오른쪽에는 선택한 파일의 최신 버전 내용을 표시합니다',
|
||
historyCompareTarget: '비교 대상',
|
||
historyCompareTargetPath: '비교 경로',
|
||
historyRestoreConfirm: '이 버전을 현재 파일로 복원하시겠습니까?',
|
||
historyRestoreDirtyConfirm:
|
||
'현재 파일에 저장되지 않은 변경 사항이 있습니다. 복원하면 덮어씌워집니다. 계속하시겠습니까?',
|
||
historyRestoreSuccess: '버전 복원이 완료되었습니다',
|
||
historyDirtyHint: '현재 편집기에는 저장되지 않은 변경 사항이 있습니다. 버전을 복원하면 덮어씌워집니다.',
|
||
historyDiffHintCurrent: '왼쪽은 기록 버전의 내용, 오른쪽은 현재 파일 내용을 표시합니다',
|
||
historyDiffHintAll: '왼쪽은 기록 버전의 내용, 오른쪽은 선택한 파일의 최신 버전을 표시합니다',
|
||
copyDir: '복사',
|
||
shareFile: '파일 공유',
|
||
shareExpire: '유효 기간',
|
||
shareExpire1h: '1시간',
|
||
shareExpire6h: '6시간',
|
||
shareExpire24h: '24시간',
|
||
shareExpire3d: '3일',
|
||
shareExpire7d: '7일',
|
||
sharePassword: '암호',
|
||
sharePasswordPlaceholder: '비워 두면 암호 없음',
|
||
shareMaxDownloads: '최대 다운로드 횟수',
|
||
shareMaxDownloadsHint: '0은 무제한',
|
||
shareGenerate: '링크 만들기',
|
||
shareRegenerate: '다시 공유',
|
||
shareClose: '닫기',
|
||
shareCancel: '공유 취소',
|
||
shareCancelConfirm: '이 파일 공유를 취소하시겠습니까?',
|
||
shareDetail: '상세',
|
||
shareCopyLink: '링크 복사',
|
||
shareLinkLabel: '공유 링크',
|
||
shareQrCode: 'QR 코드',
|
||
shareQrDialogTitle: '공유 링크 QR 코드 이미지',
|
||
shareQrDialogHelper: '모바일 기기로 QR 코드를 스캔하세요',
|
||
shareSaveImage: '이미지 저장',
|
||
shareOpenImage: '이미지 열기',
|
||
shareExtractFile: '파일 받기',
|
||
shareDownloadingHint: '파일을 준비하는 중입니다. 곧 다운로드가 시작됩니다.',
|
||
shareInvalid: '유효하지 않거나 만료된 공유 링크입니다',
|
||
shareDownloadFailed: '다운로드에 실패했습니다. 잠시 후 다시 시도해 주세요',
|
||
sharePasswordRequired: '접근 비밀번호',
|
||
sharePasswordRequiredInput: '접근 비밀번호를 입력해 주세요',
|
||
sharePasswordLengthHint: '접근 비밀번호 길이는 4-256자여야 합니다',
|
||
shareDownloadPasswordTip: '이 링크는 비밀번호로 보호되어 있습니다. 입력 후 다운로드하세요.',
|
||
shareRiskAlert:
|
||
'외부 공유 링크에는 일정한 보안 위험이 있습니다. 신뢰할 수 있는 사람에게만 공유하고 민감한 정보가 노출되지 않도록 주의하세요.',
|
||
sharePasswordSeparate:
|
||
'암호가 설정되었습니다. 안전하게 전달하세요. 수신자는 URL에 &password=...를 추가하거나 해당 매개변수를 지원하는 클라이언트를 사용해야 합니다.',
|
||
shareExpiresAt: '만료 시각',
|
||
paste: '붙여넣기',
|
||
changeOwner: '사용자 및 그룹 수정',
|
||
containSub: '권한 변경을 하위 폴더에 적용',
|
||
ownerHelper:
|
||
'PHP 운영 환경의 기본 사용자: 사용자 그룹은 1000:1000 입니다. 컨테이너 내부 및 외부에서 표시되는 불일치는 정상입니다.',
|
||
searchHelper: '* 등의 와일드카드를 지원합니다',
|
||
uploadFailed: '[{0}] 파일 업로드 실패',
|
||
fileUploadStart: '[{0}] 업로드 중...',
|
||
uploadOverallProgress: '전체 진행률',
|
||
uploadCurrentFileProgress: '현재 파일',
|
||
currentSelect: '현재 선택: ',
|
||
unsupportedType: '지원되지 않는 파일 유형',
|
||
deleteHelper: '다음 파일을 삭제하시겠습니까? 기본적으로 삭제 후 휴지통으로 이동합니다.',
|
||
fileHelper: '참고:\n1. 검색 결과는 정렬할 수 없습니다.\n2. 폴더는 크기로 정렬할 수 없습니다.',
|
||
forceDeleteHelper: '파일을 영구적으로 삭제합니다(휴지통으로 이동하지 않고 바로 삭제).',
|
||
recycleBin: '휴지통',
|
||
sourcePath: '원래 경로',
|
||
deleteTime: '삭제 시간',
|
||
confirmReduce: '다음 파일을 복원하시겠습니까?',
|
||
reduceSuccess: '복원 성공',
|
||
reduce: '복원',
|
||
reduceHelper: '원래 경로에 동일한 이름의 파일이나 디렉터리가 있으면 덮어씁니다. 계속하시겠습니까?',
|
||
clearRecycleBin: '정리',
|
||
clearRecycleBinHelper: '휴지통을 정리하시겠습니까?',
|
||
favorite: '즐겨찾기',
|
||
removeFavorite: '즐겨찾기에서 제거하시겠습니까?',
|
||
addFavorite: '즐겨찾기 추가 / 제거',
|
||
addFavoriteAction: '즐겨찾기에 추가',
|
||
removeFavoriteAction: '즐겨찾기에서 제거',
|
||
clearList: '목록 정리',
|
||
deleteRecycleHelper: '다음 파일을 영구적으로 삭제하시겠습니까?',
|
||
typeErrOrEmpty: '[{0}] 파일 유형이 잘못되었거나 빈 폴더입니다.',
|
||
dropHelper: '업로드하려는 파일을 여기에 드래그하세요',
|
||
fileRecycleBin: '휴지통 활성화',
|
||
fileRecycleBinMsg: '{0} 휴지통',
|
||
wordWrap: '자동 줄바꿈',
|
||
deleteHelper2: '선택한 파일을 삭제하시겠습니까? 삭제 작업은 되돌릴 수 없습니다.',
|
||
ignoreCertificate: '안전하지 않은 서버 연결 허용',
|
||
ignoreCertificateHelper:
|
||
'안전하지 않은 서버 연결을 허용하면 데이터 유출 또는 변조가 발생할 수 있습니다. 이 옵션은 다운로드 소스를 신뢰할 때만 사용하세요.',
|
||
useProxy: '프록시로 다운로드',
|
||
useProxyHelper: '패널 설정의 프록시 서버로 원격 다운로드 주소에 접근합니다',
|
||
uploadOverLimit: '파일 수가 1000 개를 초과했습니다! 압축하여 업로드하세요.',
|
||
clashDidNotSupport: '파일 이름에 .1panel_clash 를 포함할 수 없습니다.',
|
||
clashDeleteAlert: '"휴지통" 폴더는 삭제할 수 없습니다.',
|
||
clashOpenAlert: '휴지통 디렉터리를 열려면 "휴지통" 버튼을 클릭하세요.',
|
||
right: '앞으로',
|
||
back: '뒤로',
|
||
top: '처음으로 돌아가기',
|
||
up: '뒤로가기',
|
||
openWithVscode: 'VS Code 로 열기',
|
||
vscodeHelper:
|
||
'인증 방식, 호스트, 포트, 사용자명을 확인하세요. 키 인증을 사용하려면 먼저 VS Code를 실행하는 로컬 컴퓨터에서 SSH 설정을 완료해야 합니다.',
|
||
vscodeCopyConfig: '설정 스크립트 복사',
|
||
vscodeKeyHelper:
|
||
'개인 키 다운로드 파일명은 설정된 경로를 기준으로 생성됩니다. 파일을 해당 경로에 저장하면 설정 스크립트가 파일을 확인하고 권한을 적용합니다.',
|
||
vscodeKeyPath: 'SSH 개인 키 경로',
|
||
vscodeKeyPathPlaceholder: '예: ~/.ssh/id_ed25519',
|
||
vscodeSelectKey: 'SSH 개인 키',
|
||
vscodeScriptPreview: 'SSH 설정 스크립트',
|
||
vscodePasswordHelper:
|
||
'비밀번호 인증은 로컬 SSH 설정에 기록되지 않습니다. 원격 호스트에 연결할 때 VS Code에서 비밀번호를 입력해야 합니다.',
|
||
vscodePasswordHint:
|
||
'비밀번호 인증은 설정된 호스트, 포트, 사용자명으로 연결합니다. 설정 스크립트나 개인 키 파일은 필요하지 않습니다.',
|
||
vscodeScriptPreviewHint:
|
||
'VS Code를 실행하는 로컬 컴퓨터에서 설정 스크립트를 실행하면 원격 연결용 SSH 별칭이 등록됩니다. 호스트, 포트, 사용자명, 개인 키 또는 키 경로가 변경되면 다시 실행하세요.',
|
||
vscodePasswordModeTitle: '비밀번호 인증',
|
||
vscodePasswordModeHint:
|
||
'비밀번호 인증은 설정된 호스트, 포트, 사용자명으로 연결합니다. 설정 스크립트나 개인 키 파일은 필요하지 않습니다.',
|
||
vscodePasswordStep1: '호스트, 포트, 사용자명을 확인하세요.',
|
||
vscodePasswordStep2: 'VS Code를 열고 연결 시 비밀번호를 입력하세요.',
|
||
vscodePasswordStep3: '개인 키 다운로드는 필요하지 않습니다.',
|
||
saveContentAndClose: '파일이 수정되었습니다. 저장 후 닫으시겠습니까?',
|
||
saveAndOpenNewFile: '파일이 수정되었습니다. 저장 후 새 파일을 열겠습니까?',
|
||
noEdit: '파일이 수정되지 않았습니다. 이 작업은 필요하지 않습니다!',
|
||
noNameFolder: '제목 없는 폴더',
|
||
noNameFile: '제목 없는 파일',
|
||
minimap: '코드 미니맵',
|
||
fileCanNotRead: '파일을 읽을 수 없습니다.',
|
||
previewTruncated: '파일이 너무 커서 마지막 부분만 표시됩니다',
|
||
previewEmpty: '파일이 비어 있거나 텍스트 파일이 아닙니다',
|
||
previewLargeFile: '미리보기',
|
||
panelInstallDir: '1Panel 설치 디렉터리는 삭제할 수 없습니다.',
|
||
wgetTask: '다운로드 작업',
|
||
stopWgetConfirm: '이 다운로드 작업을 중지하시겠습니까?',
|
||
existFileTitle: '동일한 이름의 파일 경고',
|
||
existFileHelper: '업로드한 파일에 동일한 이름의 파일이 포함되어 있습니다. 덮어쓰시겠습니까?',
|
||
existFileSize: '파일 크기 (새로운 -> 오래된)',
|
||
existFileDirHelper: '선택한 파일/폴더에 동일한 이름이 이미 존재합니다. 신중하게 작업하세요!',
|
||
coverDirHelper: '덮어쓸 폴더를 선택하면 대상 경로로 복사됩니다!',
|
||
noSuchFile: '파일 또는 디렉터리를 찾을 수 없습니다. 확인 후 다시 시도하세요.',
|
||
setting: '설정',
|
||
showHide: '숨김 파일 표시',
|
||
noShowHide: '숨김 파일 숨기기',
|
||
cancelUpload: '업로드 취소',
|
||
cancelUploadHelper: '업로드를 취소할지 여부, 취소 후 업로드 목록이 비워집니다.',
|
||
keepOneTab: '최소한 하나의 탭을 유지하세요',
|
||
notCanTab: '더 이상 탭을 추가할 수 없습니다',
|
||
convert: '파일 형식 변환',
|
||
converting: '로 변환 중',
|
||
fileCanNotConvert: '이 파일은 형식 변환을 지원하지 않습니다',
|
||
formatType: '형식 종류',
|
||
sourceFormat: '원본 형식',
|
||
sourceFile: '원본 파일',
|
||
saveDir: '저장 디렉토리',
|
||
deleteSourceFile: '원본 파일 삭제 여부',
|
||
convertHelper: '선택한 파일을 다른 형식으로 변환합니다',
|
||
convertHelper1: '변환할 파일을 선택하세요',
|
||
execConvert: '변환을 시작합니다. 작업 센터에서 변환 로그를 확인할 수 있습니다',
|
||
convertLogs: '변환 로그',
|
||
formatConvert: '형식 변환',
|
||
},
|
||
ssh: {
|
||
autoStart: '자동 시작',
|
||
enable: '자동 시작 활성화',
|
||
disable: '자동 시작 비활성화',
|
||
sshAlert:
|
||
'목록 데이터는 로그인 날짜를 기준으로 정렬됩니다. 시간대 변경이나 다른 작업이 수행되면 로그인 로그의 날짜에 차이가 발생할 수 있습니다.',
|
||
sshAlert2:
|
||
'"Fail2ban"을 "도구 상자"에서 사용하여 무차별 대입 공격을 시도하는 IP 주소를 차단할 수 있으며, 이는 호스트의 보안을 강화하는 데 도움이 됩니다.',
|
||
sshOperate: 'SSH 서비스에서 "{0}" 작업을 수행합니다. 계속하시겠습니까?',
|
||
sshChange: 'SSH 설정',
|
||
sshChangeHelper: '"{0}"을(를) "{1}"로 변경하였습니다. 계속하시겠습니까?',
|
||
sshFileChangeHelper:
|
||
'구성 파일을 수정하면 서비스 가용성에 영향을 미칠 수 있습니다. 이 작업을 수행할 때는 주의하십시오. 계속하시겠습니까?',
|
||
port: '포트',
|
||
portHelper: 'SSH 서비스가 수신하는 포트를 지정하십시오.',
|
||
listenAddress: '수신 주소',
|
||
allV4V6: '0.0.0.0:{0}(IPv4) 및 :::{0}(IPv6)',
|
||
listenHelper: 'IPv4와 IPv6 설정을 모두 비워두면 "0.0.0.0:{0}(IPv4)"와 ":::{0}(IPv6)"에서 수신합니다.',
|
||
addressHelper: 'SSH 서비스가 수신할 주소를 지정하십시오.',
|
||
permitRootLogin: '루트 사용자 로그인 허용',
|
||
rootSettingHelper: '루트 사용자의 기본 로그인 방법은 "SSH 로그인 허용"입니다.',
|
||
rootHelper1: 'SSH 로그인 허용',
|
||
rootHelper2: 'SSH 로그인 비허용',
|
||
rootHelper3: '키 로그인만 허용',
|
||
rootHelper4: '미리 정의된 명령만 실행할 수 있습니다. 다른 작업은 수행할 수 없습니다.',
|
||
passwordAuthentication: '비밀번호 인증',
|
||
pwdAuthHelper: '비밀번호 인증을 활성화할지 여부입니다. 기본적으로 이 매개변수는 활성화되어 있습니다.',
|
||
pubkeyAuthentication: '키 인증',
|
||
privateKey: '개인 키',
|
||
publicKey: '공개 키',
|
||
password: '비밀번호',
|
||
createMode: '생성 방식',
|
||
generate: '자동 생성',
|
||
unSyncPass: '키 비밀번호 동기화 불가',
|
||
syncHelper: '동기화 작업으로 유효하지 않은 키를 정리하고 새로운 완전한 키 쌍을 동기화합니다. 계속하시겠습니까?',
|
||
input: '수동 입력',
|
||
import: '파일 업로드',
|
||
authKeys: 'Kunci Pengesahan',
|
||
authKeysHelper: '현재 공개 키 정보를 저장하시겠습니까?',
|
||
pubkey: '키 정보',
|
||
encryptionMode: '암호화 모드',
|
||
pubKeyHelper: '현재 키 정보는 사용자 {0}에게만 적용됩니다',
|
||
passwordHelper: '6~10자리 숫자 및 영어 대소문자를 포함할 수 있습니다.',
|
||
reGenerate: '키 재생성',
|
||
keyAuthHelper: '키 인증을 활성화할지 여부입니다.',
|
||
useDNS: 'useDNS',
|
||
dnsHelper: 'SSH 서버에서 DNS 확인 기능을 활성화하여 연결의 신원을 확인할지 여부를 제어합니다.',
|
||
confFileOrderHelper:
|
||
'드롭다운으로 구성 파일을 전환해 바로 편집/저장하세요. 적용은 로드 순서 기준이며, 먼저 로드된 값이 우선합니다.',
|
||
confFileOrderLabel: '{0} (로드 순서 #{1})',
|
||
analysis: '통계 정보',
|
||
denyHelper:
|
||
"'거부' 작업을 다음 주소에서 수행합니다. 설정 후 해당 IP는 서버에 접근할 수 없습니다. 계속하시겠습니까?",
|
||
acceptHelper:
|
||
"'수락' 작업을 다음 주소에서 수행합니다. 설정 후 해당 IP는 정상적으로 접근할 수 있습니다. 계속하시겠습니까?",
|
||
noAddrWarning: '현재 [{0}] 주소가 선택되지 않았습니다. 확인 후 다시 시도하십시오!',
|
||
loginLogs: 'SSH 로그',
|
||
loginMode: '모드',
|
||
authenticating: '키',
|
||
publickey: '키',
|
||
belong: '소속',
|
||
local: '로컬',
|
||
session: '세션 | 세션들',
|
||
loginTime: '로그인 시간',
|
||
loginIP: '로그인 IP',
|
||
stopSSHWarn: '이 SSH 연결을 끊으시겠습니까?',
|
||
remote: '원격 SSH',
|
||
},
|
||
setting: {
|
||
panel: '패널',
|
||
user: '패널 사용자',
|
||
userChange: '패널 사용자 변경',
|
||
userChangeHelper: '패널 사용자를 변경하면 로그아웃됩니다. 계속하시겠습니까?',
|
||
passwd: '패널 비밀번호',
|
||
emailHelper: '비밀번호 복구용',
|
||
watermark: '워터마크 설정',
|
||
watermarkContent: '워터마크 내용',
|
||
contentHelper:
|
||
'{0} 은 노드 이름, {1} 은 노드 주소를 나타냅니다. 변수를 사용하거나 사용자 정의 이름을 입력할 수 있습니다.',
|
||
watermarkColor: '워터마크 색상',
|
||
watermarkFont: '워터마크 글꼴 크기',
|
||
watermarkHeight: '워터마크 높이',
|
||
watermarkWidth: '워터마크 너비',
|
||
watermarkRotate: '회전 각도',
|
||
watermarkGap: '간격',
|
||
watermarkCloseHelper: '시스템 워터마크 설정을 해제하시겠습니까?',
|
||
watermarkOpenHelper: '현재 시스템 워터마크 설정을 저장하시겠습니까?',
|
||
title: '패널 별칭',
|
||
panelPort: '패널 포트',
|
||
titleHelper: '영문자, 한자, 숫자, 공백, 일반 특수 문자를 포함하여 3~30자의 길이를 지원합니다.',
|
||
portHelper:
|
||
'권장 포트 범위는 8888에서 65535 사이입니다. 참고: 서버에 보안 그룹이 있는 경우, 보안 그룹에서 새로운 포트를 사전에 허용해야 합니다.',
|
||
portChange: '포트 변경',
|
||
portChangeHelper: '서비스 포트를 수정하고 서비스를 다시 시작합니다. 계속하시겠습니까?',
|
||
theme: '테마',
|
||
menuTabs: '메뉴 탭',
|
||
menuAccordion: '메뉴 다중 펼침',
|
||
menuAccordionHelper: '활성화하면 사이드바의 여러 메뉴 그룹을 동시에 펼쳐 둘 수 있습니다.',
|
||
dark: '다크',
|
||
darkGold: '다크 골드',
|
||
light: '라이트',
|
||
auto: '시스템 따라가기',
|
||
language: '언어',
|
||
runtimeEnv: '실행 환경',
|
||
docSource: '문서 출처',
|
||
withByRegion: '운영 지역 따름(기본값)',
|
||
withByLang: '시스템 언어 따름',
|
||
region: '운영 지역',
|
||
cn: '중국 본토',
|
||
intl: '글로벌',
|
||
regionHelper: '실행 지역을 변경하면 다음 리소스 출처가 전환됩니다:',
|
||
regionHelper1: '시스템 설치 패키지',
|
||
regionHelper2: '앱 스토어 및 스크립트 라이브러리',
|
||
regionHelper3: '사용자 매뉴얼 및 관련 문서',
|
||
regionHelper4: '향후 다운로드 및 접근에 영향을 줄 수 있습니다. 주의하십시오.',
|
||
regionTip: '운영 지역은 시스템 업데이트 소스와 설치 패키지 다운로드 주소에 영향을 미칩니다.',
|
||
docSourceTip: '문서 출처는 문서와 업데이트 로그의 이동 언어를 결정합니다.',
|
||
languageHelper: '기본적으로 브라우저 언어를 따릅니다. 이 설정은 현재 브라우저에서만 적용됩니다.',
|
||
sessionTimeout: '세션 타임아웃',
|
||
sessionTimeoutError: '최소 세션 타임아웃은 300초입니다.',
|
||
sessionTimeoutHelper: '패널에서 {0}초 이상 조작이 없을 경우 자동으로 로그아웃됩니다.',
|
||
systemIP: '기본 접근 주소',
|
||
systemIPHelper:
|
||
'애플리케이션 리다이렉트, 컨테이너 접근 등의 기능은 이 주소를 사용하여 라우팅됩니다. 각 노드마다 다른 주소를 설정할 수 있습니다.',
|
||
proxy: '서버 프록시',
|
||
proxyHelper: '프록시 서버를 설정한 후 다음 시나리오에서 적용됩니다:',
|
||
proxyHelper1: '설치 패키지 다운로드 및 앱 스토어 동기화 (상용 버전 전용)',
|
||
proxyHelper2: '시스템 업데이트 및 업데이트 정보 확인 (상용 버전 전용)',
|
||
proxyHelper4: 'Docker 이미지 pull 같은 네트워크 요청은 프록시 서버를 통해 처리됩니다 (상용 버전 전용)',
|
||
proxyHelper3: '시스템 라이선스 인증 및 동기화',
|
||
proxyHelper5: '시스템 스크립트 라이브러리 통합 다운로드 및 동기화 (상용 버전 기능)',
|
||
proxyHelper6: '인증서 신청 (상용 버전 기능)',
|
||
proxyType: '프록시 유형',
|
||
proxyUrl: '프록시 주소',
|
||
proxyPort: '프록시 포트',
|
||
proxyPasswdKeep: '비밀번호 기억',
|
||
proxyDocker: 'Docker 프록시',
|
||
proxyDockerHelper:
|
||
'프록시 서버 구성을 Docker 에 동기화하여 오프라인 서버 이미지 가져오기 등의 작업을 지원합니다.',
|
||
syncToNode: '자식 노드로 동기화',
|
||
syncToNodeHelper: '다른 노드로 설정 동기화',
|
||
nodes: '노드',
|
||
selectNode: '노드 선택',
|
||
selectNodeError: '노드를 선택해 주세요',
|
||
apiInterface: 'API 활성화',
|
||
apiInterfaceClose: '비활성화하면 API 인터페이스에 접근할 수 없습니다. 계속하시겠습니까?',
|
||
apiInterfaceHelper: '서드파티 애플리케이션이 API 에 접근할 수 있도록 허용합니다.',
|
||
apiInterfaceAlert1: '운영 환경에서는 활성화하지 마십시오. 서버 보안 위험이 증가할 수 있습니다.',
|
||
apiInterfaceAlert2: '잠재적인 보안 위협을 방지하기 위해 서드파티 애플리케이션으로 API를 호출하지 마십시오.',
|
||
apiInterfaceAlert3: 'API 문서',
|
||
apiInterfaceAlert4: '사용 설명서',
|
||
apiKey: 'API 키',
|
||
apiKeyHelper: 'API 키는 서드파티 애플리케이션이 API 에 접근하는 데 사용됩니다.',
|
||
ipWhiteList: 'IP 허용 목록',
|
||
ipWhiteListEgs: '한 줄에 하나씩 입력하십시오. 예:\n172.161.10.111\n172.161.10.0/24',
|
||
ipWhiteListHelper: '허용 목록에 있는 IP만 API 에 접근할 수 있습니다. 0.0.0.0/0(모든 IPv4), ::/0(모든 IPv6)',
|
||
apiTrustedProxies: 'API 신뢰 프록시',
|
||
apiTrustedProxiesHelper:
|
||
'리버스 프록시를 사용하는 경우 클라이언트 IP를 올바르게 가져오려면 프록시 서버의 IP 또는 네트워크를 입력하세요. 사용하지 않는 경우 비워 두세요. 0.0.0.0/0 및 ::/0은 지원되지 않습니다.',
|
||
apiKeyValidityTime: '인터페이스 키 유효 기간',
|
||
apiKeyValidityTimeEgs: '인터페이스 키 유효 기간 (분 단위)',
|
||
apiKeyValidityTimeHelper:
|
||
'인터페이스 타임스탬프가 현재 타임스탬프와의 차이가 허용 범위 내에 있을 경우 유효합니다. 값이 0이면 검증이 비활성화됩니다.',
|
||
apiKeyReset: '인터페이스 키 재설정',
|
||
apiKeyResetHelper: '연관된 키 서비스가 무효화됩니다. 서비스에 새 키를 추가하십시오.',
|
||
confDockerProxy: 'Docker 프록시 구성',
|
||
restartNowHelper: 'Docker 프록시 구성을 위해 Docker 서비스를 재시작해야 합니다.',
|
||
restartNow: '즉시 재시작',
|
||
restartLater: '나중에 수동으로 재시작',
|
||
systemIPWarning: '현재 노드에 기본 접근 주소가 설정되지 않았습니다. 패널 설정에서 설정해 주세요!',
|
||
systemIPWarning1: '현재 서버 주소는 {0}으로 설정되어 있어 빠른 리디렉션이 불가능합니다!',
|
||
defaultNetwork: '네트워크 카드',
|
||
syncTime: '서버 시간',
|
||
timeZone: '시간대',
|
||
timeZoneChangeHelper: '시간대를 변경하면 서비스를 재시작해야 합니다. 계속하시겠습니까?',
|
||
timeZoneHelper: '시간대 변경은 시스템 timedatectl 서비스에 따라 작동하며, 1Panel 서비스 재시작 후 적용됩니다.',
|
||
timeZoneCN: '베이징',
|
||
timeZoneAM: '로스앤젤레스',
|
||
timeZoneNY: '뉴욕',
|
||
ntpALi: '알리바바',
|
||
ntpGoogle: '구글',
|
||
syncSite: 'NTP 서버',
|
||
syncSiteHelper: '이 작업은 {0}을(를) 시스템 시간 동기화의 소스로 사용합니다. 계속하시겠습니까?',
|
||
changePassword: '비밀번호 변경',
|
||
oldPassword: '기존 비밀번호',
|
||
newPassword: '새 비밀번호',
|
||
retryPassword: '비밀번호 확인',
|
||
passwordEmptyTip: '현재 비밀번호를 변경하지 않으려면 비워 두세요',
|
||
noSpace: '입력 정보에 공백 문자를 포함할 수 없습니다.',
|
||
duplicatePassword: '새 비밀번호는 기존 비밀번호와 동일할 수 없습니다. 다시 입력하십시오!',
|
||
diskClean: '캐시 정리',
|
||
developerMode: '미리보기 프로그램',
|
||
developerModeHelper: '새로운 기능과 수정 사항을 정식 출시 전에 체험하고 초기 피드백을 제공할 수 있습니다.',
|
||
thirdParty: '서드파티 계정',
|
||
noTypeForCreate: '현재 생성된 백업 유형이 없습니다.',
|
||
LOCAL: '서버 디스크',
|
||
OSS: 'Ali OSS',
|
||
S3: 'Amazon S3',
|
||
mode: '모드',
|
||
MINIO: 'MinIO',
|
||
SFTP: 'SFTP',
|
||
WebDAV: 'WebDAV',
|
||
WebDAVAlist: 'Alist 에 WebDAV 를 연결하는 방법은 공식 문서를 참조하십시오.',
|
||
OneDrive: 'Microsoft OneDrive',
|
||
isCN: 'Century Internet',
|
||
isNotCN: '국제 버전',
|
||
client_id: '클라이언트 ID',
|
||
client_secret: '클라이언트 시크릿',
|
||
redirect_uri: '리디렉션 URL',
|
||
onedrive_helper: '사용자 정의 구성은 공식 문서를 참조하십시오.',
|
||
refreshTime: '토큰 갱신 시간',
|
||
refreshStatus: '토큰 갱신 상태',
|
||
backupDir: '백업 디렉터리',
|
||
codeWarning: '현재 인증 코드 형식이 올바르지 않습니다. 다시 확인하십시오!',
|
||
code: '인증 코드',
|
||
codeHelper:
|
||
'"획득" 버튼을 클릭한 다음 OneDrive 에 로그인하여 리디렉션된 링크에서 "code" 이후의 내용을 복사하십시오. 이 입력 상자에 붙여넣으십시오. 자세한 지침은 공식 문서를 참조하십시오.',
|
||
googleHelper:
|
||
'먼저 Google 애플리케이션을 생성하고 클라이언트 정보를 획득한 후 양식을 작성하고 획득 버튼을 클릭하세요. 구체적인 작업은 공식 문서를 참조하십시오.',
|
||
loadCode: '획득',
|
||
COS: 'Tencent COS',
|
||
ap_beijing_1: '베이징 지역 1',
|
||
ap_beijing: '베이징',
|
||
ap_nanjing: '난징',
|
||
ap_shanghai: '상하이',
|
||
ap_guangzhou: '광저우',
|
||
ap_chengdu: '청두',
|
||
ap_chongqing: '충칭',
|
||
ap_shenzhen_fsi: '선전 금융',
|
||
ap_shanghai_fsi: '상하이 금융',
|
||
ap_beijing_fsi: '베이징 금융',
|
||
ap_hongkong: '홍콩, 중국',
|
||
ap_singapore: '싱가포르',
|
||
ap_mumbai: '뭄바이',
|
||
ap_jakarta: '자카르타',
|
||
ap_seoul: '서울',
|
||
ap_bangkok: '방콕',
|
||
ap_tokyo: '도쿄',
|
||
na_siliconvalley: '실리콘밸리 (미국 서부)',
|
||
na_ashburn: '애쉬번 (미국 동부)',
|
||
na_toronto: '토론토',
|
||
sa_saopaulo: '상파울루',
|
||
eu_frankfurt: '프랑크푸르트',
|
||
KODO: 'Qiniu Kodo',
|
||
scType: '스토리지 유형',
|
||
typeStandard: '표준',
|
||
typeStandard_IA: '저빈도 표준',
|
||
typeArchive: '아카이브',
|
||
typeDeep_Archive: '심층 아카이브',
|
||
scLighthouse: '기본값: 경량 오브젝트 스토리지는 이 스토리지 유형만 지원합니다',
|
||
scStandard:
|
||
'표준 스토리지는 실시간 접근, 빈번한 데이터 상호작용이 필요한 핫 파일이 많은 비즈니스 시나리오에 적합합니다.',
|
||
scStandard_IA:
|
||
'저빈도 스토리지는 접근 빈도가 비교적 낮고 최소 30일 동안 데이터를 저장하는 비즈니스 시나리오에 적합합니다.',
|
||
scArchive: '아카이브 스토리지는 접근 빈도가 극히 낮은 비즈니스 시나리오에 적합합니다.',
|
||
scDeep_Archive: '내구성이 뛰어난 콜드 스토리지는 접근 빈도가 극히 낮은 비즈니스 시나리오에 적합합니다.',
|
||
archiveHelper:
|
||
'아카이브 스토리지 파일은 직접 다운로드할 수 없으며, 해당 클라우드 서비스 제공자의 웹사이트를 통해 복원해야 합니다. 신중히 사용하십시오!',
|
||
backupAlert: 'S3 프로토콜을 지원하는 클라우드 공급자는 Amazon S3 를 사용하여 백업할 수 있습니다.',
|
||
domain: '가속 도메인',
|
||
backupAccount: '백업 계정 | 백업 계정',
|
||
loadBucket: '버킷 가져오기',
|
||
accountName: '계정 이름',
|
||
accountKey: '계정 키',
|
||
address: '주소',
|
||
path: '경로',
|
||
safe: '보안',
|
||
passkey: '패스키',
|
||
passkeyManage: '관리',
|
||
passkeyKeyManagement: '키 관리',
|
||
passkeyHelper: '빠른 로그인을 위해 최대 5개의 패스키를 등록할 수 있습니다',
|
||
passkeyRequireSSL: '패스키는 도메인 바인딩과 HTTPS 접속이 필요합니다',
|
||
passkeyTrustedProxies: '신뢰할 수 있는 프록시',
|
||
passkeyTrustedProxiesHelper:
|
||
'이 IP/CIDR 출처의 요청만 Forwarded와 X-Forwarded-Proto 헤더를 HTTPS 판단에 사용합니다',
|
||
passkeyNotSupported: '브라우저/환경이 패스키를 지원하지 않습니다. 도메인과 HTTPS를 확인하세요',
|
||
passkeyPrereqTitle: 'Passkey 사용을 위해 다음 전제 조건이 필요합니다',
|
||
passkeyPrereqBindDomain: '1Panel 도메인 바인딩 구성됨',
|
||
passkeyPrereqHttps: 'HTTPS를 통해 안전하게 접속됨',
|
||
passkeyPrereqBrowser: '현재 환경이 Passkey를 지원합니다 (WebAuthn + 플랫폼 인증기)',
|
||
passkeyPrereqBrowserDetailWebAuthnUnavailable:
|
||
'시스템 브라우저로 접속하고, 바인딩된 도메인으로 HTTPS에서 패널을 열었는지 확인하세요.',
|
||
passkeyPrereqBrowserDetailPlatformCapabilityUnavailable:
|
||
'현재 환경에서는 기기 인증을 사용할 수 없습니다. 더 최신 OS의 시스템 브라우저에서 시도하세요.',
|
||
passkeyPrereqBrowserDetailNoPlatformAuthenticator:
|
||
'화면 잠금/지문/얼굴 인식/Windows Hello를 활성화한 뒤 다시 시도하세요.',
|
||
passkeyPrereqBrowserDetailDetectFailed:
|
||
'감지에 실패했습니다. 페이지를 새로고침 후 다시 시도하거나 시스템 브라우저로 전환하세요.',
|
||
passkeyPrereqGoSetup: '설정',
|
||
passkeyCount: '등록됨 {0}/{1}',
|
||
passkeyName: '이름',
|
||
passkeyNameHelper: '기기를 구분할 이름을 입력하세요',
|
||
passkeyAdd: '패스키 추가',
|
||
passkeyCreatedAt: '생성 시간',
|
||
passkeyLastUsedAt: '최근 사용',
|
||
passkeyDeleteConfirm: '삭제하면 이 패스키로 로그인할 수 없습니다. 계속하시겠습니까?',
|
||
passkeyLimit: '최대 5개의 패스키를 등록할 수 있습니다',
|
||
passkeyFailed: '패스키 등록에 실패했습니다. 패널 SSL 인증서가 신뢰할 수 있는지 확인하세요',
|
||
bindInfo: '바인딩 정보',
|
||
bindAll: '모두 수신',
|
||
bindInfoHelper: '서비스 수신 주소나 프로토콜 변경은 서비스 불가 상태를 초래할 수 있습니다. 계속하시겠습니까?',
|
||
ipv6: 'IPv6 수신',
|
||
bindAddress: '수신 주소',
|
||
entrance: '진입점',
|
||
showEntrance: '"개요" 페이지에서 비활성화 경고 표시',
|
||
entranceHelper: '보안 진입점을 활성화하면 지정된 보안 진입점을 통해서만 패널에 로그인할 수 있습니다.',
|
||
entranceError: '5-116자의 안전한 로그인 진입점을 입력하십시오. 숫자나 문자만 지원됩니다.',
|
||
entranceInputHelper: '공백으로 남기면 보안 진입점이 비활성화됩니다.',
|
||
randomGenerate: '랜덤',
|
||
expirationTime: '만료 날짜',
|
||
unSetting: '미설정',
|
||
noneSetting: '패널 비밀번호의 만료 시간을 설정합니다. 만료 후 비밀번호를 재설정해야 합니다.',
|
||
expirationHelper: '비밀번호 만료 시간이 0일인 경우 비밀번호 만료 기능이 비활성화됩니다.',
|
||
days: '비밀번호 만료 일수',
|
||
expiredHelper: '현재 비밀번호가 만료되었습니다. 비밀번호를 다시 변경하십시오.',
|
||
timeoutHelper: '패널 비밀번호가 {0}일 후 만료됩니다. 만료 후 비밀번호를 재설정해야 합니다.',
|
||
complexity: '복잡성 검증',
|
||
complexityHelper: '활성화하면 비밀번호는 8-30 자이며 영문, 숫자, 특수 문자 중 최소 두 가지를 포함해야 합니다.',
|
||
bindDomain: '도메인 바인딩',
|
||
unBindDomain: '도메인 바인딩 해제',
|
||
panelSSL: '패널 SSL',
|
||
unBindDomainHelper: '도메인 이름 바인딩 해제 작업은 시스템 보안에 영향을 미칠 수 있습니다. 계속하시겠습니까?',
|
||
bindDomainHelper: '도메인을 바인딩한 후에는 해당 도메인을 통해서만 1Panel 서비스에 접근할 수 있습니다.',
|
||
bindDomainHelper1: '공백으로 남기면 도메인 이름 바인딩이 비활성화됩니다.',
|
||
bindDomainWarning:
|
||
'도메인 바인딩 후 로그아웃되며 설정에 지정된 도메인 이름을 통해서만 1Panel 서비스에 접근할 수 있습니다. 계속하시겠습니까?',
|
||
allowIPs: '허가된 IP',
|
||
unAllowIPs: '허가되지 않은 IP',
|
||
unAllowIPsWarning:
|
||
'허가되지 않은 빈 IP를 설정하면 모든 IP가 시스템에 접근할 수 있어 시스템 보안에 영향을 미칠 수 있습니다. 계속하시겠습니까?',
|
||
allowIPsHelper: '허가된 IP 주소 목록을 설정하면 목록에 있는 IP 주소만 패널 서비스에 접근할 수 있습니다.',
|
||
allowIPsWarning:
|
||
'허가된 IP 주소 목록을 설정하면 목록에 있는 IP 주소만 패널 서비스에 접근할 수 있습니다. 계속하시겠습니까?',
|
||
allowIPsHelper1: '공백으로 남기면 IP 주소 제한이 비활성화됩니다.',
|
||
allowIPEgs: '한 줄에 하나씩 입력하십시오. 예:\n172.16.10.111\n172.16.10.0/24',
|
||
mfa: '2단계 인증',
|
||
mfaClose: 'MFA를 비활성화하면 서비스 보안이 낮아집니다. 계속하시겠습니까?',
|
||
secret: '비밀키',
|
||
mfaInterval: '갱신 간격(초)',
|
||
mfaTitleHelper:
|
||
'제목은 다른 1Panel 호스트를 구별하는 데 사용됩니다. 제목을 수정한 후 다시 스캔하거나 비밀키를 수동으로 추가하세요.',
|
||
mfaIntervalHelper:
|
||
'갱신 간격을 변경한 후 다시 스캔하거나 비밀키를 수동으로 추가하세요.\n일부 인증 앱은 30초 간격만 지원합니다(예: Google/Microsoft Authenticator).',
|
||
mfaAlert:
|
||
'일회용 토큰은 현재 시간을 기반으로 생성된 동적 6자리 숫자입니다. 서버 시간이 동기화되어 있는지 확인하세요.',
|
||
mfaHelper: '활성화 후 일회용 토큰 검증이 필요합니다.',
|
||
mfaHelper1: '인증 앱을 다운로드하세요. 예를 들어,',
|
||
mfaHelper2:
|
||
'다음 QR 코드를 인증 앱으로 스캔하거나 비밀키를 복사하여 인증 앱에 입력하여 일회용 토큰을 획득하세요.',
|
||
mfaHelper3: '앱에서 생성된 6자리 숫자를 입력하세요.',
|
||
mfaCode: '일회용 토큰',
|
||
sslChangeHelper: 'HTTPS 설정을 수정하고 서비스를 재시작합니다. 계속하시겠습니까?',
|
||
sslDisable: '비활성화',
|
||
sslDisableHelper: 'HTTPS 서비스를 비활성화하면 패널을 재시작해야 적용됩니다. 계속하시겠습니까?',
|
||
noAuthSetting: '비인가 설정',
|
||
noAuthSettingHelper:
|
||
'지정된 보안 진입점을 사용하지 않거나, 지정된 IP 나 도메인에서 패널에 접근하지 않는 경우 이 응답은 패널 특성을 숨길 수 있습니다.',
|
||
responseSetting: '응답 설정',
|
||
help200: '도움말 페이지',
|
||
error400: '잘못된 요청',
|
||
error401: '권한 없음',
|
||
error403: '접근 금지',
|
||
error404: '페이지를 찾을 수 없음',
|
||
error408: '요청 시간 초과',
|
||
error416: '범위 불만족',
|
||
error444: '연결 닫힘',
|
||
error500: '서버 오류',
|
||
https: '패널에 HTTPS를 설정하면 액세스 보안이 향상됩니다',
|
||
strictHelper: '비 HTTPS 트래픽은 패널에 연결할 수 없습니다',
|
||
muxHelper:
|
||
'패널은 HTTP 및 HTTPS 프로토콜 모두를 수신하고 HTTP를 HTTPS로 리디렉션하지만 보안이 저하될 수 있습니다',
|
||
certType: '인증서 유형',
|
||
selfSigned: '자가 서명',
|
||
selfSignedHelper: '자가 서명 인증서는 브라우저에서 신뢰하지 않을 수 있으며 보안 경고가 표시될 수 있습니다.',
|
||
select: '선택',
|
||
domainOrIP: '도메인 또는 IP:',
|
||
timeOut: '시간 초과',
|
||
rootCrtDownload: '루트 인증서 다운로드',
|
||
primaryKey: '개인 키',
|
||
certificate: '인증서',
|
||
backupJump: '현재 백업 목록에 없는 파일입니다. 파일 디렉토리에서 다운로드하여 백업에 가져오기를 시도하세요.',
|
||
snapshot: '스냅샷 | 스냅샷들',
|
||
noAppData: '선택할 수 있는 시스템 앱이 없습니다',
|
||
noBackupData: '선택할 수 있는 백업 데이터가 없습니다',
|
||
stepBaseData: '기본 데이터',
|
||
stepAppData: '시스템 앱',
|
||
stepPanelData: '시스템 데이터',
|
||
stepBackupData: '백업 데이터',
|
||
stepOtherData: '기타 데이터',
|
||
operationLog: '작업 로그 유지',
|
||
loginLog: '접속 로그 유지',
|
||
systemLog: '시스템 로그 유지',
|
||
taskLog: '작업 로그 유지',
|
||
monitorData: '모니터링 데이터 유지',
|
||
dockerConf: 'Docker 설정',
|
||
selectAllImage: '모든 앱 이미지를 백업',
|
||
logLabel: '로그',
|
||
agentLabel: '노드 설정',
|
||
appDataLabel: '앱 데이터',
|
||
appImage: '앱 이미지',
|
||
appBackup: '앱 백업',
|
||
backupLabel: '백업 디렉토리',
|
||
confLabel: '설정 파일',
|
||
dockerLabel: '컨테이너',
|
||
taskLabel: '예약 작업',
|
||
resourceLabel: '앱 리소스 디렉토리',
|
||
runtimeLabel: '실행 환경',
|
||
appLabel: '앱',
|
||
databaseLabel: '데이터베이스',
|
||
snapshotLabel: '스냅샷 파일',
|
||
websiteLabel: '웹사이트',
|
||
directoryLabel: '디렉토리',
|
||
appStoreLabel: '앱 스토어',
|
||
shellLabel: '스크립트',
|
||
tmpLabel: '임시 디렉토리',
|
||
sslLabel: '인증서 디렉토리',
|
||
reCreate: '스냅샷 생성 실패',
|
||
reRollback: '스냅샷 롤백 실패',
|
||
deleteHelper: '타사 백업 계정에 포함된 스냅샷 파일을 포함하여 모든 스냅샷 파일이 삭제됩니다. 계속하시겠습니까?',
|
||
status: '스냅샷 상태',
|
||
ignoreRule: '무시 규칙',
|
||
editIgnoreRule: '@:commons.button.edit @.lower:setting.ignoreRule',
|
||
ignoreHelper:
|
||
'이 규칙은 스냅샷을 생성할 때 1Panel 데이터 디렉토리를 압축하고 백업하는 데 사용됩니다. 기본적으로 소켓 파일은 무시됩니다.',
|
||
ignoreHelper1: '한 줄에 하나씩 입력하세요. 예:\n*.log\n/opt/1panel/cache',
|
||
panelInfo: '1Panel 기본 정보 쓰기',
|
||
panelBin: '1Panel 시스템 파일 백업',
|
||
daemonJson: 'Docker 구성 파일 백업',
|
||
appData: '1Panel 에서 설치된 앱 백업',
|
||
panelData: '1Panel 데이터 디렉토리 백업',
|
||
backupData: '1Panel 의 로컬 백업 디렉토리 백업',
|
||
compress: '스냅샷 파일 생성',
|
||
upload: '스냅샷 파일 업로드',
|
||
recoverDetail: '복구 세부정보',
|
||
importHelper: '스냅샷 디렉토리: ',
|
||
lastRecoverAt: '마지막 복구 시간',
|
||
lastRollbackAt: '마지막 롤백 시간',
|
||
reDownload: '백업 파일 다시 다운로드',
|
||
recoverErrArch: '서버 아키텍처가 다른 스냅샷 복구는 지원되지 않습니다!',
|
||
recoverErrSize: '디스크 공간이 부족합니다. 확인하거나 정리 후 다시 시도하세요!',
|
||
recoverHelper: '스냅샷 {0} 에서 복구를 시작합니다. 계속하기 전에 다음 정보를 확인하세요:',
|
||
recoverHelper1: '복구에는 Docker 및 1Panel 서비스를 재시작해야 합니다.',
|
||
recoverHelper2: '서버에 충분한 디스크 공간이 있는지 확인하세요. (스냅샷 파일 크기: {0}, 사용 가능한 공간: {1})',
|
||
recoverHelper3:
|
||
'서버 아키텍처가 스냅샷이 생성된 서버의 아키텍처와 일치하는지 확인하세요. (현재 서버 아키텍처: {0})',
|
||
recoverHelper4:
|
||
'이 작업은 기본 노드만 롤백합니다. 업그레이드된 하위 노드가 있다면 먼저 하위 노드를 롤백한 후 계속 진행하세요.',
|
||
rollback: '롤백',
|
||
rollbackHelper:
|
||
'이 복구를 롤백하면 해당 복구의 모든 파일이 대체되며 Docker 및 1Panel 서비스를 재시작해야 할 수 있습니다. 계속하시겠습니까?',
|
||
upgradeHelper: '업그레이드에는 1Panel 서비스를 재시작해야 합니다. 계속하시겠습니까?',
|
||
rollbackLocalHelper:
|
||
'마스터 노드는 직접 롤백을 지원하지 않습니다. 수동으로 [1pctl restore] 명령어를 실행하여 롤백하세요!',
|
||
noUpgrade: '현재 최신 버전입니다',
|
||
upgradeNotes: '릴리스 노트',
|
||
upgradeNow: '지금 업그레이드',
|
||
source: '다운로드 소스',
|
||
versionNotSame: '노드 버전이 메인 노드와 일치하지 않습니다. 노드 관리에서 업그레이드한 후 다시 시도해 주세요.',
|
||
versionCompare:
|
||
'노드 {0}이(가) 이미 업그레이드 가능한 최신 버전입니다. 마스터 노드 버전을 확인 후 다시 시도하세요!',
|
||
about: '정보',
|
||
versionItem: '현재 버전',
|
||
backupCopies: '백업 수',
|
||
backupCopiesHelper:
|
||
'버전 롤백을 위해 보관할 업그레이드 백업 복사본 수를 설정합니다. 0은 모두 보관을 의미합니다.',
|
||
backupCopiesRule: '최소 3개의 업그레이드 백업 기록을 보관하세요',
|
||
release: '버전 업데이트 로그',
|
||
releaseHelper:
|
||
'현재 환경의 업데이트 로그를 가져오는 중 오류가 발생했습니다. 공식 문서에서 수동으로 확인하실 수 있습니다.',
|
||
project: 'GitHub',
|
||
issue: '이슈',
|
||
doc: '공식 문서',
|
||
star: '별',
|
||
description: '리눅스 서버 패널',
|
||
forum: '토론',
|
||
doc2: '문서',
|
||
currentVersion: '버전',
|
||
license: '라이선스',
|
||
bindNode: '노드 바인딩',
|
||
menuSetting: '메뉴 설정',
|
||
menuHide: '메뉴 숨김',
|
||
menuSettingHelper: '하위 메뉴가 1개만 존재할 경우, 메뉴 바에는 해당 하위 메뉴만 표시됩니다',
|
||
showAll: '모두 표시',
|
||
hideALL: '모두 숨기기',
|
||
ifShow: '표시 여부',
|
||
menu: '메뉴',
|
||
confirmMessage: '고급 메뉴 목록을 업데이트하려면 페이지가 새로 고쳐집니다. 계속하시겠습니까?',
|
||
recoverMessage: '페이지가 새로고침되어 메뉴 목록이 초기 상태로 복원됩니다. 계속하시겠습니까?',
|
||
compressPassword: '압축 비밀번호',
|
||
backupRecoverMessage: '압축 또는 압축 해제 비밀번호를 입력하세요 (설정하지 않으려면 비워 두세요)',
|
||
componentSize: '컴포넌트 크기',
|
||
scope: '범위',
|
||
public: '공개',
|
||
publicHelper: '공개 타입 백업 계정은 각 하위 노드로 동기화되어 함께 사용할 수 있습니다',
|
||
private: '비공개',
|
||
privateHelper: '비공개 타입 백업 계정은 현재 노드에서만 생성되며 현재 노드에서만 사용됩니다',
|
||
UPYUN: 'UPYUN',
|
||
ALIYUN: 'Aliyun Drive',
|
||
ALIYUNHelper:
|
||
'Aliyun Drive의 비클라이언트 다운로드 최대 용량은 100MB입니다. 초과 시 클라이언트로 다운로드하세요.',
|
||
ALIYUNRecover:
|
||
'Aliyun Drive의 비클라이언트 다운로드 최대 용량은 100MB입니다. 초과 시 클라이언트로 로컬 다운로드 후 스냅샷을 동기화해 복원하세요.',
|
||
GoogleDrive: 'Google Drive',
|
||
analysis: '분석',
|
||
analysisHelper:
|
||
'전체 토큰 내용을 붙여넣으면 필요한 항목을 자동으로 파싱합니다. 자세한 내용은 공식 문서를 참고하세요.',
|
||
serviceName: '서비스 이름',
|
||
operator: '운영자',
|
||
clickToRefresh: '클릭하여 새로고침',
|
||
recoverFailed: '스냅샷 복원 실패',
|
||
upgradeRecord: '업그레이드 기록',
|
||
upgrading: '업그레이드 중, 잠시만 기다려 주세요...',
|
||
versionHelper: '명명 규칙: [메이저].[기능].[버그 수정], 예시:',
|
||
upgradeCheck: '업데이트 확인',
|
||
panelSSLHelper: '패널 SSL 자동 갱신 후 1Panel 서비스를 수동 재시작해야 적용됩니다.',
|
||
},
|
||
license: {
|
||
offLine: '오프라인 버전',
|
||
community: 'OSS',
|
||
oss: '오픈 소스 소프트웨어',
|
||
ee: '엔터프라이즈 에디션',
|
||
pro: 'Pro',
|
||
trial: '체험판',
|
||
add: '커뮤니티 에디션 추가',
|
||
licenseBindHelper: '라이선스가 노드에 바인딩된 경우에만 무료 노드 할당량을 사용할 수 있습니다',
|
||
licenseAlert:
|
||
'라이선스가 노드에 정상적으로 바인딩된 경우에만 커뮤니티 에디션 노드를 추가할 수 있습니다. 라이선스에 정상적으로 바인딩된 노드만 전환이 지원됩니다.',
|
||
licenseUnbindHelper: '이 라이선스에 커뮤니티 에디션 노드가 존재합니다. 바인딩 해제 후 다시 시도하세요!',
|
||
subscription: '구독',
|
||
perpetual: '영구 라이선스',
|
||
product: '제품',
|
||
versionConstraint: '{0} 버전 일시불 구매',
|
||
forceUnbind: '강제 바인딩 해제',
|
||
forceUnbindHelper:
|
||
'강제 바인딩 해제를 수행하면 해제 과정에서 발생하는 오류를 무시하고 궁극적으로 라이센스 바인딩을 해제합니다.',
|
||
updateForce: '강제 업데이트 (바인딩 해제 과정의 모든 오류를 무시하고 최종 작업 성공을 보장합니다)',
|
||
trialInfo: '버전',
|
||
authorizationId: '구독 ID',
|
||
authorizedUser: '인증된 사용자',
|
||
lostHelper:
|
||
'라이센스가 최대 재시도 횟수를 초과했습니다. 상용 버전 기능이 제대로 작동하는지 확인하려면 동기화 버튼을 수동으로 클릭하세요.',
|
||
disableHelper:
|
||
'라이센스 동기화 검증에 실패했습니다. 상용 버전 기능이 제대로 작동하는지 확인하려면 동기화 버튼을 수동으로 클릭하세요.',
|
||
quickUpdate: '빠른 업데이트',
|
||
power: '권한 부여',
|
||
unbindHelper: '연결 해제 후 모든 상용 버전 관련 설정이 초기화됩니다. 계속하시겠습니까?',
|
||
importLicense: '라이센스',
|
||
securityWarningTitle: '크랙 버전 또는 출처를 알 수 없는 라이선스를 사용하지 마세요.',
|
||
securityWarningContent:
|
||
'1Panel은 시스템 관리 권한을 가진 사용자로 실행해야 합니다. 비공식 라이선스 또는 변조된 버전은 서버 제어 상실, 데이터 유출 등 심각한 보안 위험을 초래할 수 있습니다. 라이선스와 설치 패키지는 FIT2CLOUD 공식 채널을 통해 받으세요.',
|
||
importHelper: '라이센스 파일을 여기에 클릭하거나 드래그하세요',
|
||
licenseRequiredTip:
|
||
'아직 라이선스를 가져오지 않았습니다. 장치 ID를 복사해 라이선스를 받은 뒤 가져와야 로그인할 수 있습니다.',
|
||
licenseRequiredShortTip: '먼저 장치 ID를 복사해 라이선스를 받은 뒤, 라이선스를 가져오면 로그인할 수 있습니다.',
|
||
licenseRequiredUserTip:
|
||
'Enterprise Edition 라이선스가 바인딩되지 않았습니다. 슈퍼 관리자에게 라이선스 가져오기를 요청하세요.',
|
||
restoreCommunity: '커뮤니티 버전 복원',
|
||
restoreCommunityOnline: '온라인 복원',
|
||
restoreCommunityOffline: '오프라인 복원',
|
||
restoreCommunityPackageFound:
|
||
'사용 가능한 Community Edition 오프라인 설치 패키지가 감지되었습니다. 오프라인 복원을 실행할 수 있습니다.',
|
||
restoreCommunityPackageMissing:
|
||
'사용 가능한 Community Edition 오프라인 설치 패키지가 감지되지 않아 현재 오프라인 복원을 실행할 수 없습니다.',
|
||
restoreCommunityOnlineHelper:
|
||
'현재 버전의 커뮤니티 버전 패키지를 자동으로 다운로드하고 Enterprise 전용 데이터를 정리합니다.',
|
||
restoreCommunityOfflineHelper:
|
||
'현재 Enterprise 버전 이상인 공식 패키지를 {path}에 저장하세요. 사용 가능한 패키지가 감지되면 전환이 활성화됩니다.',
|
||
restoreCommunityConfirm:
|
||
'전환 후 현재 Enterprise 슈퍼 관리자 계정으로 커뮤니티 버전에 로그인할 수 있습니다. 전환 과정에서 Enterprise 전용 데이터베이스가 삭제됩니다.',
|
||
restoreCommunityStarting: '커뮤니티 버전을 준비 중입니다. 완료되면 패널이 자동으로 다시 시작됩니다.',
|
||
technicalAdvice: '기술 상담',
|
||
advice: '상담',
|
||
levelUpPro: '상용 버전으로 업그레이드',
|
||
licenseSync: '라이센스 동기화',
|
||
knowMorePro: '더 알아보기',
|
||
closeAlert: '현재 페이지는 패널 설정에서 닫을 수 있습니다.',
|
||
introduce: '기능 소개',
|
||
deviceID: '장치 ID',
|
||
corporation: '라이선스 회사',
|
||
expired: '만료 시간',
|
||
edition: '에디션',
|
||
standard: '스탠다드',
|
||
enterprise: '엔터프라이즈',
|
||
count: '허가 수량',
|
||
serialNo: '시리얼 번호',
|
||
remark: '비고',
|
||
waf: '상용 버전으로 업그레이드하면 차단 맵, 로그, 차단 기록, 지역 차단, 사용자 정의 규칙, 사용자 정의 차단 페이지 등을 사용할 수 있습니다.',
|
||
tamper: '상용 버전으로 업그레이드하면 웹사이트를 무단 수정이나 변조로부터 보호할 수 있습니다.',
|
||
setting: '상용 버전으로 업그레이드하면 패널 로고, 환영 메시지 등 정보를 사용자 정의할 수 있습니다.',
|
||
monitor:
|
||
'상용 버전으로 업그레이드하면 웹사이트의 실시간 상태, 방문자 추세, 유입 경로, 요청 로그 등을 확인할 수 있습니다.',
|
||
alert: '상용 버전으로 업그레이드하면 SMS 알림을 받고 알림 로그를 확인할 수 있습니다.',
|
||
node: '상용 버전으로 업그레이드하면 1Panel에서 여러 Linux 서버를 관리할 수 있습니다.',
|
||
nodeApp:
|
||
'상용 버전으로 업그레이드하면 노드를 수동으로 전환하지 않고도 다중 노드 애플리케이션 버전을 일괄 업그레이드할 수 있습니다.',
|
||
nodeDashboard:
|
||
'상용 버전으로 업그레이드하면 다중 노드 애플리케이션, 웹사이트, 데이터베이스, 예약 작업을 중앙에서 관리할 수 있습니다.',
|
||
fileExchange: '상용 버전으로 업그레이드하면 여러 서버 간에 파일을 빠르게 전송할 수 있습니다.',
|
||
app: '상용 버전으로 업그레이드하면 모바일 앱에서 서비스 정보와 이상 모니터링을 확인할 수 있습니다.',
|
||
cluster: '상용 버전으로 업그레이드하면 MySQL/Postgres/Redis 기본-복제 클러스터를 관리할 수 있습니다.',
|
||
'model-downloader':
|
||
'상용 버전으로 업그레이드하면 HuggingFace, ModelScope 또는 호환 미러에서 로컬 모델 파일을 검색, 다운로드 및 관리하고 모델 디렉터리와 다운로드 작업을 통합 관리할 수 있습니다.',
|
||
exceptionalHelper:
|
||
'라이선스 동기화 검증이 비정상입니다. 수동으로 동기화해 상용 버전 기능이 정상적으로 동작하는지 확인하세요. 상세: ',
|
||
tamperHelper: '작업 실패, 파일/폴더에 변조 방지가 활성화되어 있습니다. 확인 후 다시 시도하세요!',
|
||
},
|
||
clean: {
|
||
scan: '스캔 시작',
|
||
scanHelper: '1Panel 실행 중에 생성된 불필요한 파일을 쉽게 정리합니다.',
|
||
clean: '지금 정리',
|
||
reScan: '다시 스캔',
|
||
cleanHelper: '선택된 파일 및 디렉터리는 정리 후 롤백할 수 없습니다. 계속하시겠습니까?',
|
||
statusSuggest: '(권장 정리)',
|
||
statusClean: '(매우 깨끗함)',
|
||
statusEmpty: '매우 깨끗합니다. 정리가 필요하지 않습니다!',
|
||
statusWarning: '(주의하여 진행)',
|
||
lastCleanTime: '마지막 정리 시간: {0}',
|
||
lastCleanHelper: '정리된 파일 및 디렉터리: {0}, 총 정리된 크기: {1}',
|
||
cleanSuccessful: '정리 성공',
|
||
currentCleanHelper: '이번 세션에서 정리된 파일 및 디렉터리: {0}, 총 정리된 크기: {1}',
|
||
suggest: '(권장)',
|
||
totalScan: '정리해야 할 총 불필요 파일: ',
|
||
selectScan: '선택된 불필요 파일 총합: ',
|
||
system: '시스템 불필요 파일',
|
||
systemHelper: '스냅샷, 업그레이드 및 기타 프로세스 중에 생성된 임시 파일',
|
||
panelOriginal: '시스템 스냅샷 복원 전 백업 파일',
|
||
upgrade: '시스템 업그레이드 백업 파일',
|
||
agentPackages: '이전 버전 자식 노드 업그레이드/설치 패키지',
|
||
upgradeHelper: '(시스템 롤백을 위해 최신 업그레이드 백업을 유지하는 것이 좋습니다)',
|
||
rollback: '복구 전 백업 파일',
|
||
backup: '시스템 백업',
|
||
backupHelper: '로컬 백업 계정에 연결되지 않은 백업 파일',
|
||
unknownBackup: '시스템 백업',
|
||
tmpBackup: '임시 백업',
|
||
unknownApp: '연결되지 않은 앱 백업',
|
||
unknownDatabase: '연결되지 않은 데이터베이스 백업',
|
||
unknownWebsite: '연결되지 않은 웹사이트 백업',
|
||
unknownSnapshot: '연결되지 않은 스냅샷 백업',
|
||
upload: '임시 업로드 파일',
|
||
uploadHelper: '시스템 백업 리스트에서 업로드된 임시 파일',
|
||
download: '임시 다운로드 파일',
|
||
downloadHelper: '시스템에서 제3자 백업 계정으로 다운로드된 임시 파일',
|
||
directory: '디렉터리',
|
||
systemLog: '로그 파일',
|
||
systemLogHelper: '시스템 로그, 작업 로그, 웹사이트 로그 파일',
|
||
dockerLog: '컨테이너 작업 로그 파일',
|
||
taskLog: '예약 작업 실행 로그 파일',
|
||
shell: '셸 스크립트 예약 작업',
|
||
containerShell: '컨테이너 내에서 실행하는 셸 스크립트 예약 작업',
|
||
curl: 'CURL 예약 작업',
|
||
docker: '컨테이너 쓰레기',
|
||
dockerHelper: '컨테이너, 이미지, 볼륨, 빌드 캐시 등의 파일',
|
||
volumes: '볼륨',
|
||
buildCache: '컨테이너 빌드 캐시',
|
||
appTmpDownload: '앱 임시 다운로드 파일',
|
||
unknownWebsiteLog: '연결되지 않은 웹사이트 로그 백업 파일',
|
||
snapshot: '시스템 스냅샷 임시 파일',
|
||
},
|
||
app: {
|
||
app: '애플리케이션 | 애플리케이션들',
|
||
installName: '이름',
|
||
installed: '설치됨',
|
||
all: '모두',
|
||
version: '버전',
|
||
detail: '세부사항',
|
||
params: '편집',
|
||
author: '저자',
|
||
source: '출처',
|
||
appName: '애플리케이션 이름',
|
||
deleteWarn:
|
||
'삭제 작업은 모든 데이터와 백업을 함께 삭제합니다. 이 작업은 되돌릴 수 없습니다. 계속 하시겠습니까?',
|
||
syncSuccess: '동기화 성공',
|
||
canUpgrade: '업데이트',
|
||
backupName: '파일 이름',
|
||
backupPath: '파일 경로',
|
||
backupdate: '백업 시간',
|
||
versionSelect: '버전을 선택하세요',
|
||
operatorHelper: '선택한 애플리케이션에 대해 {0} 작업이 수행됩니다. 계속 하시겠습니까?',
|
||
startOperatorHelper: '애플리케이션이 시작됩니다. 계속 하시겠습니까?',
|
||
stopOperatorHelper: '애플리케이션이 중지됩니다. 계속 하시겠습니까?',
|
||
restartOperatorHelper: '애플리케이션이 재시작됩니다. 계속 하시겠습니까?',
|
||
reloadOperatorHelper: '애플리케이션이 다시 로드됩니다. 계속 하시겠습니까?',
|
||
checkInstalledWarn: '"{0}"이(가) 감지되지 않았습니다. "앱 스토어"로 가서 설치하세요.',
|
||
limitHelper: '애플리케이션은 이미 설치되었습니다.',
|
||
deleteHelper: '"{0}"은(는) 다음 리소스와 연결되어 있습니다. 확인 후 다시 시도하세요!',
|
||
checkTitle: '힌트',
|
||
defaultConfig: '기본 설정',
|
||
defaultConfigHelper: '기본 설정으로 복원되었습니다. 저장 후 적용됩니다.',
|
||
forceDelete: '강제 삭제',
|
||
forceDeleteHelper: '강제 삭제는 삭제 과정 중 오류를 무시하고 메타데이터를 삭제합니다.',
|
||
deleteBackup: '백업 삭제',
|
||
deleteBackupHelper: '애플리케이션 백업도 삭제됩니다.',
|
||
deleteDB: '데이터베이스 삭제',
|
||
deleteDBHelper: '데이터베이스도 삭제됩니다.',
|
||
noService: '{0} 없음',
|
||
toInstall: '설치하러 가기',
|
||
param: '파라미터',
|
||
alreadyRun: '설치됨',
|
||
syncAppList: '동기화',
|
||
less1Minute: '1분 미만',
|
||
appOfficeWebsite: '공식 웹사이트',
|
||
github: 'GitHub',
|
||
document: '문서',
|
||
updatePrompt: '업데이트가 없습니다.',
|
||
installPrompt: '아직 설치된 앱이 없습니다.',
|
||
updateHelper: '파라미터를 수정하면 애플리케이션이 시작되지 않을 수 있습니다. 주의하세요.',
|
||
updateWarn: '업데이트 파라미터는 애플리케이션을 재빌드해야 합니다. 계속 하시겠습니까?',
|
||
busPort: '포트',
|
||
syncStart: '동기화 시작! 나중에 앱 스토어를 새로고침 해주세요.',
|
||
advanced: '고급 설정',
|
||
cpuCore: '코어',
|
||
containerName: '컨테이너 이름',
|
||
containerNameHelper: '설정되지 않으면 컨테이너 이름이 자동으로 생성됩니다.',
|
||
allowPort: '외부 접근 허용',
|
||
allowPortHelper: '외부 포트 접근을 허용하면 방화벽 포트가 열립니다.',
|
||
appInstallWarn:
|
||
'애플리케이션은 기본적으로 외부 접근 포트를 노출하지 않습니다. "고급 설정"을 클릭하여 노출할 수 있습니다.',
|
||
upgradeStart: '업그레이드 시작! 나중에 페이지를 새로고침 해주세요.',
|
||
toFolder: '설치 디렉터리 열기',
|
||
editCompose: 'Compose 파일 편집',
|
||
editComposeHelper: 'Compose 파일을 편집하면 소프트웨어 설치가 실패할 수 있습니다.',
|
||
composeNullErr: 'Compose는 비어 있을 수 없습니다.',
|
||
takeDown: '지원 종료',
|
||
allReadyInstalled: '설치됨',
|
||
installHelper: '이미지 풀 문제 시 이미지 가속을 구성하세요.',
|
||
sortMode: '정렬',
|
||
installWarn:
|
||
'외부 접근이 활성화되지 않아 애플리케이션이 외부 네트워크에서 접근할 수 없습니다. 계속 하시겠습니까?',
|
||
showIgnore: '무시된 애플리케이션 보기',
|
||
cancelIgnore: '무시 취소',
|
||
ignoreList: '무시된 애플리케이션',
|
||
appHelper: '특수 애플리케이션 설치 지침을 보려면 애플리케이션 상세 페이지로 이동하세요.',
|
||
backupApp: '업그레이드 전 애플리케이션 백업',
|
||
backupAppHelper:
|
||
'업그레이드 실패 시 백업이 자동으로 롤백됩니다. 로그 감사 시스템 로그에서 실패 원인을 확인하세요. 백업은 기본적으로 최신 3개 복사본을 유지합니다.',
|
||
openrestyDeleteHelper: 'OpenResty 강제 삭제는 모든 웹사이트를 삭제합니다. 계속 하시겠습니까?',
|
||
downloadLogHelper1: '{0} 애플리케이션의 모든 로그가 다운로드됩니다. 계속 하시겠습니까?',
|
||
downloadLogHelper2: '{0} 애플리케이션의 최신 {1} 로그가 다운로드됩니다. 계속 하시겠습니까?',
|
||
syncAllAppHelper: '모든 애플리케이션이 동기화됩니다. 계속 하시겠습니까?',
|
||
hostModeHelper:
|
||
'현재 애플리케이션 네트워크 모드는 호스트 모드입니다. 포트를 열어야 할 경우 방화벽 페이지에서 수동으로 열어주세요.',
|
||
showLocal: '로컬 애플리케이션 보기',
|
||
reload: '새로고침',
|
||
upgradeWarn:
|
||
'애플리케이션 업그레이드는 docker-compose.yml 파일을 교체합니다. 변경 사항이 있으면 파일 비교를 클릭하여 확인할 수 있습니다.',
|
||
openclawHttpsUpgradeNoticeTitle:
|
||
'참고: 다음 안내는 OpenClaw를 2026.3.13~2026.3.22 버전에서 2026.3.23 이상으로 업그레이드하는 경우에만 적용됩니다.',
|
||
openclawHttpsUpgradeNoticeItem1:
|
||
'업그레이드 후 에이전트 접속이 다시 HTTP로 전환됩니다. 설정 -> 보안에서 접속 주소를 확인하세요.',
|
||
openclawHttpsUpgradeNoticeItem2:
|
||
'이전에 리버스 프록시 웹사이트를 사용했다면 프록시 대상 주소를 http://IP:Port 로 변경하세요.',
|
||
newVersion: '새 버전',
|
||
oldVersion: '현재 버전',
|
||
composeDiff: '파일 비교',
|
||
showDiff: '비교 보기',
|
||
useNew: '사용자 정의 버전 사용',
|
||
useDefault: '기본 버전 사용',
|
||
useCustom: '사용자 정의 docker-compose.yml 사용',
|
||
useCustomHelper:
|
||
'사용자 정의 docker-compose.yml 파일을 사용하면 애플리케이션 업그레이드가 실패할 수 있습니다. 필요하지 않으면 체크하지 마세요.',
|
||
diffHelper: '왼쪽은 이전 버전, 오른쪽은 새 버전입니다. 편집 후 사용자 정의 버전을 저장하려면 클릭하세요.',
|
||
pullImage: '이미지 풀',
|
||
pullImageHelper: '애플리케이션 시작 전에 docker pull 을 실행하여 이미지를 다운로드하세요.',
|
||
deleteImage: '이미지 삭제',
|
||
deleteImageHelper: '애플리케이션 관련 이미지를 삭제합니다. 삭제에 실패하더라도 작업은 종료되지 않습니다.',
|
||
requireMemory: '메모리 요구사항',
|
||
supportedArchitectures: '지원 아키텍처',
|
||
link: '링크',
|
||
showCurrentArch: '현재 서버 아키텍처 애플리케이션',
|
||
syncLocalApp: '로컬 애플리케이션 동기화',
|
||
memoryRequiredHelper: '현재 애플리케이션은 {0} 메모리가 필요합니다',
|
||
gpuConfig: 'GPU 지원 활성화',
|
||
gpuConfigHelper:
|
||
'NVIDIA GPU가 장착되어 있으며 NVIDIA 드라이버와 NVIDIA Docker Container Toolkit이 설치되어 있는지 확인하세요',
|
||
webUI: '웹 접속 주소',
|
||
webUIPlaceholder: '예: example.com:8080/login',
|
||
defaultWebDomain: '기본 접속 주소',
|
||
defaultWebDomainHepler: '애플리케이션 포트가 8080인 경우 접속 주소는 http(s)://기본 접속 주소:8080입니다',
|
||
webUIConfig:
|
||
'현재 노드에 기본 접근 주소가 설정되지 않았습니다. 애플리케이션 매개변수에서 설정하거나 패널 설정으로 이동하여 설정하세요!',
|
||
toLink: '이동',
|
||
customAppHelper: '사용자 정의 앱 스토어 패키지를 설치하기 전에 설치된 앱이 없는지 확인하십시오.',
|
||
forceUninstall: '강제 제거',
|
||
syncCustomApp: 'カスタムアプリを同期',
|
||
ignoreAll: '후속 모든 버전 무시',
|
||
ignoreVersion: '지정된 버전 무시',
|
||
specifyIP: '호스트 IP 바인딩',
|
||
specifyIPHelper:
|
||
'포트 바인딩을 위한 호스트 주소/네트워크 인터페이스를 설정합니다 (이 기능을 잘 모를 경우, 입력하지 마십시오)',
|
||
uninstallDeleteBackup: '앱 제거 - 백업 삭제',
|
||
uninstallDeleteImage: '앱 제거 - 이미지 삭제',
|
||
upgradeBackup: '앱 업그레이드 전 앱 백업',
|
||
upgradeDeleteImage: '앱 업그레이드 - 이전 이미지 삭제',
|
||
installAllowPort: '앱 설치 시 기본으로 외부 포트 접근 허용',
|
||
noAppHelper: '애플리케이션이 감지되지 않았습니다. 작업 센터에서 앱 스토어 동기화 로그를 확인해 주세요',
|
||
isEdirWarn: 'docker-compose.yml 파일 변경이 감지되었습니다. 차이점을 확인해 주세요.',
|
||
},
|
||
website: {
|
||
primaryDomain: '기본 도메인',
|
||
otherDomains: '기타 도메인',
|
||
static: '정적',
|
||
deployment: '배포',
|
||
supportUpType: '.tar.gz 파일 형식만 지원되며, 압축 패키지에는 {0}.json 파일이 포함되어야 합니다',
|
||
proxy: '리버스 프록시',
|
||
alias: '별칭',
|
||
ftpUser: 'FTP 계정',
|
||
ftpPassword: 'FTP 비밀번호',
|
||
ftpHelper: '웹사이트를 생성하면 해당 FTP 계정이 생성되고 FTP 디렉터리는 웹사이트 디렉터리와 연결됩니다.',
|
||
remark: '비고',
|
||
manageGroup: '그룹 관리',
|
||
groupSetting: '그룹 설정',
|
||
createGroup: '그룹 생성',
|
||
appNew: '새로운 애플리케이션',
|
||
appInstalled: '설치된 애플리케이션',
|
||
delete: '웹사이트 삭제',
|
||
deleteApp: '애플리케이션 삭제',
|
||
deleteBackup: '백업 삭제',
|
||
domain: '도메인',
|
||
domainHelper: "한 줄에 하나의 도메인.\n와일드카드 '*'와 IP 주소를 지원합니다.\n포트 추가를 지원합니다.",
|
||
addDomain: '추가',
|
||
domainConfig: '도메인 설정',
|
||
defaultDoc: '기본 문서',
|
||
perserver: '동시 연결',
|
||
perserverHelper: '현재 사이트의 최대 동시 연결 수를 제한합니다.',
|
||
perip: '단일 IP',
|
||
peripHelper: '단일 IP의 최대 동시 접속 수를 제한합니다.',
|
||
rate: '트래픽 제한',
|
||
rateLimit: '요청당 속도 제한',
|
||
rateHelper: '요청당 트래픽을 제한합니다 (단위: KB)',
|
||
rateLimitHelper: '각 요청의 전송 속도를 제한합니다 (단위: KB/s)',
|
||
limitHelper: '트래픽 제어 활성화',
|
||
other: '기타',
|
||
currentSSL: '현재 인증서',
|
||
dnsAccount: 'DNS 계정',
|
||
applySSL: '인증서 신청',
|
||
SSLList: '인증서 목록',
|
||
createDnsAccount: 'DNS 계정 생성',
|
||
aliyun: '알리윤',
|
||
aliEsa: '알리윤 ESA',
|
||
awsRoute53: 'Amazon Route 53',
|
||
manual: '수동 설정',
|
||
key: '키',
|
||
check: '보기',
|
||
acmeAccountManage: 'ACME 계정 관리',
|
||
email: '이메일',
|
||
acmeAccount: 'ACME 계정',
|
||
provider: '검증 방법',
|
||
dnsManual: '수동 설정',
|
||
expireDate: '만료일',
|
||
brand: '기관',
|
||
deploySSL: '배포',
|
||
deploySSLHelper: '인증서를 배포하시겠습니까?',
|
||
ssl: '인증서 | 인증서들',
|
||
dnsAccountManage: 'DNS 제공자 관리',
|
||
renewSSL: '갱신',
|
||
renewHelper: '인증서를 갱신하시겠습니까?',
|
||
renewSuccess: '인증서 갱신 성공',
|
||
enableHTTPS: 'HTTPS 활성화',
|
||
aliasHelper: '별칭은 웹사이트의 디렉터리 이름입니다.',
|
||
lastBackupAt: '마지막 백업 시간',
|
||
null: '없음',
|
||
nginxConfig: 'Nginx 설정',
|
||
websiteConfig: '웹사이트 설정',
|
||
proxySettings: '프록시 설정',
|
||
advancedSettings: '고급 설정',
|
||
cacheSettings: '캐시 설정',
|
||
sniSettings: 'SNI 설정',
|
||
basic: '기본',
|
||
source: '구성',
|
||
security: '보안',
|
||
nginxPer: '성능 튜닝',
|
||
neverExpire: '만료 없음',
|
||
setDefault: '기본값으로 설정',
|
||
default: '기본값',
|
||
deleteHelper: '관련 애플리케이션 상태가 비정상입니다. 확인해 주세요.',
|
||
toApp: '설치된 목록으로 이동',
|
||
cycle: '주기',
|
||
frequency: '빈도',
|
||
ccHelper: '{0}초 내에 동일한 URL을 {1}회 이상 누적 요청하면 CC 방어가 발동되며, 해당 IP가 차단됩니다.',
|
||
mustSave: '변경 사항은 저장해야 적용됩니다.',
|
||
fileExt: '파일 확장자',
|
||
fileExtBlock: '파일 확장자 차단 목록',
|
||
value: '값',
|
||
enable: '활성화',
|
||
proxyAddress: '프록시 주소',
|
||
proxyHelper: '예: 127.0.0.1:8080',
|
||
forceDelete: '강제 삭제',
|
||
forceDeleteHelper: '강제 삭제는 삭제 과정에서 발생하는 오류를 무시하고 최종적으로 메타데이터를 삭제합니다.',
|
||
deleteAppHelper: '관련 애플리케이션 및 애플리케이션 백업을 동시에 삭제합니다.',
|
||
deleteBackupHelper: '웹사이트 백업도 삭제합니다.',
|
||
deleteDatabaseHelper: '웹사이트와 연결된 데이터베이스도 삭제합니다',
|
||
deleteConfirmHelper:
|
||
'삭제 작업은 되돌릴 수 없습니다. 확인하려면 <span style=\'color:red\'>"{0}"</span>을(를) 입력하세요.',
|
||
staticPath: '해당 주요 디렉터리는 ',
|
||
limit: '제한',
|
||
blog: '포럼/블로그',
|
||
imageSite: '이미지 사이트',
|
||
downloadSite: '다운로드 사이트',
|
||
shopSite: '쇼핑몰',
|
||
doorSite: '포털',
|
||
qiteSite: '기업',
|
||
videoSite: '비디오',
|
||
errLog: '오류 로그',
|
||
stopHelper:
|
||
'사이트를 중지하면 정상적으로 액세스할 수 없으며, 사용자가 해당 사이트의 중지 페이지를 보게 됩니다. 계속하시겠습니까?',
|
||
startHelper: '사이트를 활성화하면 사용자가 정상적으로 사이트 내용을 액세스할 수 있습니다. 계속하시겠습니까?',
|
||
sitePath: '디렉터리',
|
||
siteAlias: '사이트 별칭',
|
||
primaryPath: '루트 디렉터리',
|
||
folderTitle: '웹사이트는 다음과 같은 폴더를 포함합니다.',
|
||
wafFolder: '방화벽 규칙',
|
||
indexFolder: '웹사이트 루트 디렉터리',
|
||
sslFolder: '웹사이트 인증서',
|
||
enableOrNot: '활성화 여부',
|
||
oldSSL: '기존 인증서',
|
||
manualSSL: '인증서 가져오기',
|
||
select: '선택',
|
||
selectSSL: '인증서 선택',
|
||
privateKey: '키(KEY)',
|
||
certificate: '인증서(PEM 형식)',
|
||
HTTPConfig: 'HTTP 옵션',
|
||
HTTPSOnly: 'HTTP 요청 차단',
|
||
HTTPToHTTPS: 'HTTPS로 리디렉션',
|
||
HTTPAlso: 'HTTP 요청 허용',
|
||
sslConfig: 'SSL 옵션',
|
||
disableHTTPS: 'HTTPS 비활성화',
|
||
disableHTTPSHelper: 'HTTPS 비활성화는 인증서 관련 구성을 삭제합니다. 계속하시겠습니까?',
|
||
SSLHelper:
|
||
'주의: 불법 웹사이트에는 SSL 인증서를 사용하지 마세요.\nHTTPS 액세스가 안 되는 경우 보안 그룹에서 443 포트를 올바르게 해제했는지 확인하세요.',
|
||
SSLConfig: '인증서 설정',
|
||
SSLProConfig: '프로토콜 설정',
|
||
supportProtocol: '프로토콜 버전',
|
||
encryptionAlgorithm: '암호화 알고리즘',
|
||
notSecurity: '(안전하지 않음)',
|
||
encryptHelper:
|
||
"Let's Encrypt 는 인증서 발급에 빈도 제한이 있지만 일반적인 요구 사항을 충족하기에 충분합니다. 너무 자주 작업하면 발급 실패가 발생할 수 있습니다. 자세한 제한 사항은 <a target='_blank' href='https://letsencrypt.org/zh-cn/docs /rate-limits/'>공식 문서</a>를 참조하세요.",
|
||
ipValue: '값',
|
||
ext: '파일 확장자',
|
||
wafInputHelper: '줄 단위로 데이터 입력, 한 줄에 하나씩',
|
||
data: '데이터',
|
||
ever: '영구',
|
||
nextYear: '1년 후',
|
||
noLog: '로그를 찾을 수 없습니다.',
|
||
defaultServer: '기본 사이트',
|
||
noDefaultServer: '설정되지 않음',
|
||
defaultServerHelper:
|
||
'기본 사이트를 설정한 후, 바인딩되지 않은 모든 도메인 이름과 IP는 기본 사이트로 리디렉션됩니다\n이는 악의적인 해석을 효과적으로 방지할 수 있습니다\n하지만 WAF의 무단 도메인 차단이 실패할 수도 있습니다',
|
||
restoreHelper: '이 백업을 사용하여 복원하시겠습니까?',
|
||
websiteDeploymentHelper: '설치된 애플리케이션을 사용하거나 새 애플리케이션을 생성하여 웹사이트를 만드세요.',
|
||
websiteStatictHelper: '호스트에 웹사이트 디렉터리를 생성합니다.',
|
||
websiteProxyHelper:
|
||
'리버스 프록시를 사용하여 기존 서비스를 프록시합니다. 예를 들어, 포트 8080 에서 실행 중인 서비스를 프록시하려면 프록시 주소는 "http://127.0.0.1:8080"이 됩니다.',
|
||
runtimeProxyHelper: '웹사이트 런타임을 사용하여 웹사이트를 만드세요.',
|
||
runtime: '런타임',
|
||
deleteRuntimeHelper: '런타임 애플리케이션은 웹사이트와 함께 삭제해야 하므로 신중하게 처리하세요.',
|
||
proxyType: '네트워크 유형',
|
||
unix: '유닉스 네트워크',
|
||
tcp: 'TCP/IP 네트워크',
|
||
phpFPM: 'FPM 구성',
|
||
phpConfig: 'PHP 구성',
|
||
updateConfig: '구성 업데이트',
|
||
isOn: '켜짐',
|
||
isOff: '꺼짐',
|
||
rewrite: '의사 정적',
|
||
rewriteMode: '방식',
|
||
current: '현재',
|
||
rewriteHelper: '의사 정적 설정으로 인해 웹사이트에 접근할 수 없게 되면 기본 설정으로 되돌려보세요.',
|
||
runDir: '실행 디렉터리',
|
||
runUserHelper:
|
||
'PHP 컨테이너 런타임 환경에서 배포된 웹사이트의 경우, 인덱스 및 하위 디렉터리 아래의 모든 파일 및 폴더의 소유자와 사용자 그룹을 1000으로 설정해야 합니다. 로컬 PHP 환경의 경우, 로컬 PHP-FPM 사용자 및 사용자 그룹 설정을 참조하세요.',
|
||
userGroup: '사용자/그룹',
|
||
uGroup: '그룹',
|
||
proxyPath: '프록시 경로',
|
||
proxyPass: '대상 URL',
|
||
cache: '캐시',
|
||
cacheTime: '캐시 지속 시간',
|
||
enableCache: '캐시 활성화',
|
||
proxyHost: '프록시 호스트',
|
||
disabled: '중지됨',
|
||
startProxy: '리버스 프록시를 시작합니다. 계속하시겠습니까?',
|
||
stopProxy: '리버스 프록시를 중지합니다. 계속하시겠습니까?',
|
||
sourceFile: '소스',
|
||
proxyHelper1: '이 디렉터리에 접근할 때 대상 URL 의 내용이 반환되고 표시됩니다.',
|
||
proxyPassHelper: '대상 URL 은 유효하고 접근 가능해야 합니다.',
|
||
proxyHostHelper: '요청 헤더에 있는 도메인 이름을 프록시 서버로 전달합니다.',
|
||
replacementHelper: '최대 5개의 교체를 추가할 수 있으며, 교체가 필요하지 않은 경우 비워두세요.',
|
||
modifier: '매칭 규칙',
|
||
modifierHelper: '예: = 는 정확히 일치, ~ 는 정규식 일치, ^~ 는 경로 시작 부분 일치 등을 나타냅니다.',
|
||
replace: '텍스트 교체',
|
||
replaceHelper:
|
||
'nginx 텍스트 교체 기능은 리버스 프록시 중 응답 내용의 문자열을 대체할 수 있습니다. 백엔드에서 반환된 HTML, CSS, JavaScript 및 기타 파일의 링크, API 주소 등을 수정하는 데 일반적으로 사용됩니다. 복잡한 콘텐츠 교체 요구 사항에 대해 정규식 일치를 지원합니다.',
|
||
addReplace: '추가',
|
||
replaced: '검색 문자열 (비울 수 없음)',
|
||
replaceText: '교체할 문자열',
|
||
replacedErr: '검색 문자열은 비워둘 수 없습니다',
|
||
replacedErr2: '검색 문자열은 중복될 수 없습니다',
|
||
replacedListEmpty: '텍스트 교체 규칙 없음',
|
||
proxySslName: '프록시 SNI 이름',
|
||
basicAuth: '기본 인증',
|
||
editBasicAuthHelper:
|
||
'비밀번호는 비대칭으로 암호화되어 표시할 수 없습니다. 수정하려면 비밀번호를 재설정해야 합니다.',
|
||
antiLeech: '링크 차단',
|
||
extends: '확장',
|
||
browserCache: '캐시',
|
||
noModify: '수정 안 함',
|
||
serverCache: '서버 캐시',
|
||
leechLog: '링크 차단 로그 기록',
|
||
accessDomain: '허용된 도메인',
|
||
leechReturn: '응답 리소스',
|
||
noneRef: '빈 참조 허용',
|
||
disable: '비활성화',
|
||
disableLeechHelper: '링크 차단을 비활성화할지 여부',
|
||
disableLeech: '링크 차단 비활성화',
|
||
ipv6: 'IPv6 수신 대기',
|
||
leechReturnError: 'HTTP 상태 코드를 입력하세요',
|
||
blockedRef: '비표준 참조 허용',
|
||
accessControl: '링크 차단 제어',
|
||
leechcacheControl: '캐시 제어',
|
||
logEnableControl: '정적 리소스 요청 로그 기록',
|
||
leechSpecialValidHelper:
|
||
"'빈 참조 허용'을 활성화하면 리퍼러가 없는 요청(직접 접근 등)은 차단되지 않습니다. '비표준 참조 허용'을 활성화하면 http/https로 시작하지 않는 모든 리퍼러 요청(클라이언트 요청 등)을 허용합니다.",
|
||
leechInvalidReturnHelper: '차단된 요청에 대해 반환할 HTTP 상태 코드',
|
||
leechlogControlHelper:
|
||
'정적 리소스 요청을 기록합니다. 운영 환경에서는 과도하고 불필요한 로그를 피하기 위해 보통 비활성화합니다',
|
||
selectAcme: 'Acme 계정 선택',
|
||
imported: '수동으로 생성됨',
|
||
importType: '가져오기 유형',
|
||
pasteSSL: '코드 붙여넣기',
|
||
localSSL: '서버 파일 선택',
|
||
privateKeyPath: '개인 키 파일',
|
||
certificatePath: '인증서 파일',
|
||
ipWhiteListHelper: 'IP 허용 목록의 역할: 모든 규칙이 IP 허용 목록에 대해 무효화됩니다.',
|
||
redirect: '리디렉션',
|
||
sourceDomain: '소스 도메인',
|
||
targetURL: '대상 URL 주소',
|
||
keepPath: 'URI 매개변수',
|
||
path: '경로',
|
||
redirectType: '리디렉션 유형',
|
||
redirectWay: '방식',
|
||
keep: '유지',
|
||
notKeep: '유지하지 않음',
|
||
redirectRoot: '홈페이지로 리디렉션',
|
||
redirectHelper: '301 영구 리디렉션, 302 임시 리디렉션',
|
||
changePHPVersionWarn:
|
||
'PHP 버전을 변경하면 기존 PHP 컨테이너가 삭제됩니다 (마운트된 웹사이트 코드는 손실되지 않습니다). 계속하시겠습니까?',
|
||
changeVersion: '버전 전환',
|
||
retainConfig: 'php-fpm.conf 및 php.ini 파일을 유지할지 여부',
|
||
runDirHelper2: '보조 실행 디렉터리가 인덱스 디렉터리 아래에 있는지 확인하세요.',
|
||
openrestyHelper:
|
||
'OpenResty 기본 HTTP 포트: {0}, HTTPS 포트: {1}, 이는 웹사이트 도메인 접속 및 HTTPS 강제 리디렉션에 영향을 미칠 수 있습니다.',
|
||
primaryDomainHelper: '예: example.com 또는 example.com:8080',
|
||
acmeAccountType: '계정 유형',
|
||
keyType: '키 알고리즘',
|
||
tencentCloud: '텐센트 클라우드',
|
||
containWarn: '도메인 이름에 메인 도메인이 포함되어 있습니다. 다시 입력하세요.',
|
||
rewriteHelper2:
|
||
'앱 스토어에서 설치된 WordPress 와 같은 응용 프로그램은 일반적으로 사전 설정된 가상 정적 구성이 포함됩니다. 이를 재구성하면 오류가 발생할 수 있습니다.',
|
||
websiteBackupWarn:
|
||
'로컬 백업 가져오기만 지원합니다. 다른 기기에서 가져온 백업은 복구 실패를 초래할 수 있습니다.',
|
||
ipWebsiteWarn:
|
||
'IP를 도메인 이름으로 사용하는 웹사이트는 정상적으로 접속되기 위해 기본 사이트로 설정해야 합니다.',
|
||
hstsHelper: 'HSTS 를 활성화하면 웹사이트 보안을 강화할 수 있습니다.',
|
||
includeSubDomains: '서브도메인',
|
||
hstsIncludeSubDomainsHelper: '활성화하면 HSTS 정책이 현재 도메인의 모든 서브도메인에 적용됩니다.',
|
||
defaultHtml: '기본 페이지',
|
||
website404: '웹사이트 404 오류 페이지',
|
||
domain404: '웹사이트 도메인이 존재하지 않습니다.',
|
||
indexHtml: '정적 웹사이트 인덱스',
|
||
stopHtml: '중지된 웹사이트',
|
||
indexPHP: 'PHP 웹사이트 인덱스',
|
||
sslExpireDate: '인증서 만료 날짜',
|
||
website404Helper: '웹사이트 404 오류 페이지는 PHP 실행 환경 웹사이트 및 정적 웹사이트만 지원합니다.',
|
||
sni: '원본 SNI',
|
||
sniHelper:
|
||
'역방향 프록시 백엔드가 HTTPS 인 경우 원본 SNI 를 설정해야 할 수 있습니다. 자세한 내용은 CDN 서비스 제공자의 문서를 참조하세요.',
|
||
proxySslVerify: '백엔드 SSL 인증서 검증',
|
||
proxySslVerifyHelper: '활성화하면 프록시가 업스트림 SSL 인증서를 엄격하게 검증합니다(기본값은 비활성화).',
|
||
huaweicloud: '화웨이 클라우드',
|
||
createDb: '데이터베이스 생성',
|
||
enableSSLHelper: 'SSL 활성화 실패는 웹사이트 생성에 영향을 미치지 않습니다.',
|
||
batchAdd: '도메인 일괄 추가',
|
||
batchInput: '일괄 입력',
|
||
domainNotFQDN: '이 도메인은 공용 네트워크에서 액세스할 수 없을 수 있습니다',
|
||
domainInvalid: '도메인 형식이 올바르지 않습니다',
|
||
domainBatchHelper: '한 줄에 하나의 도메인, 형식: domain:port@ssl\n예: example.com:443@ssl 또는 example.com',
|
||
generateDomain: '생성',
|
||
global: '글로벌',
|
||
subsite: '하위 사이트',
|
||
subsiteHelper: '하위 사이트는 기존 PHP 또는 정적 웹사이트의 디렉토리를 루트 디렉토리로 선택할 수 있습니다.',
|
||
parentWebsite: '상위 웹사이트',
|
||
deleteSubsite: '현재 웹사이트를 삭제하려면 먼저 하위 사이트 {0}를 삭제해야 합니다.',
|
||
loadBalance: '로드 밸런싱',
|
||
server: '노드',
|
||
algorithm: '알고리즘',
|
||
ipHash: 'IP 해시',
|
||
ipHashHelper:
|
||
'클라이언트 IP 주소를 기반으로 요청을 특정 서버에 분배하여 특정 클라이언트가 항상 동일한 서버로 라우팅되도록 합니다.',
|
||
leastConn: '최소 연결',
|
||
leastConnHelper: '활성 연결 수가 가장 적은 서버로 요청을 보냅니다.',
|
||
leastTime: '최소 시간',
|
||
leastTimeHelper: '활성 연결 시간이 가장 짧은 서버로 요청을 보냅니다.',
|
||
defaultHelper:
|
||
'기본 방법으로, 요청은 각 서버에 균등하게 분배됩니다. 서버에 가중치 설정이 있는 경우 지정된 가중치에 따라 요청이 분배됩니다. 가중치가 높은 서버는 더 많은 요청을 받습니다.',
|
||
weight: '가중치',
|
||
maxFails: '최대 실패 횟수',
|
||
maxConns: '최대 연결 수',
|
||
strategy: '전략',
|
||
strategyDown: '비활성화',
|
||
strategyBackup: '백업',
|
||
ipHashBackupErr: 'IP 해시는 백업 노드를 지원하지 않습니다',
|
||
failTimeout: '장애 시간 초과',
|
||
failTimeoutHelper:
|
||
'서버 상태 점검 시간 창 길이. 이 기간 동안 누적 실패 횟수가 임계값에 도달하면 서버가 일시적으로 제거되고 동일한 시간 후에 재시도됩니다. 기본값 10초',
|
||
staticChangePHPHelper: '현재 정적 웹사이트이며 PHP 웹사이트로 전환할 수 있습니다.',
|
||
proxyCache: '리버스 프록시 캐시',
|
||
cacheLimit: '캐시 공간 제한',
|
||
shareCache: '캐시 카운트 메모리 크기',
|
||
cacheExpire: '캐시 만료 시간',
|
||
shareCacheHelper: '1M 메모리로 약 8000개의 캐시 객체를 저장할 수 있습니다.',
|
||
cacheLimitHelper: '제한을 초과하면 이전 캐시가 자동으로 삭제됩니다.',
|
||
cacheExpireHelper: '만료 시간 내에 히트되지 않은 캐시는 삭제됩니다.',
|
||
realIP: '실제 IP',
|
||
ipFrom: 'IP 소스',
|
||
ipFromHelper:
|
||
'신뢰할 수 있는 IP 소스를 구성함으로써 OpenResty는 HTTP 헤더의 IP 정보를 분석하여 방문자의 실제 IP 주소를 정확하게 식별하고 기록합니다(액세스 로그 포함).',
|
||
ipFromExample1: '프론트엔드가 Frp와 같은 도구인 경우 Frp의 IP 주소(예: 127.0.0.1)를 입력할 수 있습니다.',
|
||
ipFromExample2: '프론트엔드가 CDN인 경우 CDN의 IP 범위를 입력할 수 있습니다.',
|
||
ipFromExample3:
|
||
'확실하지 않은 경우 0.0.0.0/0 (IPv4) 또는 ::/0 (IPv6)를 입력할 수 있습니다. [주의: 모든 소스 IP를 허용하는 것은 안전하지 않습니다.]',
|
||
http3Helper:
|
||
'HTTP/3는 HTTP/2의 업그레이드 버전으로, 더 빠른 연결 속도와 더 나은 성능을 제공합니다. 그러나 모든 브라우저가 HTTP/3를 지원하는 것은 아니며, 활성화하면 일부 브라우저가 사이트에 접근하지 못할 수 있습니다.',
|
||
cors: '교차 출처 리소스 공유(CORS)',
|
||
enableCors: 'CORS 활성화',
|
||
allowOrigins: '허용된 도메인',
|
||
allowMethods: '허용된 요청 메서드',
|
||
allowHeaders: '허용된 요청 헤더',
|
||
allowCredentials: '쿠키 전송 허용',
|
||
preflight: '프리플라이트 요청 빠른 응답',
|
||
preflightHleper:
|
||
'활성화하면 브라우저가 교차 출처 프리플라이트 요청(OPTIONS 요청)을 보낼 때 시스템이 자동으로 204 상태 코드를 반환하고 필요한 교차 출처 응답 헤더를 설정합니다',
|
||
changeDatabase: '데이터베이스 전환',
|
||
changeDatabaseHelper1: '데이터베이스 연관은 웹사이트 백업 및 복원에 사용됩니다.',
|
||
changeDatabaseHelper2: '다른 데이터베이스로 전환하면 이전 백업을 복원할 수 없게 될 수 있습니다.',
|
||
saveCustom: '템플릿으로 저장',
|
||
rainyun: 'Rainyun',
|
||
volcengine: 'volcengine',
|
||
runtimePortHelper: '현재 실행 환경에 여러 포트가 있습니다. 프록시 포트를 선택하세요.',
|
||
runtimePortWarn: '현재 실행 환경에 포트가 없습니다. 프록시할 수 없습니다',
|
||
cacheWarn: '먼저 리버스 프록시의 캐시 스위치를 끄십시오',
|
||
loadBalanceHelper:
|
||
'로드 밸런싱을 생성한 후, "리버스 프록시"로 이동하여 프록시를 추가하고 백엔드 주소를 다음으로 설정하세요: http://<로드 밸런싱 이름>.',
|
||
useProxy: '프록시 사용',
|
||
useProxyHelper: '패널 설정의 프록시 서버 주소 사용',
|
||
westCN: '서부 디지털',
|
||
openBaseDir: '사이트 간 공격 방지',
|
||
openBaseDirHelper:
|
||
'open_basedir는 PHP 파일 액세스 경로를 제한하여 사이트 간 액세스를 방지하고 보안을 향상시키는 데 사용됩니다',
|
||
serverCacheTime: '서버 캐시 시간',
|
||
serverCacheTimeHelper:
|
||
'요청이 서버에서 캐시되는 시간. 이 기간 동안 동일한 요청은 원본 서버에 요청하지 않고 캐시된 결과를 직접 반환합니다.',
|
||
browserCacheTime: '브라우저 캐시 시간',
|
||
browserCacheTimeHelper:
|
||
'정적 리소스가 브라우저 로컬에 캐시되는 시간, 중복 요청을 줄입니다. 유효기간 전에 사용자가 페이지를 새로 고치면 로컬 캐시가 직접 사용됩니다.',
|
||
donotLinkeDB: '데이터베이스 연결하지 않기',
|
||
toWebsiteDir: '웹사이트 디렉토리로 이동',
|
||
execParameters: '실행 매개변수',
|
||
extCommand: '추가 명령',
|
||
mirror: '미러 소스',
|
||
execUser: '실행 사용자',
|
||
execDir: '실행 디렉토리',
|
||
packagist: '중국 전체 미러',
|
||
batchOperate: '일괄 작업',
|
||
batchOperateHelper: '웹사이트를 일괄 {0}, 계속 작업하시겠습니까?',
|
||
stream: 'TCP/UDP 프록시',
|
||
streamPorts: '수신 포트',
|
||
streamPortsHelper:
|
||
'외부 수신 포트 번호를 설정합니다. 클라이언트는 이 포트를 통해 서비스에 액세스합니다. 쉼표로 구분하세요. 예: 5222,5223',
|
||
streamHelper: 'TCP/UDP 포트 포워딩 및 로드 밸런싱',
|
||
udp: 'UDP 활성화',
|
||
syncHtmlHelper: 'PHP 및 정적 웹사이트에 동기화',
|
||
wafValueHelper: '값',
|
||
parentWbeiste: '상위 웹사이트',
|
||
shareCahe: '캐시 수 메모리 크기',
|
||
shareCaheHelper: '메모리 1M당 약 8000개의 캐시 객체를 저장할 수 있습니다',
|
||
cacheExpireJHelper: '만료 후 미적중 시 캐시가 삭제됩니다',
|
||
},
|
||
php: {
|
||
short_open_tag: '짧은 태그 지원',
|
||
max_execution_time: '최대 스크립트 실행 시간',
|
||
max_input_time: '최대 입력 시간',
|
||
memory_limit: '스크립트 메모리 제한',
|
||
post_max_size: 'POST 데이터 최대 크기',
|
||
file_uploads: '파일 업로드 허용 여부',
|
||
upload_max_filesize: '업로드 가능한 파일의 최대 크기',
|
||
max_file_uploads: '한 번에 업로드 가능한 파일의 최대 개수',
|
||
default_socket_timeout: '소켓 타임아웃',
|
||
error_reporting: '에러 수준',
|
||
display_errors: '상세한 에러 정보 출력 여부',
|
||
cgi_fix_pathinfo: 'pathinfo 활성화 여부',
|
||
date_timezone: '시간대',
|
||
disableFunction: '비활성화 함수',
|
||
disableFunctionHelper: '비활성화할 함수를 입력하세요. 예: exec, 여러 항목은 쉼표로 구분',
|
||
uploadMaxSize: '업로드 제한',
|
||
indexHelper: 'PHP 웹사이트의 정상 작동을 위해 코드를 인덱스 디렉터리에 배치하고 이름 변경을 피하세요.',
|
||
extensions: '확장 템플릿',
|
||
extension: '확장',
|
||
extensionHelper: '여러 확장은 쉼표로 구분하여 입력하세요.',
|
||
toExtensionsList: '확장 목록 보기',
|
||
containerConfig: '컨테이너 구성',
|
||
containerConfigHelper: '환경 변수 및 기타 정보는 생성 후 구성 - 컨테이너 구성에서 수정할 수 있습니다',
|
||
dateTimezoneHelper: '예: TZ=Asia/Shanghai（필요에 따라 추가하세요）',
|
||
extensionsHelper: '여러 확장은 쉼표로 구분하세요',
|
||
},
|
||
nginx: {
|
||
serverNamesHashBucketSizeHelper: '서버 이름의 해시 테이블 크기',
|
||
clientHeaderBufferSizeHelper: '클라이언트가 요청한 헤더 버퍼 크기',
|
||
clientMaxBodySizeHelper: '최대 업로드 파일 크기',
|
||
keepaliveTimeoutHelper: '연결 시간 초과',
|
||
gzipMinLengthHelper: '최소 압축 파일 크기',
|
||
gzipCompLevelHelper: '압축률',
|
||
gzipHelper: '전송을 위한 압축 활성화',
|
||
connections: '활성 연결',
|
||
accepts: '수락',
|
||
handled: '처리됨',
|
||
requests: '요청',
|
||
reading: '읽기 중',
|
||
writing: '쓰기 중',
|
||
waiting: '대기 중',
|
||
status: '현재 상태',
|
||
configResource: '구성',
|
||
saveAndReload: '저장 및 다시 로드',
|
||
clearProxyCache: '리버스 프록시 캐시 삭제',
|
||
clearProxyCacheWarn:
|
||
'캐시가 구성된 모든 웹사이트에 영향을 미치며 OpenResty 가 다시 시작됩니다. 계속하시겠습니까?',
|
||
create: '모듈 추가',
|
||
update: '모듈 편집',
|
||
params: '매개변수',
|
||
packages: '패키지',
|
||
script: '스크립트',
|
||
module: '모듈',
|
||
build: '빌드',
|
||
buildWarn:
|
||
'로컬 모듈 빌드는 CPU와 메모리를 사용합니다. 정적 모듈은 OpenResty를 다시 빌드하고 재시작합니다. 계속하시겠습니까?',
|
||
buildPurposeHint:
|
||
'동적 모듈은 빌드 후 핫 리로드로 적용됩니다(컨테이너 재시작 없음). 정적 모듈이 포함되면 이미지 전체가 재빌드되고 컨테이너가 재생성됩니다',
|
||
buildMode: '빌드 방식',
|
||
buildModeDynamic: '동적',
|
||
buildModeStatic: '정적',
|
||
buildStatus: '빌드 상태',
|
||
loadOrder: '로드 순서',
|
||
modulesToBuild: '동적 모듈 (빌드 후 핫 리로드, 컨테이너 재시작 없음)',
|
||
staticModules: '정적 모듈',
|
||
staticModulesHelper: '빌드 시 모든 모듈이 재빌드되고 OpenResty가 재시작됩니다',
|
||
forceBuild: '캐시 없이 다시 빌드',
|
||
buildFailed: '마지막 빌드 실패',
|
||
pending: '대기 중',
|
||
ready: '준비됨',
|
||
failed: '실패',
|
||
dynamicUnsupported: '현재 OpenResty 버전에서는 동적 빌드를 지원하지 않습니다',
|
||
moduleDynamicUnsupported: '이 모듈의 파라미터는 동적 빌드를 지원하지 않습니다',
|
||
mirrorUrl: '소프트웨어 소스',
|
||
paramsHelper: '예: --add-module=/tmp/ngx_brotli; 동적 모드에서는 자동으로 변환됩니다',
|
||
packagesHelper: '예: git,curl 쉼표로 구분',
|
||
scriptHelper: '컴파일 전에 실행할 스크립트, 일반적으로 모듈 소스 코드 다운로드, 종속성 설치 등',
|
||
buildHelper: '동적 모듈은 빌드 후 설정을 통해 로드되며, 정적 모듈은 여전히 OpenResty를 다시 빌드합니다.',
|
||
defaultHttps: 'HTTPS 변조 방지',
|
||
defaultHttpsHelper1: '이를 활성화하면 HTTPS 변조 문제를 해결할 수 있습니다.',
|
||
sslRejectHandshake: '기본 SSL 핸드셰이크 거부',
|
||
sslRejectHandshakeHelper:
|
||
'활성화하면 인증서 누출을 방지할 수 있지만, 기본 웹사이트를 설정하면 이 설정이 무효화됩니다',
|
||
},
|
||
ssl: {
|
||
create: '요청',
|
||
provider: '유형',
|
||
manualCreate: '수동 생성됨',
|
||
acmeAccount: 'ACME 계정',
|
||
resolveDomain: '도메인 이름 확인',
|
||
err: '오류',
|
||
value: '레코드 값',
|
||
dnsResolveHelper: 'DNS 해석 서비스 제공업체에서 다음 해석 레코드를 추가하세요:',
|
||
detail: '세부 정보',
|
||
msg: '정보',
|
||
ssl: '인증서',
|
||
key: '개인 키',
|
||
startDate: '유효 시작 시간',
|
||
organization: '발급 기관',
|
||
renewConfirm: '도메인 이름 {0}에 대해 새 인증서를 갱신합니다. 계속하시겠습니까?',
|
||
autoRenew: '자동 갱신',
|
||
autoRenewHelper: '만료 30일 전에 자동으로 갱신',
|
||
renewSuccess: '갱신 성공',
|
||
renewWebsite: '이 인증서는 다음 웹사이트에 연결되었으며, 적용은 이러한 웹사이트에 동시에 적용됩니다.',
|
||
createAcme: '계정 생성',
|
||
acmeHelper: 'Acme 계정은 무료 인증서를 신청하는 데 사용됩니다.',
|
||
upload: '가져오기',
|
||
applyType: '유형',
|
||
apply: '갱신',
|
||
applyStart: '인증서 신청 시작',
|
||
getDnsResolve: 'DNS 해석 값을 가져오는 중입니다. 잠시 기다려주세요...',
|
||
selfSigned: '자체 서명된 CA',
|
||
ca: '인증 기관',
|
||
commonName: '공통 이름',
|
||
caName: '인증 기관 이름',
|
||
company: '기관 이름',
|
||
department: '조직 단위 이름',
|
||
city: '지역 이름',
|
||
province: '주 또는 지방 이름',
|
||
country: '국가 이름 (2자리 코드)',
|
||
commonNameHelper: '예를 들어, ',
|
||
selfSign: '인증서 발급',
|
||
days: '유효 기간',
|
||
domainHelper: '줄당 하나의 도메인 이름, * 및 IP 주소 지원',
|
||
pushDir: '로컬 디렉토리로 인증서 푸시',
|
||
dir: '디렉토리',
|
||
pushDirHelper: '인증서 파일 "fullchain.pem" 및 키 파일 "privkey.pem"이 이 디렉토리에 생성됩니다.',
|
||
organizationDetail: '조직 세부 정보',
|
||
fromWebsite: '웹사이트에서 가져오기',
|
||
dnsMauanlHelper: '수동 해석 모드에서는 생성 후 신청 버튼을 클릭하여 DNS 해석 값을 얻어야 합니다.',
|
||
httpHelper:
|
||
'HTTP 모드를 사용하려면 OpenResty를 설치해야 하며, 와일드카드 도메인 인증서 신청을 지원하지 않습니다.',
|
||
buypassHelper: 'Buypass 는 중국 본토에서 접근할 수 없습니다.',
|
||
googleHelper: 'EAB HmacKey 및 EAB kid 를 얻는 방법',
|
||
googleCloudHelper: 'Google Cloud API 는 중국 본토 대부분에서 접근할 수 없습니다.',
|
||
skipDNSCheck: 'DNS 확인 건너뛰기',
|
||
skipDNSCheckHelper: '인증 요청 중 타임아웃 문제가 발생할 경우에만 선택하세요.',
|
||
cfHelper: 'Global API Key 를 사용하지 마세요.',
|
||
deprecated: '더 이상 지원되지 않습니다.',
|
||
deprecatedHelper:
|
||
'유지 관리가 중단되었으며 향후 버전에서 제외될 수 있습니다. Tencent Cloud 방법을 사용하여 분석하세요.',
|
||
dnsPodRemoved: '제거됨',
|
||
dnsPodRemovedTip:
|
||
'DnsPod는 lego v5에서 제거되었습니다. 이 계정은 인증서 신청/갱신에 사용할 수 없습니다. Tencent Cloud DNS 계정으로 전환해 주세요.',
|
||
dnsPodRemovedSSLTip:
|
||
'이 인증서에 연결된 DnsPod 계정은 lego v5에서 사용할 수 없습니다. 자동 갱신이 실패합니다. DNS 계정을 Tencent Cloud로 전환해 주세요.',
|
||
disableCNAME: 'CNAME 비활성화',
|
||
disableCNAMEHelper: '도메인 이름에 CNAME 레코드가 있고 요청이 실패할 경우 선택하세요.',
|
||
nameserver: 'DNS 서버',
|
||
nameserverHelper: '사용자 지정 DNS 서버를 사용하여 도메인 이름을 확인합니다.',
|
||
edit: '인증서 편집',
|
||
execShell: '인증 요청 후 스크립트 실행',
|
||
shell: '스크립트 내용',
|
||
shellHelper:
|
||
'스크립트의 기본 실행 디렉토리는 1Panel 설치 디렉토리입니다. 인증서가 로컬 디렉토리에 푸시되는 경우 실행 디렉토리는 인증서 푸시 디렉토리가 됩니다. 기본 실행 제한 시간은 30분입니다.',
|
||
customAcme: '사용자 정의 ACME 서비스',
|
||
customAcmeURL: 'ACME 서비스 URL',
|
||
baiduCloud: '바이두 클라우드',
|
||
pushNode: '다른 노드에 동기화',
|
||
pushNodeHelper: '신청/갱신 후 선택한 노드로 푸시',
|
||
fromMaster: '마스터 노드에서 푸시',
|
||
hostedZoneID: 'Hosted Zone ID',
|
||
isIP: 'IP 인증서',
|
||
useEAB: 'EAB 인증 사용',
|
||
},
|
||
firewall: {
|
||
create: '규칙 만들기',
|
||
edit: '규칙 수정',
|
||
ccDeny: 'CC 보호',
|
||
ipWhiteList: 'IP 허용 목록',
|
||
ipBlockList: 'IP 차단 목록',
|
||
fileExtBlockList: '파일 확장자 차단 목록',
|
||
urlWhiteList: 'URL 허용 목록',
|
||
urlBlockList: 'URL 차단 목록',
|
||
argsCheck: 'GET 파라미터 검사',
|
||
postCheck: 'POST 파라미터 검사',
|
||
cookieBlockList: '쿠키 차단 목록',
|
||
dockerHelper:
|
||
'현재 방화벽은 컨테이너 포트 매핑을 비활성화할 수 없습니다. 설치된 애플리케이션은 [설치됨] 페이지에서 애플리케이션 매개변수를 편집하고 포트 해제 규칙을 구성할 수 있습니다.',
|
||
iptablesHelper:
|
||
'시스템이 {0} 방화벽을 사용 중인 것으로 감지되었습니다. iptables로 전환하려면 먼저 수동으로 제거하세요!',
|
||
used: '사용됨',
|
||
unUsed: '사용 안 함',
|
||
dockerRestart: '방화벽 작업에는 Docker 서비스 재시작이 필요합니다',
|
||
firewallHelper: '{0} 시스템 방화벽',
|
||
firewallNotStart: '현재 시스템 방화벽이 활성화되지 않았습니다. 먼저 활성화하세요.',
|
||
restartFirewallHelper: '이 작업은 현재 방화벽을 재시작합니다. 계속하시겠습니까?',
|
||
stopFirewallHelper: '이 작업은 서버 보안을 잃게 만듭니다. 계속하시겠습니까?',
|
||
startFirewallHelper: '방화벽이 활성화되면 서버 보안이 강화됩니다. 계속하시겠습니까?',
|
||
noPing: 'Ping 비활성화',
|
||
enableBanPing: 'Ping 차단',
|
||
disableBanPing: 'Ping 차단 해제',
|
||
noPingTitle: 'Ping 비활성화',
|
||
noPingHelper: '이 작업은 Ping 을 비활성화하며 서버는 ICMP 응답을 보내지 않게 됩니다. 계속하시겠습니까?',
|
||
onPingHelper: '이 작업은 Ping 을 활성화하여 해커가 서버를 발견할 수 있습니다. 계속하시겠습니까?',
|
||
changeStrategy: '{0} 전략 변경',
|
||
changeStrategyIPHelper1:
|
||
'IP 주소 전략을 [거부]로 변경합니다. 설정 후 해당 IP 주소는 서버 접근이 차단됩니다. 계속하시겠습니까?',
|
||
changeStrategyIPHelper2:
|
||
'IP 주소 전략을 [허용]으로 변경합니다. 설정 후 해당 IP 주소는 정상적으로 접근할 수 있습니다. 계속하시겠습니까?',
|
||
changeStrategyPortHelper1:
|
||
'포트 정책을 [차단]으로 변경합니다. 설정 후 외부 접근이 차단됩니다. 계속하시겠습니까?',
|
||
changeStrategyPortHelper2:
|
||
'포트 정책을 [허용]으로 변경합니다. 설정 후 정상적으로 포트 접근이 복원됩니다. 계속하시겠습니까?',
|
||
stop: '정지',
|
||
portFormatError: '이 필드는 유효한 포트이어야 합니다.',
|
||
portHelper1: '여러 포트, 예: 8080, 8081',
|
||
portHelper2: '포트 범위, 예: 8080-8089',
|
||
changeStrategyHelper:
|
||
'[{1}] {0} 전략을 [{2}]로 변경합니다. 설정 후 {0}은(는) {2}로 외부 접근을 허용합니다. 계속하시겠습니까?',
|
||
strategy: '전략',
|
||
accept: '허용',
|
||
drop: '차단',
|
||
anyWhere: '어디든지',
|
||
address: '지정된 IP',
|
||
addressHelper: 'IP 주소 또는 IP 범위를 지원합니다.',
|
||
allow: '허용',
|
||
deny: '거부',
|
||
addressFormatError: '이 필드는 유효한 IP 주소여야 합니다.',
|
||
addressHelper1: "IP 주소 또는 IP 범위가 필요합니다. 예: '172.16.10.11' 또는 '172.16.10.0/24'.",
|
||
addressHelper2: "여러 IP 주소는 쉼표로 구분합니다. 예: '172.16.10.11, 172.16.0.0/24'.",
|
||
allIP: '모든 IP',
|
||
portRule: '규칙 | 규칙들',
|
||
forwardRule: '포트 전달 규칙 | 포트 전달 규칙들',
|
||
ipRule: 'IP 규칙 | IP 규칙들',
|
||
userAgent: 'User-Agent 필터',
|
||
sourcePort: '소스 포트',
|
||
targetIP: '대상 IP',
|
||
targetPort: '대상 포트',
|
||
forwardHelper1: "로컬 포트로 전달하려면, 대상 IP 를 '127.0.0.1'로 설정해야 합니다.",
|
||
forwardHelper2: '대상 IP 를 비워두면 로컬 포트로 전달됩니다.',
|
||
forwardPortHelper: '포트 범위를 지원합니다, 예: 8080-8089',
|
||
forwardInboundInterface: '포워딩 인바운드 네트워크 인터페이스',
|
||
exportHelper: '{0}개의 방화벽 규칙을 내보내려고 합니다. 계속하시겠습니까?',
|
||
importSuccess: '{0}개의 규칙을 성공적으로 가져왔습니다',
|
||
importPartialSuccess: '가져오기 완료: 성공 {0}건, 실패 {1}건',
|
||
ipv4Limit: '현재 작업은 IPv4 주소만 지원합니다',
|
||
basicStatus: '현재 체인 {0}이(가) 바인딩되지 않았습니다. 먼저 바인딩하세요!',
|
||
baseIptables: 'iptables 서비스',
|
||
forwardIptables: 'iptables 포트 포워딩 서비스',
|
||
advanceIptables: 'iptables 고급 구성 서비스',
|
||
initMsg: '{0}을(를) 초기화하려고 합니다. 계속하시겠습니까?',
|
||
initHelper: '{0}이(가) 초기화되지 않았습니다. 상단 상태 표시줄의 초기화 버튼을 클릭하여 구성하세요!',
|
||
bindHelper: '바인딩 - 방화벽 규칙은 상태가 바인딩된 경우에만 효과가 있습니다. 확인하시겠습니까?',
|
||
unbindHelper:
|
||
'바인딩 해제 - 바인딩 해제 시 추가된 모든 방화벽 규칙이 무효화됩니다. 주의하여 진행하세요. 확인하시겠습니까?',
|
||
whiteList: '화이트리스트',
|
||
portWhiteList: '포트 화이트리스트',
|
||
portWhiteListAlter: '방화벽을 초기화하거나 시작할 때 화이트리스트의 포트가 자동으로 허용됩니다.',
|
||
portWhiteListHelper: '80/tcp 또는 443/udp처럼 프로토콜을 지정할 수 있습니다. 생략하면 기본값은 tcp입니다.',
|
||
defaultStrategy: '현재 체인 {0}의 기본 정책은 {1}입니다',
|
||
defaultStrategy2:
|
||
'현재 체인 {0}의 기본 정책은 {1}입니다. 현재 상태는 바인딩되지 않았습니다. 추가된 방화벽 규칙은 바인딩 후에 효과가 발생합니다!',
|
||
filterRule: '필터 규칙',
|
||
filterHelper:
|
||
'필터 규칙을 사용하면 INPUT/OUTPUT 수준에서 네트워크 트래픽을 제어할 수 있습니다. 시스템 잠금을 방지하기 위해 주의하여 구성하세요.',
|
||
chain: '체인',
|
||
targetChain: '대상 체인',
|
||
sourceIP: '소스 IP',
|
||
destIP: '대상 IP',
|
||
inboundDirection: '인바운드 방향',
|
||
outboundDirection: '아웃바운드 방향',
|
||
destPort: '대상 포트',
|
||
action: '동작',
|
||
reject: '거부',
|
||
sourceIPHelper: 'CIDR 형식, 예: 192.168.1.0/24. 모든 주소의 경우 비워 둠',
|
||
destIPHelper: 'CIDR 형식, 예: 10.0.0.0/8. 모든 주소의 경우 비워 둠',
|
||
portHelper: '0은 모든 포트를 의미합니다',
|
||
allPorts: '모든 포트',
|
||
deleteRuleConfirm: '{0}개의 규칙을 삭제합니다. 계속하시겠습니까?',
|
||
advancedControl: '고급 제어',
|
||
advancedControlNotAvailable: '현재 {0} 방화벽 사용 중이며, 고급 규칙은 iptables만 지원합니다',
|
||
quickJump: '빠른 이동',
|
||
destination: '대상',
|
||
},
|
||
runtime: {
|
||
runtime: '실행 환경',
|
||
workDir: '작업 디렉토리',
|
||
localHelper: '로컬 환경 설치 및 오프라인 환경 사용 관련 문제는 다음을 참조하세요 ',
|
||
versionHelper: 'PHP 버전, 예: v8.0',
|
||
buildHelper:
|
||
'확장 기능이 많을수록 이미지 생성 시 CPU 사용량이 증가합니다. 환경 생성 후 확장 기능을 설치하는 것도 가능합니다.',
|
||
openrestyWarn: 'PHP는 OpenResty 버전 1.21.4.1 이상으로 업그레이드해야 사용 가능합니다.',
|
||
toupgrade: '업그레이드하기',
|
||
edit: '실행 환경 수정',
|
||
extendHelper:
|
||
'목록에 없는 확장 프로그램은 수동으로 입력하고 선택할 수 있습니다. 예를 들어 "sockets"를 입력한 후 드롭다운 목록에서 첫 번째 옵션을 선택하여 확장 목록을 확인하세요.',
|
||
rebuildHelper: '확장 기능을 수정한 후에는 PHP 애플리케이션을 재빌드해야 적용됩니다.',
|
||
rebuild: 'PHP 애플리케이션 재빌드',
|
||
source: 'PHP 확장 소스',
|
||
ustc: '중국과학기술대학',
|
||
netease: '네티이즈',
|
||
aliyun: '알리바바 클라우드',
|
||
default: '기본',
|
||
tsinghua: '칭화대학교',
|
||
xtomhk: 'XTOM 미러 사이트 (홍콩)',
|
||
xtom: 'XTOM 미러 사이트 (전 세계)',
|
||
phpsourceHelper: '네트워크 환경에 맞는 적절한 소스를 선택하세요.',
|
||
appPort: '앱 포트',
|
||
externalPort: '외부 포트',
|
||
packageManager: '패키지 관리자',
|
||
codeDir: '코드 디렉터리',
|
||
appPortHelper: '애플리케이션이 사용하는 포트.',
|
||
externalPortHelper: '외부에 노출된 포트.',
|
||
runScript: '실행 스크립트',
|
||
runScriptHelper: '시작 명령 목록은 소스 디렉터리의 package.json 파일에서 분석됩니다.',
|
||
open: '열기',
|
||
operatorHelper: '{0} 작업이 선택된 운영 환경에서 수행됩니다. 계속하시겠습니까?',
|
||
taobao: '타오바오',
|
||
tencent: '텐센트',
|
||
imageSource: '이미지 소스',
|
||
moduleManager: '모듈 관리',
|
||
module: '모듈',
|
||
nodeOperatorHelper:
|
||
'{0} {1} 모듈인가요? 이 작업은 운영 환경에 비정상을 일으킬 수 있으므로 진행 전에 확인해 주세요.',
|
||
customScript: '사용자 정의 시작 명령',
|
||
customScriptHelper:
|
||
'전체 시작 명령어를 입력해 주세요. 예: npm run start. PM2 시작 명령어는 pm2-runtime로 변경해 주세요. 그렇지 않으면 시작에 실패합니다.',
|
||
portError: '포트를 중복 사용하지 마세요.',
|
||
systemRestartHelper: '상태 설명: 중단 - 시스템 재시작으로 인해 상태 가져오기가 실패했습니다.',
|
||
javaScriptHelper: '전체 시작 명령을 제공하세요. 예: "java -jar halo.jar -Xmx1024M -Xms256M".',
|
||
javaDirHelper: '디렉터리는 jar 파일을 포함해야 하며, 하위 디렉터리도 허용됩니다.',
|
||
goHelper: '전체 시작 명령을 제공하세요. 예: "go run main.go" 또는 "./main".',
|
||
goDirHelper: '디렉터리 또는 하위 디렉터리는 Go 또는 바이너리 파일을 포함해야 합니다.',
|
||
pythonHelper:
|
||
'전체 시작 명령을 제공하세요. 예: "pip install -r requirements.txt && python manage.py runserver 0.0.0.0:5000".',
|
||
dotnetHelper: '완전한 시작 명령을 입력하세요. 예: dotnet MyWebApp.dll',
|
||
dirHelper: '주의: 컨테이너 내의 디렉토리 경로를 입력하세요',
|
||
concurrency: '동시성 체계',
|
||
loadStatus: '부하 상태',
|
||
extraHosts: '호스트 매핑',
|
||
extension: '확장',
|
||
installExtension: '확장 {0} 설치를 확인하시겠습니까',
|
||
loadedExtension: '로드된 확장',
|
||
popularExtension: '인기 확장',
|
||
uninstallExtension: '확장 {0}을(를) 제거하시겠습니까',
|
||
phpConfigHelper: '설정 변경 후 운영 환경 재시작이 필요합니다. 계속하시겠습니까',
|
||
operateMode: '운영 모드',
|
||
dynamic: '동적',
|
||
static: '고정',
|
||
ondemand: '온디맨드',
|
||
dynamicHelper: '프로세스 수를 동적으로 조정합니다. 트래픽 변동이 크거나 메모리가 적은 사이트에 적합합니다',
|
||
staticHelper: '프로세스 수를 고정합니다. 고동시성·안정 트래픽 사이트에 적합하지만 자원 소모가 큽니다',
|
||
ondemandHelper: '필요 시 프로세스를 시작/종료합니다. 자원 효율은 좋지만 초기 응답이 느릴 수 있습니다',
|
||
max_children: '생성 가능한 최대 프로세스 수',
|
||
start_servers: '시작 시 생성되는 프로세스 수',
|
||
min_spare_servers: '최소 유휴 프로세스 수',
|
||
max_spare_servers: '최대 유휴 프로세스 수',
|
||
envKey: '이름',
|
||
envValue: '값',
|
||
environment: '환경 변수',
|
||
},
|
||
process: {
|
||
pid: '프로세스 ID',
|
||
ppid: '부모 PID',
|
||
numThreads: '스레드',
|
||
memory: '메모리',
|
||
diskRead: '디스크 읽기',
|
||
diskWrite: '디스크 쓰기',
|
||
netSent: '업링크',
|
||
netRecv: '다운스트림',
|
||
numConnections: '연결',
|
||
startTime: '시작 시간',
|
||
state: '상태',
|
||
running: '실행 중',
|
||
sleep: '대기 중',
|
||
stop: '중지',
|
||
idle: '유휴',
|
||
zombie: '좀비 프로세스',
|
||
wait: '대기',
|
||
lock: '잠금',
|
||
blocked: '차단됨',
|
||
cmdLine: '시작 명령',
|
||
basic: '기본',
|
||
mem: '메모리',
|
||
openFiles: '열린 파일',
|
||
env: '환경 변수',
|
||
noenv: '없음',
|
||
net: '네트워크 연결',
|
||
laddr: '출발지 주소/포트',
|
||
raddr: '목적지 주소/포트',
|
||
stopProcess: '종료',
|
||
viewDetails: '세부 사항',
|
||
stopProcessWarn: '이 프로세스(PID:{0})를 종료하시겠습니까?',
|
||
kill: '프로세스 종료',
|
||
killNow: '즉시 종료',
|
||
killHelper:
|
||
'프로세스 {0}을(를) 종료하면 일부 프로그램이 정상적으로 작동하지 않을 수 있습니다. 계속하시겠습니까?',
|
||
processName: '프로세스 이름',
|
||
},
|
||
tool: {
|
||
supervisor: {
|
||
loadStatusErr: '프로세스 상태를 가져오지 못했습니다. supervisor 서비스의 상태를 확인하세요.',
|
||
notSupport: 'Supervisor 서비스를 감지하지 못했습니다. 스크립트 라이브러리 페이지에서 수동으로 설치하세요',
|
||
list: '데몬 프로세스 | 데몬 프로세스들',
|
||
config: 'Supervisor 설정',
|
||
primaryConfig: '주 설정 파일 위치',
|
||
notSupportCtl: 'supervisorctl 이 감지되지 않았습니다. 스크립트 라이브러리 페이지에서 수동으로 설치하세요.',
|
||
user: '사용자',
|
||
command: '명령어',
|
||
dir: '디렉토리',
|
||
numprocs: '프로세스 수',
|
||
initWarn:
|
||
'이 작업은 주 설정 파일의 "[include]" 섹션에 있는 "files" 값을 수정합니다. 다른 설정 파일의 디렉토리는 "{1Panel 설치 디렉토리}/1panel/tools/supervisord/supervisor.d/"입니다.',
|
||
operatorHelper: '{1} 작업을 {0}에서 수행합니다. 계속하시겠습니까?',
|
||
uptime: '운영 시간',
|
||
notStartWarn: 'Supervisor 가 시작되지 않았습니다. 먼저 시작하세요.',
|
||
serviceName: '서비스 이름',
|
||
initHelper:
|
||
'Supervisor 서비스가 감지되었지만 초기화되지 않았습니다. 상단 상태 표시줄의 초기화 버튼을 클릭하여 구성하세요.',
|
||
serviceNameHelper: 'systemctl 로 관리되는 Supervisor 서비스 이름, 보통 supervisor 또는 supervisord입니다.',
|
||
restartHelper:
|
||
'이 작업은 초기화 후 서비스를 재시작합니다. 이로 인해 기존의 모든 데몬 프로세스가 중지됩니다.',
|
||
RUNNING: '실행 중',
|
||
STOPPED: '중지됨',
|
||
STOPPING: '중지 중',
|
||
STARTING: '시작 중',
|
||
FATAL: '시작 실패',
|
||
BACKOFF: '시작 예외',
|
||
ERROR: '오류',
|
||
statusCode: '상태 코드',
|
||
manage: '관리',
|
||
autoRestart: '자동 재시작',
|
||
EXITED: '종료됨',
|
||
autoRestartHelper: '프로그램이 비정상적으로 종료된 후 자동으로 재시작할지 여부',
|
||
autoStart: '자동 시작',
|
||
autoStartHelper: 'Supervisor 시작 후 서비스를 자동으로 시작할지 여부',
|
||
},
|
||
},
|
||
disk: {
|
||
management: '디스크 관리',
|
||
partition: '파티션',
|
||
unmount: '마운트 해제',
|
||
unmountHelper: '파티션 {0} 을(를) 마운트 해제하시겠습니까?',
|
||
mount: '마운트',
|
||
partitionAlert:
|
||
'디스크 파티션 작업은 디스크 포맷이 필요하며, 기존 데이터는 삭제됩니다. 데이터를 미리 저장하거나 스냅샷을 찍어주세요.',
|
||
mountPoint: '마운트 디렉토리',
|
||
systemDisk: '시스템 디스크',
|
||
unpartitionedDisk: '미파티션 디스크',
|
||
handlePartition: '지금 파티션',
|
||
filesystem: '파일 시스템',
|
||
unmounted: '마운트 해제됨',
|
||
cannotOperate: '작업 불가',
|
||
systemDiskHelper: '힌트: 현재 디스크는 시스템 디스크입니다. 작업할 수 없습니다.',
|
||
autoMount: '자동 마운트',
|
||
model: '장치 모델',
|
||
diskType: '디스크 유형',
|
||
serial: '시리얼 번호',
|
||
noFail: '마운트 실패는 시스템 시작에 영향을 미치지 않습니다',
|
||
},
|
||
xpack: {
|
||
ldap: {
|
||
source: '소스',
|
||
directoryMissing: 'LDAP에 없음',
|
||
localCredentialsManaged:
|
||
'이 사용자의 사용자 이름과 비밀번호는 LDAP에서 관리되므로 로컬에서 변경할 수 없습니다.',
|
||
sources: {
|
||
local: '로컬',
|
||
ldap: 'LDAP',
|
||
},
|
||
importUsers: 'AD/LDAP 사용자 가져오기',
|
||
searchUsersPlaceholder: '사용자 이름 검색',
|
||
readFromLDAP: 'LDAP에서 읽기',
|
||
selectedUsers: '{0} 선택됨',
|
||
queriedAt: '읽기 시간',
|
||
cachedResult: '캐시된 결과',
|
||
roleForNewUsers: '신규 사용자의 역할',
|
||
selectRole: '역할 선택',
|
||
roleOnlyForNewUsers: '가져오기를 통해 사용자가 생성되는 경우에만 역할이 필요합니다.',
|
||
roleRequiredForNewUsers: '새로운 LDAP 사용자의 역할을 선택합니다.',
|
||
changedFields: '변경된 필드',
|
||
importSelected: '선택 항목 가져오기',
|
||
importAll: '모두 가져오기',
|
||
importPreview: 'AD/LDAP 가져오기 미리보기',
|
||
importCompleted: 'AD/LDAP 가져오기 완료',
|
||
incompletePreview: 'LDAP 디렉터리 읽기가 완료되지 않았습니다. LDAP에서 다시 읽어보세요.',
|
||
missingUsersWarning: 'LDAP에서 누락된 사용자는 엄격한 동기화로 인해 비활성화됩니다.',
|
||
missingUsersWarningDetail: '{0} 로컬 LDAP 사용자는 더 이상 로그인할 수 없습니다.',
|
||
action: '액션',
|
||
reason: '이유',
|
||
noImportChanges: '가져오기 변경사항 없음',
|
||
confirmImport: '가져오기 확인',
|
||
created: '만들기',
|
||
updated: '업데이트',
|
||
reactivated: '재활성화',
|
||
unchanged: '변경되지 않음',
|
||
conflicts: '충돌',
|
||
missing: '누락',
|
||
missingUsersConfirm: 'LDAP에서 누락된 {0}명의 사용자를 비활성화하고 로그아웃합니다. 계속하시겠습니까?',
|
||
strictSyncConfirm: '엄격한 동기화 확인',
|
||
status: {
|
||
importable: '신규 사용자',
|
||
update_available: '업데이트 가능',
|
||
up_to_date: '최신',
|
||
conflict: '충돌',
|
||
},
|
||
fields: {
|
||
name: '사용자 이름',
|
||
externalDN: '디렉토리 DN',
|
||
externalID: '외부 ID',
|
||
authSourceStatus: '인증 상태',
|
||
},
|
||
actions: {
|
||
created: '만들기',
|
||
updated: '업데이트',
|
||
reactivated: '재활성화',
|
||
unchanged: '변경되지 않음',
|
||
skipped: '건너뛰었습니다.',
|
||
conflicts: '충돌',
|
||
conflict: '충돌',
|
||
missing: '비활성화',
|
||
errors: '오류',
|
||
error: '오류',
|
||
},
|
||
},
|
||
expiresEnterpriseAlert:
|
||
'친절한 알림: 귀하의 Enterprise Edition 라이선스가 {0}일 후 만료되며, 모든 Enterprise Edition 기능에 더 이상 접근할 수 없습니다. 지속적인 사용을 위해 신속하게 갱신하시기 바랍니다.',
|
||
expiresProAlert:
|
||
'친절한 알림: 귀하의 Pro Edition 라이선스가 {0}일 후 만료되며, 모든 Pro Edition 기능에 더 이상 접근할 수 없습니다. 지속적인 사용을 위해 신속하게 갱신하시기 바랍니다.',
|
||
menu: 'Pro',
|
||
upage: 'AI 웹사이트 빌더',
|
||
proAlert: '이 기능을 사용하려면 상용 버전으로 업그레이드하세요',
|
||
opsReport: {
|
||
name: '운영 보고서',
|
||
overview: '개요',
|
||
system: '호스트 실행',
|
||
login: '로그인 및 보안',
|
||
website: '웹사이트 보호',
|
||
resource: '실행 리소스',
|
||
cronjob: '예약 작업',
|
||
alert: '알림 통보',
|
||
history: '내보내기 기록',
|
||
setting: '설정',
|
||
page: {
|
||
enterprise: '엔터프라이즈',
|
||
reportNode: '보고서 노드',
|
||
selectReportNode: '보고서 노드 선택',
|
||
currentNode: '현재 노드',
|
||
scoreMeta: '감점 {0}점 · 위험 {1}건',
|
||
hostAddress: '호스트 주소',
|
||
panelVersion: '패널 버전',
|
||
cpuCores: '물리 코어',
|
||
coreUnit: '{0}코어',
|
||
memoryTotal: '메모리 총량',
|
||
reportDate: '보고서 날짜',
|
||
serverSecurityOverview: '서버 보안 운영 개요',
|
||
securityScore: '보안 점수',
|
||
overviewSummary: '현재 보안 등급: {0}. 총 감점 {1}점, {2}개 위험 항목 발견, {3}개 검사 대상 포함.',
|
||
riskDistribution: '위험 분포',
|
||
totalDeducted: '총 감점',
|
||
noRiskDeducted: '미감점',
|
||
scoreTrend: '점수 추이',
|
||
scoreLevelSafe: '안전',
|
||
scoreLevelAttention: '주의 필요',
|
||
scoreLevelMediumRisk: '중위험',
|
||
scoreLevelHighRisk: '고위험',
|
||
scoreCategoryHost: '호스트 리소스',
|
||
scoreCategoryLogin: '로그인 보안',
|
||
scoreCategoryWebsite: '웹사이트 및 인증서',
|
||
scoreCategoryCronjob: '예약 작업',
|
||
scoreCategoryResource: '런타임 리소스',
|
||
scoreDiskHigh: '디스크 {0} 사용률 {1}%',
|
||
scoreDiskMedium: '디스크 {0} 사용률 {1}%',
|
||
scoreResourceHigh: '{0} 현재 사용률 {1}%',
|
||
scoreResourceMedium: '{0} 현재 사용률 {1}%',
|
||
scoreLoadMedium: '현재 부하 {0}',
|
||
scoreMonitorDisabled: '호스트 모니터링 미활성화',
|
||
scorePanelLoginFailedHigh: '패널 로그인 실패 {0}회',
|
||
scorePanelLoginFailedMedium: '패널 로그인 실패 {0}회',
|
||
scoreSSHLoginFailedHigh: 'SSH 로그인 실패 {0}회',
|
||
scoreSSHLoginFailedMedium: 'SSH 로그인 실패 {0}회',
|
||
scoreMFADisabled: 'MFA 미활성화',
|
||
scoreAllowIPsOpen: '허용 IP 및 바인딩 도메인이 미구성되었거나 접근 제한이 설정되지 않음',
|
||
scorePanelHTTPSDisabled: '패널 HTTPS 미활성화',
|
||
scoreSSHRootLogin: 'SSH Root 로그인 허용됨',
|
||
scoreSSHPasswordAuth: 'SSH 비밀번호 인증 활성화, 키 인증 미활성화',
|
||
scoreSSLHigh: '{0} 인증서 만료까지 {1}일 남음',
|
||
scoreSSLMedium: '{0} 인증서 만료까지 {1}일 남음',
|
||
scoreWebsiteExpire: '{0} 웹사이트 만료까지 {1}일 남음',
|
||
scoreWebsiteHTTP: '{0} HTTPS 미사용',
|
||
scoreWebsiteStopped: '{0} 상태 비정상',
|
||
scoreWebsiteMonitorUnavailable: '웹사이트 모니터링에서 사용 불가 사이트 감지',
|
||
scoreWebsiteMonitorAvailability: '웹사이트 모니터링 가용률 {0}%가 임계값 미달',
|
||
scoreWebsiteMonitorStatusAbnormal:
|
||
'웹사이트 모니터링이 활성화되었지만 초기화되지 않았거나 비정상 상태입니다',
|
||
scoreWafDisabled: 'WAF 미활성화, 웹사이트 보호 미적용',
|
||
scoreWafHighRiskHit: 'WAF 보고 기간 내 {0}개 위험 규칙 매칭',
|
||
scoreCronjobFailed: '최근 7일간 {0}건의 예약 작업 실패 기록',
|
||
scoreAppFailed: '{0} 애플리케이션 비정상',
|
||
scoreAppStopped: '{0} 애플리케이션 중지됨',
|
||
scoreContainerHigh: '{0} 컨테이너 상태 비정상',
|
||
scoreContainerExited: '{0} 컨테이너 중지됨',
|
||
scoreContainerResource: '{0} 컨테이너 리소스 사용량 과다',
|
||
scoreContainerPublicPort: '{0} 컨테이너에 공개 포트가 있습니다',
|
||
attentionItems: '주의 필요 항목',
|
||
attentionAssets: '주의 필요 자산',
|
||
riskItems: '위험 항목',
|
||
object: '대상',
|
||
description: '설명',
|
||
itemUnit: '건',
|
||
recordUnit: '건',
|
||
certUnit: '매',
|
||
containerUnit: '개',
|
||
loginFailed: '로그인 실패',
|
||
sslExpire: '인증서 만료',
|
||
abnormalContainer: '비정상 컨테이너',
|
||
statAttentionDesc: '현재 총 감점 {0}점',
|
||
statLoginDesc: '패널 {0}건 · SSH {1}건',
|
||
statSslDesc: '총 {0}매 인증서 검사',
|
||
statContainerDesc: '총 {0}개 컨테이너 검사',
|
||
assetHostDesc: '디스크 최대 사용률 {0}%',
|
||
assetWebsiteDesc: '{0}매 인증서 만료 임박, {1}개 웹사이트 상태 비정상',
|
||
assetResourceDesc: '{0}개 앱 비정상, {1}개 컨테이너 비정상',
|
||
assetCronjobDesc: '최근 7일간 {0}건 실패 기록, {1}개 작업 미활성화',
|
||
app: '애플리케이션',
|
||
website: '웹사이트',
|
||
websiteSsl: '웹사이트 / 인증서',
|
||
cronjob: '예약 작업',
|
||
container: '컨테이너',
|
||
sslCertificate: 'SSL 인증서',
|
||
loginSecurity: '로그인 보안',
|
||
panelLogin: '패널 로그인',
|
||
sshLogin: 'SSH 로그인',
|
||
failedRecord: '실패 기록',
|
||
expiredDays: '{0}일 전 만료',
|
||
remainingDays: '{0} · {1}일 남음',
|
||
enabled: '활성화',
|
||
disabled: '비활성화',
|
||
exportRecordFailed: '내보내기 기록 저장 실패',
|
||
hostInfo: '호스트 정보',
|
||
hostname: '호스트명',
|
||
osVersion: '시스템 버전',
|
||
kernelVersion: '커널 버전',
|
||
arch: '아키텍처',
|
||
uptime: '가동 시간',
|
||
diskUsage: '디스크 사용량',
|
||
mountPoint: '마운트 포인트',
|
||
device: '장치',
|
||
capacity: '용량',
|
||
used: '사용량',
|
||
usageRate: '사용률',
|
||
memory: '메모리',
|
||
load: '부하',
|
||
maxDiskUsage: '디스크 최대 사용률',
|
||
panelLoginSecurity: '패널 로그인 보안 설정',
|
||
sshSecurity: 'Linux 서버 SSH 보안 설정',
|
||
panelFailedRecords: '패널 로그인 실패 기록',
|
||
sshFailedRecords: 'SSH 로그인 실패 기록',
|
||
location: '소재지',
|
||
configItem: '설정 항목',
|
||
currentValue: '현재 값',
|
||
securityEntrance: '보안 입구',
|
||
configured: '구성됨',
|
||
notConfigured: '미구성',
|
||
normal: '정상',
|
||
needAttention: '주의 필요',
|
||
allowIPs: '허용 IP',
|
||
restricted: '제한됨',
|
||
unrestricted: '미제한',
|
||
bindDomain: '바인딩 도메인',
|
||
accessRestriction: '접근 제한',
|
||
panelHTTPS: '패널 HTTPS',
|
||
passwordComplexity: '비밀번호 복잡도',
|
||
sshService: 'SSH 서비스',
|
||
running: '실행 중',
|
||
notRunning: '미실행',
|
||
listenPort: '리스닝 포트',
|
||
read: '읽기 완료',
|
||
rootLogin: 'Root 로그인',
|
||
passwordAuth: '비밀번호 인증',
|
||
keyAuth: '키 인증',
|
||
panelLoginFailed: '패널 로그인 실패',
|
||
sshLoginFailed: 'SSH 로그인 실패',
|
||
panelSecurityItems: '패널 보안 항목',
|
||
sshSecurityItems: 'SSH 보안 항목',
|
||
loginSecurityHealthStatus: '로그인 보안 상태',
|
||
adjustSSHSecurity: 'SSH 보안 조정',
|
||
viewLoginLogs: '로그인 로그 보기',
|
||
riskLevel: '위험 등급',
|
||
goConfig: '설정하기',
|
||
viewMore: '더 보기',
|
||
involvedIPs: '{0}개 IP 관련',
|
||
sessionTimeout: '세션 타임아웃',
|
||
countUnit: '회',
|
||
recent24Hours: '최근 24시간',
|
||
currentService: '현재 서비스',
|
||
riskItemsExist: '{0}개 위험 항목 존재',
|
||
loginHealthRiskDesc: '{0}개의 위험 설정이 감지되었습니다. 로그인 보안을 강화하여 침입 위험을 낮추세요.',
|
||
loginHealthNormalDesc: '현재 로그인 및 SSH 보안 설정이 정상 상태입니다',
|
||
loginHealthNormalReason: '로그인 보안 설정 정상',
|
||
securityEntranceConfiguredDesc: '보안 입구가 구성되어 기본 입구 노출 위험이 감소됩니다',
|
||
securityEntranceRiskDesc: '보안 입구 미개방, 기본 로그인 입구를 숨기는 것을 권장합니다',
|
||
allowIPsRestrictedDesc: '패널 접근 허용 IP가 제한되어 있습니다',
|
||
allowIPsRiskDesc: '접근 IP가 제한되지 않았습니다. 공인 환경에서는 허용 IP 구성을 권장합니다',
|
||
bindDomainRestrictedDesc: '접근 도메인이 바인딩되어 있습니다',
|
||
bindDomainRiskDesc: '접근 도메인이 바인딩되지 않았습니다. 고정 도메인 접근 제한을 권장합니다',
|
||
accessRestrictionValue: '허용 IP: {0} / 바인딩 도메인: {1}',
|
||
accessRestrictionNormalDesc: '허용 IP 또는 바인딩 도메인이 구성되어 패널 접근 경로가 제한됩니다',
|
||
accessRestrictionRiskDesc:
|
||
'허용 IP와 바인딩 도메인이 모두 미구성되었거나 접근 제한이 없습니다. 최소 하나의 설정을 권장합니다',
|
||
panelHTTPSNormalDesc: '패널 HTTPS가 활성화되어 있습니다',
|
||
panelHTTPSRiskDesc: '패널 HTTPS가 비활성화되어 있습니다. 로그인 구간의 평문 노출 위험이 있습니다',
|
||
passwordComplexityNormalDesc: '비밀번호 복잡도 검증이 활성화되어 있습니다',
|
||
passwordComplexityRiskDesc:
|
||
'비밀번호 복잡도 검증이 비활성화되어 있습니다. 약한 비밀번호 위험이 높습니다',
|
||
mfa: 'MFA 인증',
|
||
mfaNormalDesc: 'MFA 인증이 활성화되어 로그인 보안이 강화됩니다',
|
||
mfaRiskDesc: 'MFA 인증이 비활성화되어 있습니다. 다중 인증 활성화를 권장합니다',
|
||
sessionTimeoutNormalDesc: '세션 타임아웃이 안전한 범위 내에 있습니다',
|
||
sessionTimeoutRiskDesc: '세션 타임아웃이 깁니다. 유휴 세션 유효기간을 제한하는 것을 권장합니다',
|
||
sshServiceNormalDesc: 'SSH 서비스가 정상 실행 중입니다',
|
||
sshServiceRiskDesc: 'SSH 서비스가 실행되지 않거나 상태가 비정상입니다',
|
||
sshPortNormalDesc: 'SSH 포트가 기본 포트에서 변경되었습니다',
|
||
sshPortRiskDesc: '기본 22 포트를 사용 중입니다. 필요에 따라 변경을 권장합니다',
|
||
rootLoginNormalDesc: 'Root 사용자가 직접 로그인할 수 없습니다',
|
||
rootLoginRiskDesc: 'Root 사용자가 직접 로그인할 수 있습니다. 비활성화를 권장합니다',
|
||
passwordAuthNormalDesc: 'SSH 비밀번호 로그인이 비활성화되어 있습니다',
|
||
passwordAuthRiskDesc: '비밀번호 로그인이 허용되어 있습니다. 무차별 대입 공격 위험이 높습니다',
|
||
keyAuthNormalDesc: 'SSH 키 인증이 활성화되어 있습니다',
|
||
keyAuthRiskDesc: '키 인증이 비활성화되어 있습니다. 키 기반 로그인을 권장합니다',
|
||
websiteOverview: '웹사이트 개요',
|
||
primaryDomain: '주 도메인',
|
||
expireTime: '만료 시간',
|
||
domain: '도메인',
|
||
issuer: '발급 기관',
|
||
autoRenew: '자동 갱신',
|
||
websiteCount: '웹사이트 수',
|
||
httpsWebsite: 'HTTPS 웹사이트',
|
||
certCount: '인증서 수',
|
||
websiteExpire: '웹사이트 만료',
|
||
database: '데이터베이스',
|
||
remoteDatabase: '원격 데이터베이스',
|
||
address: '주소',
|
||
containerResourceUsage: '컨테이너 리소스 사용량',
|
||
spaceUsage: '사용 공간',
|
||
reclaimable: '회수 가능',
|
||
containerReclaimable: '컨테이너 회수 가능',
|
||
image: '이미지',
|
||
volume: '데이터 볼륨',
|
||
buildCache: '빌드 캐시',
|
||
alert: '알림',
|
||
alertConfigured: '알림 구성됨',
|
||
alertOperations: '알림 통보',
|
||
alertTaskCount: '알림 작업',
|
||
enabledAlertTask: '활성 작업',
|
||
disabledAlertTask: '중지 작업',
|
||
alertChannels: '통보 채널',
|
||
alertLogCount: '알림 로그',
|
||
alertSuccessRate: '알림 성공률',
|
||
alertFailedLogs: '실패 알림 로그',
|
||
alertPendingLogs: '동기화 대기 로그',
|
||
alertPending: '동기화 대기',
|
||
alertTaskStats: '알림 작업 통계',
|
||
alertTaskType: '알림 유형',
|
||
alertLogStatusStats: '알림 실행 상태',
|
||
alertHealthNormal: '정상',
|
||
alertHealthAttention: '주의 필요',
|
||
alertHealthRisk: '고위험',
|
||
alertHealthSummary: '알림 건강 상태',
|
||
alertHealthNormalReason: '알림 작업, 통보 채널, 실행 로그가 모두 정상 상태입니다',
|
||
alertNoChannelReason: '활성화된 통보 채널이 없습니다',
|
||
alertFailedLogReason: '{0}건의 실패 로그가 존재합니다',
|
||
alertPendingReason: '{0}건의 알림 로그가 동기화 대기 중입니다',
|
||
alertDisabledTaskReason: '{0}개의 알림 작업이 중지되었습니다',
|
||
alertNoTaskReason: '구성된 알림 작업이 없습니다',
|
||
goAlertConfig: '알림 설정',
|
||
goAlertLogs: '알림 로그',
|
||
configureAlertChannel: '통보 채널 설정',
|
||
createAlertTask: '알림 작업 생성',
|
||
viewAlertTasks: '알림 작업 보기',
|
||
viewFailedAlertLogs: '실패 로그 보기',
|
||
viewAlertLogs: '알림 로그 보기',
|
||
alertChannelSummary: '{0} / {1}개 채널 활성화',
|
||
alertTaskEnabledDesc: '{0}개 작업 활성화',
|
||
alertTaskSummary: '활성 {0}개, 중지 {1}개',
|
||
alertLogSummary: '성공 {0}건, 실패 {1}건',
|
||
alertPendingDesc: '{0}건의 로그 동기화 대기 중',
|
||
alertLogSuccessDesc: '통보 완료',
|
||
alertLogFailedDesc: '채널 설정 또는 전송 경로를 확인하세요',
|
||
alertLogPendingDesc: '오프라인 또는 동기화 경로 대기 중',
|
||
failedAlertLogs: '실패 알림 로그',
|
||
disabledAlertTasks: '중지된 알림 작업',
|
||
alertTableDisplayDesc: '현재 {0}건 표시, 총 {1}건',
|
||
alertMsg: '알림 내용',
|
||
alertMethod: '알림 방식',
|
||
alertRule: '알림 규칙',
|
||
noAlertTask: '알림 작업이 없습니다',
|
||
noFailedAlertLog: '실패 알림 로그가 없습니다',
|
||
noDisabledAlertTask: '중지된 알림 작업이 없습니다',
|
||
alertCronjobType: '예약 작업: {0}',
|
||
alertAllTargets: '전체 대상',
|
||
alertAllDisks: '전체 디스크',
|
||
alertAllCertificates: '전체 인증서',
|
||
alertAllWebsites: '전체 웹사이트',
|
||
alertDiskRuleShort: '{0} {1}{2} 초과, 매일 {3}회',
|
||
alertAverageRuleShort: '{0}분 평균 {1}% 초과, 매일 {2}회',
|
||
alertTimeRuleShort: '{0}일 이내 트리거, {1}회 전송',
|
||
alertSendCountRuleShort: '매일 {0}회 전송',
|
||
alertConfigInvalid: '설정 비정상',
|
||
scoreCategoryAlert: '알림 통보',
|
||
scoreAlertNoTask: '구성된 알림 작업이 없습니다',
|
||
scoreAlertNoEnabledTask: '모든 알림 작업이 비활성화되었습니다',
|
||
scoreAlertDisabledTask: '{0}개의 알림 작업이 중지되었습니다',
|
||
scoreAlertNoChannel: '활성화된 알림 통보 채널이 없습니다',
|
||
scoreAlertFailedHigh: '{0}건의 알림 실패 로그가 존재합니다',
|
||
scoreAlertFailedMedium: '{0}건의 알림 실패 로그가 존재합니다',
|
||
scoreAlertPending: '{0}건의 알림 로그가 동기화 대기 중입니다',
|
||
statAlertDesc: '활성 작업 {0}개 · 채널 {1}개',
|
||
assetAlertDesc: '실패 로그 {0}건, 동기화 대기 {1}건',
|
||
failedExecutionRecords: '실패 실행 기록',
|
||
taskID: '작업 ID',
|
||
executeTime: '실행 시간',
|
||
backupTasks: '백업 작업',
|
||
systemMetrics: '실행 지표',
|
||
cpu: 'CPU',
|
||
thresholdPercent: '임계값 {0}%',
|
||
recent24HourPeakPercent: '최근 24시간 피크 {0}',
|
||
loadAverage: '1 / 5 / 15분 부하: {0} / {1} / {2}',
|
||
sourceMount: '마운트 포인트 {0}',
|
||
storageUsage: '저장 공간 사용량',
|
||
localDisk: '로컬 디스크',
|
||
highUsagePeriods: '고부하 시간대',
|
||
timeRange: '시간 범위',
|
||
threshold: '임계값',
|
||
duration: '지속 시간',
|
||
peak: '피크',
|
||
scoring: '점수 산정',
|
||
counted: '산정됨',
|
||
notCounted: '미산정',
|
||
dataSource: '데이터 소스',
|
||
noHighUsagePeriod: '고부하 시간대가 없습니다',
|
||
monitorDisabledOrNoData: '호스트 모니터링이 미활성화되었거나 모니터 데이터가 없습니다',
|
||
systemHealthStatus: '최근 24시간 호스트 실행 위험 상태',
|
||
mainReasons: '주요 원인',
|
||
viewHostMonitor: '호스트 모니터 보기',
|
||
systemHealthAttentionDesc:
|
||
'최근 24시간 동안 {0}개의 위험 항목이 감지되었습니다. 리소스 피크와 디스크 사용률을 우선 확인하세요.',
|
||
systemHealthNormalDesc: '최근 24시간 호스트 실행 지표가 정상 상태입니다',
|
||
monitorEnabled: '모니터링 활성화됨',
|
||
cpuCoreUsage: '{0} / {1}코어',
|
||
load1Minute: '1분 부하',
|
||
diskSpaceUsage: '디스크 공간 사용량',
|
||
usedCapacity: '사용량 / 총 용량',
|
||
fileSystem: '파일 시스템',
|
||
resourceTrendSummary: '리소스 추이 요약',
|
||
last24Hours: '최근 24시간',
|
||
granularityHour: '단위: 1시간',
|
||
current: '현재',
|
||
average: '평균',
|
||
totalItems: '총 {0}건',
|
||
to: '~',
|
||
hoursShort: '{0}시간',
|
||
minutesShort: '{0}분',
|
||
websiteStatus: '웹사이트 상태',
|
||
websiteHealthStatus: '웹사이트 보호 건강 상태',
|
||
websiteHealthNormalReason: '웹사이트, 인증서, WAF, 웹사이트 모니터링이 모두 정상입니다',
|
||
websiteHealthAttentionDesc:
|
||
'{0}개의 위험 항목이 감지되었습니다. 웹사이트 보안과 가용성을 위해 신속히 처리하세요.',
|
||
websiteHealthNormalDesc: '현재 웹사이트 보호 지표가 정상 상태입니다',
|
||
handleSslRisk: '인증서 위험 처리',
|
||
viewWaf: 'WAF 보기',
|
||
priority: '우선순위',
|
||
riskDescription: '위험 설명',
|
||
deductScore: '감점 점수',
|
||
remaining: '잔여',
|
||
wafSourceIpTop: 'WAF 차단 출처 IP TOP5',
|
||
wafAffectedSiteTop: '영향받은 사이트 TOP5',
|
||
sslRisk: '인증서 위험',
|
||
sslExpiring: '인증서 만료 임박',
|
||
includedInReport: '보고서 포함',
|
||
needRenewal: '갱신 권장',
|
||
fromExpireInfo: '만료 정보 기반',
|
||
runningWebsite: '실행 중 웹사이트',
|
||
fromWebsiteStatus: '웹사이트 목록 상태 기반',
|
||
stoppedWebsite: '중지된 웹사이트',
|
||
confirmStoppedWebsite: '예상된 상태인지 확인하세요',
|
||
expiringWebsite: '만료 임박 웹사이트',
|
||
expiringSoon: '만료 임박',
|
||
none: '없음',
|
||
noSslRisk: '처리할 인증서가 없습니다',
|
||
websiteProtection: 'WAF 및 웹사이트 모니터링',
|
||
websiteMonitor: '웹사이트 모니터링',
|
||
waf: 'WAF',
|
||
siteAvailability: '사이트 가용률',
|
||
monitoredSites: '모니터링 사이트',
|
||
requestCount: '요청 수',
|
||
abnormalSites: '비정상 사이트',
|
||
count5xxSource: '5xx 요청 기준 집계',
|
||
wafIntercept: 'WAF 차단',
|
||
highRiskHit: '고위험 매칭',
|
||
websiteMonitorDisabledOrNoData: '웹사이트 모니터링이 미활성화되었거나 모니터 데이터가 없습니다',
|
||
wafDisabledOrNoData: 'WAF가 미활성화되었거나 차단 데이터가 없습니다',
|
||
noWafData: 'WAF 차단 데이터가 없습니다',
|
||
sourceIP: '출처 IP',
|
||
hitCount: '매칭 횟수',
|
||
level: '등급',
|
||
attackType: '공격 유형',
|
||
requestRatio: '요청 비율',
|
||
installed: '설치됨',
|
||
normalRunning: '정상 실행',
|
||
failedStart: '시작 실패',
|
||
manualStopped: '수동 중지',
|
||
failed: '실패',
|
||
success: '성공',
|
||
canUpdate: '업그레이드 가능',
|
||
listSeparator: '、',
|
||
containerCount: '컨테이너 수',
|
||
stopped: '중지',
|
||
abnormal: '비정상',
|
||
abnormalContainers: '비정상 컨테이너',
|
||
resourceUsage: '리소스 사용량',
|
||
exposedContainerPorts: '노출 포트',
|
||
portMapping: '포트 매핑',
|
||
risk: '위험',
|
||
noAbnormalContainer: '비정상 컨테이너가 없습니다',
|
||
noExposedContainer: '노출 포트가 감지되지 않았습니다',
|
||
publicExpose: '공인 노출',
|
||
privateExpose: '내부 매핑',
|
||
resourceHealth: '런타임 리소스 상태',
|
||
checkTime: '점검 시간',
|
||
resourceHealthNormalDesc: '현재 애플리케이션, 데이터베이스, 컨테이너 리소스가 정상입니다',
|
||
resourceHealthAttentionDesc:
|
||
'{0}개의 주의 항목이 감지되었습니다. 중지된 리소스와 공개 포트를 우선 확인하세요.',
|
||
resourceHealthRiskDesc:
|
||
'{0}개의 고위험 항목이 감지되었습니다. 비정상 컨테이너 또는 시작 실패 애플리케이션을 우선 처리하세요.',
|
||
resourceThresholdContainers: 'CPU / 메모리 임계치 초과 컨테이너',
|
||
noThresholdExceededContainer: '임계치를 초과한 컨테이너가 없습니다',
|
||
triggerMetric: '트리거 항목',
|
||
resourceReasonAppFailed: '애플리케이션 {0}개 시작 실패',
|
||
resourceReasonAppStopped: '애플리케이션 {0}개 중지됨',
|
||
resourceReasonContainerAbnormal: '컨테이너 {0}개 상태 비정상',
|
||
resourceReasonContainerStopped: '컨테이너 {0}개 중지됨',
|
||
resourceReasonPublicPorts: '공개 포트 {0}개',
|
||
resourceReasonNormal: '애플리케이션, 데이터베이스, 컨테이너 상태가 정상입니다',
|
||
viewAbnormalContainers: '비정상 컨테이너 보기',
|
||
viewExposedPorts: '노출 포트 보기',
|
||
viewAppResources: '앱 리소스 보기',
|
||
viewRuntimeResources: '런타임 리소스 보기',
|
||
viewContainerResources: '컨테이너 리소스 보기',
|
||
configuredServices: '구성된 서비스',
|
||
publicPrivatePorts: '공개 {0}개 / 내부 매핑 {1}개',
|
||
currentDisplayTotal: '총 {1}개 중 {0}개 표시',
|
||
reclaimableSpace: '회수 가능 공간',
|
||
estimatedReclaimable: '예상 회수 가능',
|
||
unusedImageSpace: '사용하지 않는 이미지 공간',
|
||
stoppedContainerSpace: '중지된 컨테이너 공간',
|
||
unusedVolumeSpace: '사용하지 않는 볼륨 공간',
|
||
buildCacheSpace: 'Docker 빌드 캐시 공간',
|
||
executionRecords: '실행 기록',
|
||
successRate: '성공률',
|
||
failedJobs: '실패 작업',
|
||
recentRecoveryPoint: '최근 복구 지점',
|
||
remoteCoverage: '원격 포함',
|
||
recent7Days: '최근 7일',
|
||
taskTypeStats: '작업 유형 통계',
|
||
total: '합계',
|
||
taskTypeDesc: '활성 {0}개, 미활성 {1}개',
|
||
failedOrAttentionTasks: '실패 또는 주의 필요 작업',
|
||
execution: '실행 현황',
|
||
latestExecution: '최근 실행',
|
||
remoteBackup: '원격 백업',
|
||
localOnly: '로컬만',
|
||
covered: '포함됨',
|
||
noAttentionCronjob: '실패 또는 주의 필요한 예약 작업이 없습니다',
|
||
cronjobHealth: '예약 작업 상태',
|
||
cronjobHealthNormalDesc: '예약 작업 실행과 백업 구성이 정상입니다',
|
||
cronjobHealthAttentionDesc:
|
||
'{0}개의 위험 항목이 감지되었습니다. 비활성 작업과 백업 범위를 우선 확인하세요.',
|
||
cronjobHealthRiskDesc: '{0}개의 위험 항목이 감지되었습니다. 실패 작업과 비활성 작업을 우선 처리하세요.',
|
||
cronjobReasonFailed: '실패 기록 {0}건',
|
||
cronjobReasonDisabled: '{0}개 작업 비활성화',
|
||
cronjobReasonLocalOnlyBackup: '로컬 전용 백업 {0}개',
|
||
cronjobReasonNormal: '예약 작업 실행과 백업 범위가 정상입니다',
|
||
viewFailedRecords: '실패 작업 보기',
|
||
viewCronjobTasks: '예약 작업 보기',
|
||
checkBackupTasks: '백업 작업 확인',
|
||
generationRule: '생성 규칙',
|
||
scheduleDaily: '매일',
|
||
scheduleDailyDesc: '매일 09:00에 최근 24시간 보고서 생성',
|
||
scheduleWeekly: '매주',
|
||
scheduleWeeklyDesc: '매주 월요일 09:00에 최근 7일 보고서 생성',
|
||
scheduleMonthly: '매월',
|
||
scheduleMonthlyDesc: '매월 1일 09:00에 전월 보고서 생성',
|
||
scheduleCurrentDaily: '매일 09:00에 최근 24시간 보고서 생성 · 다음 {0}',
|
||
scheduleCurrentWeekly: '매주 월요일 09:00에 최근 7일 보고서 생성 · 다음 {0}',
|
||
scheduleCurrentMonthly: '매월 1일 09:00에 전월 보고서 생성 · 다음 {0}',
|
||
notificationMethod: '통보 방식',
|
||
channel: '채널',
|
||
receiver: '수신 대상',
|
||
systemThreshold: '시스템 임계값',
|
||
metric: '지표',
|
||
currentRule: '현재 규칙',
|
||
hostMonitor: '호스트 모니터링',
|
||
monitorInterval: '모니터링 간격',
|
||
exportSettings: '내보내기 설정',
|
||
lastExportReport: '최근 생성 결과',
|
||
noLastExportReport: '내보내기 보고서 기록이 없습니다',
|
||
lastExportStatus: '마지막 내보내기 상태',
|
||
exportFile: '내보내기 파일',
|
||
generateTime: '생성 시간',
|
||
fileSize: '파일 크기',
|
||
viewExportHistory: '내보내기 기록 보기',
|
||
defaultFormat: '기본 형식',
|
||
savePath: '저장 경로',
|
||
savePathRequired: '보고서 저장 경로를 설정하세요',
|
||
autoExport: '자동 내보내기 활성화',
|
||
autoExportDesc: '활성화 시 매일 09:00에 자동으로 운영 보고서를 생성합니다',
|
||
autoExportEnabled: '자동 내보내기 활성화됨',
|
||
autoExportDisabled: '자동 내보내기 비활성화됨',
|
||
readOnlyPermissionTip:
|
||
'현재 계정은 운영 보고서 설정을 볼 수만 있습니다. 수정이 필요하면 관리자에게 문의하세요.',
|
||
refreshing: '새로고침 중',
|
||
exporting: '내보내기 중',
|
||
exportFailed: '보고서 내보내기 실패',
|
||
generating: '생성 중',
|
||
saved: '저장됨',
|
||
saveFailed: '설정 저장 실패',
|
||
generateNow: '즉시 생성',
|
||
generateSuccess: '보고서 파일 생성됨: {0}',
|
||
generateFailed: '보고서 생성 실패',
|
||
enabledStatus: '활성화',
|
||
disabledStatus: '비활성화',
|
||
thresholdRule: '임계값 {0}, 연속 {1}회 트리거',
|
||
hours: '{0}시간',
|
||
minutes: '{0}분',
|
||
seconds: '{0}초',
|
||
totalExports: '총 내보내기 수',
|
||
successExports: '성공 내보내기',
|
||
failedExports: '실패 내보내기',
|
||
reportName: '보고서 이름',
|
||
exportFormat: '내보내기 형식',
|
||
operator: '운영자',
|
||
triggerType: '트리거 방식',
|
||
filePath: '파일 경로',
|
||
manualExport: '수동',
|
||
scheduledExport: '예약',
|
||
exportResult: '내보내기 결과',
|
||
exportDetail: '내보내기 설명',
|
||
},
|
||
},
|
||
user: {
|
||
user: '사용자',
|
||
userInfo: '사용자 정보',
|
||
userManage: '사용자 관리',
|
||
superAdmin: '최고 관리자',
|
||
superAdminDesc: '시스템 전체 관리 권한을 보유하며 모든 리소스와 설정을 관리할 수 있습니다.',
|
||
nodeAdmin: '노드 관리자',
|
||
nodeAdminDesc: '지정된 노드의 관리 권한을 보유하며 노드 내 리소스와 설정을 관리할 수 있습니다.',
|
||
readOnly: '읽기 전용',
|
||
readOnlyDesc: '시스템의 모든 읽기 전용 권한을 보유하며 모든 리소스와 설정을 볼 수 있습니다.',
|
||
bindNode: '노드 연결',
|
||
boundUsers: '바인딩된 사용자',
|
||
role: '역할',
|
||
roleName: '이름',
|
||
permission: '권한',
|
||
permissionDuplicate: '각 노드에는 하나의 역할만 지정할 수 있습니다',
|
||
nodeAdminMasterConfirm:
|
||
'마스터 노드의 노드 관리자 권한은 높은 수준이므로 실제 관리 필요에 따라 신중하게 할당하세요.',
|
||
permissionLinkageTip:
|
||
'의존 관계가 있으면 관련 권한이 자동 선택되며, 수동으로 해제하면 일부 기능에서 "현재 사용자에게 권한이 없습니다"가 표시될 수 있습니다.',
|
||
allViewPermissionHelper: 'AI 게이트웨이의 모든 보기 권한을 부여합니다.',
|
||
apiKeyViewPermissionHelper: 'AI 게이트웨이 API Key만 볼 수 있습니다.',
|
||
masterOnlyPermission: '마스터 노드 권한',
|
||
masterOnlyPermissionHelper: '이 권한은 마스터 노드에서만 적용됩니다.',
|
||
view: '보기',
|
||
manage: '관리',
|
||
authManage: '인증 관리',
|
||
auth: {
|
||
providerNavigation: '인증 공급자',
|
||
providers: {
|
||
ldap: 'AD/LDAP',
|
||
passkey: 'Passkey',
|
||
radius: 'Radius',
|
||
oidc: 'OIDC',
|
||
saml2: 'SAML2',
|
||
cas: 'CAS',
|
||
oauth2: 'OAuth2',
|
||
dingtalk: 'DingTalk',
|
||
feishu: 'Feishu',
|
||
wecom: 'WeCom',
|
||
},
|
||
providerDescriptions: {
|
||
ldap: 'Active Directory, OpenLDAP 및 기타 LDAP 서비스와 호환 가능',
|
||
passkey: '비밀번호 없는 로그인을 위해 장치 자격 증명 사용',
|
||
radius: 'Radius 서비스를 통해 네트워크 액세스 인증',
|
||
oidc: 'OpenID Connect로 엔터프라이즈 Single Sign-On 연결',
|
||
saml2: '기업 ID 연동을 위해 SAML2 사용',
|
||
cas: 'Single Sign-On을 위한 중앙 집중식 인증 서비스 연결',
|
||
oauth2: '호환 가능한 OAuth2 ID 서비스 연결',
|
||
dingtalk: 'DingTalk 조직 ID 및 QR 로그인 사용',
|
||
feishu: 'Feishu 조직 ID 및 계정 동기화 사용',
|
||
wecom: 'WeCom 회원 본인 인증',
|
||
},
|
||
planned: '예정',
|
||
plannedTitle: '{0} 인증 설정',
|
||
plannedDesc: '이 인증 공급자는 계획되어 있으며 아직 사용할 수 없습니다.',
|
||
ldap: {
|
||
enable: '활성화',
|
||
enabled: '활성화됨',
|
||
disabled: '비활성화됨',
|
||
connection: '기본 연결',
|
||
connectionDesc: '사용자 검색에 사용되는 디렉터리 서비스와 바인딩 계정을 구성합니다.',
|
||
serverURL: '서버 URL',
|
||
serverURLHelper: 'ldap:// 및 ldaps:// URL을 지원합니다.',
|
||
userBaseDN: '사용자 Base DN',
|
||
userBaseDNHelper: 'LDAP 사용자 검색을 위해 DN 시작 OU, CN 또는 도메인 루트 DN일 수 있습니다.',
|
||
bindDN: 'DN 바인딩',
|
||
bindPassword: '비밀번호',
|
||
passwordSaved: '저장된 비밀번호를 유지하려면 비워두세요.',
|
||
userSearch: '사용자 검색',
|
||
userSearchDesc:
|
||
'사용자 검색 기반 및 필터를 설정한 다음 1Panel name로 사용되는 LDAP 속성을 매핑합니다.',
|
||
userFilter: '사용자 필터',
|
||
userFilterTooltip:
|
||
'%(user)s를 이스케이프된 사용자 이름으로 바꾸거나 전체 디렉터리 읽기를 위해 *로 바꿉니다.',
|
||
userFilterHelper: '사용자 이름은 LDAP 필터에 삽입되기 전에 이스케이프됩니다.',
|
||
attributeMap: '속성 매핑',
|
||
attributeMapTooltip: '1Panel name 필드에서 LDAP 속성으로 매핑되는 JSON.',
|
||
attributeMapHelper: '1Panel name 필드에 매핑된 LDAP 속성을 설정합니다.',
|
||
advanced: '고급 설정',
|
||
advancedDesc: 'TLS 및 LDAP 쿼리 페이징을 구성합니다.',
|
||
strictSync: '엄격한 동기화',
|
||
strictSyncTooltip:
|
||
'전체 가져오기가 완료된 후 이 LDAP 소스에서 누락된 사용자는 비활성화되지만 삭제되지는 않습니다.',
|
||
strictSyncHelper:
|
||
'완전한 전체 가져오기에만 적용됩니다. 선택한 사용자를 가져와도 다른 사용자는 비활성화되지 않습니다.',
|
||
skipTLSVerify: 'TLS 확인 건너뛰기',
|
||
skipTLSVerifyTooltip: 'LDAPS 연결에 대한 인증서 확인을 비활성화합니다.',
|
||
skipTLSVerifyHelper:
|
||
'신뢰할 수 있는 자체 서명된 인증서에만 사용하세요. 이 설정은 엄격한 동기화와 무관합니다.',
|
||
connectTimeout: '연결 시간 초과(초)',
|
||
searchPageSize: 'LDAP 쿼리 페이지 크기',
|
||
restore: '복원',
|
||
testConnection: '연결 테스트',
|
||
testLogin: '로그인 테스트',
|
||
userImport: '사용자 가져오기',
|
||
saveBeforeImport: '사용자를 가져오기 전에 현재 AD/LDAP 설정을 저장하십시오.',
|
||
format: '형식',
|
||
restoreExample: '복원 예시',
|
||
mappingValid: '유효한 JSON; name가 구성되었습니다.',
|
||
mappingInvalid: '유효한 JSON를 입력하세요.',
|
||
mappingObject: '속성 매핑은 JSON 개체여야 합니다.',
|
||
mappingOnlyName: 'name 매핑만 지원됩니다.',
|
||
mappingStringValues: '매핑된 모든 속성은 문자열이어야 합니다.',
|
||
mappingNameRequired: 'name는 비어 있지 않은 문자열이어야 합니다.',
|
||
restored: '마지막으로 저장된 설정이 복원되었습니다.',
|
||
connectionTestSuccess: 'LDAP 연결 테스트에 성공했습니다.',
|
||
recentTestSuccess: '마지막 테스트 성공: {0}',
|
||
recentTestFailed: '마지막 테스트 실패: {0}',
|
||
serverURLRequired: 'LDAP 서버 URL을 입력하세요.',
|
||
serverURLInvalid: '유효한 ldap:// 또는 ldaps:// URL을 사용하세요.',
|
||
userBaseDNRequired: '사용자 Base DN를 입력합니다.',
|
||
bindDNRequired: '바인딩 DN를 입력합니다.',
|
||
passwordRequired: '비밀번호를 입력하세요.',
|
||
userFilterRequired: '사용자 필터를 입력하세요.',
|
||
connectTimeoutRequired: '연결 시간 초과를 입력합니다.',
|
||
searchPageSizeRequired: 'LDAP 쿼리 페이지 크기를 입력합니다.',
|
||
sync: {
|
||
title: '예약된 동기화',
|
||
description: '일정에 따라 전체 LDAP 디렉터리를 읽고 가져온 LDAP 사용자를 1Panel에 유지합니다.',
|
||
enable: '일정 활성화',
|
||
enableHelper: '비활성화되면 자동 실행이 중지됩니다. 수동 동기화는 계속 사용할 수 있습니다.',
|
||
schedule: '일정',
|
||
daily: '매일',
|
||
weekly: '주간',
|
||
customCron: '커스텀 Cron',
|
||
preview: '미리보기',
|
||
previewTitle: '다음 5회 실행',
|
||
previewEmpty: '사용 가능한 실행 시간이 없습니다.',
|
||
cronHelper: '표준 5개 필드 Cron 표현식(분, 시, 일, 월, 요일)을 사용합니다.',
|
||
autoImport: '새 사용자 가져오기',
|
||
autoImportHelper:
|
||
'비활성화되면 가져온 LDAP 사용자에 대해 디렉터리 식별자와 상태만 유지됩니다. 새로운 사용자가 생성되지 않습니다.',
|
||
defaultRole: '새로운 사용자 역할',
|
||
defaultRolePlaceholder: '역할 선택',
|
||
defaultRoleHelper: '예약된 동기화로 생성된 사용자에게만 적용됩니다.',
|
||
defaultRoleRequired: '새로운 LDAP 사용자의 역할을 선택합니다.',
|
||
strictSyncHelper:
|
||
'완전한 전체 쿼리에서 누락된 사용자는 비활성화되고 해당 세션이 지워집니다. 사용자, 역할 및 권한은 삭제되지 않습니다.',
|
||
safetyTitle: '누락된 사용자는 완전한 LDAP 전체 쿼리 후에만 처리됩니다.',
|
||
safetyDescription:
|
||
'실패한 쿼리, 시간 초과 또는 불완전한 페이징 결과는 사용자 상태를 변경하지 않습니다. 동기화 범위는 사용자 Base DN, 필터 및 특성 매핑을 따릅니다.',
|
||
runNow: '지금 동기화',
|
||
lastRunSuccess: '마지막 동기화 성공: {0}',
|
||
lastRunFailed: '마지막 동기화 실패: {0}',
|
||
lastRunRunning: '동기화 시작됨: {0}',
|
||
sourceDisabled: '동기화를 실행하기 전에 AD/LDAP를 활성화하고 저장하세요.',
|
||
cronRequired: 'Cron 표현식을 입력하세요.',
|
||
saveBeforeRun: '작업을 실행하기 전에 동기화 설정을 저장하십시오.',
|
||
runConfirmTitle: '엄격한 동기화 실행',
|
||
runConfirmDescription:
|
||
'완전한 전체 쿼리에서 누락된 LDAP 사용자를 비활성화하고 활성 세션을 종료합니다. 계속하시겠습니까?',
|
||
runSuccess: 'LDAP 동기화가 완료되었습니다.',
|
||
weekdays: {
|
||
0: '일요일',
|
||
1: '월요일',
|
||
2: '화요일',
|
||
3: '수요일',
|
||
4: '목요일',
|
||
5: '금요일',
|
||
6: '토요일',
|
||
},
|
||
},
|
||
syncLogs: {
|
||
title: '동기화 로그',
|
||
description: '예약된 및 수동 LDAP 동기화 결과를 검토합니다.',
|
||
startedAt: '시작 시간',
|
||
trigger: '실행 방식',
|
||
manual: '수동',
|
||
scheduled: '예정됨',
|
||
success: '성공',
|
||
failed: '실패',
|
||
running: '실행 중',
|
||
result: '결과',
|
||
resultSummary: '{0} 생성, {1} 업데이트, {2} 누락',
|
||
duration: '기간',
|
||
action: '액션',
|
||
},
|
||
testLoginTitle: 'AD/LDAP 로그인 테스트',
|
||
testLoginDesc:
|
||
'인증을 테스트하기 위해 AD/LDAP 사용자 자격 증명으로 바인딩합니다. 1Panel 세션이 생성되지 않습니다.',
|
||
ldapUsername: 'LDAP 사용자 이름',
|
||
usernameRequired: 'LDAP 사용자 이름을 입력하세요.',
|
||
startTest: '테스트 시작',
|
||
testLoginSuccess: '인증에 성공했습니다.',
|
||
testLoginSuccessWithDN: '인증에 성공했습니다. 사용자 DN: {0}',
|
||
import: {
|
||
title: 'AD/LDAP 사용자 가져오기',
|
||
source: '데이터 소스: AD/LDAP 디렉토리',
|
||
lastRead: '마지막으로 읽은 날짜: {0}',
|
||
cacheHit: '캐시된 결과',
|
||
keywordPlaceholder: '사용자 이름 검색',
|
||
search: '검색',
|
||
refresh: 'LDAP에서 읽기',
|
||
refreshTip: '단기 캐시를 무시하고 LDAP 디렉토리를 다시 읽으십시오.',
|
||
loadFailed: 'LDAP 디렉터리를 읽지 못했습니다.',
|
||
retry: '재시도',
|
||
noData: '디렉터리 사용자를 찾을 수 없습니다.',
|
||
username: '사용자 이름',
|
||
status: '상태',
|
||
changes: '변경 사항',
|
||
noChanges: '변경사항 없음',
|
||
importable: '가져올 준비가 되었습니다.',
|
||
updateAvailable: '업데이트 가능',
|
||
upToDate: '최신',
|
||
conflict: '이름 충돌',
|
||
selectedCount: '{0} 선택됨',
|
||
totalCount: '{0}명',
|
||
newUserRole: '새로운 사용자 역할',
|
||
newUserRoleRequired: '새 사용자의 역할을 선택합니다.',
|
||
noNewUsers: '이 작업에는 새로운 사용자가 없습니다.',
|
||
roleOnlyForNewUsers: '선택한 역할은 새로 생성된 사용자에게만 적용됩니다.',
|
||
strictOff:
|
||
'엄격한 동기화가 비활성화되었습니다. 전체 가져오기는 사용자를 비활성화하지 않습니다.',
|
||
importSelected: '가져오기/업데이트 선택됨({0})',
|
||
importAll: '모두 가져오기/업데이트({0})',
|
||
previewTitle: '전체 가져오기 확인',
|
||
previewDesc: '전체 LDAP 디렉토리를 읽었습니다. 검색 키워드는 이 작업을 제한하지 않습니다.',
|
||
created: '만들기',
|
||
updated: '업데이트',
|
||
unchanged: '변경되지 않음',
|
||
conflicts: '충돌',
|
||
missing: '비활성화',
|
||
reactivated: '재활성화',
|
||
strictWarning:
|
||
'엄격한 동기화가 활성화되었습니다. LDAP에서 누락된 사용자는 로그인할 수 없지만 해당 기록, 역할 및 권한은 유지됩니다.',
|
||
missingUsers: 'LDAP에서 누락된 사용자',
|
||
missingScope: '이 LDAP 소스만 영향을 받습니다.',
|
||
willDisable: '비활성화됩니다',
|
||
confirmAll: '가져오기 확인',
|
||
confirmAllWithMissing: '가져오기를 확인하고 {0}명의 사용자 비활성화',
|
||
executeSuccess: 'LDAP 사용자가 성공적으로 처리되었습니다.',
|
||
queryExpired: '디렉터리 결과가 만료되었습니다. LDAP에서 다시 읽어보세요.',
|
||
planIncomplete: '전체 디렉터리 읽기가 불완전하여 실행할 수 없습니다.',
|
||
},
|
||
},
|
||
},
|
||
},
|
||
app: {
|
||
app: 'APP',
|
||
title: '패널 별칭',
|
||
titleHelper: '패널 별칭은 APP 에서 표시되는 데 사용됩니다(기본 패널 별칭)',
|
||
qrCode: 'QR 코드',
|
||
apiStatusHelper: '패널 APP 는 API 인터페이스 기능을 활성화해야 합니다',
|
||
apiInterfaceHelper: '패널 API 인터페이스 액세스를 지원합니다(패널 앱에서 이 기능을 활성화해야 합니다)',
|
||
apiInterfaceHelper1:
|
||
'패널 앱의 액세스에는 방문자를 화이트리스트에 추가해야 하며, 고정 IP가 아닌 경우 0.0.0.0/0(모든 IPv4), ::/0(모든 IPv6) 을 추가하는 것이 좋습니다',
|
||
qrCodeExpired: '새로 고침 시간',
|
||
apiLeakageHelper: 'QR 코드를 누출하지 마십시오. 신뢰할 수 있는 환경에서만 사용하십시오.',
|
||
},
|
||
logExport: {
|
||
title: '로그 내보내기',
|
||
records: '내보내기 기록',
|
||
retentionDays: '내보내기 기록 보관 일수',
|
||
timeRange: '시간 범위',
|
||
timeRequired: '내보낼 시간 범위를 선택하세요',
|
||
websiteRequired: '웹사이트를 선택하세요',
|
||
blackStatus: '차단 목록 상태',
|
||
black: '차단됨',
|
||
notBlack: '차단되지 않음',
|
||
fuzzy: '부분 일치',
|
||
regex: '정규식',
|
||
invalidRegex: '256자 이하의 올바른 RE2 정규식을 입력하세요',
|
||
created: '내보내기 작업이 생성되었습니다',
|
||
fileName: '파일 이름',
|
||
fileSize: '파일 크기',
|
||
expiresAt: '만료 시간',
|
||
cancelConfirm: '이 내보내기 작업을 취소하시겠습니까?',
|
||
deleteConfirm: '이 내보내기 기록과 파일을 삭제하시겠습니까?',
|
||
},
|
||
waf: {
|
||
WAF: 'WAF',
|
||
blackWhite: '블랙 및 화이트 목록',
|
||
globalSetting: '전역 설정',
|
||
websiteSetting: '웹사이트 설정',
|
||
blockRecords: '차단된 기록',
|
||
world: '전 세계',
|
||
china: '중국',
|
||
intercept: '차단',
|
||
request: '요청',
|
||
count4xx: '4xx 수량',
|
||
count5xx: '5xx 수량',
|
||
todayStatus: '오늘의 상태',
|
||
reqMap: '공격 맵 (최근 30일)',
|
||
resource: '출처',
|
||
count: '수량',
|
||
hight: '높음',
|
||
low: '낮음',
|
||
reqCount: '요청 수',
|
||
interceptCount: '차단 수',
|
||
requestTrends: '요청 트렌드 (최근 7일)',
|
||
interceptTrends: '차단 트렌드 (최근 7일)',
|
||
whiteList: '화이트 목록',
|
||
blackList: '블랙 목록',
|
||
ipBlackListHelper: '블랙 목록에 있는 IP 주소는 웹사이트에 접근할 수 없습니다.',
|
||
ipWhiteListHelper: '화이트 목록에 있는 IP 주소는 모든 제한을 우회합니다.',
|
||
uaBlackListHelper: '블랙 목록에 있는 User-Agent 값의 요청은 차단됩니다.',
|
||
uaWhiteListHelper: '화이트 목록에 있는 User-Agent 값의 요청은 모든 제한을 우회합니다.',
|
||
urlBlackListHelper: '블랙 목록에 있는 URL 로의 요청은 차단됩니다.',
|
||
urlWhiteListHelper: '화이트 목록에 있는 URL 로의 요청은 모든 제한을 우회합니다.',
|
||
ccHelper: '같은 IP 에서 {0}초 이내에 {1}회 이상 요청을 받으면 해당 IP 는 {2}동안 차단됩니다.',
|
||
blockTime: '차단 기간',
|
||
attackHelper: '누적 차단이 {0}초 이내에 {1}회를 초과하면 해당 IP 는 {2}동안 차단됩니다.',
|
||
notFoundHelper: '누적된 요청이 {0}초 이내에 404 오류를 {1}번 이상 반환하면 해당 IP 는 {2}동안 차단됩니다.',
|
||
frequencyLimit: '접속 빈도 제한',
|
||
regionLimit: '지역 제한',
|
||
defaultRule: '기본 규칙',
|
||
accessFrequencyLimit: '접속 빈도 제한',
|
||
attackLimit: '공격 빈도 제한',
|
||
notFoundLimit: '404 빈도 제한',
|
||
urlLimit: 'URL 빈도 제한',
|
||
urlLimitHelper: '단일 URL 의 접속 빈도를 설정합니다.',
|
||
sqliDefense: 'SQL 인젝션 보호',
|
||
sqliHelper: '요청에서 SQL 인젝션을 감지하여 차단합니다.',
|
||
xssHelper: '요청에서 XSS 를 감지하여 차단합니다.',
|
||
xssDefense: 'XSS 보호',
|
||
uaDefense: '악성 User-Agent 규칙',
|
||
uaHelper: '일반적인 악성 봇을 식별하는 규칙이 포함되어 있습니다.',
|
||
argsDefense: '악성 파라미터 규칙',
|
||
argsHelper: '악성 파라미터를 포함한 요청을 차단합니다.',
|
||
cookieDefense: '악성 쿠키 규칙',
|
||
cookieHelper: '악성 쿠키가 요청에 포함되지 않도록 차단합니다.',
|
||
headerDefense: '악성 헤더 규칙',
|
||
headerHelper: '악성 헤더가 포함된 요청을 차단합니다.',
|
||
httpRule: 'HTTP 요청 방법 규칙',
|
||
httpHelper:
|
||
'허용된 접근 방식 유형을 설정합니다. 특정 접근 방식을 제한하려면 해당 유형의 버튼을 끄십시오. 예를 들어: GET 방식만 허용하려면 GET 을 제외한 다른 방식의 버튼을 끄세요.',
|
||
geoRule: '지역별 접근 제한',
|
||
geoHelper:
|
||
'하나의 스위치로 지역 및 성 정책을 결합합니다. 지역 규칙을 먼저 적용한 다음 성 규칙을 적용합니다.',
|
||
regionPolicy: '지역 정책',
|
||
provincePolicy: '성 정책',
|
||
provinceRuleLabel: '성',
|
||
openRestyFeatureVersionAlert: '{0}을(를) 적용하려면 OpenResty 버전이 1.31.1.1-0보다 높아야 합니다.',
|
||
ipLocation: 'IP 위치',
|
||
ipLocationSearchHelper: 'IP 위치를 입력하세요. 부분 검색을 지원합니다',
|
||
action: '동작',
|
||
ruleType: '공격 유형',
|
||
ipHelper: 'IP 주소를 입력하세요',
|
||
attackLog: '공격 로그',
|
||
rule: '규칙',
|
||
ipArr: 'IPV4 범위',
|
||
ipStart: '시작 IP',
|
||
ipEnd: '끝 IP',
|
||
ipv4: 'IPv4',
|
||
ipv6: 'IPv6',
|
||
urlDefense: 'URL 규칙',
|
||
urlHelper: '금지된 URL',
|
||
dirFilter: '디렉터리 필터',
|
||
sqlInject: 'SQL 인젝션',
|
||
xss: 'XSS',
|
||
webshell: 'WebShell',
|
||
phpExec: 'PHP 스크립트 실행',
|
||
oneWordTrojan: '단어 트로이',
|
||
appFilter: '위험한 디렉터리 필터링',
|
||
webShell: '웹쉘',
|
||
args: '악성 파라미터',
|
||
protocolFilter: '프로토콜 필터',
|
||
javaFilter: '자바 위험 파일 필터링',
|
||
scannerFilter: '스캐너 필터',
|
||
escapeFilter: '이스케이프 필터',
|
||
customRule: '사용자 정의 규칙',
|
||
httpMethod: 'HTTP 메소드 필터',
|
||
fileExt: '파일 업로드 제한',
|
||
fileExtHelper: '업로드 제한 파일 확장자',
|
||
deny: '금지',
|
||
allow: '허용',
|
||
allowOnly: '선택 항목만 허용',
|
||
field: '객체',
|
||
pattern: '조건',
|
||
ruleContent: '내용',
|
||
contain: '포함',
|
||
equal: '같음',
|
||
regex: '정규 표현식',
|
||
notEqual: '같지 않음',
|
||
customRuleHelper: '지정된 조건에 따라 동작을 수행합니다.',
|
||
actionAllow: '허용',
|
||
blockIP: 'IP 차단',
|
||
code: '상태 코드 반환',
|
||
noRes: '연결 끊기 (444)',
|
||
badReq: '잘못된 매개변수 (400)',
|
||
forbidden: '접근 금지 (403)',
|
||
serverErr: '서버 오류 (500)',
|
||
resHtml: '응답 페이지',
|
||
allowHelper: '허용된 접근은 후속 WAF 규칙을 건너뛰게 하므로 주의해서 사용하세요.',
|
||
captcha: '사람-컴퓨터 검증',
|
||
fiveSeconds: '5초 검증',
|
||
location: '지역',
|
||
redisConfig: 'Redis 설정',
|
||
redisHelper: 'Redis 를 활성화하여 일시적으로 차단된 IP를 유지합니다.',
|
||
wafHelper: 'WAF 를 종료하면 모든 웹사이트 보호가 해제됩니다.',
|
||
websiteWafHelper: 'WAF 를 종료하면 이 웹사이트 보호가 해제됩니다.',
|
||
attackIP: '공격 IP',
|
||
attackParam: '공격 세부사항',
|
||
execRule: '적용된 규칙',
|
||
acl: 'ACL',
|
||
sql: 'SQL 인젝션',
|
||
cc: '접속 빈도 제한',
|
||
isBlocking: '차단됨',
|
||
isFree: '차단 해제됨',
|
||
unLock: '차단 해제',
|
||
unLockHelper: 'IP: {0}의 차단을 해제하시겠습니까?',
|
||
saveDefault: '기본값 저장',
|
||
saveToWebsite: '웹사이트에 적용',
|
||
saveToWebsiteHelper: '현재 설정을 모든 웹사이트에 적용하시겠습니까?',
|
||
websiteHelper: '웹사이트를 생성할 때의 기본 설정입니다. 수정 사항은 웹사이트에 적용해야 효력이 있습니다.',
|
||
websiteHelper2: '웹사이트 생성 시 기본 설정이 제공됩니다. 웹사이트에서 해당 설정을 수정해 주세요.',
|
||
ipGroup: 'IP 그룹',
|
||
ipGroupHelper:
|
||
'한 줄에 하나의 IP 또는 IP 범위를 입력하세요, IPv4 및 IPv6 을 지원합니다. 예: 192.168.1.1 또는 192.168.1.0/24',
|
||
ipBlack: 'IP 블랙리스트',
|
||
openRestyAlert: 'OpenResty 버전은 {0} 이상이어야 합니다.',
|
||
initAlert:
|
||
'처음 사용 시 초기화가 필요하며, 웹사이트 설정 파일이 수정됩니다. 기존 WAF 설정은 손실될 수 있습니다. 미리 백업해 주세요.',
|
||
initHelper: '초기화 작업은 기존 WAF 설정을 삭제합니다. 초기화하시겠습니까?',
|
||
mainSwitch: '메인 스위치',
|
||
websiteSwitch: '스위치',
|
||
websiteAlert: '먼저 웹사이트를 생성해 주세요.',
|
||
defaultUrlBlack: 'URL 규칙',
|
||
htmlRes: '차단 페이지',
|
||
urlSearchHelper: 'URL 을 입력하여 유사 검색을 지원합니다.',
|
||
hostSearchHelper: 'Host를 입력하여 유사 검색을 지원합니다.',
|
||
toCreate: '생성',
|
||
closeWaf: 'WAF 종료',
|
||
closeWafHelper: 'WAF 를 종료하면 웹사이트 보호가 해제됩니다. 계속하시겠습니까?',
|
||
addblack: '블랙 추가',
|
||
addwhite: '화이트 추가',
|
||
addblackHelper: 'IP: {0}를 기본 블랙리스트에 추가하시겠습니까?',
|
||
addwhiteHelper: 'IP: {0}를 기본 화이트리스트에 추가하시겠습니까?',
|
||
defaultUaBlack: 'User-Agent 규칙',
|
||
defaultIpBlack: '악성 IP 그룹',
|
||
cookie: '쿠키 규칙',
|
||
urlBlack: 'URL 블랙리스트',
|
||
uaBlack: 'User-Agent 블랙리스트',
|
||
attackCount: '공격 빈도 제한',
|
||
fileExtCheck: '파일 업로드 제한',
|
||
geoRestrict: '지역 접근 제한',
|
||
originProtect: 'CDN 원본 서버 보호',
|
||
attacklog: '차단 기록',
|
||
unknownWebsite: '허가되지 않은 도메인 접근',
|
||
geoRuleEmpty: '지역 또는 성을 하나 이상 선택하세요.',
|
||
unknown: '웹사이트 없음',
|
||
geo: '지역 제한',
|
||
revertHtml: '{0}을 기본 페이지로 복원하시겠습니까?',
|
||
five_seconds: '5초 검증',
|
||
header: '헤더 규칙',
|
||
methodWhite: 'HTTP 규칙',
|
||
expiryDate: '만료 날짜',
|
||
expiryDateHelper: '검증을 통과한 후 유효 기간 내에는 더 이상 검증하지 않습니다.',
|
||
defaultIpBlackHelper: '인터넷에서 수집된 일부 악성 IP로 접근을 차단합니다.',
|
||
notFoundCount: '404 빈도 제한',
|
||
matchValue: '매칭 값',
|
||
headerName: '이 필드는 특수 문자로 시작할 수 없으며,영어, 숫자, -, 길이 3-30 지원',
|
||
cdnHelper: 'CDN 을 사용하는 웹사이트는 여기서 원본 IP를 확인할 수 있습니다.',
|
||
clearLogWarn: '로그를 삭제하면 복구할 수 없습니다. 계속하시겠습니까?',
|
||
commonRuleHelper: '규칙은 유사 매칭 방식입니다.',
|
||
blockIPHelper:
|
||
'차단된 IP는 OpenResty 에 일시적으로 저장되며, OpenResty 재시작 시 차단이 해제됩니다. 차단 기능을 통해 영구적으로 차단할 수 있습니다.',
|
||
addWhiteUrlHelper: 'URL {0}를 화이트리스트에 추가하시겠습니까?',
|
||
dashHelper: '커뮤니티 버전은 전역 설정 및 웹사이트 설정에서 기능을 사용할 수 있습니다.',
|
||
wafStatusHelper:
|
||
'방화벽이 활성화되지 않아 웹사이트 보안 보호가 일시 중지되었습니다. 가능한 한 빨리 활성화하세요.',
|
||
enableProtection: '보호 활성화',
|
||
ccMode: '모드',
|
||
global: '전역 모드',
|
||
uriMode: 'URL 모드',
|
||
globalHelper: '전역 모드: 특정 시간 내에 모든 URL에 대한 요청 수가 임계값을 초과하면 트리거됩니다.',
|
||
uriModeHelper: 'URL 모드: 특정 시간 내에 개별 URL에 대한 요청 수가 임계값을 초과하면 트리거됩니다.',
|
||
ip: 'IP 블랙리스트',
|
||
globalSettingHelper:
|
||
'[웹사이트] 태그가 있는 설정은 [웹사이트 설정]에서 활성화해야 하며, 전역 설정은 새로 생성된 웹사이트의 기본 설정입니다.',
|
||
globalSettingHelper2: '[전역 설정]과 [웹사이트 설정]에서 모두 활성화해야 설정이 적용됩니다.',
|
||
urlCCHelper: '{0} 초 이내에 이 URL에 대해 {1} 회를 초과하는 요청이 있어 이 IP를 차단합니다 {2}',
|
||
urlCCHelper2: 'URL에 매개변수를 포함할 수 없습니다',
|
||
notContain: '포함하지 않음',
|
||
urlcc: 'URL 빈도 제한',
|
||
method: '요청 유형',
|
||
addIpsToBlock: 'IP 일괄 차단',
|
||
addIpSegmentToBlock: 'IP 대역 차단',
|
||
addIpSegmentsToBlock: 'IP 대역 일괄 차단',
|
||
addUrlsToWhite: 'URL을 일괄 허용 목록에 추가',
|
||
noBlackIp: 'IP가 이미 차단되어 있으므로 다시 차단할 필요가 없습니다',
|
||
noWhiteUrl: 'URL이 이미 허용 목록에 포함되어 있으므로 다시 추가할 필요가 없습니다',
|
||
spiderIpHelper: '활성화하면 선택한 크롤러만 허용하고, 비활성화하면 모든 크롤러 접근을 차단합니다.',
|
||
spiderIp: '스파이더 IP 풀',
|
||
spider: '스파이더',
|
||
spiderAllowlist: '허용할 크롤러',
|
||
spiderAllowlistEmpty: '선택한 크롤러가 없습니다. 저장하면 모든 크롤러 접근이 차단됩니다.',
|
||
geoIp: 'IP 주소 라이브러리',
|
||
geoIpHelper: 'IP의 지리적 위치를 확인하는 데 사용됩니다',
|
||
stat: '공격 보고서',
|
||
statTitle: '보고서',
|
||
attackIp: '공격 IP',
|
||
attackCountNum: '공격 횟수',
|
||
percent: '비율',
|
||
addblackUrlHelper: 'URL: {0}을(를) 기본 블랙리스트에 추가할까요?',
|
||
rce: '원격 코드 실행',
|
||
software: '소프트웨어',
|
||
cveHelper: '일반적인 소프트웨어 및 프레임워크의 취약점을 포함',
|
||
vulnCheck: '보충 규칙',
|
||
ssrf: 'SSRF 취약점',
|
||
afr: '임의 파일 읽기',
|
||
ua: '무단 액세스',
|
||
id: '정보 누출',
|
||
aa: '인증 우회',
|
||
dr: '디렉토리 순회',
|
||
xxe: 'XXE 취약점',
|
||
suid: '직렬화 취약점',
|
||
dos: '서비스 거부 취약점',
|
||
afd: '임의 파일 다운로드',
|
||
sqlInjection: 'SQL 인젝션',
|
||
afw: '임의 파일 쓰기',
|
||
il: '정보 유출',
|
||
clearAllLog: '모든 로그 삭제',
|
||
exportLog: '로그 내보내기',
|
||
appRule: '애플리케이션 규칙',
|
||
appRuleHelper:
|
||
'일반적인 애플리케이션 규칙. 활성화하면 오탐지를 줄일 수 있습니다. 하나의 웹사이트는 하나의 규칙만 사용할 수 있습니다',
|
||
logExternal: '기록 유형 제외',
|
||
ipWhite: 'IP 허용 목록',
|
||
urlWhite: 'URL 허용 목록',
|
||
uaWhite: '사용자 에이전트 허용 목록',
|
||
logExternalHelper:
|
||
'제외된 기록 유형은 로그에 기록되지 않습니다. 블랙리스트/허용 목록, 지역 액세스 제한, 사용자 정의 규칙은 많은 로그를 생성합니다. 제외를 권장합니다',
|
||
ssti: 'SSTI 공격',
|
||
crlf: 'CRLF 인젝션',
|
||
strict: '엄격 모드',
|
||
strictHelper: '더 엄격한 규칙을 사용하여 요청을 검증합니다',
|
||
executionStrategy: '실행 정책',
|
||
detectionStrength: '탐지 강도',
|
||
protectionMode: '보호 모드',
|
||
observationMode: '관찰 모드',
|
||
standardMode: '표준 모드',
|
||
observationModeHelper: '요청을 차단하지 않고 탐지 및 로그만 기록합니다',
|
||
observationModeConfirm:
|
||
'관찰 모드에서는 모든 WAF 탐지를 기록하지만 요청을 차단하지 않습니다. 계속하시겠습니까?',
|
||
globalStrictRequired: '먼저 전역 설정에서 엄격 모드를 활성화하세요',
|
||
websiteSearchHelper: '웹사이트 도메인, 별칭 또는 비고를 입력하세요',
|
||
configReadFailed: '설정을 불러오지 못했습니다',
|
||
detailSetting: '상세 설정',
|
||
observe: '관찰',
|
||
saveLog: '로그 저장',
|
||
remoteURLHelper: '원격 URL은 한 줄에 하나의 IP만 포함하고 다른 문자는 포함하지 않아야 합니다',
|
||
notFound: 'Not Found (404)',
|
||
serviceUnavailable: '서비스 불가 (503)',
|
||
gatewayTimeout: '게이트웨이 시간 초과 (504)',
|
||
belongToIpGroup: 'IP 그룹에 속함',
|
||
notBelongToIpGroup: 'IP 그룹에 속하지 않음',
|
||
unknownWebsiteKey: '알 수 없는 도메인',
|
||
special: '특수 문자',
|
||
fileToLarge: '파일이 1MB를 초과하여 업로드할 수 없습니다',
|
||
uploadOverLimit: '업로드된 파일 수가 제한을 초과했습니다, 최대 1개',
|
||
importRuleHelper: '한 줄에 하나의 규칙',
|
||
name: 'WAF 이름',
|
||
},
|
||
monitor: {
|
||
'360': '360 검색',
|
||
name: '웹사이트 모니터링',
|
||
pv: '페이지 조회수',
|
||
uv: '고유 방문자 수',
|
||
flow: '트래픽 흐름',
|
||
ip: 'IP',
|
||
spider: '스파이더',
|
||
visitors: '방문자 추세',
|
||
today: '오늘',
|
||
last7days: '지난 7일',
|
||
last30days: '지난 30일',
|
||
uvMap: '방문자 지도 (30일)',
|
||
qps: '실시간 요청 (분당)',
|
||
flowSec: '실시간 트래픽 (분당)',
|
||
excludeCode: '상태 코드 제외',
|
||
excludeUrl: 'URL 제외',
|
||
excludeExt: '확장자 제외',
|
||
cdnHelper: 'CDN 제공 헤더에서 실제 IP 가져오기',
|
||
reqRank: '방문 순위',
|
||
refererDomain: '참조 도메인',
|
||
os: '운영 체제',
|
||
browser: '브라우저/클라이언트',
|
||
device: '장치',
|
||
showMore: '더보기',
|
||
unknown: '기타',
|
||
pc: '컴퓨터',
|
||
mobile: '모바일 장치',
|
||
wechat: '위챗',
|
||
machine: '머신',
|
||
tencent: '텐센트 브라우저',
|
||
ucweb: 'UC 브라우저',
|
||
'2345explorer': '2345 브라우저',
|
||
huaweibrowser: '화웨이 브라우저',
|
||
log: '요청 로그',
|
||
statusCode: '상태 코드',
|
||
requestTime: '응답 시간',
|
||
flowRes: '응답 트래픽',
|
||
method: '요청 메서드',
|
||
statusCodeHelper: '상태 코드를 입력하세요',
|
||
statusCodeError: '유효하지 않은 상태 코드 유형',
|
||
methodHelper: '요청 메서드를 입력하세요',
|
||
all: '전체',
|
||
baidu: '바이두',
|
||
google: '구글',
|
||
bing: '빙',
|
||
bytes: '오늘의 헤드라인',
|
||
sogou: '소구',
|
||
failed: '오류',
|
||
ipCount: 'IP 수',
|
||
spiderCount: '스파이더 요청',
|
||
averageReqTime: '평균 응답 시간',
|
||
totalFlow: '총 트래픽',
|
||
logSize: '로그 파일 크기',
|
||
realIPType: '실제 IP 가져오기 방법',
|
||
realIPRecognition: '실제 IP 식별',
|
||
fromHeader: 'HTTP 헤더에서 가져오기',
|
||
fromHeaders: '헤더 목록에서 가져오기',
|
||
header: 'HTTP 헤더',
|
||
cdnConfig: 'CDN 구성',
|
||
xff1: 'X-Forwarded-For 의 1단계 프록시',
|
||
xff2: 'X-Forwarded-For 의 2단계 프록시',
|
||
xff3: 'X-Forwarded-For 의 3단계 프록시',
|
||
xffHelper:
|
||
'예: X-Forwarded-For: <client>,<proxy1>,<proxy2>,<proxy3>. 최상위 프록시는 마지막 IP <proxy3>를 가져옵니다',
|
||
headersHelper:
|
||
'일반적으로 사용되는 CDN HTTP 헤더에서 실제 IP를 가져오며, 사용 가능한 첫 번째 값을 선택합니다',
|
||
monitorCDNHelper: '웹사이트 모니터링을 위한 CDN 구성을 수정하면 WAF CDN 설정도 업데이트됩니다',
|
||
wafCDNHelper: 'WAF CDN 구성을 수정하면 웹사이트 모니터링 CDN 설정도 업데이트됩니다',
|
||
originProtection: '원본 서버 보호',
|
||
originProtectionHelper:
|
||
'선택한 IP 그룹의 CDN 노드만 원본 서버에 연결할 수 있습니다. 방문자 실제 IP 식별은 별도 스위치를 사용합니다.',
|
||
originProtectionIPGroups: 'CDN 원본 IP 그룹',
|
||
originProtectionIPGroupsPlaceholder: '신뢰할 CDN 원본 IP 그룹을 선택하세요',
|
||
originProtectionWarning:
|
||
'잘못 설정하면 웹사이트에 접속할 수 없습니다. 모든 CDN 원본 주소가 포함되었는지 확인하세요.',
|
||
originProtectionEnableConfirm:
|
||
'선택한 IP 그룹 외의 연결은 원본 서버 직접 접근으로 간주되어 차단됩니다. 계속하시겠습니까?',
|
||
statusErr: '잘못된 상태 코드 형식',
|
||
shenma: '션마 검색',
|
||
duckduckgo: '덕덕고',
|
||
yandex: 'Yandex',
|
||
gptbot: 'GPTBot',
|
||
excludeUri: 'URI 제외',
|
||
top100Helper: '상위 100 개의 데이터를 표시합니다',
|
||
logSaveDay: '로그 보관 기간 (일)',
|
||
cros: '크롬 OS',
|
||
theworld: '더월드 브라우저',
|
||
edge: '마이크로소프트 엣지',
|
||
maxthon: '맥스톤 브라우저',
|
||
monitorStatusHelper: '현재 웹사이트 모니터링이 비활성화되어 있습니다. 지금 활성화하세요',
|
||
excludeIp: 'IP 주소 제외',
|
||
excludeUa: '사용자 에이전트 제외',
|
||
remotePort: '원격 포트',
|
||
unknown_browser: '알 수 없음',
|
||
unknown_os: '알 수 없음',
|
||
unknown_device: '알 수 없음',
|
||
logSaveSize: '최대 로그 저장 크기',
|
||
logSaveSizeHelper: '이것은 단일 웹사이트의 로그 저장 크기입니다',
|
||
'360se': '360 보안 브라우저',
|
||
websites: '웹사이트 목록',
|
||
trend: '추세 통계',
|
||
reqCount: '요청 수',
|
||
uriHelper: '/test/* 또는 /*/index.php를 사용하여 Uri를 제외할 수 있습니다',
|
||
},
|
||
tamper: {
|
||
tamper: '웹사이트 변조 방지',
|
||
tamperCreateHint: '현재 디렉터리는 변조 방지 또는 파일 속성의 영향을 받아 생성에 실패할 수 있습니다.',
|
||
ignoreTemplate: '제외 템플릿',
|
||
protectTemplate: '보호 템플릿',
|
||
ignoreTemplateHelper:
|
||
'제외 내용을 입력하세요, Enter 또는 공백으로 구분합니다. (특정 디렉토리 ./log 또는 디렉토리 이름 tmp, 파일을 제외하려면 특정 파일 ./data/test.html을 입력해야 합니다)',
|
||
protectTemplateHelper:
|
||
'보호 내용을 입력하세요, Enter 또는 공백으로 구분합니다. (특정 파일 ./index.html, 파일 확장자 .html, 파일 유형 js, 디렉토리를 보호하려면 특정 디렉토리 ./log을 입력해야 합니다)',
|
||
templateContent: '템플릿 내용',
|
||
template: '템플릿',
|
||
saveTemplate: '템플릿으로 저장',
|
||
tamperHelper1:
|
||
'원클릭 배포 유형의 웹사이트의 경우 애플리케이션 디렉토리 변조 방지 기능을 활성화하는 것이 좋습니다. 웹사이트가 정상적으로 사용되지 않거나 백업/복원이 실패하는 경우 먼저 변조 방지 기능을 비활성화하세요.',
|
||
tamperHelper2:
|
||
'제외되지 않은 디렉토리에서 보호된 파일에 대한 읽기/쓰기, 삭제, 권한 및 소유자 수정 작업을 제한합니다',
|
||
tamperPath: '보호 디렉토리',
|
||
tamperPathEdit: '경로 수정',
|
||
log: '차단 로그',
|
||
totalProtect: '총 보호',
|
||
todayProtect: '오늘 보호',
|
||
templateRule: '길이 1-512, 이름에 {0} 등의 기호를 포함할 수 없습니다',
|
||
ignore: '제외',
|
||
ignoreHelper:
|
||
'제외 내용을 선택하거나 입력하세요, Enter 또는 공백으로 구분합니다. (특정 디렉토리 ./log 또는 디렉토리 이름 tmp, 파일을 제외하려면 특정 파일 ./data/test.html을 입력하거나 선택해야 합니다)',
|
||
protect: '보호',
|
||
protectHelper:
|
||
'보호 내용을 선택하거나 입력하세요, Enter 또는 공백으로 구분합니다. (특정 파일 ./index.html, 파일 확장자 .html, 파일 유형 js, 디렉토리를 보호하려면 특정 디렉토리 ./log을 입력하거나 선택해야 합니다)',
|
||
tamperHelper00: '제외와 보호는 상대 경로만 입력 가능합니다.',
|
||
tamperHelper01:
|
||
'변조 방지를 활성화한 후 시스템은 제외되지 않은 디렉토리에서 보호된 파일의 생성, 편집 및 삭제 작업을 제한합니다.',
|
||
tamperHelper02: '우선순위: 특정 경로 보호 > 특정 경로 제외 > 보호 > 제외',
|
||
tamperHelper03:
|
||
'모니터링 작업은 제외되지 않은 디렉토리만 대상으로 하며, 이러한 디렉토리에서 비보호 파일의 생성을 모니터링합니다.',
|
||
disableHelper: '다음 웹사이트의 변조 방지 기능을 비활성화하려고 합니다. 계속하시겠습니까?',
|
||
appendOnly: '추가 전용',
|
||
appendOnlyHelper:
|
||
'이 디렉토리 내 파일의 삭제 작업을 제한하며, 제외 디렉토리 또는 비보호 파일 추가만 허용합니다',
|
||
immutable: '불변',
|
||
immutableHelper: '이 파일의 편집, 삭제, 권한 및 소유자 수정 작업을 제한합니다',
|
||
onWatch: '감시',
|
||
onWatchHelper: '이 디렉토리 내 보호 파일 또는 비제외 디렉토리 생성에 대한 감시 및 가로채기를 수행합니다',
|
||
forceStop: '강제 종료',
|
||
forceStopHelper: '이 웹사이트 디렉토리의 변조 방지 기능을 강제로 비활성화하려고 합니다. 계속하시겠습니까?',
|
||
},
|
||
setting: {
|
||
setting: '패널 설정',
|
||
title: '패널 설명',
|
||
titleHelper: '사용자 로그인 페이지에 표시됩니다 (예: Linux 서버 운영 및 유지 관리 패널, 권장 길이: 8-15자)',
|
||
logo: '로고 (텍스트 없음)',
|
||
logoHelper: '메뉴가 축소되었을 때 관리 페이지의 왼쪽 상단에 표시됩니다 (권장 이미지 크기: 82px*82px)',
|
||
logoWithText: '로고 (텍스트 포함)',
|
||
logoWithTextHelper:
|
||
'메뉴가 확장되었을 때 관리 페이지의 왼쪽 상단에 표시됩니다 (권장 이미지 크기: 185px*55px)',
|
||
favicon: '웹사이트 아이콘',
|
||
faviconHelper: '웹사이트 아이콘 (권장 이미지 크기: 16px*16px)',
|
||
setDefault: '기본값 복원',
|
||
setHelper: '현재 설정이 저장됩니다. 계속하시겠습니까?',
|
||
setDefaultHelper: '모든 패널 설정이 기본값으로 복원됩니다. 계속하시겠습니까?',
|
||
logoGroup: '로고',
|
||
imageGroup: '이미지',
|
||
loginImage: '이미지',
|
||
loginImageHelper: '로그인 페이지에 표시됩니다 (권장 크기: 500*416px)',
|
||
loginBgType: '배경 유형',
|
||
loginBgImage: '배경 이미지',
|
||
loginBgImageHelper: '로그인 페이지의 배경 이미지로 표시됩니다 (권장 크기: 1920*1080px)',
|
||
loginBgColor: '배경 색상',
|
||
loginBgColorHelper: '로그인 페이지의 배경 색상으로 표시됩니다',
|
||
image: '이미지',
|
||
bgColor: '배경 색상',
|
||
loginGroup: '로그인 페이지',
|
||
loginBtnLinkColor: '버튼/링크 색상',
|
||
loginBtnLinkColorHelper: '로그인 페이지의 버튼/링크 색상으로 표시됩니다',
|
||
},
|
||
helper: {
|
||
wafTitle1: '차단 지도',
|
||
wafContent1: '지난 30일 동안의 차단 지역 분포를 표시합니다.',
|
||
wafTitle2: '지역별 접근 제한',
|
||
wafContent2: '지리적 위치에 따라 웹사이트 접근 소스를 제한합니다.',
|
||
wafTitle3: '사용자 지정 차단 페이지',
|
||
wafContent3: '요청이 차단된 후 표시할 사용자 지정 페이지를 생성합니다.',
|
||
wafTitle4: '사용자 지정 규칙 (ACL)',
|
||
wafContent4: '사용자 지정 규칙에 따라 요청을 차단합니다.',
|
||
tamperTitle1: '파일 무결성 모니터링',
|
||
tamperContent1: '핵심 파일, 스크립트 파일, 구성 파일을 포함한 웹사이트 파일의 무결성을 모니터링합니다.',
|
||
tamperTitle2: '실시간 스캔 및 감지',
|
||
tamperContent2: '웹사이트 파일 시스템을 실시간으로 스캔하여 비정상적이거나 변조된 파일을 감지합니다.',
|
||
tamperTitle3: '보안 권한 설정',
|
||
tamperContent3:
|
||
'적절한 권한 설정과 접근 제어 정책을 통해 웹사이트 파일 접근을 제한하여 잠재적 공격 면적을 줄입니다.',
|
||
tamperTitle4: '로그 기록 및 분석',
|
||
tamperContent4:
|
||
'파일 접근 및 작업 로그를 기록하여 관리자가 감사 및 분석을 수행할 수 있도록 하고, 잠재적 보안 위협을 식별합니다.',
|
||
settingTitle1: '사용자 정의 환영 메시지',
|
||
settingContent1: '1Panel 로그인 페이지에 사용자 정의 환영 메시지를 설정합니다.',
|
||
settingTitle2: '사용자 정의 로고',
|
||
settingContent2: '브랜드명이나 텍스트가 포함된 로고 이미지를 업로드할 수 있습니다.',
|
||
settingTitle3: '사용자 정의 웹사이트 아이콘',
|
||
settingContent3: '브라우저 기본 아이콘을 대체할 사용자 정의 아이콘을 업로드하여 사용자 경험을 개선합니다.',
|
||
monitorTitle1: '방문자 추세',
|
||
monitorContent1: '웹사이트 방문자 추세를 통계적으로 표시합니다.',
|
||
monitorTitle2: '방문자 지도',
|
||
monitorContent2: '웹사이트 방문자의 지리적 분포를 통계적으로 표시합니다.',
|
||
monitorTitle3: '접속 통계',
|
||
monitorContent3: '웹사이트 요청 정보(스파이더, 접속 장치, 요청 상태 등)에 대한 통계를 제공합니다.',
|
||
monitorTitle4: '실시간 모니터링',
|
||
monitorContent4: '웹사이트 요청 정보(요청 수, 트래픽 등)를 실시간으로 모니터링합니다.',
|
||
alertTitle1: 'SMS 알림',
|
||
alertContent1:
|
||
'서버 리소스 사용량 이상, 웹사이트 및 인증서 만료, 새로운 버전 업데이트, 비밀번호 만료 등의 문제가 발생하면 SMS 알림을 통해 사용자가 신속히 처리할 수 있도록 합니다.',
|
||
alertTitle2: '알림 로그',
|
||
alertContent2:
|
||
'사용자에게 알림 로그를 조회할 수 있는 기능을 제공하여 과거 알림 이벤트를 추적하고 분석할 수 있도록 합니다.',
|
||
alertTitle3: '알림 설정',
|
||
alertContent3:
|
||
'사용자에게 전화번호, 일일 푸시 빈도, 일일 푸시 시간 등을 사용자 정의할 수 있는 설정을 제공하여 보다 합리적인 푸시 알림을 설정할 수 있도록 합니다.',
|
||
nodeDashTitle1: '애플리케이션 관리',
|
||
nodeDashContent1:
|
||
'다중 노드 애플리케이션의 통합 관리, 상태 모니터링, 빠른 시작/중지, 터미널 연결 및 백업 지원',
|
||
nodeDashTitle2: '웹사이트 관리',
|
||
nodeDashContent2: '다중 노드 웹사이트의 통합 관리, 실시간 상태 모니터링, 일괄 시작/중지 및 빠른 백업 지원',
|
||
nodeDashTitle3: '데이터베이스 관리',
|
||
nodeDashContent3: '다중 노드 데이터베이스의 통합 관리, 주요 상태 한눈에 확인, 원클릭 백업 지원',
|
||
nodeDashTitle4: '예약 작업 관리',
|
||
nodeDashContent4: '다중 노드 예약 작업의 통합 관리, 상태 모니터링, 빠른 시작/중지 및 수동 트리거 실행 지원',
|
||
nodeTitle1: '원클릭 노드 추가',
|
||
nodeContent1: '여러 서버 노드를 빠르게 통합',
|
||
nodeTitle2: '일괄 업그레이드',
|
||
nodeContent2: '한 번의 작업으로 모든 노드를 동기화 및 업그레이드',
|
||
nodeTitle3: '노드 상태 모니터링',
|
||
nodeContent3: '각 노드의 운영 상태를 실시간으로 파악',
|
||
nodeTitle4: '빠른 원격 연결',
|
||
nodeContent4: '원클릭으로 노드 원격 터미널에 직접 연결',
|
||
fileExchangeTitle1: '키 인증 전송',
|
||
fileExchangeContent1: 'SSH 키를 통해 인증하여 전송 보안을 보장합니다.',
|
||
fileExchangeTitle2: '효율적인 파일 동기화',
|
||
fileExchangeContent2: '변경된 내용만 동기화하여 전송 속도와 안정성을 크게 향상시킵니다.',
|
||
fileExchangeTitle3: '다중 노드 상호 통신 지원',
|
||
fileExchangeContent3: '다른 노드 간에 프로젝트 파일을 쉽게 전송하고, 여러 서버를 유연하게 관리합니다.',
|
||
nodeAppTitle1: '애플리케이션 업그레이드 관리',
|
||
nodeAppContent1: '다중 노드 애플리케이션 업데이트 통합 모니터링, 원클릭 업그레이드 지원',
|
||
appTitle1: '유연한 패널 관리',
|
||
appContent1: '언제 어디서나 1Panel 서버를 쉽게 관리하세요.',
|
||
appTitle2: '종합적인 서비스 정보',
|
||
appContent2:
|
||
'모바일 앱에서 애플리케이션, 웹사이트, Docker, 데이터베이스 등의 기본 관리를 하고, 애플리케이션과 웹사이트의 빠른 생성을 지원합니다.',
|
||
appTitle3: '실시간 이상 모니터링',
|
||
appContent3:
|
||
'모바일 앱에서 서버 상태, WAF 보안 모니터링, 웹사이트 방문 통계 및 프로세스 건강 상태를 실시간으로 확인하세요.',
|
||
clusterTitle1: '마스터-슬레이브 배포',
|
||
clusterContent1:
|
||
'다른 노드에서 MySQL/Postgres/Redis 마스터-슬레이브 인스턴스를 생성하는 것을 지원하며, 자동으로 마스터-슬레이브 연결 및 초기화를 완료합니다',
|
||
clusterTitle2: '마스터-슬레이브 관리',
|
||
clusterContent2:
|
||
'통합 페이지에서 여러 마스터-슬레이브 노드를 중앙에서 관리하고, 역할, 실행 상태 등을 확인합니다',
|
||
clusterTitle3: '복제 상태',
|
||
clusterContent3:
|
||
'마스터-슬레이브 복제 상태 및 지연 정보를 표시하여 동기화 문제를 해결하는 데 도움을 줍니다',
|
||
modelDownloaderTitle1: '모델 탐색',
|
||
modelDownloaderContent1:
|
||
'HuggingFace 모델 저장소를 직접 검색하고 다운로드 수, 좋아요, 모델 상세 정보, 파일 목록을 확인합니다.',
|
||
modelDownloaderTitle2: '가속 다운로드',
|
||
modelDownloaderContent2:
|
||
'HuggingFace 가속 엔드포인트와 HF Token을 설정하여 공식 사이트, 미러, 비공개 모델에 대응합니다.',
|
||
modelDownloaderTitle3: '작업 추적',
|
||
modelDownloaderContent3:
|
||
'다운로드 대기열, 작업 상태, 진행률, 오류를 한곳에서 확인하고 취소, 재시도, 기록 정리를 지원합니다.',
|
||
modelDownloaderTitle4: '로컬 관리',
|
||
modelDownloaderContent4:
|
||
'로컬 모델 디렉토리를 중앙에서 관리하고 경로, 크기, 시간을 확인하며 불필요한 모델 파일을 삭제합니다.',
|
||
vllmTitle1: '통합 관리',
|
||
vllmContent1:
|
||
'분산된 vLLM 서비스를 1Panel에 통합하여 인스턴스、버전、상태、실행 디렉토리를 집중 조회할 수 있습니다.',
|
||
vllmTitle2: '빠른 배포',
|
||
vllmContent2:
|
||
'시각적 양식으로 버전 선택、모델 디렉토리 마운트、시작 매개변수 설정을 완료하여 수동 구성 비용을 줄입니다.',
|
||
vllmTitle3: '운영 효율성',
|
||
vllmContent3:
|
||
'같은 페이지에서 생성、편집、시작、중지、재시작、삭제、작업 추적을 완료하여 로컬 모델 서비스 유지보수 효율을 향상시킵니다.',
|
||
vllmTitle4: '구성 제어',
|
||
vllmContent4:
|
||
'고급 설정으로 포트、컨테이너、시작 명령、Compose 구성을 통합 관리하여 표준화된 배포와 후속 조정을 용이하게 합니다.',
|
||
},
|
||
node: {
|
||
master: '주 노드',
|
||
masterBackup: '마스터 노드 백업',
|
||
backupNode: '백업 노드',
|
||
backupFrequency: '백업 주기(시간)',
|
||
backupCopies: '백업 수',
|
||
noBackupNode: '현재 백업 노드가 비어 있습니다. 저장할 백업 노드를 선택한 후 다시 시도하십시오!',
|
||
masterBackupAlert:
|
||
'현재 마스터 노드 백업이 구성되지 않았습니다. 데이터 보안을 위해 장애 시 새로운 마스터 노드로 수동 전환이 가능하도록 가능한 빨리 백업 노드를 설정하십시오.',
|
||
node: '노드',
|
||
addr: '주소',
|
||
nodeUpgrade: '업데이트 설정',
|
||
nodeUpgradeHelper:
|
||
'선택된 노드는 마스터 노드 업그레이드 완료 후 자동으로 업그레이드를 시작하며 수동 작업이 필요하지 않습니다.',
|
||
nodeUpgradePackageManage: '설치 패키지 관리',
|
||
nodeUpgradePackageClean: '정리',
|
||
nodeUpgradePackageFormatHelper: '`1panel-agent_v*_*` 또는 `1panel-v*-linux-*` 설치 패키지만 지원됩니다',
|
||
nodeUpgradePackageHostConfirm: '서버 파일 {0}을(를) 선택합니다. 계속하시겠습니까?',
|
||
nodeUpgradePackageCleanHelper: '모든 낮은 버전의 업데이트 패키지를 정리합니다. 계속하시겠습니까?',
|
||
nodeUpgradeOfflinePackageHelper:
|
||
'오프라인 환경에서는 다른 아키텍처의 노드를 업데이트하기 전에 해당 업데이트 패키지를 먼저 업로드해야 합니다.',
|
||
nodeUnhealthy: '노드 상태 이상',
|
||
deletedNode: '삭제된 노드 {0}은(는) 현재 업그레이드 작업을 지원하지 않습니다!',
|
||
nodeUnhealthyHelper: '노드 상태 이상이 감지되었습니다. [노드 관리]에서 확인 후 다시 시도하세요!',
|
||
nodeUnbind: '노드가 라이선스에 바인딩되지 않음',
|
||
nodeUnbindHelper:
|
||
'이 노드가 라이선스에 바인딩되지 않은 것으로 감지되었습니다. [패널 설정 - 라이선스] 메뉴에서 바인딩 후 다시 시도하세요!',
|
||
memTotal: '총 메모리',
|
||
nodeManagement: '다중 머신 관리',
|
||
multiOverview: '다중 머신',
|
||
commonNodes: '자주 사용하는 노드',
|
||
searchNodePlaceholder: '노드 이름, 그룹 또는 주소 검색',
|
||
nodeItem: '노드 관리',
|
||
panelItem: '패널 관리',
|
||
addPanel: '패널 추가',
|
||
addPanelHelper: 'パネルの追加に成功後、[概要 - パネル]で対象パネルに迅速にアクセスできます。',
|
||
panel: '1Panel パネル',
|
||
others: 'その他のパネル',
|
||
addNode: '노드 추가',
|
||
connInfo: '연결 정보',
|
||
nodeInfo: '노드 정보',
|
||
withProxy: '프록시 액세스 활성화',
|
||
withoutProxy: '프록시 액세스 비활성화',
|
||
withProxyHelper:
|
||
'패널 설정에서 유지 관리되는 시스템 프록시 {0}을(를) 사용하여 자식 노드에 액세스합니다. 계속하시겠습니까?',
|
||
withoutProxyHelper:
|
||
'패널 설정에서 유지 관리되는 시스템 프록시를 사용하여 자식 노드에 액세스하는 것을 중지합니다. 계속하시겠습니까?',
|
||
syncInfo: '데이터 동기화,',
|
||
syncHelper: '마스터 노드 데이터가 변경되면, 이 자식 노드에 실시간으로 동기화됩니다,',
|
||
syncBackupAccount: '백업 계정 설정',
|
||
syncWithMaster:
|
||
'상용 버전으로 업그레이드 후 모든 데이터가 기본적으로 동기화됩니다. 노드 관리에서 동기화 정책을 수동으로 조정할 수 있습니다.',
|
||
syncProxy: '시스템 프록시 설정',
|
||
syncProxyHelper: '시스템 프록시 설정 동기화에는 Docker 재시작이 필요합니다',
|
||
syncProxyHelper1: 'Docker 재시작은 현재 실행 중인 컨테이너 서비스에 영향을 줄 수 있습니다.',
|
||
syncProxyHelper2: '컨테이너 - 설정 페이지에서 수동으로 재시작할 수 있습니다.',
|
||
syncProxyHelper3:
|
||
'시스템 프록시 설정 동기화에는 Docker 재시작이 필요하며, 현재 실행 중인 컨테이너 서비스에 영향을 줄 수 있습니다',
|
||
syncProxyHelper4:
|
||
'시스템 프록시 설정 동기화에는 Docker 재시작이 필요합니다. 나중에 컨테이너 - 설정 페이지에서 수동으로 재시작할 수 있습니다.',
|
||
syncCustomApp: '사용자 정의 앱 저장소 동기화',
|
||
syncAlertSetting: '시스템 경고 설정',
|
||
syncNodeInfo: '노드 기본 데이터,',
|
||
nodeSyncHelper: '노드 정보 동기화는 다음 정보를 동기화합니다:',
|
||
nodeSyncHelper1: '1. 공용 백업 계정 정보',
|
||
nodeSyncHelper2: '2. 주 노드와 하위 노드 간의 연결 정보',
|
||
nodeCheck: '가용성 확인',
|
||
checkSSH: '노드 SSH 연결 확인',
|
||
checkUserPermission: '노드 사용자 권한 확인',
|
||
isNotRoot:
|
||
'이 노드에서 비밀번호 없이 sudo를 사용할 수 없으며 현재 사용자가 root가 아닌 것으로 감지되었습니다',
|
||
checkLicense: '노드 라이선스 상태 확인',
|
||
checkService: '노드의 기존 서비스 정보 확인',
|
||
checkPort: '노드 포트 접근 가능 여부 확인',
|
||
panelExist:
|
||
'이 노드에서 1Panel V1 서비스가 실행 중인 것으로 감지되었습니다. 추가 전에 마이그레이션 스크립트로 V2로 업그레이드하십시오.',
|
||
coreExist:
|
||
'현재 노드가 마스터 노드로 활성화되어 있어 슬레이브 노드로 직접 추가할 수 없습니다. 추가하기 전에 먼저 슬레이브 노드로 다운그레이드하십시오. 자세한 내용은 문서를 참조하십시오.',
|
||
agentExist:
|
||
'이 노드에 1panel-agent가 이미 설치되어 있는 것으로 감지되었습니다. 계속하면 기존 데이터를 유지하고 1panel-agent 서비스만 교체됩니다.',
|
||
agentNotExist:
|
||
'이 노드에 1panel-agent가 설치되지 않아 노드 정보를 직접 편집할 수 없습니다. 삭제 후 다시 추가해 주세요.',
|
||
oldDataExist:
|
||
'이 노드에서 1Panel V2 기록 데이터가 감지되었습니다. 다음 정보를 사용하여 현재 설정을 덮어씁니다:',
|
||
errLicense: '이 노드에 바인딩된 라이선스를 사용할 수 없습니다. 확인 후 다시 시도하십시오!',
|
||
errNodePort:
|
||
'노드 포트 [ {0} ]에 접근할 수 없는 것으로 감지되었습니다. 방화벽 또는 보안 그룹에서 해당 포트가 허용되었는지 확인하십시오.',
|
||
reinstallHelper: '노드 {0}를 재설치합니다. 계속하시겠습니까?',
|
||
unhealthyCheck: '비정상 체크',
|
||
fixOperation: '수정 작업',
|
||
checkName: '체크 항목',
|
||
checkSSHConn: 'SSH 연결 가능성 확인',
|
||
fixSSHConn: '노드를 수동으로 편집하여 연결 정보를 확인합니다',
|
||
checkConnInfo: '에이전트 연결 정보 확인',
|
||
checkStatus: '노드 서비스 가용성 확인',
|
||
fixStatus: '"systemctl status 1panel-agent.service"를 실행하여 서비스가 실행 중인지 확인합니다.',
|
||
checkAPI: '노드 API 가용성 확인',
|
||
fixAPI: '노드 로그를 확인하고 방화벽 포트가 정상적으로 열려 있는지 확인합니다.',
|
||
forceDelete: '강제 삭제',
|
||
operateHelper: '다음 노드에 대해 {0} 작업을 수행합니다. 계속하시겠습니까?',
|
||
operatePanelHelper: '다음 패널에 대해 {0} 작업을 수행합니다. 계속하시겠습니까?',
|
||
forceDeleteHelper: '강제 삭제는 노드 삭제 오류를 무시하고 데이터베이스 메타데이터를 삭제합니다',
|
||
uninstall: '노드 데이터 삭제',
|
||
uninstallHelper: '이 작업은 노드의 모든 1Panel 관련 데이터를 삭제합니다. 신중하게 선택하세요!',
|
||
baseDir: '설치 디렉토리',
|
||
baseDirHelper: '설치 디렉토리가 비어 있으면 기본적으로 /opt 디렉토리에 설치됩니다',
|
||
nodePort: '노드 포트',
|
||
offline: '오프라인 모드',
|
||
freeCount: '무료 할당량 [{0}]',
|
||
offlineHelper: '노드가 오프라인 환경일 때 사용',
|
||
appUpgrade: '앱 업그레이드',
|
||
appUpgradeHelper: '업그레이드가 필요한 앱이 {0}개 있습니다',
|
||
},
|
||
customApp: {
|
||
name: '사용자 정의 앱 저장소',
|
||
appStoreType: '앱 스토어 패키지 소스',
|
||
appStoreUrl: '저장소 URL',
|
||
local: '로컬 경로',
|
||
remote: '원격 링크',
|
||
imagePrefix: '이미지 접두사',
|
||
imagePrefixHelper:
|
||
'기능: 이미지 접두사를 사용자 정의하고 compose 파일의 이미지 필드를 수정합니다. 예를 들어 이미지 접두사를 1panel/custom으로 설정하면 MaxKB의 이미지 필드는 1panel/custom/maxkb:v1.10.0으로 변경됩니다',
|
||
closeHelper: '사용자 정의 앱 저장소 사용 취소',
|
||
appStoreUrlHelper: '.tar.gz 형식만 지원합니다',
|
||
postNode: '서브 노드로 동기화',
|
||
postNodeHelper:
|
||
'사용자 정의 스토어 패키지를 하위 노드의 설치 디렉토리에 있는 tmp/customApp/apps.tar.gz로 동기화합니다',
|
||
nodes: '노드 선택',
|
||
selectNode: '노드 선택',
|
||
selectNodeError: '노드를 선택하세요',
|
||
licenseHelper: '상용 버전은 사용자 정의 애플리케이션 저장소 기능을 지원합니다',
|
||
databaseHelper: '애플리케이션 관련 데이터베이스, 대상 노드 데이터베이스를 선택하세요',
|
||
nodeHelper: '현재 노드는 선택할 수 없습니다',
|
||
migrateHelper:
|
||
'현재 단일 애플리케이션과 MySQL, MariaDB, PostgreSQL 데이터베이스만 연결된 애플리케이션의 마이그레이션만 지원합니다',
|
||
opensslHelper:
|
||
'암호화된 백업을 사용하는 경우 두 노드 간의 OpenSSL 버전이 일치해야 합니다. 그렇지 않으면 마이그레이션이 실패할 수 있습니다.',
|
||
installApp: '일괄 설치',
|
||
installAppHelper: '선택한 노드에 앱 일괄 설치',
|
||
},
|
||
alert: {
|
||
isAlert: '알림',
|
||
alertCount: '알림 횟수',
|
||
clamHelper: '감염된 파일을 스캔할 때 알림 트리거',
|
||
cronJobHelper: '작업 실행 실패 시 알림 트리거',
|
||
licenseHelper: '상용 버전에서는 알림을 지원합니다.',
|
||
alertCountHelper: '최대 일일 알림 빈도',
|
||
alert: 'SMS 알림',
|
||
logs: '알림 로그',
|
||
list: '알림 목록',
|
||
addTask: '알림 생성',
|
||
editTask: '알림 수정',
|
||
alertMethod: '알림 방법',
|
||
alertMsg: '알림 메시지',
|
||
alertRule: '알림 규칙',
|
||
titleSearchHelper: '알림 제목을 입력하여 검색하세요',
|
||
taskType: '유형',
|
||
ssl: 'SSL 인증서 만료',
|
||
siteEndTime: '웹사이트 만료',
|
||
panelPwdEndTime: '패널 비밀번호 만료',
|
||
panelUpdate: '새 패널 버전 사용 가능',
|
||
cpu: '서버 CPU 알림',
|
||
memory: '서버 메모리 알림',
|
||
load: '서버 부하 알림',
|
||
disk: '서버 디스크 알림',
|
||
website: '웹사이트',
|
||
certificate: 'SSL 인증서',
|
||
remainingDays: '남은 일수',
|
||
sendCount: '발송 횟수',
|
||
recipientPlaceholder: '이메일 주소를 입력하세요',
|
||
addRecipient: '수신자 추가',
|
||
webhookItem: 'Webhook 링크',
|
||
addWebhook: 'Webhook 추가',
|
||
selectAlertType: '알림 유형 선택',
|
||
configDetail: '세부 설정',
|
||
webhookCount: 'Webhook 수',
|
||
sms: 'SMS',
|
||
wechat: '위챗',
|
||
dingTalk: '딩톡',
|
||
feiShu: '페이슈',
|
||
mail: '이메일',
|
||
email: '이메일 알림',
|
||
weCom: 'WeCom',
|
||
bark: 'Bark',
|
||
sendCountRulesHelper: '만료 전 발송된 총 알림 수 (하루 1회)',
|
||
panelUpdateRulesHelper: '새 패널 버전에 대한 총 알림 수 (하루 1회)',
|
||
oneDaySendCountRulesHelper: '하루 최대 발송 가능한 알림 수',
|
||
siteEndTimeRulesHelper: '만료되지 않는 웹사이트는 알림이 발생하지 않습니다',
|
||
autoRenewRulesHelper: '자동 갱신이 설정된 인증서의 남은 일수가 31일 미만이면 알림이 발생하지 않습니다',
|
||
panelPwdEndTimeRulesHelper: '만료가 설정되지 않은 경우 패널 비밀번호 만료 알림이 비활성화됩니다',
|
||
sslRulesHelper: '모든 SSL 인증서',
|
||
diskInfo: '디스크',
|
||
monitoringType: '모니터링 유형',
|
||
autoRenew: '자동 갱신',
|
||
useDisk: '디스크 사용량',
|
||
usePercentage: '사용 비율',
|
||
changeStatus: '상태 변경',
|
||
disableMsg: '알림 작업을 중지하면 알림 메시지가 전송되지 않습니다. 계속하시겠습니까?',
|
||
enableMsg: '알림 작업을 활성화하면 알림 메시지가 전송됩니다. 계속하시겠습니까?',
|
||
useExceed: '사용량 초과',
|
||
useExceedRulesHelper: '사용량이 설정 값을 초과하면 알림을 트리거합니다',
|
||
cpuUseExceedAvg: '평균 CPU 사용량이 지정된 값을 초과함',
|
||
memoryUseExceedAvg: '평균 메모리 사용량이 지정된 값을 초과함',
|
||
loadUseExceedAvg: '평균 부하 사용량이 지정된 값을 초과함',
|
||
cpuUseExceedAvgHelper: '지정된 시간 내의 평균 CPU 사용량이 지정된 값을 초과함',
|
||
memoryUseExceedAvgHelper: '지정된 시간 내의 평균 메모리 사용량이 지정된 값을 초과함',
|
||
loadUseExceedAvgHelper: '지정된 시간 내의 평균 부하 사용량이 지정된 값을 초과함',
|
||
resourceAlertRulesHelper: '참고: 30분 내에 연속적인 알림은 한 번만 발송됩니다',
|
||
specifiedTime: '지정된 시간',
|
||
deleteTitle: '알림 삭제',
|
||
deleteMsg: '알림 작업을 삭제하시겠습니까?',
|
||
allSslTitle: '모든 웹사이트 SSL 인증서 만료 알림',
|
||
sslTitle: '웹사이트 {0}의 SSL 인증서 만료 알림',
|
||
allSiteEndTimeTitle: '모든 웹사이트 만료 알림',
|
||
siteEndTimeTitle: '웹사이트 {0} 만료 알림',
|
||
panelPwdEndTimeTitle: '패널 비밀번호 만료 알림',
|
||
panelUpdateTitle: '새 패널 버전 알림',
|
||
cpuTitle: '고 CPU 사용량 알림',
|
||
memoryTitle: '고 메모리 사용량 알림',
|
||
loadTitle: '고 부하 알림',
|
||
diskTitle: '디스크 사용량 초과 알림 {0}',
|
||
allDiskTitle: '고 디스크 사용량 알림',
|
||
timeRule: '{0}일 이하 남은 시간 (처리되지 않으면 다음 날 다시 전송)',
|
||
panelUpdateRule: '새 패널 버전이 감지되면 한 번 알림을 전송 (처리되지 않으면 다음 날 다시 전송)',
|
||
avgRule: '{0}분 내 평균 {1} 사용량이 {2}% 초과 시 알림을 트리거하며 하루에 {3}번 발송',
|
||
diskRule: '디스크 사용량이 마운트 디렉토리 {0}에서 {1}{2}를 초과하면 알림을 트리거하고 하루에 {3}번 발송',
|
||
allDiskRule: '디스크 사용량이 {0}{1}을 초과하면 알림을 트리거하고 하루에 {2}번 발송',
|
||
cpuName: ' CPU ',
|
||
memoryName: '메모리',
|
||
loadName: '부하',
|
||
diskName: '디스크',
|
||
syncAlertInfo: '수동 푸시',
|
||
syncAlertInfoMsg: '알림 작업을 수동으로 푸시하시겠습니까?',
|
||
pushError: '푸시 실패',
|
||
pushSuccess: '푸시 성공',
|
||
syncError: '동기화 실패',
|
||
success: '알림 성공',
|
||
pushing: '푸시 중...',
|
||
error: '알림 실패',
|
||
cleanLog: '로그 정리',
|
||
cleanAlertLogs: '알림 로그 정리',
|
||
daily: '일일 알림 수: {0}',
|
||
cumulative: '누적 알림 수: {0}',
|
||
clams: '바이러스 검사',
|
||
taskName: '작업 이름',
|
||
cronJobType: '작업 유형',
|
||
clamPath: '검사 디렉토리',
|
||
cronjob: '예약 작업 실행 {0} 중 오류가 발생했습니다',
|
||
app: '백업 애플리케이션',
|
||
web: '백업 웹사이트',
|
||
database: '백업 데이터베이스',
|
||
directory: '백업 디렉토리',
|
||
log: '백업 로그',
|
||
snapshot: '시스템 스냅샷',
|
||
clamsRulesHelper: '알림이 필요한 바이러스 검사 작업',
|
||
cronJobRulesHelper: '이 유형의 예약된 작업은 구성해야 합니다',
|
||
clamsTitle: '바이러스 검사 작업 「 {0} 」 감염된 파일 알림',
|
||
cronJobAppTitle: '크론 작업 - 백업 애플리케이션 「 {0} 」 작업 실패 알림',
|
||
cronJobWebsiteTitle: '크론 작업 - 백업 웹사이트「 {0} 」작업 실패 알림',
|
||
cronJobDatabaseTitle: '크론 작업 - 백업 데이터베이스「 {0} 」작업 실패 알림',
|
||
cronJobDirectoryTitle: '크론 작업 - 백업 디렉토리「 {0} 」작업 실패 알림',
|
||
cronJobLogTitle: '크론 작업 - 백업 로그「 {0} 」작업 실패 알림',
|
||
cronJobSnapshotTitle: '크론 작업 - 백업 스냅샷「 {0} 」작업 실패 알림',
|
||
cronJobShellTitle: '크론 작업 - 셸 스크립트 「 {0} 」작업 실패 알림',
|
||
cronJobCurlTitle: '크론 작업 - URL 접근「 {0} 」작업 실패 알림',
|
||
cronJobCutWebsiteLogTitle: '크론 작업 - 웹사이트 로그 자르기「 {0} 」작업 실패 알림',
|
||
cronJobCleanTitle: '크론 작업 - 캐시 정리「 {0} 」작업 실패 알림',
|
||
cronJobNtpTitle: '크론 작업 - 서버 시간 동기화「 {0} 」작업 실패 알림',
|
||
clamsRule: '바이러스 검사로 감염된 파일 알림, 하루에 {0}번 발송',
|
||
cronJobAppRule: '백업 애플리케이션 작업 실패 알림, 하루에 {0}번 발송',
|
||
cronJobWebsiteRule: '백업 웹사이트 작업 실패 알림, 하루에 {0}번 발송',
|
||
cronJobDatabaseRule: '백업 데이터베이스 작업 실패 알림, 하루에 {0}번 발송',
|
||
cronJobDirectoryRule: '백업 디렉토리 작업 실패 알림, 하루에 {0}번 발송',
|
||
cronJobLogRule: '백업 로그 작업 실패 알림, 하루에 {0}번 발송',
|
||
cronJobSnapshotRule: '백업 스냅샷 작업 실패 알림, 하루에 {0}번 발송',
|
||
cronJobShellRule: '셸 스크립트 작업 실패 알림, 하루에 {0}번 발송',
|
||
cronJobCurlRule: 'URL 접근 작업 실패 알림, 하루에 {0}번 발송',
|
||
cronJobCutWebsiteLogRule: '웹사이트 로그 자르기 작업 실패 알림, 하루에 {0}번 발송',
|
||
cronJobCleanRule: '캐시 정리 작업 실패 알림, 하루에 {0}번 발송',
|
||
cronJobNtpRule: '서버 시간 동기화 작업 실패 알림, 하루에 {0}번 발송',
|
||
alertSmsHelper: 'SMS 한도: 총 {0}개의 메시지, {1}개 사용됨',
|
||
goBuy: '추가 구매',
|
||
phone: '전화',
|
||
phoneHelper: '알림 메시지를 위한 실제 전화번호를 제공하세요',
|
||
dailyAlertNum: '일일 알림 한도',
|
||
dailyAlertNumHelper: '하루에 보낼 수 있는 최대 알림 수 (최대 100개)',
|
||
timeRange: '시간 범위',
|
||
sendTimeRange: '발송 시간 범위',
|
||
sendTimeRangeHelper: '{0} 시간 범위를 푸시할 수 있습니다',
|
||
to: '부터',
|
||
startTime: '시작 시간',
|
||
endTime: '종료 시간',
|
||
defaultPhone: '기본적으로 라이선스에 묶인 계정의 전화번호 사용',
|
||
noticeAlert: '공지 알림',
|
||
resourceAlert: '리소스 알림',
|
||
agentOfflineAlertHelper:
|
||
'노드에서 오프라인 알림이 활성화되면, 메인 노드가 30분마다 스캔하여 알림 작업을 수행합니다.',
|
||
offline: '오프라인 알림',
|
||
offlineHelper: '오프라인 알림으로 설정하면, 메인 노드가 30분마다 스캔하여 알림 작업을 수행합니다.',
|
||
offlineOff: '오프라인 알림 활성화',
|
||
offlineOffHelper: '오프라인 알림을 활성화하면, 메인 노드가 30분마다 스캔하여 알림 작업을 수행합니다.',
|
||
offlineClose: '오프라인 알림 비활성화',
|
||
offlineCloseHelper:
|
||
'오프라인 알림을 비활성화하면, 하위 노드가 알림을 직접 처리해야 합니다. 알림 실패를 방지하려면 네트워크 연결이 원활한지 확인하세요.',
|
||
alertNotice: '알림 통지',
|
||
methodConfig: '알림 방법 설정',
|
||
createMethod: '알림 방법 생성',
|
||
methodInvalid: '유효하지 않은 설정 {0}',
|
||
commonConfig: '전역 설정',
|
||
smsConfig: 'SMS',
|
||
smsConfigHelper: 'SMS 알림을 받을 전화번호를 설정합니다',
|
||
emailConfig: '이메일',
|
||
emailConfigHelper: 'SMTP 이메일 발송 서비스를 설정합니다',
|
||
deleteConfigTitle: '알림 설정 삭제',
|
||
deleteConfigMsg: '알림 설정을 삭제하시겠습니까?',
|
||
test: '테스트',
|
||
alertTestOk: '테스트 알림 성공',
|
||
alertTestFailed: '테스트 알림 실패',
|
||
displayName: '표시 이름',
|
||
sender: '발신 주소',
|
||
password: '비밀번호',
|
||
host: 'SMTP 서버',
|
||
port: '포트 번호',
|
||
encryption: '암호화 방식',
|
||
recipient: '수신자',
|
||
licenseTime: '라이선스 만료 알림',
|
||
licenseTimeTitle: '라이선스 만료 알림',
|
||
displayNameHelper: '이메일 발신자 표시 이름',
|
||
senderHelper: '이메일 발송에 사용되는 주소',
|
||
passwordHelper: '메일 서비스의 인증 코드',
|
||
hostHelper: 'SMTP 서버 주소, 예: smtp.qq.com',
|
||
portHelper: 'SSL 은 일반적으로 465, TLS 는 587',
|
||
sslHelper: 'SMTP 포트가 465 이면 일반적으로 SSL 이 필요합니다',
|
||
tlsHelper: 'SMTP 포트가 587 이면 일반적으로 TLS 가 필요합니다',
|
||
triggerCondition: '트리거 조건',
|
||
loginFail: ' 이내 로그인 실패',
|
||
nodeException: '노드 이상 알림',
|
||
licenseException: '라이선스 이상 알림',
|
||
panelLogin: '패널 로그인 이상 알림',
|
||
sshLogin: 'SSH 로그인 이상 알림',
|
||
panelIpLogin: '패널 로그인 IP 이상 알림',
|
||
sshIpLogin: 'SSH 로그인 IP 이상 알림',
|
||
ipWhiteListHelper:
|
||
'화이트리스트에 있는 IP는 규칙의 제한을 받지 않으며, 로그인에 성공해도 알림이 발생하지 않습니다',
|
||
nodeExceptionRule: '노드 이상 알림은 하루 {0}회 전송',
|
||
licenseExceptionRule: '라이선스 이상 알림은 하루 {0}회 전송',
|
||
panelLoginRule: '패널 로그인 알림은 하루 {0}회 전송',
|
||
sshLoginRule: 'SSH 로그인 알림은 하루 {0}회 전송',
|
||
userNameHelper: '사용자 이름이 비어 있으면 기본적으로 발신자 주소가 사용됩니다',
|
||
alertConfigHelper: '패널 메시지 푸시를 수신하기 위한 알림 채널 구성',
|
||
weComConfigHelper: 'WeCom 알림 구성',
|
||
wechatConfigHelper: 'WeChat 공식 계정 알림 구성',
|
||
dingTalkConfigHelper: 'DingTalk 알림 구성',
|
||
feiShuConfigHelper: 'Feishu 알림 구성',
|
||
barkConfigHelper: 'Bark 알림 구성',
|
||
webhookName: '봇 이름',
|
||
webhookUrl: 'Webhook URL',
|
||
alertConfigProHelper: '상용 버전에서는 WeCom, DingTalk, Feishu, SMS 알림도 지원합니다.',
|
||
},
|
||
theme: {
|
||
lingXiaGold: 'LXware Gold',
|
||
classicBlue: '클래식 블루',
|
||
freshGreen: '프레시 그린',
|
||
customColor: '사용자 정의 색상',
|
||
setDefault: '기본값',
|
||
setDefaultHelper: '테마 색상 스킴이 초기 상태로 복원됩니다. 계속하시겠습니까?',
|
||
setHelper: '현재 선택한 테마 색상 스킴이 저장됩니다. 계속하시겠습니까?',
|
||
},
|
||
sync: {
|
||
menu: '리소스 동기화',
|
||
file: '파일 전송',
|
||
fileSyncConfirm: '{0} 노드의 파일/폴더 {1}을(를) {2} 노드의 디렉터리 {3}(으)로 전송하시겠습니까?',
|
||
|
||
image: '이미지 전송',
|
||
imageBatchDesc: '먼저 원본 노드와 원본 이미지를 선택한 후 대상 노드를 선택하여 전달합니다.',
|
||
imageBatchConfirmPrefix: '{0}개의 이미지를 {1}개 노드로 전달합니다. 총 {2}개의 작업이 생성됩니다.',
|
||
|
||
ssl: '인증서 동기화',
|
||
sslBatchDesc: '원본 노드를 선택한 후 지정된 인증서를 현재 패널 환경으로 동기화할 수 있습니다.',
|
||
sslBatchConfirmPrefix: '{0}개의 인증서를 {1}개 노드로 동기화합니다. 총 {2}개의 작업이 생성됩니다.',
|
||
|
||
app: '애플리케이션 전송',
|
||
appBatchDesc:
|
||
'원본 노드, 애플리케이션 및 대상 노드를 선택한 후 리소스 종속성을 확인하고 애플리케이션 전송 작업을 실행합니다.',
|
||
appSelectedApp: '선택한 애플리케이션:',
|
||
appPreviewTitle: '전송 미리보기',
|
||
appPreviewDesc: '대상 노드와 종속 리소스를 확인한 후 애플리케이션 전송을 실행하세요.',
|
||
appDatabaseDependency: '데이터베이스 종속성',
|
||
appResourceRequired: '필수 연관 리소스를 모두 먼저 선택하세요.',
|
||
appUnsupportedMultipleResources:
|
||
'현재 최대 하나의 리소스만 연결된 애플리케이션만 마이그레이션할 수 있습니다.',
|
||
appUnsupportedResourceType:
|
||
'현재 리소스 종속성이 없거나 MySQL, MariaDB, PostgreSQL에만 의존하는 애플리케이션만 마이그레이션할 수 있습니다.',
|
||
|
||
targetTitle: '대상 노드',
|
||
targetDesc: '원본 노드는 자동으로 제외됩니다. 하나 이상의 대상 노드를 선택할 수 있습니다.',
|
||
targetSearchPlaceholder: '노드 이름 또는 주소 검색',
|
||
noTargetNodes: '선택 가능한 대상 노드가 없습니다',
|
||
noSourceNode: '먼저 원본 노드를 선택하세요',
|
||
reviewTargets: '대상 노드',
|
||
reviewEmpty: '먼저 리소스와 대상 노드를 선택하세요',
|
||
selectSourceFirst: '먼저 원본 노드를 선택하세요.',
|
||
selectResourceFirst: '먼저 동기화할 리소스를 선택하세요.',
|
||
selectTargetFirst: '최소 하나의 대상 노드를 선택하세요.',
|
||
submitSuccess: '동기화 작업이 제출되었습니다.',
|
||
},
|
||
vm: {
|
||
vm: '가상 머신',
|
||
title: '가상 머신 관리',
|
||
healthCheck: '상태 점검',
|
||
healthCheckResult: {
|
||
pass: '정상',
|
||
info: '정보',
|
||
warn: '경고',
|
||
fail: '실패',
|
||
normal: '정상',
|
||
fixCommand: '수정 명령어',
|
||
technicalDetail: '기술 세부 정보',
|
||
check: {
|
||
vmName: '가상 머신 이름',
|
||
libvirtConnection: 'Libvirt 연결',
|
||
vmDefinition: '가상 머신 정의',
|
||
domainXML: '가상 머신 XML',
|
||
architecture: '아키텍처',
|
||
virtualizationType: '가상화 유형',
|
||
machineType: '머신 유형',
|
||
efiCapability: 'EFI 기능',
|
||
qemuEmulator: 'QEMU 에뮬레이터',
|
||
bootOrder: '부팅 순서',
|
||
arm64Firmware: 'ARM64 펌웨어',
|
||
arm64Features: 'ARM64 기능',
|
||
arm64Video: 'ARM64 디스플레이',
|
||
arm64FirmwareFile: 'ARM64 펌웨어 파일',
|
||
arm64CDROM: 'ARM64 CD-ROM',
|
||
blockDevice: '블록 장치',
|
||
isoArchitecture: 'ISO 아키텍처',
|
||
network: '네트워크',
|
||
qemuLog: 'QEMU 로그',
|
||
arm64RuntimeFirmware: 'ARM64 런타임 펌웨어',
|
||
},
|
||
reason: {
|
||
invalidName: '가상 머신 이름이 올바르지 않습니다.',
|
||
connectionFailed: '{uri}에 연결할 수 없습니다.',
|
||
vmNotFound: '가상 머신 {name}을(를) 찾을 수 없습니다.',
|
||
xmlReadFailed: '가상 머신 XML을 읽지 못했습니다.',
|
||
liveXMLFallback: '영구 설정을 읽을 수 없어 현재 실행 설정을 사용합니다.',
|
||
xmlParseFailed: '가상 머신 XML을 분석하지 못했습니다.',
|
||
stateReadFailed: '가상 머신 상태를 확인할 수 없어 런타임 펌웨어 검사를 건너뛰었습니다.',
|
||
guestArchMissing: 'XML에 게스트 아키텍처가 없습니다.',
|
||
archMismatch:
|
||
'호스트 아키텍처는 {hostArch}, 게스트 아키텍처는 {guestArch}입니다. 교차 아키텍처 실행은 지원되지 않습니다.',
|
||
nonKVMType: '가상화 유형이 {type}이며 기본 KVM 유형이 아닙니다.',
|
||
archOrMachineMissing: 'XML에 아키텍처 또는 머신 유형이 없습니다.',
|
||
machineUnsupported: '호스트가 {arch}/{machine}을(를) 지원하지 않습니다.',
|
||
emulatorNotSpecified: 'XML에 에뮬레이터가 지정되지 않아 Libvirt가 선택합니다.',
|
||
fileNotFound: '파일을 찾을 수 없습니다: {path}',
|
||
fileNotExecutable: '파일을 실행할 수 없습니다: {path}',
|
||
bootDeviceMissing: 'XML에 부팅 장치가 정의되어 있지 않습니다.',
|
||
diskNotFirst: '디스크가 첫 번째 부팅 장치가 아닙니다. 현재 순서: {order}',
|
||
cdromNotInBootOrder: 'CD-ROM이 연결되어 있지만 부팅 순서에 포함되어 있지 않습니다.',
|
||
firmwareNotConfigured:
|
||
'EFI 또는 Loader가 설정되지 않아 게스트의 디스플레이 초기화나 부팅이 실패할 수 있습니다.',
|
||
acpiCustom: 'ACPI가 설정되어 있습니다. 게스트에 필요한 사용자 지정 설정인지 확인하세요.',
|
||
acpiRequiresUEFI: 'UEFI 없이 ACPI가 설정되어 ACPI requires UEFI 오류가 발생합니다.',
|
||
apicUnsupported: 'x86 APIC가 설정되어 있지만 ARM64에서는 사용할 수 없습니다.',
|
||
gicNotDeclared: '영구 XML에 GIC가 없습니다. Libvirt가 런타임에 추가할 수 있습니다.',
|
||
videoNotConfigured: 'XML에 디스플레이 장치가 설정되어 있지 않습니다.',
|
||
videoNotVirtio: '디스플레이 장치 유형은 {type}입니다. Virtio 사용을 권장합니다.',
|
||
firmwareFileMissing: '펌웨어 파일이 없거나 일반 파일이 아닙니다: {path}',
|
||
firmwareNotAvailable: 'Libvirt에서 EFI 기능을 보고하지 않았으며 ARM64 UEFI 펌웨어도 없습니다.',
|
||
cdromBusNotSCSI: 'CD-ROM이 {bus} 버스를 사용합니다. ARM64에는 SCSI가 필요합니다.',
|
||
cdromNotOnVirtioSCSI: 'CD-ROM이 Virtio SCSI 컨트롤러에 연결되어 있지 않습니다.',
|
||
diskSourceMissing: '{device} {target}에 소스 파일이 설정되어 있지 않습니다.',
|
||
sourceNotFound: '{device} {target}의 소스 파일이 없습니다: {path}',
|
||
sourceIsDirectory: '{device} {target}의 소스 경로가 디렉터리입니다: {path}',
|
||
systemDiskNotFound: '시스템 디스크를 찾지 못했습니다.',
|
||
isoArchMismatch: '{guestArch} 게스트에 {imageArch}용으로 보이는 이미지가 연결되어 있습니다: {path}',
|
||
networkReadFailed: '네트워크 {name}을(를) 읽을 수 없습니다.',
|
||
networkStateReadFailed: '네트워크 {name}의 상태를 읽을 수 없습니다.',
|
||
networkInactive: '네트워크 {name}이(가) 존재하지만 활성화되지 않았습니다.',
|
||
logUnavailable: '분석할 수 있는 시작 로그가 없습니다.',
|
||
logErrorsFound: '최근 시작 기록에서 일반적인 오류가 발견되었습니다.',
|
||
vmNotRunning: '가상 머신이 실행 중이 아니므로 QEMU 런타임 인수 검사를 건너뛰었습니다.',
|
||
runtimeFirmwareMissing: 'QEMU 로그에서 pflash, AAVMF 또는 QEMU_EFI 항목을 찾지 못했습니다.',
|
||
},
|
||
},
|
||
dependencies: '종속성',
|
||
dependencyPurpose: '용도',
|
||
dependencyPurposeMap: {
|
||
libvirt: '가상 머신 관리 서비스를 제공하며 수명 주기와 리소스 스케줄링을 담당합니다.',
|
||
storage: '가상 머신 디스크 파일을 저장하기 위한 기본 저장소 디렉터리 또는 스토리지 풀을 제공합니다.',
|
||
},
|
||
dependencyNotReady: '가상 머신 종속성 검사를 통과하지 못했습니다. 종속성을 처리한 후 사용하세요.',
|
||
helperUnavailable:
|
||
'가상 머신 기능 초기화에 실패했습니다. Core 로그를 확인하거나 다시 업그레이드한 후 사용하세요.',
|
||
cpu: 'CPU',
|
||
memory: '메모리',
|
||
disk: '디스크',
|
||
overview: 'Overview',
|
||
kvmUnavailable: 'No available KVM hardware virtualization capability was detected.',
|
||
kvmCheckCpu: 'Confirm that the host CPU supports Intel VT-x or AMD-V virtualization.',
|
||
kvmCheckBios: 'Enable virtualization options in BIOS/UEFI.',
|
||
kvmCheckModule: 'Confirm that the kvm, kvm_intel, or kvm_amd kernel module is loaded correctly.',
|
||
kvmCheckDevice:
|
||
'Confirm that /dev/kvm exists and the current environment is not a container or cloud host without KVM support.',
|
||
abnormal: 'Abnormal',
|
||
resourceOverview: 'Resource Overview',
|
||
cpuAllocated: 'CPU Allocated',
|
||
memoryAllocated: 'Memory Allocated',
|
||
storageUsed: 'Storage Used',
|
||
riskReminder: 'Risk Reminders',
|
||
noRisk: 'No risks',
|
||
runtimeHealth: 'Runtime Health',
|
||
runtimeAbnormal: 'VM runtime is abnormal',
|
||
noDependency: 'No dependency check data',
|
||
storageOverview: 'Storage Overview',
|
||
totalAllocated: 'Calculated by total VM configuration',
|
||
runningAllocated: 'Running allocation: {0}',
|
||
storageAvailable: 'Available: {0}',
|
||
inProgress: 'In progress',
|
||
needAttention: 'Needs attention',
|
||
normal: 'Normal',
|
||
environmentRisk: 'The VM runtime is not ready. Fix dependencies or virtualization services.',
|
||
storageRisk: 'Storage pool {0} usage has reached {1}%.',
|
||
abnormalRisk: '{0} VMs are in an abnormal state.',
|
||
pausedRisk: '{0} VMs are paused.',
|
||
memoryRisk: 'VM memory allocation has reached {0}%.',
|
||
cpuLimitHelper: '현재 사용 가능한 CPU: {0} 코어',
|
||
cpuLimitExceeded: 'CPU가 제한을 초과했습니다. 현재 최대 사용 가능: {0} 코어.',
|
||
memoryLimitHelper: '현재 할당 가능한 메모리: {0} (호스트는 {1} 메모리를 예약해야 함)',
|
||
memoryLimitExceeded: '메모리가 제한을 초과했습니다. 현재 최대 할당 가능: {0}.',
|
||
storageLimitHelper: '대상 스토리지 풀의 현재 사용 가능 공간: {0}',
|
||
storageLimitExceeded: '디스크 용량이 제한을 초과했습니다. 현재 최대 사용 가능: {0}.',
|
||
iso: 'ISO',
|
||
createFromTemplate: '템플릿에서 생성',
|
||
template: 'Template',
|
||
templateName: 'Template Name',
|
||
convertToTemplate: 'Convert to Template',
|
||
sourceVM: 'Source VM',
|
||
templateSize: 'Template Size',
|
||
deleteTemplateConfirm: '템플릿 {0}을(를) 삭제합니다. 이 작업은 되돌릴 수 없습니다. 계속하시겠습니까?',
|
||
orphanClean: '고아 데이터 정리',
|
||
orphanScan: '다시 검색',
|
||
orphanCleanHelper:
|
||
'가상 머신, 스냅샷 또는 등록된 템플릿에서 참조되지 않는 후보 파일만 표시됩니다. 정리하기 전에 더 이상 사용되지 않는지 확인하세요. 이 작업은 되돌릴 수 없습니다.',
|
||
orphanSelected: '{0}개 파일 선택됨, 총 {1}',
|
||
orphanSize: '크기',
|
||
orphanCleanConfirm: '선택한 {0}개 파일({1})을 정리하시겠습니까? 이 작업은 되돌릴 수 없습니다.',
|
||
orphanCleanSuccess: '{0}개 파일을 정리하여 {1}을(를) 확보했습니다.',
|
||
orphanType: {
|
||
orphan_domain_disk: '고아 디스크',
|
||
orphan_snapshot: '고아 스냅샷',
|
||
partial_file: '미완료 파일',
|
||
},
|
||
diskSize: '디스크 용량',
|
||
diskPath: '디스크 경로',
|
||
isoPath: 'ISO 경로',
|
||
storagePool: '스토리지 풀',
|
||
network: '네트워크',
|
||
bridgeName: '브리지 이름',
|
||
natNetworkHelper:
|
||
'VM은 호스트를 통해 네트워크에 연결할 수 있지만, 외부 장치에서는 일반적으로 VM에 직접 접근할 수 없습니다.',
|
||
bridgeNetworkHelper:
|
||
'VM을 호스트의 기존 브리지(예: br0)에 연결합니다. 호스트에 사용하지 않는 추가 네트워크 카드가 있으면 브리지를 만들어 사용할 수 있습니다.',
|
||
bridgeNameHelper:
|
||
'br0와 같이 호스트에 이미 존재하는 Linux bridge를 선택하세요. 물리 NIC는 bridge가 아니며 docker/libvirt가 관리하는 bridge는 여기서 선택할 수 없습니다.',
|
||
natCIDRHelper: 'CIDR, 게이트웨이, DHCP 주소 범위는 새 NAT 가상 네트워크에 사용됩니다.',
|
||
networkCIDR: '네트워크 CIDR',
|
||
gateway: '게이트웨이',
|
||
dhcpStart: 'DHCP 시작 주소',
|
||
dhcpEnd: 'DHCP 종료 주소',
|
||
bootOrder: '부팅 순서',
|
||
bootDiskFirst: '디스크 우선 (HD → CD-ROM)',
|
||
bootIsoFirst: 'ISO 우선 (CD-ROM → HD)',
|
||
bootOrderConfirm:
|
||
'부팅 순서를 {0}(으)로 변경하시겠습니까? 다음 시작 시 가상 머신은 현재 연결된 부팅 가능한 장치를 이 순서대로 시도합니다.',
|
||
startAfterCreate: '생성 후 시작',
|
||
autoStart: '자동 시작',
|
||
resourceAutoStart: '자동 시작',
|
||
capacity: '용량',
|
||
available: '사용 가능',
|
||
vmCount: '연결된 VM',
|
||
usedIPs: '사용된 IP',
|
||
monitor: 'Monitor',
|
||
monitorNotReady: 'The virtual machine is not running. Monitoring data is unavailable.',
|
||
monitorLoadFailed: 'Failed to get VM monitoring data.',
|
||
monitorLoadFailedWithReason: 'Failed to get VM monitoring data: {0}',
|
||
rename: 'Rename',
|
||
newName: '새 이름',
|
||
renameHelper: 'Enter a new VM name. The VM must be shut down before renaming.',
|
||
renameConfirm: 'Rename virtual machine [{0}] to [{1}]?',
|
||
renameRunningHelper: 'Shut down the virtual machine before renaming it.',
|
||
cpuUsage: 'CPU Usage',
|
||
memoryUsage: 'Memory Usage',
|
||
diskIO: 'Disk IO',
|
||
networkIO: 'Network IO',
|
||
diskReadWrite: 'Disk Read / Write',
|
||
networkRxTx: 'Network RX / TX',
|
||
rx: 'RX',
|
||
tx: 'TX',
|
||
console: '콘솔',
|
||
consoleNotReady: 'VNC 콘솔을 사용할 수 없습니다. VM을 시작하고 VNC 그래픽 구성을 확인하세요.',
|
||
consoleDisconnected: 'VNC 콘솔 연결이 끊어졌습니다.',
|
||
consoleConnectFailed: 'VNC 콘솔 연결에 실패했습니다. 콘솔 프록시 서비스를 확인하세요.',
|
||
consoleCredentialsRequired: 'VNC 콘솔에 인증 정보가 필요합니다. 백엔드 프록시 구성을 확인하세요.',
|
||
snapshot: 'Snapshot',
|
||
createSnapshot: 'Create Snapshot',
|
||
recoverSnapshot: 'Recover Snapshot',
|
||
snapshotSize: '사용량',
|
||
currentSnapshot: 'Current',
|
||
snapshotEmpty: 'No snapshots',
|
||
snapshotHelper:
|
||
'A snapshot saves the current VM state as a restore point. Subsequent data changes are recorded in a delta file without changing the original disk. Restoring a snapshot returns the VM to that point in time.',
|
||
snapshotRecoverConfirm:
|
||
'Recover virtual machine [{1}] to snapshot [{0}]? The VM disk will be restored to the snapshot state.',
|
||
interface: '네트워크 인터페이스',
|
||
device: '장치',
|
||
path: '경로',
|
||
start: '시작',
|
||
shutdown: '종료',
|
||
reboot: '재부팅',
|
||
destroy: '강제 중지',
|
||
suspend: '일시 중지',
|
||
resume: '재개',
|
||
operateConfirm: '{0} 가상 머신 [{1}]을(를) 실행하시겠습니까?',
|
||
forceDelete: '강제 삭제',
|
||
forceDeleteHelper:
|
||
'강제 삭제는 VM 삭제 오류를 무시하고 패널 메타데이터를 삭제하며 리소스 사용을 해제합니다.',
|
||
deleteNameHelper: '" 입력 시 이 가상 머신 삭제',
|
||
isoSource: 'ISO 출처',
|
||
downloadFromServer: '원격 다운로드',
|
||
isoTargetDir: 'ISO 대상 경로',
|
||
isoTargetDirHelper: '로컬 업로드 또는 서버 다운로드 ISO가 이 디렉터리에 저장됩니다.',
|
||
addingIsoRecord: 'ISO 레코드를 추가하는 중',
|
||
transferInProgress: 'ISO 전송이 진행 중입니다. 이 패널이나 페이지를 닫지 마세요.',
|
||
isoSize: 'ISO 크기',
|
||
deleteIsoConfirm: '이 삭제 작업은 되돌릴 수 없습니다. 계속하시겠습니까?',
|
||
deleteSourceFile: '원본 파일 삭제',
|
||
deleteSourceFileHelper: '선택하면 이 ISO 레코드가 참조하는 원본 파일도 삭제되며 복구할 수 없습니다.',
|
||
dir: '로컬 디렉터리',
|
||
},
|
||
cluster: {
|
||
cluster: '애플리케이션 고가용성',
|
||
name: '클러스터 이름',
|
||
addCluster: '클러스터 추가',
|
||
installNode: '노드 설치',
|
||
master: '마스터 노드',
|
||
slave: '슬레이브 노드',
|
||
replicaStatus: '마스터-슬레이브 상태',
|
||
unhealthyDeleteError: '설치 노드 상태가 비정상입니다. 노드 목록을 확인한 후 다시 시도하세요!',
|
||
replicaStatusError: '상태 획득이 비정상입니다. 마스터 노드를 확인하세요.',
|
||
masterHostError: '마스터 노드의 IP는 127.0.0.1이 될 수 없습니다',
|
||
},
|
||
},
|
||
template: {
|
||
create: '템플릿 생성',
|
||
edit: '템플릿 편집',
|
||
name: '템플릿 이름',
|
||
type: '템플릿 유형',
|
||
single: '단일 파일',
|
||
multi: '다중 파일(zip)',
|
||
content: '템플릿 내용',
|
||
variables: '변수 정의',
|
||
remark: '비고',
|
||
filePath: '파일 경로',
|
||
upload: 'zip 업로드',
|
||
preview: '미리보기',
|
||
previewEmpty: '템플릿을 선택하면 실시간으로 미리볼 수 있습니다',
|
||
generate: '산출물 생성',
|
||
outputName: '산출물 이름',
|
||
outputList: '산출물 목록',
|
||
outputCreate: '산출물 생성',
|
||
confirmDelete: '이 템플릿을 삭제하시겠습니까? 연관된 산출물도 함께 삭제됩니다',
|
||
confirmDeleteOutput: '이 산출물을 삭제하시겠습니까?',
|
||
variableKey: '변수명',
|
||
variableLabel: '레이블',
|
||
variableType: '유형',
|
||
variableDefault: '기본값',
|
||
variableOptions: '옵션(쉼표로 구분)',
|
||
variableRequired: '필수',
|
||
varTypeText: '한 줄 텍스트',
|
||
varTypeTextHelper: '일반 텍스트 입력란',
|
||
varTypeTextarea: '여러 줄 텍스트',
|
||
varTypeTextareaHelper: '문단이나 긴 텍스트에 적합',
|
||
varTypeNumber: '숫자',
|
||
varTypeNumberHelper: '숫자만 입력 가능',
|
||
varTypeSelect: '드롭다운 선택',
|
||
varTypeSelectHelper: '사전 설정된 옵션에서 선택, 옵션 입력 필요',
|
||
varTypeColor: '색상',
|
||
varTypeColorHelper: '색상 선택기',
|
||
autoDetectHelper: '내용에서 이중 중괄호로 감싸진 변수를 자동 인식하여 변수 정의 테이블에 추가합니다',
|
||
selectTemplate: '템플릿 선택',
|
||
fillVariables: '변수 입력',
|
||
noVariables: '이 템플릿에는 정의된 변수가 없습니다',
|
||
outputSuccess: '산출물이 성공적으로 생성되었습니다',
|
||
importButton: '템플릿에서 가져오기',
|
||
},
|
||
};
|
||
|
||
export default {
|
||
...getFuLocaleMessage('ko'),
|
||
...message,
|
||
};
|