<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Jungeun on Medium]]></title>
        <description><![CDATA[Stories by Jungeun on Medium]]></description>
        <link>https://medium.com/@angal2310?source=rss-0431dd1f32f5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*JnGS7MdidNZ8S7eD</url>
            <title>Stories by Jungeun on Medium</title>
            <link>https://medium.com/@angal2310?source=rss-0431dd1f32f5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 08:07:24 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@angal2310/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[[Kafka] 카프카란?]]></title>
            <link>https://medium.com/@angal2310/kafka-%EC%B9%B4%ED%94%84%EC%B9%B4%EB%9E%80-c5a8961e702f?source=rss-0431dd1f32f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/c5a8961e702f</guid>
            <dc:creator><![CDATA[Jungeun]]></dc:creator>
            <pubDate>Fri, 20 Sep 2024 04:33:41 GMT</pubDate>
            <atom:updated>2024-10-20T13:59:57.624Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/918/1*xTHcWsiT_u6HNNd8WwJoHQ.png" /></figure><p>Kafka의 주요 개념을 정리하기에 앞서 메시지 큐와 기본 개념들에 대해서 설명하려고 한다. 특히 MSA 아키텍쳐로 많은 개발이 이루어지고 있는 요즘, 이해가 꼭 필요할 것이라고 생각한다.</p><h3>데이터의 중요성</h3><p>모든 애플리케이션은 데이터를 생성하고, 모든 기업은 데이터로 움직인다. 데이터의 모든 부분은 의미가 있으며 그 다음 처리되어야 하는 작업과 같이 뭔가 중요한 정보를 담고 있다. 이것이 무엇인지 알기 위해서는 데이터를 생성된 곳에서 분석할 수 있는 곳으로 옮겨야 한다.</p><p>여기서 중요한 것은 우리가 데이터를 분석할 수 있는 곳으로 이동시키는 작업에 더 적은 노력을 들일수록 핵짐 비지니스에 더욱 집중할 수 있다는 것이다. 따라서 데이터가 중심이 되는 기업에서 파이프라인이 핵심요소가 되는 이유이다. 데이터를 어떻게 이동시키느냐의 문제는 데이터 그 자체만큼이나 중요한 것이다.</p><h3>메시지 지향 미들웨어(MOM: Message Oriented Middleware)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/688/1*G6zAWaWGmPO4O9_j_xKl6Q.png" /></figure><p>카프카에 대해 설명하기 전에 먼저 메시지 큐에 대해 알아보자. 메시지 큐를 이해하기 위해서는 <strong><em>MOM</em></strong>에 대해 알아야 한다.</p><ul><li>미들웨어 : 애플리케이션을 연결해 이들이 서로 데이터를 교환할 수 있게 해주는 소프트웨어</li><li>메시지 지향 시스템 : 메시지 API를 통해 각 분산되어 있는 애플리케이션의 다리 역할을 함으로써 데이터를 교환할 수 있도록 하는 시스템</li><li>MOM : 메시지를 통해 여러 분산되어 있는 시스템 간의 Connector 역할로 결합성을 낮추고, 이들이 서로 실시간 비동기식 데이터를 교환할 수 있도록 하는 소프트웨어이다. <strong><em>다수의 애플리케이션 및 시스템 간에 비동기적으로 데이터를 전송하고 처리할 수 있는 기능</em></strong>을 제공한다.</li></ul><p><strong>[ 특징 ]</strong></p><ul><li>비동기 방식으로 메시지를 전달한다.</li><li>Queue, Broadcast, Multicast 등의 방식으로 메시지를 전달한다.</li><li>메시지를 발행하는 Publisher (Producer), 소비하는 Subscribe (Consumer)로 구성되어 있다.</li><li>메시지는 특정 대상에게 직접 전달되지 않고 메시지 브로커(message broker, message provider)라는 중간 매개체를 통해 전달된다.</li></ul><p>결국 MOM은 프로세스, 프로그램 간에 데이터를 교환할 때 사용하는 통신 방법중에 하나일 뿐이다.</p><h3>메시지 큐 (Message Queue, MQ)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/781/1*58JgS886MsK3rGm_5k6M9Q.png" /></figure><p>Queue란 선입선출(First in First out) 구조를 가진 자료구조이다.<br>Queue는 2개의 끝을 가지며 각각은 입구와 출구이다. 새로운 데이터는 입구로 들어오고, 나가는 데이터는 출구에서 나간다.</p><p>Message Queue 란 Queue라는 자료구조를 채택해서 메시지를 전달하는 시스템이며, MOM을 구현한 시스템이다.</p><p>메시지 큐를 통해 메시지를 전달하려면 메시지를 전달하는 부분과 메시지를 받는 부분이 필요한데, 여기서 메시지를 발행하고 전달하는 부분을 <strong><em>Producer</em></strong>, 메시지를 받아서 소비하는 부분을 <strong><em>Consumer</em></strong>라고 한다. <br>메시지 큐는 Producer와 Consumer의 메시지 전달 역할을 하는 매개체이다.</p><p>메시지 큐는 요즘 가장 핫한 소프트웨어 아키텍처 디자인 패턴인 MSA (MicroService Architecture)에서 아키텍처의 핵심적인 역할을 한다.</p><h3><strong>메시지 브로커 VS 이벤트 브로커</strong></h3><p>메시지 큐에서 데이터를 운반하는 방식에 따라 메시지 브로커 와 이벤트 브로커 로 나눌 수 있다.</p><p>메시지 큐가 메시지 혹은 이벤트가 송신되고 수신되는 하나의 <strong><em>통신 통로</em></strong>라고 하면, 브로커는 메시지 큐에 메시지 혹은 이벤트를 넣어주고 <strong><em>중개하는 역할</em></strong>을 하는 주체이다. 메시지 큐 자체를 메시지 브로커 혹은 이벤트 브로커로 이해하면 좋다.</p><h4>메시지 브로커(Message Broker)</h4><ul><li>메시지 브로커는 주로 <strong><em>단일 큐 시스템</em></strong>이나 소규모 분산 처리를 지원하는 구조이기 때문에, 초대용량 데이터나 높은 트래픽을 처리하는 데 상대적으로 한계가 있을 수 있다.</li><li>실시간 처리가 중요하지 않은 상황 즉, 특정 이벤트가 즉각적으로 소비될 필요가 없는 상황에서 사용이 유리하다.</li><li>ex) RabbitMQ, ActiveMQ, AWS SQS, Redis</li></ul><h4>이벤트 브로커(Event Broker)</h4><ul><li>이벤트 브로커는 메시지를 큐에서 삭제하지 않고 <strong><em>로그 형태로 저장</em></strong>하는 특징이 있다. 이 덕분에 <strong><em>구독자가 소비한 데이터도 다시 조회</em></strong>할 수 있고, 여러 소비자가 같은 데이터를 여러 번 소비할 수 있다. 이를 통해 더 많은 이벤트와 데이터를 장기간 저장하고 다시 처리할 수 있는 유연성을 제공한다.</li><li>이벤트 브로커는 일반적으로 <strong><em>분산형 시스템</em></strong>을 기반으로 설계돼 있어, 대용량 데이터를 실시간으로 처리하는 데 적합하다. <strong><em>카프카와</em></strong> 같은 이벤트 브로커는 <strong><em>클러스터링을 통해 수평적으로 확장</em></strong> 가능하며, 수백 테라바이트의 데이터를 손쉽게 관리하고 분산 처리할 수 있다.</li><li>실시간 분석이나 대규모 로그 처리가 필요한 상황에서 적합하다.</li><li>ex) Kafka</li></ul><h3>메시지 큐의 장점</h3><ol><li>비동기(Asynchronous): 큐에 넣어두기 때문에 나중에 처리할 수 있다.</li><li>낮은 결합도(Decoupling): 애플리케이션과 분리할 수 있어 확장성이 좋다.</li><li>탄력성(Resilience): 일부가 실패해도 전체에 영향을 받지 않는다.</li><li>과잉(Redundancy): 실패 할 경우 재실행이 가능하다.</li><li>신뢰성(Guarantees): 작업이 처리된 걸 확인할 수 있다.</li><li>확장성(Scalable): 다수의 프로세스들이 큐에 메시지를 보낼 수 있다.</li></ol><h3>메시지 채널</h3><p>메시지 채널은 송신자와 수신자 간의 <strong><em>메시지를 전달하는 통로</em></strong>를 뜻한다. 메시지 채널을 통해 송신자는 메시지를 보내고, 수신자는 이 채널에서 메시지를 읽어 처리한다.</p><ul><li>Point-to-Point (P2P) 채널 : 메시지를 보내는 송신자가 하나의 수신자에게만 메시지를 보내는 방식, 일대일 통신이다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zE2GQ2AceXZaGrHF.png" /></figure><ul><li>발행-구독(Publish-Subscribe) 채널 : 송신자가 하나의 메시지를 여러 수신자에게 동시에 보낼 수 있는 방식, 일대다 통신이다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Xa-fmduuM3grkg-9.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/729/1*ytN40tyCom0k-r-xBkaL5A.png" /></figure><h3>비동기 메시지 패턴</h3><p>비동기 메시지 패턴은 메시지 큐를 사용해 비동기적으로 <strong><em>전달하고 처리하는 방식</em></strong>을 의미한다. 이는 송신자가 메시지를 큐에 넣으면, 수신자가 나중에 그 메시지를 큐에서 읽어 처리하는 방식으로 동작한다.</p><p><strong><em>Fire &amp; Forget 패턴</em></strong></p><p>호출자가 작업을 요청한 후, 결과를 기다리지 않고 바로 다음 작업을 수행하는 방식으로, 메시지 큐를 사용하는 패턴 중 가장 일반적인 비동기 호출 패턴이다. 이메일 전송 시스템이나 푸시 알림과 같은 결과를 신경쓰지 않아도 되는 경우 유리하다.</p><p><strong><em>Publish &amp; Subscribe 패턴</em></strong></p><p>메시지 큐에 구독자를 등록하면 클라이언트에서 보낸 하나의 메시지가 등록된 모든 구독자에게 전달이 되어 처리된다. 1:N, M:N관계의 비동기 처리를 구현하기 위한 방법이다.</p><p><strong><em>Routing 패턴</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Bdl9vwHNaZHtDR-D.png" /></figure><p>큐에 저장된 메시지를 조건에 따라서 특정 비지니스 컴포넌트로 라우팅하는 기능이다. Pub/Sub 처럼 여러 개의 비지니스 컴포넌트가 붙기는 하지만, 특정 메시지는 조건에 따라서 특정 비지니스 컴포넌트 한 개에만 전달된다.</p><p><strong><em>Callback 패턴</em></strong></p><p>메시지 큐를 이용한 비동기 패턴은 클라이언트가 메시지 처리에 대한 응답을 받을 수 없지만, 예외적으로 콜백 패턴을 사용하면 메시지 처리에 대한 응답을 받을 수 있다.</p><p>클라이언트가 요청을 보내서 메시지 큐에 저장한 후에 콜백 패턴도 다른 비동기 패턴과 마찬가지로 응답을 기다리지 않고 다음 로직을 진행한다. 비즈니스 컴포넌트에서 처리가 끝나면 서버는 다시 클라이언트에 처리가 끝났다는 응답과 함께 처리 결과 (Response) 메시지를 콜백으로 보낸다. 서버가 콜백 응답을 보낼 때, 요청에 부여된 Correlation ID를 이용해 어느 요청에 대한 응답인지 식별한다.</p><h3>카프카(kafka) 란?</h3><p>이제 카프카에 대해 알아보도록 하자.</p><p>카프카는 <strong><em>대규모 실시간 데이터 스트리밍</em></strong>을 처리하는 데 사용되는 <strong><em>분산 이벤트 스트리밍 플랫폼</em></strong>이다. Pub / Sub 모델의 메시지 큐 형태로 동작한다.</p><ul><li>분산 이벤트 : 여러 대의 서버(노드)에 분산되어 저장된 이벤트(데이터)</li><li>이벤트 스트리밍 : 대량의 이벤트(데이터)를 실시간으로 처리하는 방식</li></ul><p>=&gt; 분산되어 있는 이벤트들을 실시간으로 처리하는 플랫폼 = 데이터 스트림을 쓰고, 읽고, 저장하고 처리할 수 있게 해주는 시스템</p><h4>카프카의 장점</h4><p><strong><em>현대적인 분산 시스템 ⇒ 확장이 쉽다</em></strong></p><ul><li>컴퓨터 네트워크로 연결된 일반적인 하드웨어 위에서 분산 클라스터 형태로 작동하며, 가장 거대한 회사들의 모든 애플리케이션을 처리할 수 있을 정도로 확장이 가능하다.</li></ul><p><strong><em>원하는 만큼 오랫동안 데이터를 저장할 수 있도록 만들어진 저장 시스템</em></strong></p><ul><li>서로 다른 시스템간의 연결 계층으로 사용하고자 할 때 큰 이점이 된다. 영구적이고 원하는 만큼 오랫동안 보존할 수 있는 만큼 데이터 전송을 확실하게 보장할 수 있기 때문이다.</li></ul><p><strong><em>스트림 처리의 세계는 추상화의 수준을 현격히 끌어올린다.</em></strong></p><ul><li>대부분의 메시징 시스템은 단순히 메시지를 전달만 하는 것이 보통이다. 하지만 카프카에 내재된 스트림 처리 능력은 훨씬 더 적은 코드를 사용해서 기존 스트림에서 파생 스트림과 데이터세트를 동적으로 산출할 수 있게 해준다.</li></ul><p>아래의 사진은 카프카를 개발한 링크드인의 카프카 적용 전 후 아키텍쳐이다. 적용 전에는 DB와 각 애플리케이션이 END-TO-END로 연결되어 있어 요구 사항이 늘어나면 데이터 시스템 복잡도가 높아지게 된다. 따라서 데이터 파이프라인의 관리가 어렵고 복잡해진다.</p><p>카프카를 적용하고 나서는 모든 이벤트/데이터의 흐름을 중앙에서 관리할 수 있게 된 걸 알 수 있다. 따라서 각 서비스간의 연결이 아닌 비지니스 로직에 집중할 수 있게 된다. 또한 새로운 서비스/시스템이 추가되도 카프카가 제공하는 표준 포맷으로 연결하면 되므로 확장성과 신뢰성이 증가한다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/680/0*V_8mQtNu_z7Z8F8E.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/0*bsXc9TTrgHHDm-WL.png" /></figure><h3>RabbitMQ VS Kafka VS Redis (Pub/Sub 모델 별 차이)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/691/1*rsbP-irbxicEtI2Da0a43w.png" /></figure><h3>카프카 용어 정리</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jHUWUFufnXIdn4NLYmYKUA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/745/1*Am-ZCo5NlyaUJrmZALpUjQ.png" /></figure><h4>메시지와 배치</h4><p><strong><em>배치</em></strong></p><ul><li>대량의 작업이나 데이터를 한꺼번에 처리하는 방식</li></ul><p><strong><em>해시</em></strong></p><ul><li>임의의 크기를 가진 데이터를 고정된 크기의 데이터로 변환하는 과정</li></ul><p><strong><em>메시지</em></strong></p><ul><li>카프카에서의 데이터의 기본 단위</li><li>카프카의 입장에서는 단순히 바이트의 배열</li><li>키를 포함할 수도 있다.</li><li>키 : 메시지를 저장할 파티션을 결정하기 위해서 사용됨</li><li>키값에서 일정한 해시값을 생성한 뒤 이 값을 토픽의 파티션 수로 나눴을 때 나오는 나머지 값에 해당하는 파티션에 메시지를 저장</li></ul><p>⇒ 파티션 수가 변하지 않는 한 같은 키값을 가진 메시지는 항상 같은 파티션에 저장되게 된다.</p><ul><li>카프카는 메시지를 배치 단위로 저장한다. 따라서 메시지를 배치 단위로 처리함으로써 네트워크 I/O를 줄일 수 있다. 하지만 지연과 처리량에 <strong><em>트레이드오프</em></strong> 발생 = 배치 크기가 커질수록 시간당 처리되는 수는 늘어나지만, 각각의 메시지가 전달되는 데 걸리는 시간은 늘어나는 게 된다.</li></ul><h4>토픽과 파티션</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*VOYGn5qcwX4KsaEjcDEVQQ.png" /></figure><ul><li>카프카에 저장되는 메시지는 토픽 단위로 분류된다. (DB의 테이블, 파일시스템의 폴더와 유사한 개념)</li><li>토픽은 다시 여러개의 파티션으로 나누어진다.</li><li>파티션은 하나의 로그로 볼 수 있다. 파티션에 메시지가 쓰여질 때는 추가만 가능한 형태로 쓰여지며, 읽을 때는 맨 앞부터 제일 끝까지의 순서로 읽힌다.(FIFO) 대개 토픽에 여러 개의 파티션이 있는 만큼 토픽 안의 메시지 전체에 대해 순서는 보장되지 않으며, 단일 파티션 안에서만 순서가 보장된다.</li><li>파티션은 카프카가 데이터 중복과 확장성을 제공하는 방법이기도 하다.</li><li>각 파티션이 서로 다른 서버에 저장될 수 있기 때문에 하나의 토픽이 여러 개의 서버로 수평적으로 확장되어 하나의 서버를 용량을 넘어가는 성능을 보여줄 수 있다.</li><li>파티션은 복제될 수 있다. 즉, 서로 다른 서버들이 동일한 파티션의 복제본을 저장하고 있기 때문에 서버 중 하나에 장애가 발생한다고 해서 읽거나 쓸 수 없는 상황이 벌어지지 않는다.</li></ul><p>간단하게 말하면 토픽 = 데이터 / 파티션 = 데이터를 나눈다. 주의할 점은 컨슈머 하나가 여러 파티션을 해결할 수는 있지만 하나의 파티션에 여러 개의 컨슈머를 넣지는 못한다. 그래야 순서대로 처리할 수 있기 때문이다. 병렬 처리를 원한다면 파티션도 컨슈머도 늘리면 된다.</p><h4>오프셋과 랙</h4><p><strong><em>오프셋(Offset)</em></strong></p><ul><li><strong>오프셋</strong>은 카프카의 각 <strong>파티션 내에서 메시지의 위치</strong>를 나타내는 숫자이다. 파티션에 메시지가 기록될 때마다 그 메시지에 고유한 오프셋이 부여되며, 이는 메시지를 고유하게 식별할 수 있도록 해준다.</li><li>컨슈머가 메시지를 읽을 때, 각 메시지가 어느 위치까지 읽혔는지를 추적하기 위해 오프셋을 기록한다. 이를 통해 컨슈머는 이전에 읽은 메시지를 중복으로 읽지 않고, 이어서 읽을 수 있다.</li><li>예를 들어, 컨슈머가 파티션에서 메시지 0, 1, 2를 읽었다면, 그 다음에 읽을 메시지는 오프셋 3인 메시지가 된다.</li></ul><p><strong><em>랙(Lag)</em></strong></p><ul><li>랙(Lag)은 컨슈머가 <strong>얼마나 뒤처져 있는지</strong>를 나타낸다. 랙은 프로듀서가 새로운 메시지를 계속해서 파티션에 추가하는 속도와, 컨슈머가 그 메시지를 읽는 속도 사이의 차이로 생긴다.</li><li>랙은 컨슈머가 특정 파티션에서 읽은 마지막 오프셋과 파티션에 저장된 최신 메시지의 오프셋 차이로 계산된다. 즉, <strong>랙 = 최신 메시지의 오프셋 — 컨슈머가 읽은 마지막 오프셋</strong>이다.</li><li>랙이 커지면 컨슈머가 많은 메시지를 읽지 못하고 뒤처졌다는 의미이며, 이는 성능 이슈나 처리 속도의 불균형을 나타낼 수 있다.</li></ul><h4>프로듀서와 컨슈머</h4><p><strong><em>스트림</em></strong></p><ul><li>하나의 토픽에 저장된 데이터를 의미.</li><li>메시지의 집합</li><li>프로듀서 → 컨슈머로 이동되는 하나의 데이터 흐름을 의미</li></ul><p><strong><em>프로듀서</em></strong></p><ul><li>새로운 메시지 생성, 발행자, 작성자</li><li>파티션들 사이에 고르게 나눠서 쓰도록 되어 있다.</li><li>어떠한 경우에는, 프로듀서가 특정한 파티션을 지정해서 메시지를 쓰기도 한다.</li><li>파티셔너(키-키값:해시를 특정 파티션으로 대응지켜주는것)를 사용해서 구현</li></ul><p><strong><em>컨슈머</em></strong></p><ul><li>메시지를 읽음, 구독자, 독자</li><li>컨슈머는 1개 이상의 토픽을 구독해서 여기에 저장된 메시지들은 각 파티션에 쓰여진 순서대로 읽어온다.</li><li>메시지의 오프셋을 기록함으로써 어느 메시지까지 읽었는지를 유지</li></ul><p><strong><em>컨슈머 그룹</em></strong></p><ul><li>토픽에 저장된 데이터를 읽어오기 위해 협업하는 하나 이상의 컨슈머</li><li>컨슈머 그룹은 각 파티션이 하나의 컨슈머에 의해서만 읽히도록 한다.</li><li>따라서 2개이상의 클러스터를 통해 컨슈머를 분리하여도 메시지의 순서가 유지될 수 있다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*NXD46iK0E3zP-ZClXrG3pw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*A3rQ9N_JgdEhrwarIcTd8g.png" /></figure><h4><strong><em>브로커와 클러스터</em></strong></h4><p><strong><em>브로커</em></strong></p><ul><li>하나의 카프카 서버를 브로커(Broker) 라고 한다. 브로커는 프로듀서로부터 메시지를 수신하고 오프셋(몇개의 데이터를 전송할지)을 지정한 후 해당 메시지를 디스크에 저장한다. 또한 컨슈머의 파티션 읽기 요청에 응답하고 디스크에 수록된 메시지를 전송한다.</li><li>카프카의 브로커는 클러스터(Cluster) 의 일부 구성원으로 동작하도록 설계되었다. 여러 개의 브로커가 하나의 클러스터에 포함될 수 있으며, 그 중 하나는 클러스터의 컨트롤러(Controller) 역할을 수행한다. 컨트롤러는 클러스터 내의 각 브로커에게 담당 파티션을 할당하고, 브로커들이 정상적으로 동작하는지 모니터링한다.</li></ul><p><strong><em>클러스터</em></strong></p><ul><li>클러스터는 여러 대의 브로커들이 모여서 하나의 시스템처럼 동작하는 구조를 의미한다.</li><li>클러스터 내에서 각 브로커는 토픽의 파티션을 나누어 저장하고, 컨슈머와 프로듀서의 요청에 따라 메시지를 주고받는 역할을 수행한다.</li></ul><p><strong><em>파티션 리더(Partition Leader)</em></strong></p><ul><li>각 파티션은 클러스터 안의 브로커 중 하나에 할당되고, 해당 파티션의 리더만 데이터 처리를 담당한다.</li><li>모든 프로듀서는 메시지를 리더 파티션에만 발행할 수 있으며, 메시지는 반드시 리더 파티션을 통해 저장된다.</li></ul><p><strong><em>파티션 팔로워(Partition Follower)</em></strong></p><ul><li>파티션은 복제본을 가질 수 있다. 복제본은 여러 브로커에 저장되며, 이를 <strong>팔로워</strong>라고 부른다.</li><li><strong>팔로워 브로커</strong>는 리더 브로커의 상태를 따라가면서 복제된 데이터를 저장한다. 이 복제를 통해 파티션이 리더 브로커 하나에만 의존하지 않도록 보장하는 것이다.</li></ul><p><strong><em>레플리카(Replica)</em></strong></p><ul><li><strong>레플리카</strong>는 카프카의 <strong>파티션 데이터를 복제한 사본</strong>을 의미한다. 카프카는 각 파티션을 여러 브로커에 복제하여 저장하며, 이를 통해 고가용성(High Availability)과 내결함성(Fault Tolerance)을 보장한다.</li><li>레플리카는 <strong>리더</strong>와 <strong>팔로워</strong>로 구분되며, <strong>리더 레플리카</strong>는 파티션의 주 역할을 담당하고 모든 쓰기 요청을 처리한다. <strong>팔로워 레플리카</strong>는 리더의 데이터를 복제하며, 리더가 장애가 발생할 경우 <strong>팔로워 레플리카</strong> 중 하나가 새로운 리더로 승격된다.</li><li>레플리카 복제는 <strong>동기화</strong>된 상태를 유지하는 것이 중요하다. 만약 팔로워 레플리카가 리더보다 뒤처지게 되면, 해당 팔로워는 비동기 레플리카(out-of-sync replica)로 간주되어 잠시 동안 리더로 승격될 수 없다.</li></ul><p><strong><em>컨슈머(Consumer)와의 관계</em></strong></p><ul><li>컨슈머는 메시지를 읽을 때 리더뿐만 아니라 <strong>팔로워 브로커</strong>로부터도 데이터를 읽을 수 있다. 이렇게 함으로써 데이터의 가용성을 높이고, 리더 브로커에 과부하가 걸리는 것을 방지한다.</li></ul><p><strong><em>주키퍼</em></strong></p><ul><li>주키퍼는 카프카 클러스터의 안정적인 운영을 위한 관리자로 볼 수 있다.</li><li>브로커를 관리하고, 브로커에 대한 메타데이터를 저장하고 관리한다. 여기에는 브로커의 상태, 파티션, 리더와 팔로와의 정보 등이 포함된다.</li><li>리더 선출 : 각 파티션에는 하나의 리더가 있고, 나머지 브로커들은 데이터를 복제한다.</li><li>클러스터 구성 관리 : 카프카 클러스터에 새로운 브로커가 추가되거나, 기존 브로커가 종료될 때 이를 주키퍼가 관리하여 클러스터의 구성 변화를 반영한다.</li></ul><h3>Reference</h3><ul><li><a href="https://joojae.com/what-is-message-queue/">메시지 큐(Message Queue)?? 그게 뭔데</a></li><li><a href="https://www.code-review.tech/pub-sub-vs-ptp-understanding-messaging-patterns-in-event-driven-architecture/">Pub/Sub vs. PTP: Understanding Messaging Patterns in Event-Driven Architecture - CODE REVIEW</a></li><li><a href="https://www.rabbitmq.com/tutorials">RabbitMQ Tutorials | RabbitMQ</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c5a8961e702f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[Python] 파이썬 동시성 프로그래밍(Concurrency Programming)]]></title>
            <link>https://medium.com/@angal2310/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EB%8F%99%EC%8B%9C%EC%84%B1-%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%B0%8D-concurrency-programming-a4a21df6b4cd?source=rss-0431dd1f32f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/a4a21df6b4cd</guid>
            <dc:creator><![CDATA[Jungeun]]></dc:creator>
            <pubDate>Mon, 09 Sep 2024 05:51:25 GMT</pubDate>
            <atom:updated>2024-11-15T06:19:17.201Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jz4SHO88jplp1gAWX2Kccw.png" /></figure><p>과거의 컴퓨터는 단일 코어 프로세스를 사용했다. 하지만 성능이 향상되면서 요즘 나오는 컴퓨터들은 멀티 코어를 탑재하고 있다. 이를 효과적으로 활용하기 위해 동시성 프로그래밍이 등장했다.</p><h3>동시성, 병렬성, 비동기</h3><p>동시성 프로그래밍에 대해 공부하다보면 동시성, 병렬성, 비동기 등 유사한 듯 다른 단어들에 의해 혼돈이 온다.</p><p>쉽게 이해를 하기 위해, 카페를 예로 들겠다.</p><ul><li>동시성 : 카페에서 한 명의 알바생(하나의 코어)이 커피를 내리다가 주문을 받고, 서빙을 하는 등 여러 일을 빠르게 번갈아가면서 처리하는 것</li><li>병렬성 : 여러 알바생(여러개의 코어)이 각자 다른 일을 동시에 처리하는 것</li><li>비동기 : 한 명의 알바생이 커피를 내리고 기다리는 시간동안 다른 주문을 받거나 서빙을 하는 등 대기 시간을 효율적으로 활용하는 방식, 비동기는 동시성을 구현하는 한 방법이다.</li></ul><p>더 깊은 이해를 위한 기초 지식에 대해서 설명하겠다.</p><h3>프로세스와 스레드</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/238/0*X2BZhYr5KZsDHhUm.png" /></figure><p>우리가 컴퓨터를 사용하기 위해서는 OS(운영체제)가 필요하다. OS는 컴퓨터 하드웨어와 소프트웨어 사이에서 자원 관리와 작업을 조정하는 소프트웨어이다. OS는 사용자가 여러 프로그램을 실행하고 동시에 다양한 작업을 수행할 수 있게 해준다.</p><p>OS의 중요한 역할 중 하나는 프로그램을 실행 가능한 상태로 만드는 것이다. 즉, 프로그램이 실행되면 OS는 프로그램을 <strong>프로세스</strong>라는 형태로 변환한다.</p><p><strong><em>프로그램</em></strong></p><ul><li>파일이 저장 장치에 저장되어 있지만 메모리에는 올라가 있지 않은 정적인 상태</li><li>메모리에 올라가 있지 않다는 것은 OS가 프로그램을 실행하기 위한 독립적인 메모리를 할당하지 않았다는 뜻이다.</li></ul><p><strong><em>프로세스</em></strong></p><ul><li>메모리에 로드된 실행 중인 프로그램</li><li>각 프로세스는 독립적인 메모리 공간을 가지고, CPU 자원을 할당받아 실행된다.</li><li>여러 프로세스는 동시에 실행될 수 있으며, OS는 프로세스들이 CPU를 효율적으로 사용할 수 있도록 스케줄링한다.</li></ul><p><strong><em>멀티 프로세싱</em></strong></p><p>​멀티 프로세싱은 다수의 프로세서가 협력적으로 일을 처리하는 것을 의미한다. 여기서 주의해야 할 점은 프로세스가 아니라 프로세서이다.</p><ul><li>프로세서 : CPU나 Microprocessor와 같은 하드웨어</li><li>프로세스 : 실제 메모리에 적재되어 프로세서에 의해 실행되고 있는 프로그램</li></ul><p>보통 하나의 프로세서(CPU)가 하나의 작업을 맡지만 멀티 프로세싱은 다수의 프로세서가 다수의 작업을 함께 처리하는 것을 의미한다.</p><p><strong><em>스레드</em></strong></p><ul><li>운영체제에서 작동되는 스케줄링될 수 있는 인스트럭션의 순차적인 흐름</li><li>각 프로세스는 최소 하나의 스레드를 포함한다.</li><li>하나의 프로세스는 여러 스레드를 생성할 수 있고, 각 스레드는 프로세스 내의 자원을 공유하며 작업을 병렬로 수행할 수도 있다.</li><li>프로세스는 데이터, 힙, 스택 영역을 서로 공유하지 않지만, 스레드는 스택 영역을 제외한 데이터, 힙 영역을 서로 공유하여 메모리 부분에서 더 효율적이다.</li></ul><p><strong><em>멀티스레딩</em></strong></p><p>시간을 쪼개어 여러 작업을 진행하는 방식으로 멀티태스킹의 개념이다.</p><p>스레딩은 입출력 범위가 막혔을 때(=연산은 간단하지만 입출력이 많아 속도가 떨어지는 것) 속도를 획기적으로 높여준다. 또한 프로세서와 비교했을 때 메모리를 덜 차지한다.</p><h3>동시성</h3><p>동시성이란 동시에 여러 작업을 하는 것을 뜻하지만, 병렬성과는 차이가 있다. 동시성을 쉽게 이해하려면 한 사람이 여러 작업을 하고 있고 그 작업을 빠르게 바꾸며 진행하는 것을 상상하면 된다.</p><p>즉, 동시성은 하나의 CPU 코어에서 여러 스레드가 돌아가는 것을 의미한다. 한 프로세스 내에서 여러 스레드가 작업을 번갈아가면서 수행하는 것이다.</p><p>이때 각 작업은 큐에 들어가고, 스레드는 그 큐에 있는 작업을 빠르게 전환하면서 처리한다.</p><ul><li><strong>스레드(Thread)</strong>: 알바생 한 명이 커피를 내리다가, 잠시 멈추고 주문을 받다가, 다시 커피를 내리러 가는 식으로 <strong>하나의 알바생(스레드)이 여러 작업을 번갈아 가며</strong> 처리하는 것과 비슷하다.</li><li><strong>큐(Queue)</strong>: 해야 할 일(주문, 서빙, 커피 내리기 등)이 대기열(큐)에 쌓이고, 알바생(스레드)은 그 대기열에 있는 일을 하나씩 처리한다.</li><li><strong>코어(Core)</strong>: 한 명의 알바생은 CPU의 코어 하나에 해당한다. 이 코어는 여러 작업을 처리할 수 있지만, 한 번에 하나씩만 처리해요. 동시성에서는 알바생이 빠르게 작업을 전환해서 <strong>여러 작업이 동시에 처리되는 것처럼 보이게</strong> 한다.</li></ul><h3>병렬성</h3><p>CPU 코어에서 각각의 작업이 동시에 처리되는 것을 의미한다. 즉, 여러 프로세스가 여러 코어에서 동시에 실행되며, 각 프로세스는 독립적으로 수행된다.</p><p>병렬성은 프로그램의 실행 흐름중 어떤 순간의 단면을 딱 자르면 두 개 또는 그 이상의 프로그램이 실행되고 있는 것이고, 동시성은 딱 하나의 프로그램이 실행되는 것이다.</p><h3>비동기</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/779/0*iekKMm9wuq-Q9EIw.png" /></figure><p>비동기는 동시성을 구현하는 한 가지 방법으로, 특히 입출력(I/O) 작업이 많은 프로그램에서 효율적이다. 비동기의 핵심 개념은 대기 시간을 효율적으로 활용하는 것이다.</p><p>동기적인 방식에서는 CPU가 작업을 하나씩 처리하고, 하나의 작업이 끝나기를 기다려야 다음 작업을 시작할 수 있다. 따라서 요청을 보내고 서버의 응답을 기다리는 동안 CPU는 단순히 대기하게 된다.</p><p>비동기의 방식에서는 이러한 대기 시간을 활용해 다른 작업을 처리하여 CPU가 효율적으로 사용된다. 비동기는 보통 이벤트 기반이나 콜백패턴으로 동작한다.</p><p>하지만 항상 비동기로 구현한다고 해서 이점이 있는 건 아니다. 이전 작업이 완료된 후에만 다음 작업을 할 수 있는 경우에는 동기 방식이 유리하고, 비동기로 구현한다고 해도 효과를 볼 수 없다.</p><p>비동기 프로그래밍은 입출력 작업이 많거나, 병렬로 처리할 수 있는 작업이 있거나, 실시간 응답이 중요한 경우( 다수의 클라이언트 요청을 빠르게 처리해야 하는 경우) 와 같을 때 유리하다.</p><h3>언제 어떤 방법을 사용해야 할까?</h3><p><strong><em>I/O-bound</em></strong></p><p>I/O-bound 작업은 CPU 계산보다는 입출력 작업에서 많은 시간이 소모되는 작업을 의미한다. 예를 들면 파일 읽기/쓰기, 사용자 입력/출력, 네트워크 요청(HTTP 요청, 데이터베이스 쿼리 등)이 이에 해당한다.</p><p>이러한 작업에서는 CPU가 해야할 일은 실제로 그리 많지 않다. 대신, 네트워크 응답을 기다리거나 파일이 읽히기를 기다리는 동안 CPU는 유휴 상태가 된다. 유휴 상태(Idle State)는 컴퓨터 시스템에서 CPU나 다른 하드웨어 자원이 아무런 작업을 하지 않고 대기하고 있는 상태를 뜻한다.</p><p><strong><em>CPU-bound</em></strong></p><p>대부분의 시간이 CPU 계산에 소비되는 작업을 의미한다. 예를 들면, 복잡한 계산이나 데이터 처리, 이미지 처리, 머신러닝 모델 학습이 있다.</p><p>이러한 작업에서는 CPU가 지속적으로 사용되기 때문에 입출력 대기 시간이 거의 없고 CPU의 계산 성능이 중요하다. 그렇다면 여러 스레드를 사용해 병렬 처리로 성능을 향상시킬 수 있다.</p><p><strong><em>GIL(Global Interpreter Lock)</em></strong></p><p>GIL은 병렬 파이썬 코드를 실행할 때 여러 스레드의 사용을 제한하는 상호 배제 락이다. 즉, 한번에 1개의 스레드를 유지하는 락이고, 여러 개의 스레드를 자체 코드에서 실행하려면 자체 코드를 실행하기 전에 락을 먼저 점유해야 한다.</p><p>동시성의 경우, 물리적으로 한번에 하나씩만 작업을 처리하기 때문에 GIL이 별다른 문제가 되지 않는다.</p><p>하지만 파이썬으로 병렬성을 구현하기 위해 멀티 스레딩을 사용하더라도, GIL로 인해 여러 스레드가 동시에 CPU를 사용하지 못한다. 파이썬으로 병렬성을 구현하고 싶다면 멀티 프로세싱을 사용해야 한다.</p><p>따라서 I/O-bound 작업을 위해 멀티 스레딩이나 비동기를 구현하는 것은 파이썬에서 효과적이다. 이유는 스레드가 I/O 작업을 기다리는 동안은 GIL이 해제되어 다른 스레드가 작업을 수행할 수 있기 때문이다.</p><p>하지만, CPU-bound 작업을 위해 멀티 스레딩을 사용하면 성능 향상이 거의 없으므로(동시 계산 불가능), 멀티 프로세싱이 더 나은 선택일 수 있다. 멀티 프로세싱은 각 프로세스가 독립적인 메모리 공간을 사용하므로 GIL의 영향을 받지 않고 병렬로 작업을 처리할 수 있다.</p><h3>파이썬으로 구현하는 동시성 프로그래밍</h3><p><strong><em>asyncio로 동시성 구현하기(비동기 방식)</em></strong></p><p>코드를 살펴보기 전에, <strong><em>asyncio </em></strong>를 이해하기 위한 몇가지 개념을 살펴보겠다.</p><p><strong><em>이벤트 기반 프로그래밍</em></strong></p><p>이벤트 기반 프로그래밍은 이벤트(발생하는 일)에 의해 프로그램의 흐름이 결정되는 방식이다. 특정 이벤트가 발생할 때만 프로그램이 반응하고 그 이벤트에 맞는 작업을 처리한다.</p><p><strong><em>이벤트 루프</em></strong></p><p>프로그램이 종료될 때까지 계속 돌아가는 루프로, 이벤트가 발생하기를 기다렸다가 발생한 이벤트를 처리하는 역할을 한다. 비동기 작업이 등록되면, 이벤트 루프는 그 작업이 완료될 때까지 기다리지 않고, 다른 작업을 처리한다.</p><p>비동기 작업(코루틴)을 관리하고 실행하는 관리자 라고 할 수 있다. 쉽게 말해, 여러 작업을 동시에 처리하는 것처럼 보이게 해주는 도구이다.</p><p><strong>역할</strong></p><ul><li>할 일을 순서대로 관리하고 처리하는 역할을 한다.</li><li>비동기 작업은 즉시 완료되지 않고 시간이 걸리기 때문에, 이벤트 루프는 한 작업이 끝날 때까지 기다리는 대신 다른 작업을 먼저 처리할 수 있게 해준다.</li><li>이벤트 루프는 <strong>비동기 작업과 콜백을 실행하고, 각 작업이 I/O 작업을 대기할 때 다른 작업으로 전환</strong>하면서 시스템 자원을 효율적으로 사용하게 해준다. ( = 네트워크 I/O 작업을 수행하며, 하위 프로세스를 실행한다. )</li></ul><p><strong>작동 원리</strong></p><ul><li>네트워크 요청을 보내고 응답이 돌아올 때까지 기다리면 시간이 오래 걸리기 때문에 이벤트 루프는 그 시간동안 다른 작업을 먼저 처리한다.</li><li>작업이 끝나면 알람이 울리고 이벤트 루프가 그 결과를 처리한다.</li><li>이렇게 작업들이 완료될 때까지 않고 기다리지 않고, 그 사이에 다른 비동기 작업들을 계속해서 처리하면서 효율적으로 시간을 사용한다.</li></ul><p><strong>동작 과정</strong></p><ul><li>할일을 등록 : 비동기 작업을 이벤트 루프에 등록</li><li>작업 시작 : 작업을 시작하지만, 결과를 기다리지 않고 다른 할일을 처리</li><li>작업이 끝날 때까지 대기 : 작업이 완료되면, 이벤트 루프는 알림을 받고 그 결과를 처리</li><li>다음 작업 처리 : 이벤트 루프는 처리할 다른 비동기 작업이 있으면 계속해서 순서대로 처리</li></ul><p><strong><em>코루틴</em></strong></p><p>코루틴(Coroutine)은 <strong>비동기 프로그래밍</strong>에서 주로 사용되는 특별한 함수 형태로, 일반 함수와는 다르게 실행 중에 <strong>일시 중단</strong>하고, 나중에 다시 <strong>중단된 지점부터 재개</strong>할 수 있는 함수이다. 파이썬에서 코루틴은 async def로 정의되며, 비동기 작업을 효율적으로 처리하기 위한 핵심 개념이다.</p><p><strong><em>await</em></strong></p><p>await 는 비동기 프로그래밍을 위한 키워드로, 비동기 함수의 실행을 일시 중단하고, 그 작업이 완료될 때까지 기다린 후 다시 실행을 재개하는 역할을 한다. 함수의 실행이 중단되면, 다른 작업들을 계속 처리할 수 있다.</p><pre>import asyncio<br>import time<br><br>async def task1():<br>    print(f&quot;{time.strftime(&#39;%X&#39;)} - 작업 1 시작&quot;)<br>    await asyncio.sleep(2)  # 2초 대기<br>    print(f&quot;{time.strftime(&#39;%X&#39;)} - 작업 1 완료&quot;)<br><br>async def task2():<br>    print(f&quot;{time.strftime(&#39;%X&#39;)} - 작업 2 시작&quot;)<br>    await asyncio.sleep(1)  # 1초 대기<br>    print(f&quot;{time.strftime(&#39;%X&#39;)} - 작업 2 완료&quot;)<br><br># 여러 코루틴 실행<br>async def main():<br>    start_time = time.time()<br>    await asyncio.gather(task1(), task2())<br>    print(f&quot;비동기 방식 전체 수행 시간: {time.time() - start_time:.2f} 초&quot;)<br><br>asyncio.run(main())</pre><p>아주 간단한 예시를 가져왔다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/261/1*-e7-_maxcmO1lzYcbANkqg.png" /></figure><p>비동기로 구현했기 때문에, 작업 1이 시작 후 완료를 기다리지 않고, 바로 작업2가 시작된다. 이를 동기로 구현하면 아래와 같은 결과가 나온다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/247/1*ss3u3gucZwMwB3d-myY3ag.png" /></figure><p>더 복잡한 예제를 시도해보자. 비동기로 구현하면 더욱 이점이 생기는 작업은 I/O-bound 작업 대기 시간이 긴 경우이다. 웹 크롤링을 떠올렸고 이를 동기와 비동기, 두개의 방법으로 구현해보았다.</p><p>상세한 코드는 깃허브를 참고 바란다. ( <a href="https://github.com/jungeunyooon/python-practice">링크</a> )</p><p>기사 순위 사이트를 크롤링 했는데 기사가 30개일 때는 차이가 거의 없었고 오히려 동기 방식이 더 빠른 결과를 보였다.</p><ul><li>비동기 방식 전체 수행 시간: 0.81 초</li><li>동기 방식 전체 수행 시간: 0.73 초</li></ul><p>기사를 150개로 늘리니 비동기로 구현한 코드가 훨씬 빠른 속도를 보였다.</p><ul><li>비동기 방식 전체 수행 시간 : 0.96 초</li><li>동기 방식 전체 수행 시간 : 3.64 초</li></ul><p><strong><em>threading으로 동시성 구현하기(스레딩)</em></strong></p><p>위에서 진행한 기사 순위 사이트 크롤링을 threading을 이용해서 구현했다.</p><ul><li>스레딩 방식 전체 수행 시간: 1.31 초 ( 한 페이지를 크롤링)</li><li>스레딩 방식 전체 수행 시간 : 1.15 초 ( 다섯 페이지를 크롤링 )</li></ul><p>10개의 페이지를 크롤링 했을 때는 아래와 같은 결과를 보였다.</p><ul><li>비동기 방식 전체 수행 시간: 3.17 초</li><li>동기 방식 전체 수행 시간: 18.98 초</li><li>스레딩 방식 전체 수행 시간 : 5.60 초</li></ul><pre>def main():<br>    start_time = time.time()<br>    print(f&quot;{time.strftime(&#39;%X&#39;)} : 스레딩 크롤링 작업 시작&quot;)<br><br>    total_pages = 5  # 크롤링할 페이지 수 설정<br>    threads = []<br>    for page in range(1, total_pages + 1):<br>        thread = threading.Thread(target=newsCrawler, args=(page,))<br>        threads.append(thread)<br>        thread.start()<br><br>    # 모든 스레드가 끝날 때까지 대기<br>    for thread in threads:<br>        thread.join()<br><br>    print(f&quot;{time.strftime(&#39;%X&#39;)} : 모든 크롤링 작업 완료&quot;)<br>    print(f&quot;스레딩 방식 전체 수행 시간: {time.time() - start_time:.2f} 초&quot;)</pre><p>멀티스레딩은 CPU가 순간적으로 여러 작업을 번갈아 가며 처리하기 때문에,여러 스레드가 동시에 실행되는 것처럼 보이지만 각 스레드는 한번에 한 작업만 처리할 수 있다. 병렬 처리와 달리, 멀티 스레드는 한정된 CPU 리소스를 여러 스레드가 나누어 사용한다.</p><p>위의 코드는 각 페이지를 크롤링할 때마다 새로운 스레드를 생성한다. 스레드가 동작하는 동안 다른 스레드들이 크롤링 작업을 병렬로 수행하는 것처럼 보이지만 실제로는 스레드가 짧은 시간동안 작업을 번갈아 수행하는 것이다.</p><p>이러한 방식은 CPU를 많이 사용하는 작업에는 멀티스레딩의 효율성이 떨어지지만, 크롤링과 같이 I/O-bound 작업에서는 멀티스레딩이 적합하다.</p><p>따라서, <strong>비동기와 병렬 작업 </strong>중 어떤 방식을 선택할지는 작업의 특성에 따라 선택해야한다. <strong>I/O-bound 작업</strong>(예: 웹 크롤링, 파일 다운로드)처럼 대기 시간이 중요한 경우, <strong>비동기 프로그래밍</strong>이 성능적으로 더 효율적일 수 있다.</p><p>반면, <strong>CPU-bound 작업</strong>(예: 데이터 처리, 복잡한 계산 작업)에서는 여러 스레드가 동시에 작업을 나눠 처리하는 <strong>병렬을 이용한 작업</strong>이 적합할 수 있다.</p><p><a href="https://github.com/jungeunyooon/python-practice">https://github.com/jungeunyooon/python-practice</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a4a21df6b4cd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Jenkins pipeline 을 구축하여 Docker build 및 이미지 push 하기]]></title>
            <link>https://medium.com/@angal2310/jenkins-pipeline-%EC%9D%84-%EA%B5%AC%EC%B6%95%ED%95%98%EC%97%AC-docker-build-%EB%B0%8F-%EC%9D%B4%EB%AF%B8%EC%A7%80-push-%ED%95%98%EA%B8%B0-4ada8fb092ac?source=rss-0431dd1f32f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/4ada8fb092ac</guid>
            <dc:creator><![CDATA[Jungeun]]></dc:creator>
            <pubDate>Sat, 10 Aug 2024 08:09:00 GMT</pubDate>
            <atom:updated>2025-11-15T09:13:59.802Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g0hjdyRg1lC1p-Jg8nFuyg.png" /></figure><p>위 사진처럼 최근에 진행한 프로젝트에서는 프론트와 백엔드를 분리하여 소스 코드를 관리하고 컨테이너 레지스트리를 통해 도커 이미지를 가져와 배포를 자동화했다. 이 과정에 대해서 설명하려고 한다.</p><h3>플로우</h3><ol><li>레포지토리 구성</li><li>서버 설정(포트 열기, 고정 아이피 할당 등)</li><li>서버에 Docker/Compose 설치</li><li>Docker hub 설정</li><li>Jenkins 설정</li><li>Github Webhook 설정</li><li>Jenkins 파일 설정</li><li>Slack 알림 설정</li></ol><h3>레포지토리 구성</h3><p>배포 자동화 프로세스를 위한 레포지토리 구성은 다음과 같다.</p><ol><li>백엔드 레포지토리 : 백엔드 소스코드 저장</li><li>프론트엔드 레포지토리 : 프론트엔드 소스코드 저장</li><li>버전 관리 및 배포 레포지토리 : Team-A 레포지토리에 해당한다.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/597/1*J66JLgyulLldrMST872kMQ.png" /></figure><p><strong>[ 전체 과정 ]</strong></p><ol><li>개발자가 PR 생성</li><li>Webhook을 이용한 감지 : Github는 새로운 PR이 발생하면 해당 레포지토리에 설정된 Webhook을 통해 Jenkins에 통보한다.</li><li>Jenkins 파이프라인 실행 : 백엔드나 프론트엔드 각각에 대한 빌드 파이프라인을 설정한다.</li><li>Docker 이미지 생성 : 성공적으로 빌드 및 테스트가 완료되면 <strong><em>docker build</em></strong> 명령어를 사용하여 Docker 이미지를 생성하고, <strong><em>docker push</em></strong> 명령어를 통해 Docker Hub에 푸시한다.</li><li>배포 서버에 푸시 : 만들어진 이미지를 배포 서버에 반영하고 싶다면 배포 레포지토리에서 이미지 버전만 수정하여 푸시한다. 이러한 PR이 Webhook을 통해 Jenkins에서 감지되고, 자동으로 배포되는 파이프라인을 통해 배포 자동화가 이루어진다.</li></ol><h3>서버 설정</h3><p>서버는 젠킨스 관리 서버와 배포 서버로 2개의 서버가 필요하다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qK7xeTgtyvfSRIgFFDc3bg.png" /></figure><p>GCP(Google Cloud Platform)을 이용하여 VM 인스턴스를 생성하는 방법은 다음과 같다.</p><ul><li>GCP 콘솔에서 <strong><em>Compoute Engine</em></strong> -&gt; <strong><em>VM 인스턴스</em></strong> 선택</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/464/1*e-WlEUIIAFLrTazIzDdxyA.png" /></figure><ul><li>프로젝트가 없다면 <strong><em>프로젝트 만들기</em></strong>를 선택하고, <strong><em>Open API 사용</em></strong>을 선택</li><li><strong><em>인스턴스 만들기</em></strong>를 선택하고, 생성하려는 인스턴스의 이름, 리전, 영역을 선택한다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/897/1*RxtwO0UrAgQ0cAEee98gtw.png" /></figure><ul><li>머신 구성, 방화벽 설정(HTTP, HTTPS) : 부팅 디스크를 설정할 때 디스크 용량은 20 이상으로 설정하는 것이 좋다.</li><li>OS 선택 : GCE Ubuntu 20.04 LTS</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*0he_9LkcQ_IKAzHu.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*0kiZaMyH_wXQlXr-.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/924/0*BfLOrYFX7uMjBJfF.png" /></figure><ul><li>위의 과정을 거친 후에 만들기를 선택하면 상태 확인에서 초록색 아이콘이 뜨면 끝이다.</li></ul><h3>서버에 Docker/Compose 설치</h3><p>이제 생성한 인스턴스에 도커를 설치해야 한다.</p><ul><li>서버에 안전하게 접근하기 위한 SSH 키 생성</li></ul><pre>ssh-keygen -t rsa -b 4096 -f ~/.ssh/deploy_key -C &quot;your_email@example.com&quot;</pre><ul><li>서버에 SSH를 통해 접속</li></ul><pre>ssh -i ~/.ssh/{키값} 유저@ip</pre><ul><li>스크립트 파일 생성 : vi docker.sh 로 파일을 생성하고 아래의 내용을 넣는다.</li></ul><pre>#!/bin/bash<br><br># 패키지 업데이트 및 의존성 설치<br>sudo apt-get update<br>sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common<br><br># Docker의 공식 GPG 키 추가<br>curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -<br><br># Docker 저장소 추가<br>sudo add-apt-repository &quot;deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable&quot;<br><br># 패키지 업데이트 및 Docker 설치<br>sudo apt-get update<br>sudo apt-get install -y docker-ce<br><br># Docker 서비스 시작<br>sudo systemctl start docker<br>sudo systemctl enable docker<br><br># 현재 사용자를 Docker 그룹에 추가<br>sudo usermod -aG docker $USER<br><br># Docker Compose 설치<br>sudo curl -L &quot;https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)&quot; -o /usr/local/bin/docker-compose<br>sudo chmod +x /usr/local/bin/docker-compose<br><br># 설치 확인<br>docker --version<br>docker-compose --version<br><br>echo &quot;Docker 및 Docker Compose 설치 완료.”</pre><ul><li>스크립트 실행 및 서버 재시작</li></ul><pre># 스크립트 파일 실행<br>sh docker.sh<br><br># 설치가 완료된 후, 서버 재부팅<br>sudo systemctl reboot<br>sudo systemctl restart docker<br><br># 실행중인 컨테이너 확인<br>docker ps</pre><h3>Docker hub 설정</h3><p>Docker hub는 도커 이미지 원격 저장소이다. 도커 이미지를 저장할 수 있는 클라우드 서비스이고 사용자는 이미지를 올리고 이미지를 내려받기만 하면 되므로 간단하게 사용이 가능하다.</p><ul><li>계정 생성 후 이미지 Repository 생성 : 백엔드와 프론트엔드 각각 Repository가 필요하다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iWkHLbK_SVeg8TW3aFgsqA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/842/1*8EzsorApeC-c00E6vNy7iw.png" /></figure><ul><li>액세스 토큰 생성</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/755/1*r6VJvBMuJiI21VlPqxCcGw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3sSUMEnSts78A9CEcJgoRg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/934/1*RNGqS_iqdUli3Y5ev21RFw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/654/1*z28Yt2eRhfS5Y09R7eirNQ.png" /></figure><p>설명을 입력한 뒤, Generate 버튼을 클릭하게 되면 토큰이 발급되고, 발급 시에만 토큰을 확인할 수 있고 이후에는 확인할 수 없기 때문에 꼭 따로 보관해야한다.</p><h3>Jenkins 설정</h3><p>이제 젠킨스 서버에 올릴 도커 파일, docker-compose.yml을 작성하고 이를 서버에서 실행해야 한다.</p><ul><li>도커 파일</li></ul><pre># 젠킨스 이미지<br>FROM jenkins/jenkins:latest<br><br># 유저 루트 (권한 이슈)<br>USER root<br><br># 도커 관련 라이브러리 설치<br>RUN apt-get update &amp;&amp; \<br>    apt-get install -y \<br>    apt-transport-https \<br>    ca-certificates \<br>    curl \<br>    gnupg \<br>    lsb-release<br><br># 도커 gpg key 저장소<br>RUN mkdir -p /etc/apt/keyrings<br><br># 도커 gpg key 다운로드<br>RUN curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg<br><br># 도커 저장소 등록<br>RUN echo &quot;deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian $(lsb_release -cs) stable&quot; | tee /etc/apt/sources.list.d/docker.list &gt; /dev/null<br><br># 도커 &amp; 컴포즈 설치<br>RUN apt-get update &amp;&amp; \<br>    apt-get install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin<br><br>RUN usermod -aG docker jenkins &amp;&amp; \<br>    usermod -aG users jenkins<br><br># 루트 권한 회수<br>USER jenkins</pre><ul><li>docker-compose-jenkins.yml</li></ul><pre>version: &#39;3.8&#39;<br><br>services:<br>  # 젠킨스<br>  jenkins:<br>    build:<br>      context: .<br>      dockerfile: jenkins.Dockerfile<br>    restart: always<br>    user: root<br>    container_name: jenkins<br>    ports:<br>      - &quot;8080:8080&quot;<br>    volumes:<br>      - /var/run/docker.sock:/var/run/docker.sock # 중요! 호스트 도커 연결<br>      - jenkins_home:/var/jenkins_home<br><br>    networks:<br>      - jenkins-network<br><br>volumes:<br>  jenkins_home:<br><br>networks:<br>  jenkins-network:<br>    driver: bridge</pre><ul><li>docker-compose-deploy.yml</li></ul><p>필요한 데이터베이스, 프론트, 백엔드 설정을 여기에 작성해주면 된다. 더 구체적인 코드는 링크를 참고하면 된다.</p><p><a href="https://github.com/2024-SUMMER-BOOTCAMP-TEAM-A/Team-A/blob/main/docker-compose-deploy.yml">https://github.com/2024-SUMMER-BOOTCAMP-TEAM-A/Team-A/blob/main/docker-compose-deploy.yml</a></p><pre>version: &#39;3.8&#39;<br><br>services: <br>  node:<br>      container_name: node<br>      image: jungeunyoon/teama-backend:1.0.89 #원하는 버전으로 업데이트<br>      restart: always<br>      environment:<br>        - MONGO_INITDB_ROOT_USERNAME=${MONGO_INITDB_ROOT_USERNAME}<br>        - 필요한 환경변수 파일 설정을 넣는다. <br>      ports:<br>        - &#39;8000:8000&#39;<br>      depends_on:<br>        - db<br>        - redis<br>        - mongo<br>      command: npm start # 컨테이너가 시작될 때 실행할 명령<br>      networks:<br>        - app-network<br>  <br>  <br>  front:<br>      image: jungeunyoon/team-a-frontend:1.0.87 #원하는 버전으로 업데이트 <br>      container_name: front<br>      ports:<br>        - &quot;3000:3000&quot;<br>      command: yarn dev<br>      restart: always<br>  <br><br>networks:<br>  app-network:<br>    driver: bridge<br><br>volumes:<br>  db_data:<br>  mongodb:</pre><ul><li>깃 레포지토리 클론</li></ul><pre>git clone https://github.com/2024-SUMMER-BOOTCAMP-TEAM-A/Team-A.git</pre><ul><li>도커 컨테이너 실행</li></ul><pre>cd Team-A<br>docker compose -f docker-compose-jenkins.yml build</pre><p>실행이 완료된 후 올바르게 실행되었는지는 <strong><em>docker ps</em></strong> 명령어를 통해 확인할 수 있다. 올바르게 실행이 되었다면 http://&lt;host ip&gt;:8080 에 접속 시 아래와 같은 화면이 뜬다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/767/1*jEupsgOUsaU71URVI4yKfg.png" /></figure><p>로그인을 위한 비밀번호는 젠킨스 컨테이너 로그를 확인하면 알 수 있다. 로그는 <strong><em>docker logs [컨테이너 아이디]</em></strong> 명령어를 통해 로그를 확인하면 된다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*qUavPS6DG7JQQZvmcblinQ.png" /></figure><ul><li>로그인 후, Install suggested plugins을 선택한다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/861/1*O72LGCAjKZvmEhgoYrsRYg.png" /></figure><ul><li>필요한 플러그인들이 설치가 끝나면 계정 생성을 위한 화면이 나온다. 계정명, 암호 등은 로그인을 위한 것들이니 원하는 대로 설정하면 된다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/864/1*zj4sjFtin3Rd6vqjLaEqOA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/958/1*E77VAKhX_JyDb2NcqsBvFA.png" /></figure><p>위의 화면은 계정 생성이 끝난 후 접속한 화면이다. 이제 필요한 설정들을 세팅해야한다. 일단 필요한 플러그인을 설치해야한다. 플러그인은 젠킨스 관리 → Plugins → Available Plugins에서 설치할 수 있다.</p><ul><li>Pipeline : Stage View (UI 개선)</li><li>SSH Agent : 배포 서버 접속용</li><li>Slack Notification : 슬랙 연동을 위함</li></ul><p>이렇게 3가지를 설치한다.</p><h3>Github Webhook 설정</h3><p>이제 젠킨스 초기 화면에서 <strong><em>새로운 item </em></strong>을 선택한다. 이 과정은 파이프라인을 생성하고 깃허브를 연동하기 위함이다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/893/1*1ttsv5cblQltbkqQcF8ePA.png" /></figure><p>이름은 원하는 대로 설정하고,<strong><em> Multibranch Pipeline</em></strong>을 선택한다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/947/1*V3EZiDCf8jqHZzXFcut2HA.png" /></figure><p>이제 <strong><em>Branch Sources</em></strong>에서 <strong><em>Add Sources</em></strong>를 선택하고, <strong><em>Github</em></strong>를 선택한다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/586/1*nNoQwfwrEDUKqUjf_4uoDg.png" /></figure><p>이제 깃허브에서 웹훅 설정을 진행한다.</p><ul><li>Settings -&gt; Developer Settings 선택</li><li>Tokens 에서 액세스 토큰 생성</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uXHpzz39DnVu_W4KSna2XA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8noyo0yFB0RefZToGZoSPA.png" /></figure><ul><li>admin:repo_hook, repo를 선택하고 액세스 토큰을 생성한다. 이 토큰 또한 따로 저장해놔야 한다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_RbH0uqzO29zXaANqjrzcQ.png" /></figure><p>이제 파이프라인을 생성하려는 레포지토리로 들어간다.</p><ul><li>Settings -&gt; Webhooks -&gt; Add webhook 선택</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iN9X4EJYxVEb4ja8-L7MJA.png" /></figure><p>위와 같이 작성해준다. 주의할 점은 Payload URL은 <strong><em>http://&lt;IP&gt;:port/github-webhook/</em></strong> 이 형식을 올바르게 지켜야한다. Add webhook을 누르고 초록색 체크표시가 있다면 올바르게 설정된 것이다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vgZr2uLQC47fxBUdR7I5bw.png" /></figure><ul><li>이제 다시 젠킨스 서버로 이동한다.</li><li>젠킨스 대시보드 -&gt; Jenkins 관리 -&gt; Credentials -&gt; global -&gt; Add Credentials</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FIsSV6pRRqBQe43l3j6J-w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qKjUtAi0YlBuq51yVv4bEQ.png" /></figure><ul><li>아래의 사진처럼 설정하고, 패스워드는 복사해 둔 깃허브 액세스 토큰을 넣는다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/931/1*W0UxPWpDSlo3WsF3SnT5CQ.png" /></figure><ul><li>Dashboard -&gt; 만들었던 파이프라인 선택 -&gt; Configure접속</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/947/1*CFDrCWpWb87_5ZElTi0P9Q.png" /></figure><ul><li>Branch Sources -&gt; Add Source -&gt; Github 추가</li></ul><p>Credentials은 아까 만들어둔 Credentials을 선택하고, Repository HTTPS URL에는 레포지토리 URL을 입력한다.</p><ul><li>Behaviours</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y9U7sGShfWW_lidhoLxfcg.png" /></figure><p>필요한 환경 변수 관리도 따로 필요하다.</p><p>Jenkins 관리 -&gt; System -&gt; Global Properties -&gt; Environment Variables</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p8M06xttRWmuSYhMTQDzAw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_ci94k7ahi5l2pFa02vc-Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*ctE8pxKE_Y16B96w4xdpAA.png" /></figure><p>필요한 값들을 하나씩 만들고, Apply -&gt; 저장을 클릭한다.</p><h3>Jenkins 파일 설정</h3><p>현재 젠킨스 서버에 컨테이너를 띄우고 파이프라인이 존재하기만 한 상황이다. 이제 젠킨스서버에서 PR이 감지되면 배포를 자동화하기 위한 파이프라인 코드 작성이 필요하다.</p><p>파이프라인 코드는 백엔드, 프론트엔드 파이프라인과 버전 관리 레포지토리 파이프라인 총 3가지가 필요하다.</p><ul><li>백엔드, 프론트엔드 파이프라인</li></ul><pre>pipeline {<br>    agent any<br>    <br>    environment {<br>        repository = &quot;jungeunyoon/teama-backend&quot;  //docker hub id와 repository 이름<br>        DOCKERHUB_CREDENTIALS = credentials(&#39;team-a-docker-hub&#39;) // jenkins에 등록해 놓은 docker hub credentials 이름<br>        IMAGE_TAG = &quot;&quot; // docker image tag<br>    }<br><br>    stages {<br>        stage(&#39;Checkout&#39;) {<br>            steps {<br>                cleanWs()<br>                git branch: &#39;develop&#39;, url: &quot;https://github.com/2024-SUMMER-BOOTCAMP-TEAM-A/backend.git&quot;<br>            }<br>        }<br><br>        stage(&#39;Test&#39;) {<br>            steps {<br>                script {<br>                    sh &quot;docker --version&quot;<br>                    sh &quot;docker compose --version&quot;<br>                }<br>            }<br>        }<br><br>        stage(&#39;Set Image Tag&#39;) {<br>            steps {<br>                script {<br>                    // Set image tag based on branch name<br>                    if (env.BRANCH_NAME == &#39;develop&#39;) {<br>                        IMAGE_TAG = &quot;1.0.${BUILD_NUMBER}&quot;<br>                    } else {<br>                        IMAGE_TAG = &quot;0.0.${BUILD_NUMBER}&quot;<br>                    }<br>                    echo &quot;Image tag set to: ${IMAGE_TAG}&quot;<br>                }<br>            }<br>        }<br><br>        stage(&#39;Building our image&#39;) { <br>            steps { <br>                script { <br>                    sh &quot;docker build -t ${repository}:${IMAGE_TAG} .&quot; // docker build<br><br>                }<br>            } <br>        }<br>        stage(&#39;Login&#39;){<br>            steps{<br>                sh &quot;echo ${DOCKERHUB_CREDENTIALS_PSW} | docker login -u $DOCKERHUB_CREDENTIALS_USR --password-stdin&quot; // docker hub 로그인<br>            }<br>        }<br>        stage(&#39;Deploy our image&#39;) { <br>            steps { <br>                script {<br>                    sh &quot;docker push ${repository}:${IMAGE_TAG}&quot;//docker push<br>                } <br>            }<br>        } <br>        stage(&#39;Cleaning up&#39;) { <br>            steps { <br>                sh &quot;docker rmi ${repository}:${IMAGE_TAG}&quot; // docker image 제거<br>            }<br>        } <br>    }<br><br>    post {<br>        always {<br>            cleanWs(cleanWhenNotBuilt: false,<br>                    deleteDirs: true,<br>                    disableDeferredWipeout: true,<br>                    notFailBuild: true,<br>                    patterns: [[pattern: &#39;.gitignore&#39;, type: &#39;INCLUDE&#39;],<br>                            [pattern: &#39;.propsfile&#39;, type: &#39;EXCLUDE&#39;]])<br>        }<br>        success {<br>            echo &#39;Build and deployment successful!&#39;<br>        }<br>        failure {<br>            echo &#39;Build or deployment failed.&#39;<br>        }<br>    }<br>}</pre><p>프론트엔드 파이프라인의 경우 docker hub repository 이름과 깃허브 url만 수정하면 된다.</p><ul><li>버전 관리 레포지토리 파이프라인</li></ul><pre>pipeline {<br>    agent any<br>    <br>    environment {<br>        DOCKER_COMPOSE_FILE = &#39;docker-compose-deploy.yml&#39;<br>        MYSQL_ROOT_PASSWORD=&quot;${MYSQL_ROOT_PASSWORD}&quot;<br>        MYSQL_DATABASE=&quot;${MYSQL_DATABASE}&quot;<br>        MYSQL_USER=&quot;${MYSQL_USER}&quot;<br>        MYSQL_PASSWORD=&quot;${MYSQL_PASSWORD}&quot;<br>        NODE_ENV=&quot;${NODE_ENV}&quot;<br>        TZ=&quot;${TZ}&quot;<br>        DEPLOY_SERVER=&quot;angal2310@34.83.113.214&quot;<br>        MONGO_INITDB_ROOT_USERNAME=&quot;${MONGO_INITDB_ROOT_USERNAME}&quot;<br>        MONGO_INITDB_ROOT_PASSWORD=&quot;${MONGO_INITDB_ROOT_PASSWORD}&quot;<br>        ME_CONFIG_MONGODB_SERVER=&quot;mongodb&quot;<br>        ME_CONFIG_MONGODB_PORT=&quot;27017&quot;<br>        ME_CONFIG_MONGODB_ENABLE_ADMIN=&quot;true&quot;<br>        MONGOEXPRESS_LOGIN=&quot;${MONGOEXPRESS_LOGIN}&quot;<br>        MONGOEXPRESS_PASSWORD=&quot;${MONGOEXPRESS_PASSWORD}&quot;<br>        REDIS_URL=&quot;redis://redis:6379&quot;<br>        MYSQL_HOST=&quot;db&quot;<br>        GOOGLE_CLOUD_PROJECT=&quot;${GOOGLE_CLOUD_PROJECT}&quot;<br>        GCLOUD_STORAGE_BUCKET=&quot;${GCLOUD_STORAGE_BUCKET}&quot;<br>        OPENAI_API_KEY=&quot;${OPENAI_API_KEY}&quot;<br>        CLOVA_API_KEY=&quot;${CLOVA_API_KEY}&quot;<br>        CLOVA_CLIENT_ID=&quot;${CLOVA_CLIENT_ID}&quot;<br>        JWT_SECRET=&quot;${JWT_SECRET}&quot;<br>        REFRESH_TOKEN_SECRET=&quot;${REFRESH_TOKEN_SECRET}&quot;<br>        ELEVENLABS_API_KEY=&quot;${ELEVENLABS_API_KEY}&quot;<br>        GCP_TYPE=&quot;${GCP_TYPE}&quot;<br>        GCP_PROJECT_ID=&quot;${GCP_PROJECT_ID}&quot;<br>        GCP_PRIVATE_KEY_ID=&quot;${GCP_PRIVATE_KEY_ID}&quot;<br>        GCP_PRIVATE_KEY=&quot;${GCP_PRIVATE_KEY}&quot;<br>        GCP_CLIENT_EMAIL=&quot;${GCP_CLIENT_EMAIL}&quot;<br>        GCP_AUTH_URI=&quot;${GCP_AUTH_URI}&quot;<br>        GCP_TOKEN_URI=&quot;${GCP_TOKEN_URI}&quot;<br>        GCP_AUTH_PROVIDER_X509_CERT_URL=&quot;${GCP_AUTH_PROVIDER_X509_CERT_URL}&quot;<br>        GCP_CLIENT_X509_CERT_URL=&quot;${GCP_CLIENT_X509_CERT_URL}&quot;<br>        GCP_UNIVERSE_DOMAIN=&quot;${GCP_UNIVERSE_DOMAIN}&quot;<br>        MONGODB_DOCKER_URL=&quot;${MONGODB_DOCKER_URL}&quot;<br>    }<br><br>    stages {<br>        stage(&#39;Checkout&#39;) {<br>            steps {<br>                cleanWs()<br>                git branch: &#39;main&#39;, url: &#39;https://github.com/2024-SUMMER-BOOTCAMP-TEAM-A/Team-A.git&#39;<br>            }<br>        }<br><br>        stage(&#39;Test&#39;) {<br>            steps {<br>                script {<br>                    sh &quot;docker --version&quot;<br>                    sh &quot;docker compose --version&quot;<br>                    sh &quot;echo hello world!&quot;<br>                }<br>            }<br>        }<br><br>        stage(&#39;Deploy&#39;) {<br>            when {<br>                anyOf {<br>                    branch &#39;main&#39;<br>                    branch &#39;master&#39;<br>                }<br>            }<br>            steps {<br>                script {<br>                    sshagent([&#39;deploy-ssh&#39;]) {<br>                        sh &quot;&quot;&quot;<br>                        ls <br>                        pwd<br>                        ssh angal2310@34.83.113.214 &#39;mkdir -p ~/Team-A&#39; &amp;&amp; scp -r -o StrictHostKeyChecking=no . ${DEPLOY_SERVER}:~/Team-A<br>                        ssh -o StrictHostKeyChecking=no ${DEPLOY_SERVER} &#39;<br>                        cd ~ &amp;&amp;<br>                        ls -al &amp;&amp;<br>                        docker compose -f Team-A/${DOCKER_COMPOSE_FILE} down --remove-orphans &amp;&amp;<br>                        docker compose -f Team-A/${DOCKER_COMPOSE_FILE} pull &amp;&amp;<br>                        docker compose -f Team-A/${DOCKER_COMPOSE_FILE} up -d&#39;<br>                        rm r -f Team-A<br>                        &quot;&quot;&quot;<br>                    }<br>                }<br>            }<br>        }<br>    }<br><br>    post {<br>        always {<br>            cleanWs(cleanWhenNotBuilt: false,<br>                    deleteDirs: true,<br>                    disableDeferredWipeout: true,<br>                    notFailBuild: true,<br>                    patterns: [[pattern: &#39;.gitignore&#39;, type: &#39;INCLUDE&#39;],<br>                            [pattern: &#39;.propsfile&#39;, type: &#39;EXCLUDE&#39;]])<br>        }<br>        success {<br>            echo &#39;Build and deployment successful!&#39;<br>        }<br>        failure {<br>            echo &#39;Build or deployment failed.&#39;<br>        }<br>    }<br>}</pre><ul><li>코드에서 stages에서 빌드 스테이지(코드가 실제 운영 환경에 배포되기 전에 모든 것들이 제대로 작동하는 지 확인하는 과정)를 만들 수 있다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*l3eIh20OSGyMvCbG_ho4OQ.png" /></figure><ul><li>테스트를 해보면 올바르게 파이프라인이 작성하는 지 확인할 수 있다.</li></ul><h3>Slack 알림 설정</h3><p>여러명이서 협업을 진행할 때, 빌드가 될 때마다 하나씩 파이프라인을 확인하는 것은 비효율적이기 때문에, 각 빌드가 올바르게 되는지 슬랙과 연동하여 알림을 받을 수 있다.</p><ul><li>슬랙에서 Jenkins CI Add apps</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j5XNXz21Wm3SdlApx4tA_g.png" /></figure><ul><li>jenkins 추가</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*61xByrNvcF6rK-8P4mQE4A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ysVSLswSbDJ9TP_-F8nfdw.png" /></figure><ul><li>이후의 과정은 젠킨스에서 제공하는 문서를 보면 쉽게 따라할 수 있다. 이 과정을 완료하게 되면, 연동한 채널에 빌드 결과를 확인할 수 있다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*r2qb0tCFdgkToUP1DFuLrA.png" /></figure><h3>주의 : Jenkins 디스크 공간 확보하기</h3><p>파이프라인을 다 설정 후, 슬랙을 통해 모니터링하는 과정에서 계속 빌드 실패하는 일이 일어났다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/1*QMWz7Xx4af4MD5cmtIsC5Q.png" /></figure><p>원인은 젠킨스 서버의 디스크 공간이 부족했기 때문이였다.</p><pre>du -hsx * | sort -rh | head -n 10<br>$df -h</pre><p>위의 명령어를 통해 디스크 사용량을 확인 할 수 있다.</p><p>디스크 사용량이 높은 이유는 도커 빌드 캐시가 원인이였다. 도커는 레이어 구조로 이미지를 생성하기에 빌드 속도 향상을 위해 캐시를 사용한다.</p><pre>docker stop $(docker ps -a -q)<br>docker rm $(docker ps -a -q)<br>docker system prune -a -f</pre><p>위의 명령어를 통해 빌드 캐시를 제거할 수 있다.</p><p>주의할 점은 절대로 젠킨스 서버의 빌드 캐시가 아닌 <strong>배포 서버</strong>의 빌드 캐시를 제거해야한다는 점이다. 또한 위의 명령어는 아주 강력하고 파괴적인 명령어이기 때문에 운영하고 있는 컨테이너라면 조심해서 사용해야 한다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4ada8fb092ac" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[SiliconValley Summer Bootcamp] Person-A]]></title>
            <link>https://medium.com/@angal2310/siliconvalley-summer-bootcamp-person-a-e12d2177d349?source=rss-0431dd1f32f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/e12d2177d349</guid>
            <dc:creator><![CDATA[Jungeun]]></dc:creator>
            <pubDate>Fri, 26 Jul 2024 08:01:39 GMT</pubDate>
            <atom:updated>2024-08-02T18:00:29.796Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rYO0F0OwWUTQCB_iIeSjFQ.png" /></figure><h3>Introduction</h3><p>2024.06.24 ~ 2024.08.03</p><p>6주간의 부트 캠프가 진행되었다.</p><p>다른 팀들과 달리 4명이라는 적은 인원으로 진행이 되었음에도 불구하고, 모든 팀원들이 최선을 다하고 잠을 줄이며 열정적으로 참여했다. Person-A 서비스를 만들기 위해서 구현한 핵심 기술 및 오류들에 대해서 공유하려 한다.</p><p>Person-A는 인격을 부여한 ChatGPT와 고민 상담을 진행하는 서비스이다. 채팅과 STT(음성)을 통해 고민을 이야기하고, 답변을 텍스트와 TTS로 받아 고민상담을 진행할 수있다. 상담 종료 후 ChatGPT와 DALL-E3로 만들어진 상담일지를 시각화 할 수 있으며, PDF로 다운로드가 가능하다.</p><h3>Demo</h3><h4>온보딩 페이지</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*9UDZ0-1wSFV4p6aa2PnYDw.gif" /></figure><h4>캐릭터 선택 페이지</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*cw9llCOe-cx0FQk1iRrJuw.gif" /></figure><p>사용자는 자신이 원하는 캐릭터를 선택할 수 있으며, 해당 캐릭터에 대한 설명을 볼 수 있다.</p><h4>채팅 &amp; STT페이지</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*dgeh7UkBoAq-cjzicf4Puw.gif" /></figure><p>Socket.IO로 타이핑 또는 STT로 ChatGPT에게 메시지를 전송할 수 있고, 답변은 텍스트와 TTS 두가지를 받을 수 있으며, 상담 내용은 Redis에 임시 저장된다.</p><h4>상담 일지 페이지</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*5nYMK2og2v2C8xuZ4T-MRg.gif" /></figure><p>캐릭터와 고민 상담을 진행하고, 채팅 기록이 누적되고 이를 ChatGPT를 통해 상담 일지를 생성한다. 또한 DALL-E3를 통해 상담 결과와 관련된 그림이 상담 일지에 포함된다.</p><h4>인기 순위 페이지</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*KrU8TeIna8TboY4wjhSQ-A.gif" /></figure><h3>System Architecture</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*Cb-3Ih7SlDEvvqPf" /></figure><h3>Tech Stacks</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/809/1*Th-yGiW1lxHENS7AWK_QEA.png" /></figure><h3>Frontend</h3><h4>VITE</h4><p>Vite는 웹 개발에 특화된 최신 JavaScript 프레임워크로, 빠른 환경에서 개발이 가능하다. ES Module 기반의 운영체제를 통해 브라우저 요청에 즉시 응답하며, 브라우저에서 모듈 번들링을 수행하여 빠른 초기 로딩 속도를 제공한다.</p><h4>Chart.js</h4><p>Chart.js는 복잡한 데이터에 대한 이해를 단순화하기 위해 다양한 차트 유형을 생성할 수 있는 데이터 시각화용 JavaScript 라이브러리다. 다양한 데이터 형식을 시각적으로 표현하는 데 Chart.js를 활용하여 복잡한 데이터에 대한 접근성을 높여 사용자 경험을 향상시켰다. 또한 실시간 데이터 업데이트를 차트에 반영하기 위해 라이브러리를 사용하여 사용자가 항상 최신 정보에 액세스할 수 있도록 했다.</p><h4>Style-Component</h4><p>Styled-Components는 CSS-in-JS를 작성하여 React 구성 요소의 스타일을 향상시킬 수 있는 라이브러리다. Styled-Components를 사용하여 별 필드를 만들었고, 문제 해결이 달빛 밤하늘 아래에서 영감을 주는 노력처럼 느껴지도록 만들었다. CSS-in-JS의 강력한 기능을 활용하여 깨끗하고 체계적인 코드베이스를 유지하여 구성 요소 수준에서 스타일을 쉽게 적용하고 관리할 수 있게 하여 시각적으로 일관되고 유지 관리 가능한 사용자 인터페이스를 만들었다.</p><h4>Socket.client</h4><p>Socket.client는 WebSocket 및 기타 대체 프로토콜을 통해 웹 클라이언트와 서버 간의 실시간 양방향 통신을 가능하게 하는 JavaScript 라이브러리다. 우리 서비스에서는 페이지를 새로 고칠 필요 없이 실시간 채팅, 알림, 동적 업데이트와 같은 실시간 기능에 socket.client를 사용하였는데, 이는 다양한 전송 방법, 자동 재연결 및 구현 용이성을 처리하고 다양한 브라우저와 네트워크 조건에서 원활한 사용자 경험을 보장하는 능력 때문에 다른 기술보다 Socket.io을 선택하였다.</p><h3>Backend</h3><h4>Node Express &amp; Socket.IO</h4><p>Node Express는 Node.js를 이용하여 서버를 구성할 수 있도록 하는 라이브러리로, 라우팅이 편리하고 빠른 응답 시간과 높은 처리량을 가진다는 장점을 갖는다. 또한, Socket.io는 웹소켓을 기반으로 실시간 통신을 위한 라이브러리이다. 본 프로젝트에서는 채팅 내용을 실시간으로 GPT로 보내고 다시 가져오는 양방향 통신을 구현해야 하므로, SSE 대신 Socket.IO를 사용하였다.</p><h4>MongoDB</h4><p>MongoDB는 비관계형 데이터베이스 관리 시스템(DBMS)으로, 테이블과 행 대신 유연한 문서를 활용해 다양한 데이터 형식을 처리하고 저장한다. 따라서 사용자가 다변량 데이터 유형을 손쉽게 저장하고 쿼리할 수 있으며, 데이터베이스 관리를 간소화하고 뛰어난 확장성을 갖춘다.</p><p>우리의 서비스에서는 채팅 누적 기록들을 MongoDB에 저장한다. 채팅이 종료되면 누적된 채팅 기록을 프롬프트 메시지에 포함하여 ChatGPT에게 전송한다.</p><h4>ChatGPT</h4><p>ChatGPT는 OpenAI에서 개발한 대규모 사전 학습 모델로, 다양한 자연어 처리 태스크를 수행할 수 있다. 본 프로젝트에서는 AI에게 사람의 인격을 부여하기 위해 모델 학습, 문맥 파악, 문장 생성에 중점을 두었다. ChatGPT는 모델 학습이 용이하며, 유연한 문장 생성 기능을 갖추고 있어 인격이 부여된 상황에서도 자연스러운 문장을 생성할 수 있는 장점이 있다.</p><p>프롬프팅을 통해 사용자가 GPT로 메시지를 보낼 때 미리 작성한 JSON 파일을 선행하여 전송함으로써 AI가 해당 내용을 학습하게 한다. JSON 형식을 사용하는 이유는 가독성이 높아 쉽게 수정할 수 있고, 다른 파일 형식보다 파싱 속도가 빠르며 메모리 사용이 적어 효율적이기 때문이다.</p><h4>DALL-E3 &amp; GCS</h4><p>상담 일지에는 DALL-E3로 생성한 이미지가 포함되어 있으며, 이 이미지는 상담 내용 요약을 토대로 생성된다. 일관되고 높은 퀄리티의 이미지를 위해 프롬프트는 간결하게 영어로 작성되었다.</p><p>데이터베이스는 구조화된 정보 처리에 최적화되어 있기 때문에 대용량 이진 데이터는 이미지를 저장하면 성능이 저하된다. 데이터베이스에 이미지를 저장하게 된다면 이미지 파일은 크기가 커서 데이터베이스의 크기가 급격히 증가하며, 이로 인해 비용이 증가하게 된다. 또한 많은 사용자가 동시에 접근할 경우 비약적으로 트래픽이 증가할 것이고 이로 인해 서버의 성능이 저하된다. 이런 문제들을 해결하기 위해 클라우드 스토리지 중 구글 클라우드 스토리지를 이용했다.</p><p>생성된 이미지를 바로 버킷에 업로드하게 되면 전송 시간이 길어져 사용자 경험에 영향을 미칠 수 있으므로 이미지 리사이징을 진행했다.</p><h3>DevOps</h3><h4>CI/CD : Jenkins</h4><p>백엔드와 프론트 레포지토리를 분리해서 관리함과 동시에 편리한 배포 환경을 구성하기 위해 Jenkins 파이프라인을 구축했다.</p><p>대략적인 흐름은 다음과 같다.</p><ol><li>레포지토리 구성</li></ol><ul><li>백엔드 레포지토리</li><li>프론트 레포지토리</li><li>통합 배포 레포지토리</li></ul><p>2. 코드 변경 및 커밋</p><ul><li>Github Webhook을 통해서 새로운 PR이 발생하면 설정된 Webhook을 통해 Jenkins에 알린다.</li></ul><p>3. Jenkins 파이프라인 실행</p><ul><li>백엔드와 프론트엔드 각각에 대한 파이프라인이 설정되어 있다. 이 파이프라인 빌드 및 테스트가 완료되면 Docker 이미지를 생성 후 Docker Hub에 생성된 이미지가 올라간다.</li></ul><p>4. 배포 레포지토리</p><ul><li>생성된 최신 이미지를 배포 레포지토리에서 버전 업그레이드를 진행한다.</li><li>젠킨스 서버에서 이를 인식하고 Docker Hub에서 새로운 이미지를 가져와 배포 서버의 docker compose로 배포한다.</li></ul><p>Jenkins와 슬랙봇을 연동하여 중요한 이벤트와 상태 변화를 실시간으로 팀원들과 모니터링했다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*22Wv0tLAEmA1ZygveGZjhQ.png" /></figure><h4>GCP &amp; NginX</h4><p>우리의 서비스에서는 2개의 서버를 사용했다.</p><ol><li>Jenkins 서버</li></ol><ul><li>Jenkins 서버에서는 레포지토리의 PR이 감지될 때마다 이를 자동으로 처리한다.</li></ul><p>2. 서비스 배포 서버</p><ul><li>배포 서버는 실제 애플리케이션이 실행되는 환경이다. Jenkins 서버의 요청을 받아, 새로운 Docker 이미지를 가져와 배포한다.</li><li>NginX를 사용하여 웹서버 리버스 프록시 기능을 수행하게 했다. 리벅스 프록시는 외부 클라이언트의 요청을 서버로 전달하는 역할을 한다.</li><li>Certbot을 통해 HTTPS를 설정해 데이터 전송의 보안을 강화했다. 이를 통해 사용자들은 안전하게 서비스를 이용 할 수 있다.</li></ul><h3>Github</h3><ul><li><a href="https://github.com/2024-SUMMER-BOOTCAMP-TEAM-A">https://github.com/2024-SUMMER-BOOTCAMP-TEAM-A</a></li></ul><h3>Meet our team</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/583/1*KKhNzDX2Tfnx_-yhJQmZ9Q.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e12d2177d349" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[K6, InfluxDB, Grafana를 이용한 성능 테스트 시각화]]></title>
            <link>https://medium.com/@angal2310/k6-influxdb-grafana%EB%A5%BC-%EC%9D%B4%EC%9A%A9%ED%95%9C-%EC%84%B1%EB%8A%A5-%ED%85%8C%EC%8A%A4%ED%8A%B8-%EC%8B%9C%EA%B0%81%ED%99%94-42a1ed185c16?source=rss-0431dd1f32f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/42a1ed185c16</guid>
            <dc:creator><![CDATA[Jungeun]]></dc:creator>
            <pubDate>Sun, 16 Jun 2024 08:43:53 GMT</pubDate>
            <atom:updated>2024-06-16T08:43:53.090Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/768/1*Ce4do4Uq9cb7lgihBnSQ2g.png" /></figure><p>K6, InfluxDB, Grafana를 활용해서 부하테스트를 Grafana 대시보드에 나타내는 과정을 설명하고자 한다.</p><h3>성능 테스트</h3><p><strong>성능 테스트(Performance Testing)</strong>는 특정 상황에서 소프트웨어, CPU, 램 등의 성능을 측정하는 테스트이다. 시스템이 특정 작업을 수행하는 데 걸리는 시간, 처리량, 사용 가능한 리소스 등을 평가하기 위해 수행한다.</p><p>어느정도의 트래픽까지 버틸 수 있는지 미리 확인하면 실제 서비스 운영 상황에서 부하가 발생할 것 같을 때 미리 대응할 수 있다.</p><p>성능 테스트에는 여러 종류가 잇는데, 그 중 <strong>부하 테스트(Load Testing)</strong>와<strong> 스트레스 테스트(Stress Testing)</strong>에 대해 설명해보려 한다.</p><p><strong>부하테스트</strong></p><p>시스템이 예상되는 작업 부하를 얼마나 잘 처리할 수 있는지 평가하는 테스트이다. 시스템의 처리 능력, 응답 시간, 리소스 사용량을 측정한다.</p><p><strong>스트레스 테스트</strong></p><p>시스템이 극도로 높은 부하나 다양한 스트레스 조건에서 어떻게 동작하는 지를 확인하는 테스트이다. 시스템의 한계를 찾고, 언제 어떻게 실패하는 지 그리고 회복하는 데 얼마나 시간이 걸리는지를 알아보기 위해 진행한다.</p><h3>K6</h3><p>성능 테스트를 위해 설계된 오픈 소스 도구로, 특히 부하 테스트에 강점을 가지고 있다. 사용하기 쉽고, Grafana 등과 연동하여 UI를 구성할 수 있다. javascript를 이용하여 스크립트를 작성하고 CLI툴을 사용하여 성능 테스트를 수행한다. <br>로컬에 직접 설치해서 테스트를 진행하는 것도 가능하지만, 백엔드와 DB를 같은 네트워크상에 위치시킨 후 도커로 테스트를 수행했다.</p><h3>InfluxDB</h3><p>시계열 데이터베이스로, 성능 테스트 결과와 같은 시계열 데이터를 효율적으로 저장하고 쿼리하는 데 사용된다.</p><h3>Grafana</h3><p>다양한 데이터 소스로 부터 데이터를 시각화하는 오픈 소스 플랫폼이다. InfluxDB와 함께 사용하여 성능 테스트 결과를 모니터링하고 분석할 수 있다.</p><p>따라서 K6를 사용하여 작성한 스크립트 기반으로 테스트를 실행하고, 테스트 결과를 InfluxDB에 저장한다. 이 데이터는 시계열 데이터로 저장되고, 이를 Grafana에서 데이터 소스로 추가한다. 이를 통해 성능 테스트 시각화가 가능하다.</p><h3>docker-compose.yml</h3><pre>version: &#39;3&#39;<br><br>services:<br>  neo4j:<br>    container_name: neo4j<br>    image: neo4j:latest<br>    restart: always<br>    environment:<br>      NEO4J_AUTH: ${NEO4J_AUTH}<br>    ports:<br>      - &quot;7474:7474&quot;<br>      - &quot;7687:7687&quot;<br>    volumes:<br>      - ./nextpage-db/neo4j/data:/data<br>      - ./nextpage-db/neo4j/logs:/logs<br>    networks:<br>      - npage<br><br>  postgresql:<br>    container_name: postgresql<br>    image: postgres:12.0-alpine<br>    restart: always<br>    environment:<br>      POSTGRES_USER: ${POSTGRES_USERNAME}<br>      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}<br>      POSTGRES_DB: ${POSTGRES_DB}<br>    volumes:<br>      - ./init.sql:/docker-entrypoint-initdb.d/init.sql<br>      - ./nextpage-db/postgres-data:/var/lib/postgresql/data<br>    ports:<br>      - 5432:5432<br>    networks:<br>      - npage<br><br>  pgadmin:<br>    image: dpage/pgadmin4<br>    restart: always<br>    container_name: pgadmin4<br>    ports:<br>      - &quot;5050:80&quot;<br>    environment:<br>      PGADMIN_DEFAULT_EMAIL: ${PGADMIN_DEFAULT_EMAIL}<br>      PGADMIN_DEFAULT_PASSWORD: ${PGADMIN_DEFAULT_PASSWORD}<br>    volumes:<br>      - ./nextpage-db/pgadmin/:/var/lib/pgadmin<br>    networks:<br>      - npage<br><br>  # 스프링 로컬로 실행 시 주석 처리하고 DB만 도커 빌드<br>  springboot:<br>    build:<br>      context: .<br>      dockerfile: Dockerfile<br>    restart: always<br>    depends_on:<br>      - neo4j<br>      - postgresql<br>    ports:<br>      - 8080:8080<br>    container_name: springboot<br>    environment:<br>      SPRING_DATASOURCE_URL: ${SPRING_DATASOURCE_URL}<br>      SPRING_DATASOURCE_USERNAME: ${SPRING_DATASOURCE_USERNAME}<br>      SPRING_DATASOURCE_PASSWORD: ${SPRING_DATASOURCE_PASSWORD}<br>      SPRING_PROFILES_ACTIVE: ${SPRING_PROFILES_ACTIVE}<br>      NEO4J_URI: ${SPRING_NEO4J_URI}<br>      NEO4J_PASSWORD: ${SPRING_NEO4J_PASSWORD}<br>    networks:<br>      - npage<br><br>  # Monitoring<br>  grafana:<br>    image: grafana/grafana:latest<br>    container_name: grafana<br>    ports:<br>      - &quot;3001:3000&quot;<br>    env_file:<br>      - &#39;./monitoring/grafana/env.grafana&#39;<br>    volumes:<br>      - &#39;./monitoring/grafana:/var/lib/grafana&#39;<br>    restart: always<br>    environment: # 이 설정을 통해 로그인하지 않고 grafana 접속 가능<br>      - GF_AUTH_ANONYMOUS_ORG_ROLE=Admin # 사용자에게 Adimin 역할 부여<br>      - GF_AUTH_ANONYMOUS_ENABLED=true # 익명 접근 활성화<br>      - GF_AUTH_BASIC_ENABLED=false # 기본 인증 비활성화<br>    networks:<br>      - npage<br><br>  k6:<br>    image: grafana/k6:latest<br>    container_name: k6<br>    networks:<br>      - npage<br>    ports:<br>      - &quot;6565:6565&quot;<br>    environment:<br>      - K6_OUT=influxdb=http://influxdb:8086/k6<br>    volumes:<br>      - ./monitoring/k6:/scripts<br>    extra_hosts:<br>      - &quot;host.docker.internal:host-gateway&quot; # 호스트와 연결(로컬테스트를 위함)<br>    command: [&quot;run&quot;, &quot;/scripts/test_script.js&quot;]<br><br>  influxdb:<br>    image: influxdb:1.8<br>    ports:<br>      - &quot;8086:8086&quot;<br>    environment:<br>      - INFLUXDB_DB=k6<br>    restart: on-failure # 실패 시 재시작<br>    networks:<br>      - npage<br><br>networks:<br>  npage:<br>    driver: bridge<br></pre><p>여기서 중요한 점은, 서버와 K6가 같은 네트워크를 가지고 있어야 한다. 또한 K6는 명령어로 실행되기 때문에, K6의 볼륨 설정 위치와 스크립트 파일 위치에 주의해야 한다.</p><p>Grafana를 실행하면 빌드할 때마다 로그인을 해야하는 데, docker-compose의 grafana 부분에서 environment를 위와 같이 설정하면 로그인하지 않아도 실행이 가능하다.</p><h3>스크립트 파일(js)</h3><pre>import http from &#39;k6/http&#39;;<br>import { check, sleep } from &#39;k6&#39;;<br><br>export let options = {<br>    stages: [<br>        { duration: &#39;30s&#39;, target: 20 }, // 첫번째 스테이지 : 30초동안 사용자 수를 0 -&gt; 20으로 증가<br>        { duration: &#39;1m&#39;, target: 20 },  // 두번째 스테이지 : 1분간 사용자 수를 20으로 유지<br>        { duration: &#39;10s&#39;, target: 0 },  // 세번째 스테이지 : 10초간 사용자 수를 20 -&gt; 0으로 감소<br>    ],<br>};<br><br>// Base URL : springboot는 도커 컨테이너 이름이다. <br>const BASE_URL = &#39;http://springboot:8080/api/v2&#39;;<br><br>// Headers<br>const headers = {<br>    &#39;Content-Type&#39;: &#39;application/json&#39;,<br>};<br><br>export default function () {<br>    // 루트 스토리 조회<br>    let rootStoriesRes = http.get(`${BASE_URL}/stories`, { headers });<br>    check(rootStoriesRes, {<br>        &#39;getRootStories is status 200&#39;: (r) =&gt; r.status === 200,<br>        &#39;getRootStories response time is less than 200ms&#39;: (r) =&gt; r.timings.duration &lt; 200,<br>    });<br><br>    // 스토리 상세 조회 (storyId = 1 예시)<br>    let storyDetailsRes = http.get(`${BASE_URL}/stories/details/1`, { headers });<br>    check(storyDetailsRes, {<br>        &#39;getStoryDetails is status 200&#39;: (r) =&gt; r.status === 200,<br>        &#39;getStoryDetails response time is less than 200ms&#39;: (r) =&gt; r.timings.duration &lt; 200,<br>    });<br><br>    // 시나리오 조회 (rootId = 1 예시)<br>    let scenarioRes = http.get(`${BASE_URL}/stories/1`, { headers });<br>    check(scenarioRes, {<br>        &#39;getStoriesByRootId is status 200&#39;: (r) =&gt; r.status === 200,<br>        &#39;getStoriesByRootId response time is less than 200ms&#39;: (r) =&gt; r.timings.duration &lt; 200,<br>    });<br><br>    // 특정 분기 조회 (storyId = 1 예시)<br>    let branchStoriesRes = http.get(`${BASE_URL}/stories/branch/1`, { headers });<br>    check(branchStoriesRes, {<br>        &#39;getStoriesByleafId is status 200&#39;: (r) =&gt; r.status === 200,<br>        &#39;getStoriesByleafId response time is less than 200ms&#39;: (r) =&gt; r.timings.duration &lt; 200,<br>    });<br><br>    sleep(1);<br>}</pre><ul><li>check : 테스트 검증을 위함</li><li>sleep : 일정 시간 동안 테스트를 멈추기 위함</li><li>options : 테스트의 부하 단계를 정의</li><li>BASE_URL : 테스트할 API의 기본 URL 정의, springboot는 백엔드 서버의 도커 컨테이너 이름을 나타낸다. 만약에 로컬 환경에서 테스트를 원한다면 localhost로 수정하면 된다.</li><li>테스트 함수 정의 : export default function()은 K6 테스트의 메인 함수이다.</li></ul><p>도커를 빌드하면 테스트 결과가 수행되고, 다음과 같은 결과가 나온다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e8N0Qvfvo-wyGwJz9BGbhg.png" /></figure><h3>Grafana 시각화</h3><p>테스트 결과를 Grafana에 시각화하는 과정이다.</p><ol><li>Grafana 접속 후 Import a dashboard (대시보드 아이디 : 2587)</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aVFQk44S6Tbd00Dux7rc8w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*otZkToxBlqnAZ-BWdHspyA.png" /></figure><p>바로 influxdb가 연결되지 않으면, data source를 직접 등록해야 한다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cfUhIga6czhHjbffg8GVWg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CCgBD3F6qN0hEbMqxtKu3Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZgkTMurLZpLgLWpWs2isBA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bqyNQ4FvKyqdOa1w_BCFLg.png" /></figure><ul><li>Add data source</li><li>InfluxDB 클릭</li><li>URL, Database 입력</li><li>Save &amp; Test</li></ul><p>이 과정을 수행하면 data source가 등록된다. 위와 같은 화면이 보인다면, 등록이 완료된 것이다.</p><p>2. Import 완료된 Grafana</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M0Pcrt8dSLAPVolhA5iQag.png" /></figure><p>대시보드 아이디를 이용해 임포트 완료된 화면은 다음과 같다.</p><p>3. API 별 처리속도 커스텀</p><p><strong>Visualization</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PSzN_MPJqRBLMlbkRM7b7w.png" /></figure><p><strong>Query 설정</strong></p><p>아래의 과정을 그대로 수행해도 되고, 쿼리문을 직접 작성해도 된다.</p><pre>SELECT mean(&quot;value&quot;) FROM &quot;http_req_duration&quot; WHERE (&quot;name&quot;::tag = &#39;http://springboot:8080/api/v2/stories&#39;) AND $timeFilter GROUP BY time($__interval) fill(none)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PKlsUqiStIBVgRBP2r6Cqw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g_Vv-TdfV-isrlEiltvpxw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pmwJ-CmaHhwHR_N4QabR1A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UcuVXLlBH_D63dq_GFX8zg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CKUIT1-A1ZcCk_b-GGtVlA.png" /></figure><p>위와 같은 화면이 나와야한다.</p><p><strong>Add Row(그룹화)</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aL-AN-54BnKdw71MJDtw_A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dzoDSH8pxhwmjJVdFqDA_Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bnEjOGE3iMK4OftWZIa4GA.png" /></figure><p>위와 같이 K6, Influxdb, Grafana를 이용한 성능 테스트 시각화에 대해 알아보았다.</p><h3>참고자료</h3><ul><li><a href="https://k6.io/docs/results-output/grafana-dashboards/">https://k6.io/docs/results-output/grafana-dashboards/</a></li><li><a href="https://velog.io/@eastperson/Spring-Boot-%ED%99%98%EA%B2%BD%EC%97%90%EC%84%9C-K6-Grafana%EB%A5%BC-%ED%99%9C%EC%9A%A9%ED%95%9C-%EB%B6%80%ED%95%98%ED%85%8C%EC%8A%A4%ED%8A%B8-%ED%95%B4%EB%B3%B4%EA%B8%B0">https://velog.io/@eastperson/Spring-Boot-환경에서-K6-Grafana를-활용한-부하테스트-해보기</a></li><li><a href="https://grafana.com/blog/2024/01/30/api-load-testing/">https://grafana.com/blog/2024/01/30/api-load-testing/</a></li><li><a href="https://one-armed-boy.tistory.com/entry/k6-Prometheus-Grafana-%EC%9E%90%EB%8F%99-%ED%99%98%EA%B2%BD-%EA%B5%AC%EC%84%B1%ED%95%98%EA%B8%B0-with-Docker-compose">https://one-armed-boy.tistory.com/entry/k6-Prometheus-Grafana-자동-환경-구성하기-with-Docker-compose</a></li><li><a href="https://grafana.com/grafana/dashboards/18030-k6-prometheus-native-histograms/">https://grafana.com/grafana/dashboards/18030-k6-prometheus-native-histograms/</a></li><li><a href="https://medium.com/@nairgirish100/k6-with-docker-compose-influxdb-grafana-344ded339540">https://medium.com/@nairgirish100/k6-with-docker-compose-influxdb-grafana-344ded339540</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=42a1ed185c16" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[실시간 피드백이 가능한 피트니스 앱 구현]]></title>
            <link>https://medium.com/@angal2310/%EC%8B%A4%EC%8B%9C%EA%B0%84-%ED%94%BC%EB%93%9C%EB%B0%B1%EC%9D%B4-%EA%B0%80%EB%8A%A5%ED%95%9C-%ED%94%BC%ED%8A%B8%EB%8B%88%EC%8A%A4-%EC%95%B1-%EA%B5%AC%ED%98%84-d41eceb7b4b4?source=rss-0431dd1f32f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/d41eceb7b4b4</guid>
            <dc:creator><![CDATA[Jungeun]]></dc:creator>
            <pubDate>Tue, 28 May 2024 08:27:12 GMT</pubDate>
            <atom:updated>2024-05-28T08:40:16.880Z</atom:updated>
            <content:encoded><![CDATA[<p>현재 졸업 작품으로 AI 기반의 실시간 피드백을 제공하는 피트니스 앱을 개발하고 있다. 앱은 플러터를 이용해서 개발했는데, 카메라에서 스켈레톤(관절 포인트)를 띄우고, 좌표 값을 백엔드 서버로 전송하며 운동 카운트와 피드백을 받아서 실시간 통신을 구현했다. 이 과정에 대해 자세하게 설명해보려 한다.</p><h3>플러터에서 스켈레톤 띄우기</h3><ul><li>의존성 추가</li></ul><pre>dependencies:<br>  google_mlkit_commons: ^0.3.0<br>  google_mlkit_pose_deteciont: ^0.6.0<br>  camera: ^0.10.4</pre><ul><li>스켈레톤 코드</li></ul><pre>// pose_painter.dart<br>import &#39;package:flutter/material.dart&#39;;<br>import &#39;package:google_mlkit_pose_detection/google_mlkit_pose_detection.dart&#39;;<br><br>import &#39;coordinates_translator.dart&#39;;<br><br>class PosePainter extends CustomPainter {<br>  PosePainter(this.poses, this.absoluteImageSize, this.rotation);<br><br>  final List&lt;Pose&gt; poses;<br>  final Size absoluteImageSize;<br>  final InputImageRotation rotation;<br><br>  @override<br>  void paint(Canvas canvas, Size size) {<br>    // 초록: 33개의 관절 포인트(랜드마크) 색깔<br>    final paint = Paint()<br>      ..style = PaintingStyle.stroke<br>      ..strokeWidth = 10.0<br>      ..color = Colors.white;<br><br>    // 파랑: 왼쪽 선 색깔(왼팔~왼다리)<br>    final leftPaint = Paint()<br>      ..style = PaintingStyle.stroke<br>      ..strokeWidth = 3.0<br>      ..color = Colors.blueAccent;<br><br>    // 파랑: 오른쪽 선 색깔(오른팔~오른다리)<br>    final rightPaint = Paint()<br>      ..style = PaintingStyle.stroke<br>      ..strokeWidth = 3.0<br>      ..color = Colors.blueAccent;<br><br>    // 추출된 관절 포인트 갯수만큼 점 그리기<br>    for (final pose in poses) {<br>      pose.landmarks.forEach((_, landmark) {<br>        canvas.drawCircle(<br>            Offset(<br>              translateX(landmark.x, rotation, size, absoluteImageSize),<br>              translateY(landmark.y, rotation, size, absoluteImageSize),<br>            ),<br>            1,<br>            paint);<br>      });<br><br>      // 점1과 점2를 선으로 이어주는 함수(랜드마크 타입1, 랜드마크 타입2, 선 색깔 타입)<br>      void paintLine(<br>          PoseLandmarkType type1, PoseLandmarkType type2, Paint paintType) {<br>        final PoseLandmark joint1 = pose.landmarks[type1]!;<br>        final PoseLandmark joint2 = pose.landmarks[type2]!;<br>        canvas.drawLine(<br>            Offset(translateX(joint1.x, rotation, size, absoluteImageSize),<br>                translateY(joint1.y, rotation, size, absoluteImageSize)),<br>            Offset(translateX(joint2.x, rotation, size, absoluteImageSize),<br>                translateY(joint2.y, rotation, size, absoluteImageSize)),<br>            paintType);<br>      }<br><br>      //Draw arms<br>      paintLine(<br>          PoseLandmarkType.leftShoulder, PoseLandmarkType.leftElbow, leftPaint);<br>      paintLine(<br>          PoseLandmarkType.leftElbow, PoseLandmarkType.leftWrist, leftPaint);<br>      paintLine(PoseLandmarkType.rightShoulder, PoseLandmarkType.rightElbow,<br>          rightPaint);<br>      paintLine(<br>          PoseLandmarkType.rightElbow, PoseLandmarkType.rightWrist, rightPaint);<br><br>      //Draw Body<br>      paintLine(<br>          PoseLandmarkType.leftShoulder, PoseLandmarkType.leftHip, leftPaint);<br>      paintLine(PoseLandmarkType.rightShoulder, PoseLandmarkType.rightHip,<br>          rightPaint);<br><br>      //Draw legs<br>      paintLine(PoseLandmarkType.leftHip, PoseLandmarkType.leftKnee, leftPaint);<br>      paintLine(<br>          PoseLandmarkType.leftKnee, PoseLandmarkType.leftAnkle, leftPaint);<br>      paintLine(<br>          PoseLandmarkType.rightHip, PoseLandmarkType.rightKnee, rightPaint);<br>      paintLine(<br>          PoseLandmarkType.rightKnee, PoseLandmarkType.rightAnkle, rightPaint);<br>    }<br>  }<br><br>  @override<br>  bool shouldRepaint(covariant PosePainter oldDelegate) {<br>    return oldDelegate.absoluteImageSize != absoluteImageSize ||<br>        oldDelegate.poses != poses;<br>  }<br>}</pre><ul><li>각 운동별 좌표 반환 코드</li></ul><pre>// 허리 좌표를 반환하는 함수<br>  static List&lt;Offset&gt; getWaistCoordinates(List&lt;Pose&gt; poses) {<br>    final List&lt;Offset&gt; coordinates = [];<br>    for (final pose in poses) {<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.leftShoulder]!.x,<br>          pose.landmarks[PoseLandmarkType.leftShoulder]!.y,<br>        ),<br>      );<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.rightShoulder]!.x,<br>          pose.landmarks[PoseLandmarkType.rightShoulder]!.y,<br>        ),<br>      );<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.leftElbow]!.x,<br>          pose.landmarks[PoseLandmarkType.leftElbow]!.y,<br>        ),<br>      );<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.rightElbow]!.x,<br>          pose.landmarks[PoseLandmarkType.rightElbow]!.y,<br>        ),<br>      );<br>    }<br>    return coordinates;<br>  }<br><br>  // 스쿼트 운동(골반 운동)을 위한 좌표 반환 함수<br>  static List&lt;Offset&gt; getSquatCoordinates(List&lt;Pose&gt; poses) {<br>    final List&lt;Offset&gt; coordinates = [];<br>    for (final pose in poses) {<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.leftHip]!.x,<br>          pose.landmarks[PoseLandmarkType.leftHip]!.y,<br>        ),<br>      );<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.rightHip]!.x,<br>          pose.landmarks[PoseLandmarkType.rightHip]!.y,<br>        ),<br>      );<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.leftKnee]!.x,<br>          pose.landmarks[PoseLandmarkType.leftKnee]!.y,<br>        ),<br>      );<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.rightKnee]!.x,<br>          pose.landmarks[PoseLandmarkType.rightKnee]!.y,<br>        ),<br>      );<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.leftAnkle]!.x,<br>          pose.landmarks[PoseLandmarkType.leftAnkle]!.y,<br>        ),<br>      );<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.rightAnkle]!.x,<br>          pose.landmarks[PoseLandmarkType.rightAnkle]!.y,<br>        ),<br>      );<br>    }<br>    return coordinates;<br>  }<br><br>   // 목 운동을 위한 좌표 반환 함수<br>  static List&lt;Offset&gt; getNeckCoordinates(List&lt;Pose&gt; poses) {<br>    final List&lt;Offset&gt; coordinates = [];<br>    for (final pose in poses) {<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.nose]!.x,<br>          pose.landmarks[PoseLandmarkType.nose]!.y,<br>        ),<br>      );<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.leftEye]!.x,<br>          pose.landmarks[PoseLandmarkType.leftEye]!.y,<br>        ),<br>      );<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.leftShoulder]!.x,<br>          pose.landmarks[PoseLandmarkType.leftShoulder]!.y,<br>        ),<br>      );<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.rightShoulder]!.x,<br>          pose.landmarks[PoseLandmarkType.rightShoulder]!.y,<br>        ),<br>      );<br>    }<br>    return coordinates;<br>  }<br><br>  // 런지 운동을 위한 좌표 반환 함수<br>  static List&lt;Offset&gt; getLegCoordinates(List&lt;Pose&gt; poses) {<br>    final List&lt;Offset&gt; coordinates = [];<br>    for (final pose in poses) {<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.leftHip]!.x,<br>          pose.landmarks[PoseLandmarkType.leftHip]!.y,<br>        ),<br>      );<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.rightHip]!.x,<br>          pose.landmarks[PoseLandmarkType.rightHip]!.y,<br>        ),<br>      );<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.leftKnee]!.x,<br>          pose.landmarks[PoseLandmarkType.leftKnee]!.y,<br>        ),<br>      );<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.rightKnee]!.x,<br>          pose.landmarks[PoseLandmarkType.rightKnee]!.y,<br>        ),<br>      );<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.leftAnkle]!.x,<br>          pose.landmarks[PoseLandmarkType.leftAnkle]!.y,<br>        ),<br>      );<br>      coordinates.add(<br>        Offset(<br>          pose.landmarks[PoseLandmarkType.rightAnkle]!.x,<br>          pose.landmarks[PoseLandmarkType.rightAnkle]!.y,<br>        ),<br>      );<br>    }<br>    return coordinates;<br>  }</pre><ul><li>만약 안드로이드로 앱을 실행할 경우에는, 버전이 너무 낮은 경우, 스켈레톤 라이프러리가 실행되지 않는 경우가 있다.</li><li>최신 Kotlin 버전과 최소 SDK 버전을 설정하여 스켈레톤 라이브러리가 올바르게 작동하도록 설정해야한다.</li></ul><pre>// android/build.gradle <br><br>buildscript {<br>    ext.kotlin_version = &#39;1.8.10&#39; // 최신 Kotlin 버전으로 수정(아주 중요하다.)<br>    repositories {<br>        google()<br>        mavenCentral()<br>    }<br>    dependencies {<br>        classpath &quot;org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version&quot;<br>        classpath &#39;com.android.tools.build:gradle:7.2.0&#39;<br>    }<br>}<br><br>allprojects {<br>    repositories {<br>        google()<br>        mavenCentral()<br>    }<br>}<br><br>rootProject.buildDir = &#39;../build&#39;<br>subprojects {<br>    project.buildDir = &quot;${rootProject.buildDir}/${project.name}&quot;<br>}<br>subprojects {<br>    project.evaluationDependsOn(&#39;:app&#39;)<br>}<br><br>tasks.register(&quot;clean&quot;, Delete) {<br>    delete rootProject.buildDir<br>}</pre><pre>// android/app/build.gradle<br><br>plugins {<br>    id &quot;com.android.application&quot;<br>    id &quot;kotlin-android&quot;<br>    id &quot;dev.flutter.flutter-gradle-plugin&quot;<br>}<br><br>def localProperties = new Properties()<br>def localPropertiesFile = rootProject.file(&#39;local.properties&#39;)<br>if (localPropertiesFile.exists()) {<br>    localPropertiesFile.withReader(&#39;UTF-8&#39;) { reader -&gt;<br>        localProperties.load(reader)<br>    }<br>}<br><br>def flutterVersionCode = localProperties.getProperty(&#39;flutter.versionCode&#39;)<br>if (flutterVersionCode == null) {<br>    flutterVersionCode = &#39;1&#39;<br>}<br><br>def flutterVersionName = localProperties.getProperty(&#39;flutter.versionName&#39;)<br>if (flutterVersionName == null) {<br>    flutterVersionName = &#39;1.0&#39;<br>}<br><br>android {<br>    namespace &quot;com.example.matchup&quot;<br>    compileSdkVersion 34<br>    ndkVersion flutter.ndkVersion<br><br>    compileOptions {<br>        sourceCompatibility JavaVersion.VERSION_1_8<br>        targetCompatibility JavaVersion.VERSION_1_8<br>    }<br><br>    kotlinOptions {<br>        jvmTarget = &#39;1.8&#39;<br>    }<br><br>    sourceSets {<br>        main.java.srcDirs += &#39;src/main/kotlin&#39;<br>    }<br><br>    defaultConfig {<br>        // TODO: Specify your own unique Application ID (https://developer.android.com/studio/build/application-id.html).<br>        applicationId &quot;com.example.matchup&quot;<br>        minSdkVersion 21 // 최소 21이사이어야 실행이 가능하다.<br>        targetSdkVersion 33 // 최소 33이상이어야 실행이 가능하다.<br>        versionCode 1<br>        versionName &quot;1.0&quot;<br>    }<br><br>    buildTypes {<br>        release {<br>            // TODO: Add your own signing config for the release build.<br>            // Signing with the debug keys for now, so `flutter run --release` works.<br>            signingConfig signingConfigs.debug<br>        }<br>    }<br>}<br><br>flutter {<br>    source &#39;../..&#39;<br>}<br><br>dependencies {<br>    implementation &#39;com.google.mlkit:text-recognition-korean:16.0.0&#39;<br>    implementation &#39;com.google.mlkit:pose-detection:18.0.0-beta4&#39;<br>    implementation &#39;com.google.mlkit:pose-detection-accurate:18.0.0-beta4&#39;<br>    implementation &quot;androidx.camera:camera-core:1.0.0-beta07&quot;<br>    implementation &quot;androidx.camera:camera-camera2:1.0.0-beta07&quot;<br>    implementation &quot;androidx.camera:camera-view:1.0.0-alpha14&quot;<br>    implementation &quot;androidx.camera:camera-extensions:1.0.0-alpha14&quot;<br>    implementation &quot;androidx.camera:camera-lifecycle:1.0.0-beta07&quot;<br>}<br><br></pre><ul><li>만약에 안드로이드 태블릿으로 빌드할 경우, 태블릿 기기의 사용가능한 램이 2GB 이하라면, 연산량을 감당하지 못하고 앱이 강제 종료될 수 있다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/576/0*Dulg250V3bSAOEuy.png" /></figure><h3>웹소켓이란?</h3><p>웹소켓(WebSocket)은 클라이언트와 서버간의 실시간 양방향 통신을 가능하게 하는 프로토콜이다. HTTP 프로토콜은 단방향 통신 모델로, 클라이언트에서 서버로 요청을 보내고 서버는 그에 대한 응답을 보낸다.</p><p>웹소켓은 이러한 단점을 극복하기 위해 개발되었고, 따라서 웹소켓을 사용하면 실시간으로 데이터를 주고받을 수 있으며, 서버 또는 클라이언트 측에서 데이터를 보낼 때 지연 시간을 최소화하고 효율적인 양방향 통신을 구현할 수 있다.</p><p>웹소켓은 주로 실시간 채팅, 온라인 게임, 주식 시장의 실시간 데이터 전송, 협업 도구 등의 분야에서 활용된다.</p><p>[ 웹소켓의 특징 ]</p><ol><li>양방향 통신 : 웹소켓을 통해 클라이언트와 서버 간에 실시간 양방향 통신이 가능하다. 서버는 클라이언트로부터 요청 없이도 데이터를 전송할 수 있다.</li><li>지속적 연결 : 웹소켓은 HTTP와 달리 연결을 계속 유지한다. 이로써 데이터를 전송하거나 수신하기 위해 매번 새로운 연결을 설정할 필요가 없다.</li><li>낮은 지연 시간 : 웹소켓은 헤더 정보의 크기를 최소화하고, 연결 설정과 해제에 드는 시간을 줄여 실시간 통신에서 높은 성능을 제공한다.</li><li>프레임워크 지원 : 많은 프레임워크와 라이브러리에서 웹소켓을 지원하고 있어, 상대적으로 쉽게 구현하고 사용할 수 있다.</li><li>이벤트 기반 : 서버와 클라이언트 간의 데이터 전송은 이벤트 기반으로 이루어지며, 이로써 실시간 업데이트와 상호작용을 구현할 수 있다.</li></ol><p>[ 웹소켓 동작 원리 ]</p><p><strong>1. 핸드쉐이크(Handshake):</strong></p><p>웹소켓 연결은 HTTP를 통해 시작된다. 클라이언트가 서버에게 웹소켓 연결을 요청하면, 클라이언트와 서버 간에 일련의 핸드쉐이크 과정이 발생한다. 클라이언트는 HTTP Upgrade 요청 헤더를 사용하여 웹소켓 연결로 업그레이드하고, 서버는 이를 승인하며 101 Switching Protocols 응답을 보낸다.</p><p><strong>2. 연결 유지(Keeping Connection):</strong></p><p>핸드쉐이크 이후에는 TCP 기반의 연결이 설정되며, 이 연결은 지속적으로 유지된다. 이로써 양방향 데이터 전송이 가능해진다.</p><p><strong>3. 데이터 교환(Data Exchange):</strong></p><p>연결이 확립되면 클라이언트와 서버 간에 데이터를 교환할 수 있다. 데이터는 메시지의 형태로 주고받으며, 이 메시지는 이벤트 기반으로 동작한다. 클라이언트 또는 서버는 언제든지 메시지를 보낼 수 있으며, 상대방은 이에 응답할 수 있다.</p><p><strong>4. 연결 종료(Connection Termination, Close Handshake):</strong></p><p>웹소켓 연결을 종료하려면 클라이언트 또는 서버가 종료 프레임을 보내면 된다. 이 프레임은 연결을 명시적으로 닫는 데 사용된다. 또한, 연결이 비정상적으로 종료되는 경우에는 네트워크 문제 또는 다른 이유로 인해 연결이 끊어진 것으로 판단된다.</p><h3>웹소켓 통신</h3><ul><li>프론트에서 서버로 exercise_id와 액세스 토큰 전송</li></ul><pre>try {<br>  _channel = WebSocketChannel.connect(<br>    Uri.parse(&#39;ws://172.30.1.72:8000/api/v1/exercise/ws&#39;),<br>  );<br><br>  final userProvider = Provider.of&lt;UserProvider&gt;(context, listen: false);<br>  String? accessToken = userProvider.accessToken;<br>  _channel.sink.add(jsonEncode({<br>    &quot;exercise_id&quot;: widget.exerciseId,<br>    &quot;access_token&quot;: accessToken,<br>  }));</pre><ul><li>백엔드에서 토큰을 확인하고 user_id, exercise_id, date를 session 테이블에 저장</li></ul><pre>@router.websocket(&quot;/ws&quot;)<br>async def websocket_endpoint(<br>    websocket: WebSocket,<br>    background_tasks: BackgroundTasks,<br>    Authorize: AuthJWT = Depends(),<br>    db: Session = Depends(get_db),<br>):<br>    await websocket.accept()<br>    background_tasks.add_task(keep_websocket_alive, websocket)<br>    <br>    try:<br>        initial_data = await websocket.receive_text()<br>        logger.info(f&quot;Received initial data: {initial_data}&quot;)<br>        initial_payload = json.loads(initial_data)<br>        exercise_id = initial_payload.get(&quot;exercise_id&quot;)<br>        access_token = initial_payload.get(&quot;access_token&quot;)<br><br>        email = authenticate_access_token(access_token, Authorize)<br>        logger.info(f&quot;Authenticated user: {email}&quot;) <br><br>        user = get_user(db, email)<br>        logger.info(f&quot;User: {user}&quot;)<br>        if user is None:<br>            raise ValueError(f&quot;User not found for email: {email}&quot;)<br>        userId = user.id<br>        logger.info(f&quot;Authenticated user: {email} with userId: {userId}&quot;)<br><br>        create_session(db, user_id=userId, exercise_id=exercise_id, date=datetime.now(kst))<br>        await websocket.send_text(f&quot;Session created for exercise ID: {exercise_id}&quot;)<br>        logger.info(f&quot;Session created for exercise ID: {exercise_id}&quot;)</pre><ul><li>저장 후 프론트에서 실행하는 운동에 해당하는 좌표를 1초에 한번씩 전송</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VkKrutErLw7JJ7GQHBq8tg.png" /></figure><pre>@override<br>void dispose() {<br>  _timer.cancel();<br>  if (_coordinateTimer != null &amp;&amp; _coordinateTimer.isActive) {<br>    _coordinateTimer.cancel();<br>  }<br>  _channel.sink.close();<br>  super.dispose();<br>}<br><br>void _sendCoordinatesPeriodically() {<br>  _coordinateTimer = Timer.periodic(Duration(milliseconds: 100), (Timer timer) {<br>    if (_isExercising &amp;&amp; _isWebSocketConnected) {<br>      List&lt;Offset&gt; coordinates = [];<br>      switch (widget.exerciseId) {<br>        case 1:<br>          coordinates = PosePainter.getNeckCoordinates(_detectedPoses);<br>          break;<br>        case 2:<br>          coordinates = PosePainter.getSquatCoordinates(_detectedPoses);<br>          break;<br>        case 3:<br>          coordinates = PosePainter.getLegCoordinates(_detectedPoses);<br>          break;<br>        case 4:<br>          coordinates = PosePainter.getWaistCoordinates(_detectedPoses);<br>          break;<br>        default:<br>          coordinates = [];<br>      }<br>      _channel.sink.add(jsonEncode({<br>        &quot;coordinates&quot;: coordinates.map((offset) =&gt; customEncode(offset)).toList(),<br>      }));<br>      print(&#39;Coordinates: $coordinates&#39;);<br>    } else {<br>      timer.cancel();<br>    }<br>  });<br>}</pre><ul><li>백엔드는 받은 좌표로 카운트와, 피드백을 반환한다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JDP9WN3ktX5kiIkLfr-vsQ.png" /></figure><pre>@router.websocket(&quot;/ws&quot;)<br>async def websocket_endpoint(<br>    websocket: WebSocket,<br>    background_tasks: BackgroundTasks,<br>    Authorize: AuthJWT = Depends(),<br>    db: Session = Depends(get_db),<br>):<br>    await websocket.accept()<br>    background_tasks.add_task(keep_websocket_alive, websocket)<br>    <br>    try:<br>        initial_data = await websocket.receive_text()<br>        logger.info(f&quot;Received initial data: {initial_data}&quot;)<br>        initial_payload = json.loads(initial_data)<br>        exercise_id = initial_payload.get(&quot;exercise_id&quot;)<br>        access_token = initial_payload.get(&quot;access_token&quot;)<br><br>        email = authenticate_access_token(access_token, Authorize)<br>        logger.info(f&quot;Authenticated user: {email}&quot;) <br><br>        user = get_user(db, email)<br>        logger.info(f&quot;User: {user}&quot;)<br>        if user is None:<br>            raise ValueError(f&quot;User not found for email: {email}&quot;)<br>        userId = user.id<br>        logger.info(f&quot;Authenticated user: {email} with userId: {userId}&quot;)<br><br>        create_session(db, user_id=userId, exercise_id=exercise_id, date=datetime.now(kst))<br>        await websocket.send_text(f&quot;Session created for exercise ID: {exercise_id}&quot;)<br>        logger.info(f&quot;Session created for exercise ID: {exercise_id}&quot;)<br><br>        if exercise_id == 1:<br>            exercise = NeckExercise() # 목 운동을 위한 클래스 인스턴스 생성<br>        elif exercise_id == 2:<br>            exercise = SquatExercise()  # 스쿼트 운동을 위한 클래스 인스턴스 생성<br>        elif exercise_id == 3:<br>            exercise = LegExercise() # 다리 운동을 위한 클래스 인스턴스 생성<br>        elif exercise_id == 4:<br>            exercise = WaistExercise() # 허리 운동을 위한 클래스 인스턴스 생성<br>        else:<br>            await websocket.send_text(&quot;Invalid exercise ID&quot;)<br>            await websocket.close()<br>            return<br><br>    except Exception as e:<br>        logger.error(f&quot;Authentication failed: {e}&quot;)<br>        await websocket.send_text(f&quot;Authentication failed: {e}&quot;)<br>        await websocket.close()<br>        return<br><br>    try:<br>        while True:<br>            data = await websocket.receive_text()<br>            coordinates = json.loads(data)<br>            logger.info(f&quot;Received coordinates: {coordinates}&quot;)<br><br>            try:<br>                exercise.write_exercise(coordinates)<br>                metrics = exercise.calculate_metrics(coordinates=coordinates)<br>                logger.info(f&quot;Metrics: {metrics}&quot;)<br>                await websocket.send_json(metrics)<br>                logger.info(f&quot;Sent metrics: {metrics}&quot;)<br>            except Exception as e:<br>                logger.error(f&quot;Error calculating metrics: {e}&quot;)<br>                await websocket.send_json({&#39;error&#39;: str(e)})<br><br>    except WebSocketDisconnect:<br>        logger.info(&quot;Client disconnected&quot;)<br>    except Exception as e:<br>        logger.error(f&quot;Error during WebSocket communication: {e}&quot;)<br>        await websocket.close()</pre><ul><li>더 자세한 코드는 <a href="https://github.com/2024-Match-up/matchup">깃허브</a>를 참고 바란다. (<a href="https://github.com/2024-Match-up/matchup">https://github.com/2024-Match-up/matchup</a>)</li></ul><h3>참고 자료</h3><ul><li><a href="https://min-wachya.tistory.com/245">[Flutter] MediaPipe로 스켈레톤 추출하기</a></li><li><a href="https://dev-in-seoul.tistory.com/45">[FastAPI/Python] 양방향 통신을 위한 웹소켓 in FastAPI</a></li><li><a href="https://velog.io/@jinyeong-afk/%EA%B8%B0%EC%88%A0-%EB%A9%B4%EC%A0%91-%EC%9B%B9%EC%86%8C%EC%BC%93-%EA%B0%9C%EB%85%90-%EB%B0%8F-%EB%8F%99%EC%9E%91-%EC%9B%90%EB%A6%AC">[기술 면접] 웹소켓 개념 및 동작 원리</a></li><li><a href="https://kellis.tistory.com/65">WebSocket의 동작원리</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d41eceb7b4b4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Image Resize + Webp]]></title>
            <link>https://medium.com/@angal2310/image-resize-webp-4dffafd68683?source=rss-0431dd1f32f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/4dffafd68683</guid>
            <dc:creator><![CDATA[Jungeun]]></dc:creator>
            <pubDate>Tue, 14 May 2024 09:58:18 GMT</pubDate>
            <atom:updated>2024-05-14T17:03:13.309Z</atom:updated>
            <content:encoded><![CDATA[<h3>이미지 리사이징 + Webp</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*HEc58zq4x8GNJdSw.png" /></figure><p>위의 사진은 지난 겨울 진행했던 프로젝트의 일부분이다. 페이지를 보면 알 수 있듯, 이 프로젝트는 이미지가차지하는 비중이 아주 높다. <br>페이지에 보여지는 이미지들은 OpenAI 인 Dalle-3를 이용해서 생성되었다. 이 페이지를 개발을 끝내고 나서, 이미지의 큰 크기로 인해 로딩시간이 너무 길어지는 문제가 생겼다. 이미지 리사이징과 webp 확장자를 적용해서 문제를 해결한 과정을 설명하려 한다.</p><h3>Dalle-3의 이미지 크기</h3><p>1. 1024x1024 : 정사각형<br>2. 1024x1792 : 노트북 배경화면과 비슷한 넓은 이미지<br>3. 1792x1024 : 초상화처럼 세로로 긴 이미지</p><p>우리의 프로젝트에서는 1번인 정사각형 이미지를 택했다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*nQj_Se50gsTuT41X.png" /></figure><p>1024x1024 크기로 생성한 이미지를 AWS S3에 업로드하면, Dalle-3의 이미지 크기가 3MB임을 알 수 있다. 따라서 이미지 크기를 줄이는 것을 목표로 조사를 시작했다.</p><h3>Webp 적용</h3><blockquote>2010년 9월 30일 구글이 공개한 이미지 포맷으로, 사양 발표 시 각종 도구와 함께 제공되었다. 인터넷 웹페이지에서 널리 사용되고 있는 JPEG(제이펙)을 대체하기 위해 제시된 규격이다. 웹사이트의 트래픽 감소 및 로딩 시간 단축을 겨냥한 것으로, 주로 사진 이미지 압축 효과가 높은 것으로 알려졌다. JPEG 등과 같은 손실 압축 포맷으로 화질 저하를 최소화하면서 파일 크기를 축소(같은 품질의 JPEG 이미지의 10 ~ 80 % 정도까지 압축)하였다.</blockquote><p>손실을 최소화하면서 이미지의 크기를 줄이기 위해 Webp를 선택했다.</p><h3>자바를 이용한 이미지 리사이징</h3><p>자바는 이미지 리사이징을 위한 여러 라이브러리를 제공한다.</p><p><strong>1. java.awt.Graphics2D </strong><br>자바의 AWT(Abstract Window Toolkit) 패키지에서 제공하는 2차원 그래픽을 위한 확장된 그래픽 컨텍스트이다. 이미지의 품질을 세밀하게 조정할 수 있지만, 직접 코드를 작성해야 하므로 다른 라이브러리들에 비해 다소 복잡하고, 대규모 이미지 처리 시 성능이 떨어질 수 있다.</p><p><strong>2. Image.getScaledInstance</strong><br>Image 클래스의 일부로, 이미지를 간단하게 리사이징할 수 있는 메서드를 제공하여 사용법이 매우 간단하지만, 리사이징 과정에서 성능이 떨어지고 이미지 품질이 낮아질 수 있다. 소규모 이미지 처리나 간단한 용도에 적합하다. 특히 품질이 중요한 경우라면 다른 라이브러리를 추천한다.</p><p><strong>3. Thumbnailator </strong><br>고성능과 간단한 API를 제공하는 이미지 처리 라이브러리이다. 썸네일 생성 및 리사이징 작업을 쉽게 수행할 수 있고, 성능과 품질 모두 뛰어나다. 대규모 이미지 처리에 적합하고, 코드 작성이 간단하다.</p><p><strong>4. Imagescalr</strong><br>이미지 크기 조정 작업에 최적화되어 있다. 내부적으로 Graphics2D를 사용하여 동작한다. 다양한 옵션을 통해 리사이징 품질을 제어할 수 있다. <br>가장 중요하게 고려해야 할 기준인 품질과 처리 속도를 기준으로 선택해보려고 한다.</p><p><strong>[ 품질유지 : 화질 ]</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*W59xz_wXOPHtkWPq.jpg" /></figure><p><strong>[ 평균적인 처리속도 ]</strong></p><p>1. Graphics2D : 0.034s<br>2. Imagescalr : 0.143s<br>3. Image.getScaledInstance : 0.235s<br>4. Thumbnailator : 0.547s</p><p>나는 간단한 사용법과 성능을 모두 잡을 수 있는 Thumnailator를 선택했다.</p><h3>구현 예시</h3><p><strong>[ 코드의 흐름 ]</strong></p><p>1. 스토리 생성 요청<br>2. 이미지 파일 다운로드<br>3. 이미지 리사이징 (512 * 512)<br>4. 리사이징된 이미지 임시 저장<br>5. webp 변환<br>6. S3에 업로드, 임시 저장 파일은 삭제됨</p><p><strong>build.gradle 추가</strong></p><pre>// Webp<br>implementation &#39;com.sksamuel.scrimage:scrimage-webp:4.1.1&#39;<br><br>// thumbnailator<br>implementation &#39;net.coobird:thumbnailator:0.4.14&#39;</pre><p><strong>코드</strong></p><pre>private File resizeImage(File imageFile) throws ImageResizeException {<br>    try {<br>        BufferedImage resizedImage = Thumbnails.of(imageFile)<br>                .size(512, 512)<br>                .asBufferedImage();<br>        File tempFile = new File(imageFile.getParent(), &quot;resized_&quot; + System.currentTimeMillis() + &quot;.png&quot;);<br>        ImageIO.write(resizedImage, &quot;png&quot;, tempFile);<br>        return tempFile;<br>    } catch (Exception e) {<br>        throw new ImageResizeException();<br>    }<br>}<br><br>private File convertToWebP(File imageFile) throws ImageConversionException {<br>    try {<br>        ImmutableImage image = ImmutableImage.loader().fromFile(imageFile);<br>        File outputFile = new File(imageFile.getParent(), System.currentTimeMillis() + &quot;.webp&quot;);<br>        image.output(WebpWriter.DEFAULT, outputFile);<br>        return outputFile;<br>    } catch (Exception e) {<br>        throw new ImageConversionException();<br>    }<br>}<br><br>private String uploadFileToS3(File file) throws ImageUploadException {<br>    try {<br>        ObjectMetadata metadata = new ObjectMetadata();<br>        metadata.setContentLength(file.length());<br>        PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, file.getName(), new FileInputStream(file), metadata);<br>        amazonS3.putObject(putObjectRequest);<br>        return amazonS3.getUrl(bucketName, file.getName()).toString();<br>    } catch (Exception e) {<br>        throw new ImageUploadException();<br>    }<br>}</pre><h3>적용 후 결과</h3><p><strong>원본 이미지</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*MoEI1mWYj-yg7cox.png" /></figure><p><strong>webp + 이미지 리사이징 후 이미지</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*RNSnQSaoei0jkYk8.png" /></figure><h3>이미지 크기 비교</h3><ul><li>원본 이미지 : 3MB</li><li>리사이징 후 크기 : 0.42 MB | 425.91 KB</li><li>webp 적용 후의 크기 : 0.04 MB | 40.74 KB</li></ul><p>원본 이미지에서 리사이징 후 약 86% 정도 감소했으며, webp 적용 후 90% 정도 감소했다.</p><h3>AWS Lambda를 사용한 이미지 리사이징 + Webp</h3><blockquote>프로젝트에서 이미지 관련 작업을 처리하기 위해 AWS S3를 사용할 때, AWS Lambda와의 높은 호환성을 이용하는 경우가 많다. 이를 활용한 결과를 기존의 백엔드 서버 방식과 비교하여 차이점을 살펴보고자 한다. 이러한 비교를 통해, 각 방식의 장단점을 분석하고, 프로젝트 요구사항에 가장 적합한 선택에 도움이 될 것이다.</blockquote><h3><strong>AWS Lambda란?</strong></h3><p>Lambda는 코드를 서버 없이 실행할 수 있게 해주는 서비스이다. 이를 서버리스라 한다. 서버를 관리하거나 구성할 필요없이, 단순히 코드를 작성하고 실행하면 된다. 이 서비스는 개발자가 인프라 관리에 시간을 소비하는 대신, 실제 코드 개발과 비즈니스 로직 구현에 더 집중할 수 있게 한다.</p><ul><li>이벤트 기반 실행 : Lambda는 특정 이벤트에 반응해 자동으로 코드를 실행한다. 우리 프로젝트의 경우, S3 버킷에 파일이 업로드될 때 자동으로 이미지를 처리하거나, 데이터 스트림을 분석할 수 있다.</li><li>자동 확장 : 요구에 따라 자동으로 확장되기 때문에, 사용자는 트래픽 급증 시에도 안정적인 성능을 기대할 수 있다.</li><li>비용 효율성 : 실제로 코드가 실행될 때만 비용을 지불한다. 사용하지 않는 시간에는 비용이 발생하지 않으므로, 경제적이다.</li></ul><h3><strong>AWS Lambda의 단점</strong></h3><ul><li>Cold Starts : Lambda 함수는 사용되지 않는 동안 비활성 상태가 되며, 이벤트가 발생했을 때 다시 활성화된다. 이 과정에서 발생하는 초기 지연을 Cold Starts라 한다. 특히 자바와 같은 무거운 런타임을 사용할 경우, Cold starts로 인해 응답 시간이 상당히 지연될 수 있다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*joaiPqKxH3NcUXVc.png" /></figure><ul><li>리소스 제한 : Lambda 함수는 실행 시간, 메모리 할당, 저장 공간 등에 여러 제한이 있다. 예를 들어, 함수의 최대 실행 시간은 15분으로 제한되어 있으며, 장시간 실행이 필요한 작업에는 적합하지 않을 수 있다.</li></ul><h3><strong>언제 AWS Lambda를 사용하는 게 좋은가?</strong></h3><ul><li>서버를 띄우지 않고 간단한 코드를 실행시키고 싶은 경우</li><li>특정 기간 또는 특정 주기로 코드를 실행시켜야 하는 경우</li><li>트리거가 실행될때만 코드를 실행시키고 싶은 경우</li></ul><p>즉, 코드를 계속 실행시키기 보다는 특정한 시기에만 실행시키는 경우에 Lambda를 사용하면 유용하다.</p><p><strong>JAVA 코드로 AWS Lambda 실행하기</strong></p><ul><li>JAVA를 이용해서 Lambda 함수를 만들기 위해서는 jar 나 zip 으로 관련 라이브러리와 코드를 주입해야 한다.</li></ul><p>[ 동작 흐름 ]</p><ol><li>파일 다운로드 후 S3에 업로드</li><li>S3 업로드를 트리거로 설정하여, Lambda 함수 자동 실행</li><li>Lambda 함수에서 이미지 리사이징 및 Webp 형식으로 변환</li><li>변환된 파일 다른 S3 버킷에 저장됨</li></ol><h3>실행 시간 비교</h3><p>코드를 수정하여 각각의 과정의 시간이 얼마나 걸리는 지를 확인했다.</p><p><strong>[ 백엔드 서버만 사용했을 시 ]</strong></p><ul><li>전체 과정(스토리 생성) : 3.9 초</li><li>다운로드: 약 2.707초</li><li>리사이징: 약 0.129초</li><li>webp 변환 및 최종 처리: 약 0.232초</li></ul><p><strong>[ AWS Lambda 사용 ]</strong></p><ul><li>전체 과정(스토리 생성) : 약 4.3 초</li><li>리사이징 및 webp 변환 : 약 2.7 초</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*9pzDBEcM6zW506ORPucOww.png" /></figure><h3>결론</h3><p>AWS Lambda를 사용할지, 백엔드 서버만을 활용할 지는 프로젝트의 요구사항에 따라 선택한다.</p><p>[ 트래픽 대응 능력 ]</p><ul><li>Lambda는 높은 수준의 트래픽에 자동으로 확장성있게 대응한다. 특히 이벤트 기반의 실행을 활용해 사용자의 요구사항이 증가할 때마다 자동으로 확장되므로, 대규모 이미지 처리 요구에 효과적으로 대응할 수 있다.</li><li>백엔드 서버만을 활용하면, 트래픽이 급증할 경우 수동으로 리소스를 추가하거나 스케일링을 조정해야하는 단점이 있다.</li></ul><p>[ 경제적 측면 ]</p><ul><li>Lambda는 실행된 만큼 비용을 지불하는 구조로, 비활성 시간에는 비용이 발생하지 않아 경제적이다. 불규칙적인 사용 패턴에 적합하다.</li><li>백엔드 서버는 지속적인 유지 관리 및 운영 비용이 발생하기 때문에, 지속적인 리소스 사용이 없는 경우 비효율적일 수 있다.</li></ul><p>[ 시간적 측면 ]</p><ul><li>Lambda의 경우, 초기에 Cold starts가 있을 수 있지만, 한 번 활성화된 후에는 빠른 처리 속도를 보인다.</li><li>백엔드 서버는 일관된 응답 시간을 제공하지만, 리소스의 한계를 도달하면 성능 저하가 발생한다.</li></ul><p>[ 성능적 측면 ]</p><ul><li>Lambda는 자동으로 여러 인스턴스로 확장되어 대량의 이미지를 동시에 처리할 수 있고, 최신 AWS 인프라에서 실행되므로 높은 성능을 유지한다.</li><li>백엔드 서버의 경우, 서버의 사양과 구성에 따라 처리 성능이 결정되며, 확장을 위해서는 추가적인 구성 변경이 필요하다.</li></ul><p>종합적으로, 높은 트래픽과 자동 확장, 비용 효율성이 중요하다면 AWS Lambda를, Cold start 없이 일관된 성능을 원하고 서버 상태를 세밀하게 제어하고 싶다면 백엔드 서버만을 사용하는 것이 나을 수 있다.</p><p>중요한 점은 각 방식의 특징을 이해하고 프로젝트의 특성에 맞게 적절한 기술을 선택하는 것이다.</p><h3>참고</h3><ul><li><a href="https://wildeveloperetrain.tistory.com/289">java image resize library 이미지 리사이즈 라이브러리 비교해보기</a></li><li><a href="https://github.com/saniaky/aws-lambda-create-thumbnail/blob/master/src/main/java/com/saniaky/aws/ImageHandler.java">aws-lambda-create-thumbnail/src/main/java/com/saniaky/aws/ImageHandler.java at master · saniaky/aws-lambda-create-thumbnail</a></li><li><a href="https://github.com/circlee/java-aws-lambda-imageResize/blob/master/src/main/java/com/test/ImageResize.java">java-aws-lambda-imageResize/src/main/java/com/test/ImageResize.java at master · circlee/java-aws-lambda-imageResize</a></li><li><a href="https://docs.aws.amazon.com/ko_kr/lambda/latest/dg/java-package.html">.zip 또는 JAR 파일 아카이브를 사용하여 Java Lambda 함수 배포</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4dffafd68683" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[SiliconValley Winter Bootcamp] NextPage English Ver]]></title>
            <link>https://medium.com/@angal2310/siliconvalley-winter-bootcamp-nextpage-english-ver-19fa610c68d2?source=rss-0431dd1f32f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/19fa610c68d2</guid>
            <dc:creator><![CDATA[Jungeun]]></dc:creator>
            <pubDate>Fri, 26 Jan 2024 11:04:22 GMT</pubDate>
            <atom:updated>2024-02-02T07:34:11.792Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6NPFq42UCLeOEDlWvgy-BA.png" /></figure><h3>Introduction</h3><p>2023.12.26 ~ 2024.02.03</p><p>The six-week boot camp has ended. I would like to share the errors I encountered in this process and the core skills I learned for implementation.</p><p>NextPage is a service that creates an image as you write a story through it. You can check the stories you have created at a glance, and continue the stories of other users.</p><h3>Demo</h3><h4>Onboarding Page</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C5weMavqDgs3R4JlKAiMbA.gif" /></figure><h4>Landing Page</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-fgamj8qgluexN6kFVEuxg.gif" /></figure><p>On the landing page, the user is prompted to enter a nickname to enter the main page. The nickname is stored in the MySQL database afterward.</p><h4>Main Page</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*db7IJh-jtrFGg5KRQ0xrdw.gif" /></figure><p>The main page shows the initial topics and the scenario page represents the expansion of the scanrios. Initial topics are stored in both MySQL and Neo4j as a pivot for future scanrios. Afterward, subsequent branch subject data is stored only in Neo4j to provide flexibilty to represent the continuation of scenarios in branches.</p><h4>Scenario Create Modal</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*12itAE_Fpx5v7MJbYs75nA.gif" /></figure><p>If you press the button on the lower right of the main page, you enter the scenario creation modal window. When text is entered, a request is sent to DALL-E to generate an image. DALL-E prompting was performed for a uniform picture body and higher quality of the image.</p><h4>Scenario Page</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NjR1zePOy_0f_WGMpISf0w.gif" /></figure><p>Scenario page shows extended branches on the first subject. We used Neo4j to show the bifurcation structure. Neo4j uses a declarative graph query language called Cypher, which is intuitively understandable and can reduce the amount of code over SQL. We chose Django as the backend framework. However, Neo4j is not compatible with Django. Django is primarily a web framework designed to support RDBMS, unlike Neo4j that uses graph-like structured databases that are unique compared to relational databases and other data models. Therefore, we used drivers and libraries such as neomodel and django-neomodel to link Neo4j with Django.</p><h3>System Architecture</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m5Ji6maW1uS76UwfhsLTWA.png" /></figure><h3>Tech Stacks</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/549/1*doatqeIOLw2c_pe9lWkNug.png" /></figure><h3>Frontend</h3><h4>VITE</h4><p>Vite is one of the modern JavaScript frameworks specialized for web development, enabling development in a fast environment. It responds immediately to browser requests through an ES Module-based operating system and provides fast initial loading speed by performing module bundling in the browser.</p><h4>Three.js</h4><p>Three.js is a JavaScript 3D library that helps you easily render 3D objects on web pages using WebGL. To match our service with infinite scalability, the space-themed background made of Three.js was applied to all pages of the service. In addition, the camera and the viewing angle were adjusted to allow users to immerse themselves in the service and immerse themselves in imagination.</p><h4>D3.js</h4><p>D3 is a JavaScript library for data visualization. It was used to visualize scenarios and stories as a branch graph in conjunction with neo4j. It was implemented to intuitively grasp the branch of the entire story by expressing the image of the story generated by the user as the node of the graph.</p><h3>Backend</h3><h4>Neo4j</h4><p>Neo4j is a graph-based NoSQL database. A graph database consists of nodes, relationships, and properties, and this structure is useful for efficiently representing complex relationships and networks. In our project, Neo4j is used to represent branches of stories generated by AI image generation tools such as DALL-E, to represent nodes.</p><h4>Celery</h4><p>Celery is a distributed job queue system that enables asynchronous processing of tasks requiring long execution time. When an image is generated using DALL-E, the image generation job is converted into a Celery job so that it can be processed in the background. Therefore, the response time of the web application is shortened.</p><h4>RabbitMQ</h4><p>RabbitMQ is a message broker, which is used with Celery to store job messages in a queue and deliver them to Celery workers as needed. Therefore, it is possible to increase the stability and efficiency of the system by using RabbitMQ in DALL-E to manage a large amount of image generation requests and sequentially assign them to Celery.</p><h3>DevOps</h3><h4>Nginx</h4><p>Nginx is a high-performance web server, reverse proxy software. It is lightweight and has high simultaneous processing power, and is particularly effective when providing static content or performing roles such as load balancing, caching, and reverse proxy.</p><h4>EC2</h4><p>EC2 is a cloud-based virtual server service provided by AWS. It effectively deploys systems through EC2’s flexible and scalable cloud infrastructure.</p><h3>Github</h3><ul><li><a href="https://github.com/2023-Winter-Bootcamp-Team-J">https://github.com/2023-Winter-Bootcamp-Team-J</a></li></ul><h3>Meet our team</h3><ul><li>Jungeun : Team leader, Backend, DevOps (<a href="https://github.com/jungeunyooon">jungeunyooon</a>)</li><li>Miyoung : Team leader, Frontend (<a href="https://github.com/miyoung12">miyoung12</a>)</li><li>Hana : Frontend, Backend (<a href="https://github.com/dlwhsk0">dlwhsk0</a>)</li><li>Hyeongjun : Frontend (<a href="https://github.com/brojj22">brojj22</a>)</li><li>Gwanghyeon : Backend, DevOps (<a href="https://github.com/Gwanghyeon-k">Gwanghyeon-k</a>)</li><li>Kanguk : Backend, DevOps (<a href="https://github.com/kanguk01">kanguk01</a>)</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=19fa610c68d2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[SiliconValley Winter Bootcamp] NextPage Korean Ver]]></title>
            <link>https://medium.com/@angal2310/siliconvalley-winter-bootcamp-nextpage-korean-ver-9be40743773d?source=rss-0431dd1f32f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/9be40743773d</guid>
            <dc:creator><![CDATA[Jungeun]]></dc:creator>
            <pubDate>Fri, 26 Jan 2024 11:02:57 GMT</pubDate>
            <atom:updated>2024-02-02T07:33:12.142Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6NPFq42UCLeOEDlWvgy-BA.png" /></figure><h3>Introduction</h3><p>2023.12.26 ~ 2024.02.03</p><p>6주간의 부트캠프가 마무리됐다. 이 과정속에서 만났던 오류들과, 구현을 위해 공부했던 핵심 기술을 공유하려고 한다.</p><p>NextPage는 텍스트를 입력하여 이미지를 생성하고, 이를 통해 본인만의 스토리를 써나가는 서비스이다. 내가 만든 스토리들을 한 눈에 확인할 수 있으며, 다른 사용자들의 스토리도 만들 수 있다.</p><h3>Demo</h3><h4>온보딩 페이지</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C5weMavqDgs3R4JlKAiMbA.gif" /></figure><h4>랜딩페이지</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-fgamj8qgluexN6kFVEuxg.gif" /></figure><p>랜딩페이지에서는 사용자가 닉네임을 입력하고, 메인 페이지로 입장한다. 이때 닉네임 정보를 저장하기 위해 MySQL을 사용한다.</p><h4>메인페이지</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*db7IJh-jtrFGg5KRQ0xrdw.gif" /></figure><p>메인페이지는 최초로 생성된 주제들을 보여주고, 시나리오 페이지에서는 최초로 생성된 1개의 주제의 확장을 분기로 표현한다. 따라서 메인페이지에서는 MySQL을 이용하고, 시나리오 페이지에서는 Neo4j를 이용한다. 따라서 최초의 주제에 대해서는 Mysql과 Neo4j에 모두 저장하고, 이후의 분기 주제 데이터들은 Neo4j에만 저장하도록 한다.</p><h4>시나리오 생성 모달</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*12itAE_Fpx5v7MJbYs75nA.gif" /></figure><p>메인페이지 오른쪽 하단의 버튼을 누르면, 시나리오 생성 모달창으로 입장한다. 텍스트를 입력하면 달리(DALL-E)에게 요청을 보내 이미지를 생성한다. 이미지의 통일성있는 그림체와 더 높은 퀄리티를 위해 달리(DALL-E) 프롬프팅을 진행했다.</p><h4>시나리오 페이지</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NjR1zePOy_0f_WGMpISf0w.gif" /></figure><p>최초의 주제에 대해 확장된 분기를 보여주는 페이지이다. 분기 구조를 보여주기 위해 Neo4j를 사용했다. Neo4j는 Cypher라는 선언형 그래프 쿼리 언어를 사용하는데 Cypher는 직관적으로 이해하기 좋으며 SQL보다 코드 양을 줄일 수 있다. 우리는 백엔드 프레임워크로 Django를 선택했다. 하지만 Neo4j는 Django와 호환성이 좋지않다. Django는 주로 RDBMS를 지원하도록 설계된 웹 프레임워크인 반면, Neo4j는 그래프 데이터베이스로 관계형 데이터베이스와 다른 데이터 모델을 사용한다. 따라서 Neo4j와 Django를 연동하기 위해 드라이버와 neomodel, django-neomodel과 같은 라이브러리를 사용했다.</p><h3>System Architecture</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m5Ji6maW1uS76UwfhsLTWA.png" /></figure><h3>Tech Stacks</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/549/1*doatqeIOLw2c_pe9lWkNug.png" /></figure><h3>Frontend</h3><h4>VITE</h4><p>Vite는 웹 개발에 특화된 모던 자바스크립트 프레임워크 중 하나로, 빠른 환경에서 개발을 가능하게 한다. ES Module 기반의 동작 체계를 통해 브라우저 요청에 즉각적으로 응답하며, 모듈 번들링을 브라우저에서 수행하여 빠른 초기 로딩 속도를 제공한다.</p><h4>Three.js</h4><p>Three.js는 WebGL을 이용하여 웹페이지에 3D 객체를 쉽게 렌더링 하도록 도와주는 자바스크립트 3D 라이브러리이다. 무한한 확장성을 갖춘 우리 서비스와 어울리게끔 서비스의 모든 페이지에 Three.js로 제작된 우주 테마의 배경을 적용하였다. 또한 카메라와 시야각을 조절하여 사용자가 서비스에 몰두하고 상상에 깊이 빠져들 수 있도록 구현하였다.</p><h4>D3.js</h4><p>D3는 데이터 시각화를 위한 JavaScript 라이브러리이다. neo4j와 연동하여 시나리오와 스토리를 분기 형태의 그래프로 시각화 하기 위해 사용하였다. 사용자가 생성한 스토리의 이미지를 그래프의 노드로 표현하여, 전체 스토리의 분기를 직관적으로 파악할 수 있도록 구현되었다.</p><h3>Backend</h3><h4>Neo4j</h4><p>Neo4j는 그래프 기반의 NoSQL 데이터베이스이다. 그래프 데이터베이스는 노드, 관계, 속성으로 구성되어 있고, 이러한 구조는 복잡한 관계와 네트워크를 효율적으로 표현하는데 유용하다. 우리의 프로젝트에서는 달리(DALL-E)와 같은 AI 이미지 생성 도구에서 생성된 이야기의 분기를 표현하는 데 Neo4j를 사용하여, 노드를 표현한다.</p><h4>Celery</h4><p>Celery는 분산 작업 큐 시스템으로, 긴 실행 시간이 필요한 작업을 비동기적으로 처리할 수 있게 한다. 달리(DALL-E)를 사용하여 이미지를 생성하는 경우, 이미지 생성 작업을 Celery 작업으로 전환하여 백그라운드에서 처리할 수 있게 한다. 따라서 웹 애플리케이션의 응답 시간이 단축된다.</p><h4>RabbitMQ</h4><p>RabbitMQ는 메시지 브로커로, Celery와 함께 사용되어 작업 메시지를 큐에 저장하고, 필요에 따라 이를 Celery 워커에게 전달한다. 따라서 달리(DALL-E)에서 RabbitMQ를 사용하여 대량의 이미지 생성 요청을 관리하고, 이를 순차적으로 Celery에게 할당함으로써 시스템의 안정성과 효율성을 높일 수 있다.</p><h3>DevOps</h3><h4>Nginx</h4><p>Nginx는 고성능의 웹 서버, 리버스 프록시 소프트웨어이다. 가볍고 높은 동시성 처리 능력을 가지고 있고, 특히 정적 컨텐츠를 제공하거나, 로드 밸런싱, 캐싱, 리버스 프록시 등의 역할을 수행할 때 매우 효과적이다.</p><h4>EC2</h4><p>EC2는 AWS에서 제공하는 클라우드 기반의 가상 서버 서비스이다. EC2의 유연하고 확장 가능한 클라우드 인프라를 통해, 시스템을 효과적으로 배포한다.</p><h3>Github</h3><ul><li><a href="https://github.com/2023-Winter-Bootcamp-Team-J">https://github.com/2023-Winter-Bootcamp-Team-J</a></li></ul><h3>Meet our team</h3><ul><li>윤정은 : Team leader, Backend, DevOps (<a href="https://github.com/jungeunyooon">jungeunyooon</a>)</li><li>김미영 : Team leader, Frontend (<a href="https://github.com/miyoung12">miyoung12</a>)</li><li>조하나 : Frontend, Backend (<a href="https://github.com/dlwhsk0">dlwhsk0</a>)</li><li>김형준 : Frontend (<a href="https://github.com/brojj22">brojj22</a>)</li><li>김광현 : Backend, DevOps (<a href="https://github.com/Gwanghyeon-k">Gwanghyeon-k</a>)</li><li>이강욱 : Backend, DevOps (<a href="https://github.com/kanguk01">kanguk01</a>)</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9be40743773d" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>