pip --trusted-host pypi.org --trusted-host files.pythonhosted.org install [패키지명]

poetry에서는 옵션을 추가해서 ssl 에러를 넘어갈 방법이 없다.

poetry는 아래와 같은 방법으로 가능하다.

우선 pip --version을 실행해서 패키지 설치 경로를 확인 후

[패키지 설치 경로]/pip/_vendor/requests/sessions.py 파일의 아래 코드에서

        #: SSL Verification default.
        #: Defaults to `True`, requiring requests to verify the TLS certificate at the
        #: remote end.
        #: If verify is set to `False`, requests will accept any TLS certificate
        #: presented by the server, and will ignore hostname mismatches and/or
        #: expired certificates, which will make your application vulnerable to
        #: man-in-the-middle (MitM) attacks.
        #: Only set this to `False` for testing.
        self.verify = True

        #: SSL client certificate default, if String, path to ssl client
        #: cert file (.pem). If Tuple, ('cert', 'key') pair.
        self.cert = None

self.verify = True를 False로 변경한다.

위 방법으로 해결 안되는 경우 site-packages/requests/adapters.py line 394에 send() 함수가 있는데 아래와 같이 한줄을 추가해준다.

    def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None):
        """Sends PreparedRequest object. Returns Response object.

        :rtype: requests.Response
        """

        verify = False        # ==> 추가

        try:
            conn = self.get_connection(request.url, proxies)
        except LocationValueError as e:
            raise InvalidURL(e, request=request)

Loading Properties https://daily-study.tistory.com/7?category=697146

public class TcpClient {

    public void run(String hostname, int port, String data) {
        try (Socket socket = new Socket(hostname, port)) {
            OutputStream out = socket.getOutputStream();
            out.write(data.getBytes());
            InputStream input = socket.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(input));

            String time = reader.readLine();
            System.out.println(time);

        } catch (UnknownHostException ex) {
            System.out.println("Server not found: " + ex.getMessage());

        } catch (IOException ex) {
            System.out.println("I/O error: " + ex.getMessage());
        }
    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Base64;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import java.util.stream.Stream;

public class Utils {

    public static void printCurrentPath() {
        String currentDir = System.getProperty("user.dir");
        System.out.println("Current dir using System:" + currentDir);
    }

    public static void sleep(long ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

/*
    public static String toJson(Object o) {
        return new Gson().toJson(o);
    }

    public static <T> T fromJson(String s, Class<T> cls) {
        return new Gson().fromJson(s, cls);
    }
*/
    public static String getUuid() {
        return UUID.randomUUID().toString();
    }

    // run external application
    public static void execute(String... args) throws IOException {
        Process process = new ProcessBuilder(args).start();
        InputStream is = process.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        BufferedReader br = new BufferedReader(isr);
        String line;

        System.out.printf("Output of running %s is:", Arrays.toString(args));

        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
    }

    public static List<String> getFileList(String path) throws IOException {
        return Files.list(new File(path).toPath()).map(p -> p.toString()).toList();
    }

    public static List<String> getFileListRecursive(String path) throws IOException {
        List<String> files = new ArrayList<>();
        try (Stream<Path> paths = Files.walk(Paths.get(path))) {
            paths.filter(Files::isRegularFile).forEach(p -> files.add(p.toString()));
        }
        return files;
    }

    public static String encodeBase64(String s) throws UnsupportedEncodingException {
        return Base64.getEncoder().encodeToString(s.getBytes(StandardCharsets.UTF_8));
    }

    public static String decodeBase64(String s) {
        return new String(Base64.getDecoder().decode(s), StandardCharsets.UTF_8);
    }

    public String encrypt(String text) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        md.update(text.getBytes());

        return bytesToHex(md.digest());
    }

    private String bytesToHex(byte[] bytes) {
        StringBuilder builder = new StringBuilder();
        for (byte b : bytes) {
            builder.append(String.format("%02x", b));
        }
        return builder.toString();
    }

    public static void writeFile(String content) throws IOException {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("./OUTPUT/REPORT.TXT"))) {
            writer.write(content);
        }
    }

    public static List<String> readFile() {
        List<String> content = new ArrayList<>();
        try (BufferedReader reader = new BufferedReader(new FileReader("./INPUT/MONITORING.TXT"))) {
            while (true) {
                String line = reader.readLine();
                if (line == null) {
                    break;
                }

                content.add(line);
            }
            return content;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void copyFile(String src, String dst) {
        try (InputStream inputStream = new FileInputStream(src);
                OutputStream outputStream = new FileOutputStream(dst);) {
            int byteRead = -1;
            int BUF_LEN = 4096;
            byte[] bytes = new byte[BUF_LEN];
            while ((byteRead = inputStream.read(bytes)) != -1) {
                outputStream.write(bytes, 0, byteRead);
            }

        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    public static String getInput() throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String line = reader.readLine();
        return line;
    }


    public static long timeDiff(String t1, String t2) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

        Date d1 = sdf.parse(t1);
        Date d2 = sdf.parse(t2);

        long diff = d1.getTime() - d2.getTime();

        return diff / 1000;
    }



    public static void example_sort() {
        List<String> strList = new ArrayList<>();
        Collections.sort(strList);
        Collections.sort(strList, Collections.reverseOrder());
        Collections.sort(strList, (m1, m2) -> m1.compareTo(m2));

        strList.sort((m1, m2) -> m1.length() - m2.length());

        int[] ar = {};
        Arrays.sort(ar);

        List<String> strList2 = Arrays.asList("1", "2");
        Collections.sort(strList2);
    }

    public static void example_time() throws ParseException {

        LocalDateTime now = LocalDateTime.now();
        String nowS = now.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"));

        long ct = System.currentTimeMillis();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        String sdfS = sdf.format(ct);

        String sTime = "2022-12-12 12:00:00";
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        Date dt = format.parse(sTime);

        LocalDateTime ldt = dt.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
    }

}

ResponseBody.java

public class ResponseBody {
    public String result = "ok";

    public ResponseBody() {

    }

    public String toString() {
        return new Gson().toJson(this);
    }

}

ThreadInClass.java

public class ThreadInClass {
    public void run() throws Exception {
        Thread th = new Thread(() -> {
            while(true) {
                Utils.sleep(1000);

                // todo
            }
        });

        th.start();
    }
}

이클립스에서 input 데이터 파일 설정

자동완성 설정 https://devlimk1.tistory.com/9

이클립스 단축키

참고: https://blog.naver.com/PostView.naver?blogId=ambidext&logNo=222434508009&categoryNo=0&parentCategoryNo=10&viewDate=&currentPage=1&postListTopCurrentPage=1&from=search

fastapi는 자체적으로 background 기능을 제공한다. https://fastapi.tiangolo.com/tutorial/background-tasks/

정말 오래걸리는 작업을 별도 프로세스/서버로 실행해야 한다면 celery가 좋은 방법이 되겠지만 나는 단순하지만 약간의 지연을 발생시키고 실시간으로 처리될 필요는 없는 그런 작업을 비동기로 처리하고자 했고 fastapi의 BackgroundTask를 최적의 선택지로 판단했다.

요청을 받고 오래 걸리는 작업은 background로 보내놓고 background로 넘어간 작업은 기다리지 않고 바로 응답할 수 있어서 불필요한 지연을 제거할 수 있다.

fastapi 거의 대부분의 기능이 그러하듯 사용법은 정말 간단하다. path 처리 함수에 BackgroundTask를 파라미터로 정의하고 함수 안에서는 BackgroundTask에 오래 걸리는 작업을 추가(addTask)만 하면 된다. https://fastapi.tiangolo.com/tutorial/background-tasks/#using-backgroundtasks

처음엔 간단하게 rdb에 처리 이력을 저장하는 용도로 BackgroundTask를 사용했는데 처리 시간이 오래 걸리는 작업도 비동기로 처리할 필요가 생겼다. celery를 추가하기엔 너무 과한것 같아서 마찬가지로 BackgroundTask로 처리했다.

잘 실행되는 듯 했는데 gunicorn_error.log를 확인해보니 gunicorn timeout을 넘어가는 경우 해당 worker가 죽임(?)을 당했다.

[2017-01-21 14:07:37 +0000] [26635] [CRITICAL] WORKER TIMEOUT (pid:27202)
[2017-01-21 14:07:37 +0000] [26635] [CRITICAL] WORKER TIMEOUT (pid:27205)

이제와서 celery, mq를 추가 적용해야 하나 걱정하면서 열심히 찾아봤는데 아래 링크에 제시된 방법 중 3번째 fastapi.concurrency.run_in_threadpool를 적용해서 해결했다. https://stackoverflow.com/questions/67599119/fastapi-asynchronous-background-tasks-blocks-other-requests

위 링크에 제시된 다른 방법도 검토하고 테스트도 해봤는데..

1. Use more workers (e.g. uvicorn main:app --workers 4). This will allow up to 4 somelongcomputation in parallel.

• worker를 늘리더라도 timeout은 피할 수 없는 구조라서 제외

2. Rewrite your task to not be async (i.e. define it as def task(data): ... etc). Then starlette will run it in a separate thread.

• path 처리 함수부터 이미 async로 정의되고 거의 대부부의 함수를 async로 정의한 상태라서 전부 다 수정해야 해서 제외

3. Use fastapi.concurrency.run_in_threadpool, which will also run it in a separate thread

• 선택

4. use asyncios's run_in_executor directly (which run_in_threadpool uses under the hood)

• 테스트해봤는데 문제가 해결되지 않아서 제외

5. Spawn a separate thread / process yourself. E.g. using concurrent.futures.

• 테스트해봤는데 문제가 해결되지 않아서 제외

6. Use something more heavy-handed like celery.

• celery라서 제외

얼마나 좋은 라이브러리인지 알아보고자 readme와 quickstart를 열심히 읽어봤다.

그러다가 오타(push에 대한 설명인데 delete를 사용)를 확인했고 내 생애 처음으로 github 오픈소스에 pull request를 해봤다.

그리고 다행히(?) merge까지 됐다.

https://github.com/bentoml/BentoML/pull/2319

그러나 벌써 한달이 지나서 pull request 절차가 기억이 나질 않는다.. 이래서 미리미리 정리해야 하는데.. ㅠ

• gcr에 등록된 docker image 중에 tag가 지정되어 있지 않은 image 일괄 삭제 스크립트

  export IMG_NAME="This-is-test-image"  # docker image명
  
  gcloud container images list-tags $IMG_NAME --filter='-tags:*' --format="get(digest)" | xargs -I{} gcloud container images delete $IMG_NAME@"{}" --quiet

• 앞 부분: tag가 지정되어 있지 않은(--filter='-tags:*') docker image명을 조회하는데 hash값만 출력(--format="get(digest)")

  export IMG_NAME="This-is-test-image"  # docker image명
  
  gcloud container images list-tags $IMG_NAME --filter='-tags:*' --format="get(digest)"

• 뒷 부분: 앞에서 출력된 hash값을 xargs로 받아서 조용히(--quiet) gcr에서 삭제

  export IMG_NAME="This-is-test-image"  # docker image명
  
  xargs -I{} gcloud container images delete $IMG_NAME@"{}" --quiet

그래서 로그 레벨을 warn 이상으로 변경을 알아봤다.

그렇게 찾은 아래 링크에서 TF_CPP_MIN_VLOG_LEVEL을 설정하라고 하는데 효과가 없었다. https://github.com/tensorflow/serving/issues/285

정답은 TF_CPP_MIN_LOG_LEVEL

export TF_CPP_MIN_LOG_LEVEL=1

설정 후에 다시 실행하니 warning 레벨 이상 로그만 출력되는 것을 확인..

참고로 TF_CPP_MIN_LOG_LEVEL 설정값은 아래와 같다.

0: debug
1: warn
2: error
3: disable

(info가 안보인다?... 이건 나중에 알아보기로... )

@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    private final TokenProvider tokenProvider;
    private final JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;
    private final JwtAccessDeniedHandler jwtAccessDeniedHandler;

    ...
}

public class JwtAccessDeniedHandler implements AccessDeniedHandler {
    ...
}

public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
    ...
}

에러 메시지는 아래와 같다. Parameter 1 of constructor in ClassA required a bean of type 'ClassB' that could not be found

단순한건데.. 오랜만에 보니 한참을 헤맸다. JwtAccessDeniedHandler, JwtAuthenticationEntryPoint 정의부 상단에 @Component를 추가하니 해결~

@Component
public class JwtAccessDeniedHandler implements AccessDeniedHandler {
    ...
}

@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
    ...
}

application.yml에는 아래와 같은 ssl 설정을 추가한다.

server:
  ssl:
    enabled: true
    key-store: keystore.p12
    key-store-password: 1q2w3e4r
    key-store-type: PKCS12
    key-alias: bns-ssl
  port: 8443

위에서 정한 값을 keytool 인자로 전달하여 인증서 파일을 생성한다. (keytool은 jdk에 포함됨)

# linux
# keytool -genkey -alias ${key-alias} -storetype ${key-store-type} -keyalg RSA -keysize 2048 -keystore ${key-store} -validity 3650

# windows: java_home 설정 필요 
# keytool.exe -genkey -alias ${key-alias} -storetype ${key-store-type} -keyalg RSA -keysize 2048 -keystore ${key-store} -validity 3650

keytool -genkey -alias bns-ssl -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -validity 3650

생성된 인증서 파일 keystore.p12을 springboot 프로젝트 root 경로로 이동한다.

서버를 실행하고 브라우저에서 https://localhost:8443으로 접속해서 확인한다.

참고: https://jojoldu.tistory.com/350?category=635883

    @PostConstruct
    public void initData() {
        Team teamA = new Team("teamA");
        Team teamB = new Team("teamB");

        for (int i = 0; i < 100; i++) {
            Team selectedTeam = i % 2 == 0 ? teamA : teamB;
            em.persist(new Member("member" + i, selectedTeam, i));
        }
    }

그리고 맞이한 에러 메시지...

Caused by: javax.persistence.TransactionRequiredException: No EntityManager with actual transaction available for current thread - cannot reliably process 'persist' call

그래서 찾아본 결과 아래와 같은 해결방법을 찾았다. https://sorjfkrh5078.tistory.com/311

• 다른 스프링 빈을 호출해서 사용하는 방법
• AOP를 사용하지 않고 트랜잭션을 직접 코딩하는 방법
• 애플리케이션 컨텍스트가 완전히 초기화된 이벤트를 받아서 호출하는 방법
• 초기화하는 메서드와 초기화를 실행하는 메서드를 분리하는 방법

내가 적용한 방법은 4번째. 다른 스프링 빈을 호출해서 사용하는 방법.

아래와 같은 InitMemberService를 추가하고,

@Component
public class InitMemberService {

    @PersistenceContext
    EntityManager em;

    @Transactional
    public void init() {
        Team teamA = new Team("teamA");
        Team teamB = new Team("teamB");

        em.persist(teamA);
        em.persist(teamB);

        for (int i = 0; i < 100; i++) {
            Team selectedTeam = i % 2 == 0 ? teamA : teamB;
            em.persist(new Member("member" + i, selectedTeam, i));
        }
    }
}

RestController 클래스에서 주입받고 실행하니 정상적으로 처리됐다.

@RestController
public class MemberController {

    @Autowired
    private InitMemberService initMemberService;

    @PostConstruct
    public void initData() {
        initMemberService.init();
    }

참조

• https://sorjfkrh5078.tistory.com/311
• https://www.inflearn.com/questions/270247

## https://fastapi.tiangolo.com/ko/advanced/custom-response/?h=#fileresponse

import uvicorn as uvicorn
from fastapi import FastAPI
from fastapi.responses import FileResponse

some_file_path = "pyproject.toml"
app = FastAPI()


@app.get("/")
async def main():
    return FileResponse(some_file_path, filename=some_file_path)


if __name__ == "__main__":
    uvicorn.run("main:app", reload=True)

브라우저 개발자 화면에서 보이는 Reponse Headers에 포함된 content-disposition

하지만 javascript에서 읽으려고 하니 undefined가 나온다.

뭐가 문젤까..

검색을 해보니 백엔드의 cors 설정 문제이고 expose header 설정이 필요하다고 하여 fastapi 공식 가이드에 나온데로 아래와 같이 설정해봤지만 결과는 동일했다.

## https://fastapi.tiangolo.com/tutorial/cors/

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

origins = [
    "http://localhost.tiangolo.com",
    "https://localhost.tiangolo.com",
    "http://localhost",
    "http://localhost:8080",
]

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)


@app.get("/")
async def main():
    return {"message": "Hello World"}

고민하던 차에 CORSMiddleware 객체 정의부 소스를 살펴보니

class CORSMiddleware:
    def __init__(
        self,
        app: ASGIApp,
        allow_origins: typing.Sequence[str] = (),
        allow_methods: typing.Sequence[str] = ("GET",),
        allow_headers: typing.Sequence[str] = (),
        allow_credentials: bool = False,
        allow_origin_regex: str = None,
        expose_headers: typing.Sequence[str] = (),
        max_age: int = 600,
    ) -> None:

여기에 expose_headers 옵션이 있었구나!

그래서 아래와 같이 옵션을 추가하니 해결~~

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
    expose_headers=["*"],
)

오늘의 교훈..

프레임워크의 기능을 구글링해서 못 찾겠으면 정의된 코드를 찾아보자!

다 적고 보니 아래 링크에 잘 설명되어 있다.. https://fastapi.tiangolo.com/ko/tutorial/cors/?h=

다시 적어보는 오늘의 교훈

우선 tutorial을 잘 읽어볼것!!