언제부터 해당 이슈가 발생했는지는 파악이 어려우나, 갈수록 이슈 발생률이 높아져 상품등록 10개중 9개가 실패하는 지경에 이르렀다.

간헐적으로 성공하기도 하여, 우리쪽 문제가 아니라 판단했지만 이슈의 발생 정도가 너무 빈번하여 우리쪽 유저의 불편사항이 날로 커지고 있어서 원인 파악에 착수했다!

우리쪽 문제가 아니지만, 상대쪽 스펙으로 인해 우리쪽 버그가 되는 경우...........

1. S3 액세스 로그 활성화

먼저 해당 S3이미지 접근시 상황을 파악하기 위해 S3 액세스 로그를 살펴보고자 한다.

그러나 활성화가 되어있지 않다!

먼저 S3호출시 상황을 파악하기 위해 "액세스 로그" 활성화를 지정한다. // 활성화 하는 법

2. AWS athena 사용

액세스 로그가 저장되는 버킷의 내용을 살펴보려고 하는데.. 이거 일일히 하나하나 열람하는게 영 보통일이 아니다.

보다 효율적으로 저장된 로그를 파악하는 방법을 찾아보다가 aws 공식문서에서 "athena"를 지원함을 알수 있었다.

3. 공백이 포함된 S3 객체명

객체 자체에는 문제가 없음이 확실하기에, 동일한 객체인데도 어떨때 403 에러가 발생하는지 찾아보았다. aws 공식문서에 따르면 객체의 이름이 정확하지 않을때 404 에러가 아닌 403 에러가 반환된다고 한다. // 403 에러난다는 문서 캡쳐본

실제로 postman을 통해 객체명 뒤에 "공백"을 하나 추가하여 호출하니 Access Denied가 발생했다.

오류가 발생한 외부 api는 json 형태로 데이터 처리 후, xml형태로 변환하여 utf-8로 인코딩 하여 byte 형태로 데이터를 전송하고 있다. 즉, byte 형태의 데이터를 해당 외부 사이트에서 가공하여 다시 우리쪽 s3이미지를 호출할때, 가비지 캐릭터가 추가된건 아닐까 하는 의심이 생겼다.

간헐적으로 통신요청이 성공할때와 그렇지 않을때 요청보낸 데이터에 어떠한 차이가 있는지 파악이 필요하다.

• java
• spring boot
• ningx, ec2
• mongodb

controller -> service -> repository 구조로 mongodb에 새로운 document를 insert하고, read, update 진행하기

언어 : golang 소셜 : Facebook (Instagram Graph API 사용) 기타 스펙 : API Gateway, AWS Labmda

어려워 죽는줄

언어 : golang, python 소셜 : NAVER, GOOGLE ( Youtube Data API 사용) 기타 스펙 : API gateway, AWS Lambda

언어가 두개인 이유는.. python으로 다 해놨는데 golang으로 다시 하라고 했기 때문이지.......

들은바에 의하면 (?) 옛날 동작 방식으로 데이터를 xml형식으로 만들어 해당 데이터가 저장된 url로 api 통신을 하는 방법도 있다고 한다. 이번에 이런 방식을 사용해 데이터를 주고 받아야 하는 일이 있어서 지난번과 마찬가지로 버킷을 생성하고 정책설정을 해서 퍼블릭 접근이 가능하도록 하였다.

IAM

S3에 업로드, 다운로드, 읽기 등 모든 권한을 가진 역할자를 하나 만들어준다.

버킷 생성하기

버킷의 이름은 "test-for-xml-just-text"로 하였다. region도 아시아/서울로. 앞서 말했듯 퍼블릭 접근이 가능해야 하기 때문에 버킷을 생성하면서 "이 버킷의 퍼블릭 액세스 차단 설정" 에 모든 퍼블릭 액세스 차단을 해제해 주었다.

다른건 건드릴것이 없어서 바로 생성하였다.

1. 버킷 정책 설정

이 버킷에 대한 정책을 설정한다. 버킷에 xml을 업로드하고, 업로드된 xml을 자유롭게 읽어올수 있어야 하기 때문이다.

"정책 생성기"를 통해 먼저 생성할 정책의 상태를 선언한다. 정확하게 사용할 actions 지정해도 되지만 번거로우므로 s3에 대한 모든 action들을 허용하도록 했다. 그리고 ARN에는 생성된 버킷의 ARN을 입력하면 된다.

설정한 후 "Add statement"를 누르면 정책json 예제가 생성되고 "Generate Policy"로 정책 내용을 확인하여 복사해둔다.

{
  "Id": "{정책번호}",
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "{생성된 statement의 ID}",
      "Action": "s3:*",
      "Effect": "Allow",
      "Resource": "arn:aws:s3:::test-for-xml-just-text",
      "Principal": "*"
    }
  ]
}

그리고 나서 버킷 정책 편집창에 붙여넣고 저장한다. 이때 에러가 난다면 에러 메세지를 잘 보고 해결하도록 한다!

2. CORS 설정

나의 경우 외부 사이트에서도 해당 객체 url을 호출하기 때문에 CORS 정책도 설정해야 한다. 모든 요청을 다 허용해 주면 된다.!

[
    {
        "AllowedHeaders": [
            "*"
        ],
        "AllowedMethods": [
            "GET",
            "PUT",
            "POST",
            "HEAD"
        ],
        "AllowedOrigins": [
            "*",
            "http://localhost:*"
        ],
        "ExposeHeaders": [
            "ETag"
        ],
        "MaxAgeSeconds": 3000
    }

객체 업로드 하기

먼저 AWS UI를 통해 객체를 업로드 해본다. 이때 업로드 하는 파일 목록 아래에 보면 "권한" 설정 탭이 있다. 여기서 "미리 정의된 ACL"에 프라이빗 으로 하면 url 호출 시 "Access denied"가 뜬다.

- 프라이빗 설정 시

따라서 "퍼블릭 읽기 액세스 권한 부여" 설정을 해준다.

- 퍼블릭 설정 시

그러면 업로드 된 파일의 객체 url을 호출하면 내용이 정상적으로 보인다.

이제 python 로직을 통해 객체 업로드를 진행해 보자!

xml 업로드 endpoint 작성

python 프로젝트로 작성하려고 한다. 이때 데이터를 구성할때부터 xml 형식으로하면 매우 까다로우므로 일단 dict 형식으로 작성후 xml로 converting 해주도록 한다. 이때 필요한 모듈은 "xmltodict"이다.

import boto3
import xmltodict

upload_dict = {
  "data": {
    "goods_data": {
    "goodsNm": "testgoods",
    "goodsprice": "1000"
    }
  }
}

def convert_xml_to_dict(target):
    return loads(dumps(target))

upload_xml = convert_xml_to_dict(target=xmltodict.parse(upload_dict))

스터디이기 때문에 각자 파트를 맡아 세미나 형식으로 진행하기로 했고 내가 맡은 부분은 AWS의 여러 도구와 EC2에 대한 챕터이다. 때문에 EC2에 대한 내용을 정리하면서 스터디를 준비하고자 한다.

1. EC2 ?

*EC2 ?? * Elastic Compute Cloud의 줄임말. C가 두번 들어가서 EC2이다. 컴퓨팅 용량을 제공하는 서비스로 서버에 필요한 세트를 Cloud에서 빌릴수 있게 해준다.

그리고 EC2는 managed service가 아니기 때문에 서버 및 네트워크 운영은 AWS가 담당하지만 그 외 OS를 포함한 소프트웨어는 사용자가 직접 설치하고 운영해야 한다.

+) AWS managed service

AWS에서 제공하는 서비스들은 크게 두 종류로 나눌수 있다. managed service인지 아닌지가 그 기준이다.

managed service ?? AWS가 관리하는 서비스의 통칭 ex) Amazon S3, Amazon RDS

매니지드 서비스는 백업 및 업데이트가 자동으로 이뤄져 관리 부담이 줄어든다. S3의 경우 상황에 맞게 storage 용량이 자동으로 증가한다. 하지만 자동으로 이뤄지기때문에 업데이트 하고싶지 않은 소프트웨어가 업데이트 되거나 필요 이상으로 용량이 커져서 과한 요금이 부과될 수 있기 대문에 완전히 신경을 쓰지 않을 수는 없다.

- 매니지드 서비스의 기능

• 자동 백업
• 자동 알림
• 모니터링
• 패치 관리
• 보안
• 이중화 : 같은 시스템을 여러개 준비해 장애시 서비스가 완전히 멈추는 것을 방지해 주는 것.

- EC2의 장점

EC2는 Cloud 서비스이다. 즉, 어디서든지 EC2에 접근이 가능하고, 가상화 기술로 백업이 용이하며, AWS의 여러 리전과 가용영역을 활용하여 물리적으로 다른 여러 장소에 서버를 생성할 수 있다.

또한 EC2의 관리 콘솔 화면을 통해 클릭한번으로 생성, 삭제, 중지 등 여러가지 조작이 가능하다. 기능 조작이 즉각적이므로 장애에 대비해 즉각적인 대응도 가능하다.

• 고장 => 서버 복제, 복구
• 부하 증가 => 서버 복제, 분산
• 접속량 감소 => 스케일 다운
• 일시 사용 => 잠깐동안만 EC2를 사용

- EC2 사용하기

EC2를 생성하기 위해서는 인스턴스 유형, OS 종류, 소프트웨어 설치 유무, AMI 종류 등 여러가지를 선택해야 한다. 역시 AWS에서 다양한 유형을 제공해 준다.

1) 운영

EC2가 아닌 직접 서버를 구축한다면 물리적인 환경을 조성하기 위해 현지에 가서 케이블을 연결해야 한다. 하지만 EC2를 사용하면 관리 콘솔을 통해 이를 대신할 수 있다. 또한 소프트웨어적인 작업을 진행할 때에는 SSH를 이용해 원격으로 로그인하여 조작할 수 있다.

** SSH ?? ** Secure Shell Protocol의 줄임말로 네트워크 프로토콜 중에 하나이며 서버를 원격에서 작업하기 위한 프로토콜이다.원격제어 뿐만이 아니라 데이터를 전송할 때에도 사용되며 FTP나 Telnet 보다 보안적인 면에서 더욱 우수하다.
SSH의 보안 SSH의 보안은 한쌍의 key로 구성되어 있다. 바로 public key와 private key이다. (이전에 잠깐 봤던 SSL과 마찬가지. 두가지는 다르다.) => HTTP와 SSL public key를 이용해 "암호화"는 가능하되 "복호화"는 불가능 하다. 때문에 정보를 받는 입장에서는 private key를 이용해 정보를 복호화 하여야 한다.
따라서 private key를 처음 발급 받으면 사용자는 이를 컴퓨터에 꼭 저장해야 한다. (두번 발급이 안된다.)

2) 서비스 기능

EC2 서비스에는 다양한 기능이 있다.

** AMI ?? ** Amazon Machine Image의 줄임말로 Amazon EC2안에 가상 머신을 생성하기 위해 사용되는 특수한 유형의 가상 어플라이언스 이며 EC2를 사용하여 배포하는 서비스의 디플레이의 기본 단위 역할을 한다.
** AMI의 주요 구성 요소** 모든 가상 어플라이언스와 마찬가지로 운영체제(리눅스, 마이크로소프트 윈도우 등)와 서비스 전달에 필요한 추가 소프트웨어를 포함하는 읽기 전용 파일 시스템 이미지로 구성되어 있다. Wiki - AMI

IPv4 ?? 요즘 사용되는 정적 주소는 IPv4와 IPv6 두종류가 있다. IPv4는 4개로 구분된 10진수의 숫자로 표시되며 생성되는 수의 종류는 약 43억개이다. 하지만 점점 잔여 수가 부족해지고 있어 현재는 IPv6가 대체되고 있다. IPv6는 8개로 구분되어 16진수로 표현되 약 340간개를 사용할 수 있다.

3) 사용 절차

1. AWS로그인 : 리전을 선택하고 관리 콘솔을 열어 EC2 대시보드를 선택
2. EC2 인스턴스 생성 : AMI와 인스턴스 유형 선택 / 네트워크와 IP주소 할당 / 스토리지 추가 / 보안그룹 설정 / 키페어 선택(작성)
3. EC2 접속 : SSH로 EC2에 접속
4. 소프으웨어 설치 & 설정 (SSH 사용)

- 인스턴스 설정 항목

VPC ?? AWS 계정 전용 가상 네트워크

4) 요금 책정

4가지 요소로 요금이 부과된다.

1. 인스턴스 사용량(가동 시간 X 단가) : 인스턴스가 가동한 시간(초) 단위로 과금
2. EBS(스토리지) 요금 (용량 X 단가) : 인스턴스가 사용하는 EBS 요금
3. 통신 요금 (아웃바운드 통신 요금) : 인스턴스 통신 요금
4. 그 외 옵션

• Elastic IP 서비스 등의 옵션을 선택했을 경우 해당 요금 추가

-----------------------------

2. EC2 이용 관련

1) AMI

AMI를 통해 같은 환경의 서버를 쉽게 재구축 할수 있다. AMI는 공식 AWS의 AMI만 존재하는 것은 아니다. 커뮤니티나 기업에서 생성한 AMI도 이용 가능하며 종류에 따라서는 이용에 따른 별도 요금이 발생할 수 있다. 개인이 만들수도 있다. 생성한 AMI는 마켓플레이스에서 배포 가능하다.

그러나 AMI가 반드시 안전하다는 보장이 없기 때문에 새로운 AMI를 사용할땐 항상 유의해야한다.

2) 인스턴스 유형

인스턴스 유형이란 머신의 용도이다. 용도는 다섯가지로 구분되며 각 용도에 따라 선택할수 있는 여러 유형이 존재한다.

유형을 선택 한 후에는 크기를 선택해야 한다. 이 두가지를 모두 선택하면 t2.micro와 같이 표기된다. 프리티어를 사용중일땐 보통 t2.micro를 선택한다. 가장 작은 크기로 해야 무료로 이용할 수 있기 때문이다.

3) EBS

AWS managed service 아님. EBS 영구적인 블록 스토리지 볼륨으로 EC2와 조합하여 사용 가능하다. 스토리지 곧, 데이터를 기록하는 장소의 대표적인 예시는 HDD와 SSD이다.

4) Elastic IP

AWS managed service 아님. AWS는 정적인 공인 IP로 Elastic IP를 제공한다. (IPv4) 이는 AWS계정에 속해있으므로 인스턴스를 삭제해도 계속 사용할 수 있다.

참고로 EC2는 서버를 껏다 키면 공인 IP주소가 변경되므로 Elastic IP를 사용해 변경되지 않는 IP주소를 사용할 수 있다. 그러나 인스턴스에 기본적으로 제공되는 IP가 아닌 추가 IP를 연결할 경우 추가 요금이 부과된다. 이는 인스턴스가 중단되거나 했을때도 계속해서 요금이 부과되니 사용하지 않는 IP는 반드시 해지해야 한다.

5) Elastic Load Balancing

AWS managed service 아님. AWS가 제공하는 로드 밸런서. (분산 처리 장치) 3가지 종류가 있다. ALB, NLB, CLB

다음의 OSI 모형을 기준으로 어느 계층에서 작동하는지 확인 할 수 있다.

1. ALB (Application Load Balancer)

HTTP및 HTTPS에 가장 적합한 로드 밸런서.애플리케이션 계층(구체적인 통신을 제공하는 계층)에서 작동한다.

내용을 판단하기 때문에 대상의 URL 디렉토리 단위로 분배가 가능하고, 인스턴스와 로드 밸런서 사이의 통신을 암호화 할 수 있다. 단, IP할당은 못한다.

지원 프로토콜 : HTTP, HTTPS

2. NLB (Network Load Balancer)

네트워크 계층 (전송된 데이터의 제어를 담당하는 계층)에서 작동한다. 패킷 (단편)데이터만 확인할수 있으므로 ALB보단 덜 섬세하지만 분배 대상의 정적 IP주소를 설정할수 있다는 차이가 있다. 또한 서버에 접속한 클라이언트의 IP주소를 그대로 서버에 전송하도록 설정할 수 있다.

지원 프로토콜 : TCP, TLS

3. CLB (Classic Load Balancer)

지원하는 프로토콜은 많지만 오래됐기 때문에 새로 구축할때는 사용을 권장하지 않는다.

지원 프로토콜 : TCP, SSL/TLS, HTTP, HTTPS

6) 스냅샷 : 서버 데이터 백업

AWS managed service 아님.

스냅샷이란 어떤 시점의 서버 디스크 상태를 통째로 보존한 파일이나 폴더 등의 집합으로 스냅샷을 작성해 Amazon EBS볼륨의 데이터를 Amazon S3에 백업할 수 있다. 스냅샷의 데이터 보존 장소는 S3이지만 사용자가 그 파일을 자유롭게 다운로드 할수 있는 것은 아니며 S3 서비스를 사용할때와는 다른 영역의 S3에 저장되는 것이다. 때문에 볼 수 없지만 이로 인한 S3요금은 발생하지 않는다.

7) 오토 스케일링

AWS managed service 아님.

오토 스케일링이란 서버의 액세스 상태에 따라 서버 대수를 늘리거나 줄이는 기능이다.

** Scale ** 서버 부하와 관련해 해결책으로 Scale ## 방법이 있다. 4가지 이다.

1. Scale-Up : 성능을 향상시킨다. ex) 4GB => 8GB
2. Scale-Out : 물리 갯수를 늘린다. ex) 1개 => 2개
3. Scale-Down : 성능을 저하시킨다. ex) 8GB => 4GB
4. Scale-In : 물리 갯수를 줄인다. ex) 2개 => 1개

오토 스케일링은 Scale-out이다. 이를 사용하기 위해선 Auto Scaling 그룹 (인스턴스의 집합)을 생성하고 그 그룹에 인스턴스(서버)의 최소 대수와 최대 대수를 설정해야 한다. 그 범위 안에서 오토 스케일링이 활성화 되는 것이다. 또한 기능을 위해선 서버 가동에 필요한 AMI와 키페어, 보안그룹 등을 설정해야 한다.

요금은 기본적으로 무료이지만 CloudWatch를 사용할 경우 모니터링에 관련된 요금이 부과된다.

-----------------------------

3. EC2 생성 실습

프리티어 등급에서 EC2의 새 인스턴스를 생성해보자

1) AMI 선택

AWS에서 제공하는 AWS 공식 AMI를 선택한다. 이때 나의 AMI혹은 AMI MarketPlace를 이용한다. 먼저 화면의 가장 최신 Ubuntu 버전을 선택하고, 64비트(x86)을 선택한다. 이때 m1이라서 Arm했더니 프리티어 버전으로 선택할수 있는 인스턴스 유형이 없었다.

2) 인스턴스 유형 선택

프리티어 등급으로 이용 가능한 t2.micro를 선택한다.

*t2.micro ?? * t는 instance family를 나타낸다. (t 외에도 M, C, 등이 있다) t2의 2는 인스턴스의 세대를 나타낸다. micro 는 인스턴스의 크기를 나타낸다.

** 마이크로(T) ?? ** 인스턴스 크기별 기본 수준의 CPU 성능 제공 간헐적으로 높은 성능이 필요할 때 유휴시간에 모아 놓은 크레딧을 기반으 로 버스팅하여 높은 성능을 제공 적용사례 : 개발환경, 소규모 웹, 마이크로 서비스

3) 인스턴스 구성

VPC와 서브넷 / IAM역할 / CloudWatch 이용여부 등을 선택할 수 있다. 앞서 말했듯 CloudWatch를 이용할 경우 과금되니 주의가 필요하다.

4) 스토리지 추가

EBS 볼륨을 구성하는 단계이다.

5) 태그 추가

임의로 한개 태그를 생성해 보았다.

6) 보안 그룹 구성

보안 그룹을 구성한다. 새로운 보안그룹을 생성할수도 있고, 기존에 생성한 보안그룹을 선택할 수도 있다. 이때 유형은 다양한 것이 있지만 Linux기준 SSH를 사용하기로 했다.

7) 인스턴스 시작 검토

마지막으로 설정한 값들을 검토하여 최종 시작하기를 진행한다. 이때 경고 문구도 확인하자.

💡💡💡) 키페어

SSH유형의 보안그룹 선택으로 사용할 키페어를 지정한다. 이때 기존에 만든 키페어를 선택할수도 있고, 새로 생성할 수도 있다.

새로 생성하면 반드시 다운로드 받아 개인적인 곳이 보관해야 한다. 키페어는 생성할 때만 다운 가능하고, 추가로 다운로드 되지 않으므로 주의한다.

생성완료 : 생성 대기, 실행

생성하면 바로 실행되지 않고 시간이 조금 걸리며 이때 인스턴스 상태는 대기중으로 표기된다. 조금 기다리면 실행된다.

종료 == 삭제

사용하지 않는 인스턴스는 "중지" 할수도 있지만 "종료" 할수도 있다. 종료 역시 시간이 조금 걸리며 종료는 곧 삭제를 의미한다. 하지만 콘솔 화면상에서 "종료" 상태로 계속 보이긴 한다.

끝!

간단히 개념과 생성까지 정리해보았다. 너무 길게 정리한것 같지만 빠뜨릴 내용이 없어서 그랬던...것...!

환경

- S3

[S3 내 구조]

.
├── 조건1
│   ├── 파일1
│   └── 파일2
├── 조건2
│   ├── 파일1
│   └── 파일2
└── 조건3
    ├── 파일1
    ├── 파일2
    └── 파일3

# 파일 속 내용 : 다음의 형태가 string으로 기록됨
{time : 기록 날짜, name : 이름, age : 나이, hobby : 취미}

# 이때 기록날짜는 datetime.datetime 형태이다

- DB : mongoDB

------------------------------

0. S3에 접근하기 : aws 액세스키

먼저 S3에 접근하는 경로를 선택해야 한다.

1. 퍼블릭 bucket에 접근한다
2. bucket에 접근할수 있는 정책을 가진 사용자를 사용한다.

나의 경우 처음에 퍼블릭 bucket임에도 불구하고 aws_access 키를 요구했어서.. 꽤나 고생하면서 액세스 키까지 발급받고 진행하긴 했다. 나중에 다시해보니 해당 키 내용을 제거하고 bucket이름만 명시해도 접근이 되더라! 그치만 둘다 해봤으므로 모두기록한다.

1) 유효한 정책을 지닌 사용자 이용하기

먼저 이용하고자 하는 사용자의 액세스 키를 발급받아야 한다. 이를 위해선 로그인 후 화면 우측 상단의 username을 클릭해 드롭다운박스에 보이는 내 보안 자격 증명을 들어간다.

이후 액세스 키를 들어가 새로운 액세스 키를 발급받도록 한다! 해당 정보가 기록된 문서는 생성시에만 다운 가능하다!! 이점유의해서 꼭 명확한 경로에 저장하도록 하자 (혹시나 분실했을 경우 해당 액세스 키를 삭제하고 다시 발급받으면 된다. 주기적으로 교체해 주는것도 보안상 중요!)

aws client

터미널상에 액세스키에 대한 정보를 입력하고 해당 계정으로 aws 서비스를 이용하는것으로 이해했다..! 처음엔 무조건 이를 수행해야 되는줄 알았는데 그냥 로직상에 액세스키 번호를 입력해주면 되더라! 일단 해보긴 했다.

=> 터미널상에서 aws client를 사용하기 위해 awscli 모듈을 설치해 준다. 그리고 액세스 키에 대한 정보를 입력한다.

> pip install awscli
> aws configure --profile #사용할name
>>> access_key 입력
>>> secret_key 입력
>>> region 입력 (나의 경우 ap-northease-2)

그럼 설정 끝!

이걸 하면 로직상 액세스키를 입력안해줘도 되는거같긴한데 쓰는 방법은 모르겠다.. 그래서 그리고 나서 코드상에 boto3를 이용해 s3와 연결하면서 bucket에 접근할때 해당 키값을 다시 명시해 주었다. ㅎㅎ;

2) 퍼블릭 bucket에 접근하기

이거는 여러번 삽질끝에 한 것이라 한번에 성공하는 법은 모른다!

하지만 bucket의 버킷정책에 다음과 같이 입력하였다.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "PublicRead",
            "Effect": "Allow",
            "Principal": "*",
            "Action": [
                "s3:*Object",
                "s3:*ObjectVersion"
            ],
            "Resource": "arn:aws:s3:::{내 bucket이름}/*"
        }
    ]
}

*은 전부를 뜻한다는거!

이 설정의 경우 다음과 같이 접근할수 있는걸로 알고있다...! (이렇게 말하는 이유는 내가 한번에 성공하지 못했기 때문)

------------------------------

2. bucket내의 파일 이름 읽어오기 : list_objects

boto3.client의 속성을 검색해 보았다.

엄청많다...! 궁금하면 boto3가 설치된 환경에서

#python shell
>>> import boto3
>>> s3 = boto3.client('s3')
>>> s3. #입력 후 tap 키를 누른다.

구글링 하면서 알아낸 것은 해당 bucket의 모든 object들을 읽어오는 s3.list_objects라는 속성이다.

하위개념 X

S3에 저장할때 폴더 내에 파일을 저장할 수 있다. 그렇게 되면 폴더와 파일의 이름형식은 다음과 같이 설정된다.

# 폴더1
폴더1/

# 폴더1 내의 파일1
폴더1/파일1

하지만 위의 list_objects를 사용하면 폴더 자체로도 object로 여겨져 이를 불러온다.

# list_objects 결과
- 폴더1/
- 폴더1/파일1

list_objects를 사용해 bucket에 저장된 object들을 확인해보자. 전부를 가져오면 hostid나 기타등등의 정보도 다 불러와지니까 딱 원하는 정보인 저장된 객체에 대한 것만 확인해보자 그러기 위해선 가져온 object의 Contents키의 내용을 확인하면 된다. 이말은 즉 list_objects로 가져온 s3의 objects들은 dictionary형태로 온다는 말이다.

import boto3
s3 = boto3.client('s3', accesskey, secretykey)
obj = s3.list_objects(Bucket='velog-practice')
print("저장된 것 :", obj['Contents']

>>>
저장된것 [
{'Key': '2021-06-20-PM05/green5.log', 'LastModified': datetime.datetime(2021, 6, 20, 14, 21, 49, tzinfo=tzutc()), 'ETag': '"~~~~"', 'Size': 78, 'StorageClass': 'STANDARD', 'Owner': {'ID': '~~~'}},
{'Key': '22021-06-20-PM05/purple5.log', 'LastModified': datetime.datetime(2021, 6, 20, 14, 21, 50, tzinfo=tzutc()), 'ETag': '"~~~~"', 'Size': 79, 'StorageClass': 'STANDARD', 'Owner': {'ID': '~~~'}}, 
{'Key': '2021-06-20-PM05/red5.log', 'LastModified': datetime.datetime(2021, 6, 20, 14, 21, 49, tzinfo=tzutc()), 'ETag': '"~~~~"', 'Size': 78, 'StorageClass': 'STANDARD', 'Owner': {'ID': '~~~'}}, 
{'Key': '2021-06-20-PM05/yellow5.log', 'LastModified': datetime.datetime(2021, 6, 20, 14, 21, 50, tzinfo=tzutc()), 'ETag': '"~~~~"', 'Size': 79, 'StorageClass': 'STANDARD', 'Owner': {'ID': '~~~'}}, 
{'Key': '22021-06-20-PM12/green.log', 'LastModified': datetime.datetime(2021, 6, 20, 14, 21, 49, tzinfo=tzutc()), 'ETag': '"~~~~"', 'Size': 76, 'StorageClass': 'STANDARD', 'Owner': {'ID': '~~~'}}, 
{'Key': '2021-06-20-PM12/purple.log', 'LastModified': datetime.datetime(2021, 6, 20, 14, 21, 50, tzinfo=tzutc()), 'ETag': '"~~~~"', 'Size': 77, 'StorageClass': 'STANDARD', 'Owner': {'ID': '~~~'}}, 
{'Key': '2021-06-20-PM12/red.log', 'LastModified': datetime.datetime(2021, 6, 20, 14, 21, 49, tzinfo=tzutc()), 'ETag': '"~~~~"', 'Size': 79, 'StorageClass': 'STANDARD', 'Owner': {'ID': '~~~'}}, 
{'Key': '2021-06-20-PM12/yellow.log', 'LastModified': datetime.datetime(2021, 6, 20, 14, 21, 50, tzinfo=tzutc()), 'ETag': '"~~~~"', 'Size': 80, 'StorageClass': 'STANDARD', 'Owner': {'ID': '~~~'}}
]

내가 원한것은 폴더 안에 속한 파일들은 dictionary속 list로 묶는 형태였으므로 이를 위해 가공이 필요했다.

3. {폴더 : [폴더 내 파일들]} : python의 lambda

저장된 objects의 형태를 보면 폴더명/파일명의 형태이다. 폴더명은 통일되도록 일시로 저장되게 하였고, 같은 일시에 작성된 것들은 같은 폴더에 저장된다.

오랜만에 python의 lambda 함수를 사용해 보자!

순서는 다음과 같다.

1. s3의 Contenst내용을 가져온다. 이때 file들은 list형태의 Contenst의 dictionary속 Key값에 저장되어 있다.
2. folder이름만을 담은 list를 선언한다.
3. lambda를 활용해 folder명이 같은 file들끼리 묶어준다.

# 과정

obj = s3.list_objects(Bucket=bucket)['Contents']
obj_key = [row['Key'] for row in obj]

folder_list = []
for row in obj_key:
    if row[:15] not in folder_list:
        folder_list.append(row[:15])

res_list = []
for row in folder_list:
  gather_files = list(filter(lambda x:x[:15] == row, obj_key))
  tmp_dict = {}
  for row in gather_files:
    if not tmp_dict:
      tmp_dict = {row[:15]: []}
    else:
      tmp_dict[row[:15]].append(row[16:])
  if tmp_dict:
    res_list.append(tmp_dict)

>>> res_list = [
{'2021-06-20-PM05': ['purple5.log', 'red5.log', 'yellow5.log']}, 
{'2021-06-20-PM12': ['purple.log', 'red.log', 'yellow.log']}
]

4. 파일 내 data 읽기 : get_object

반복문을 통해서 진행한다.

from ast import literal_eval

for row in res_list:
    for file_name in list(row.values())[0]:
        folder_name = row.keys()
        log_file = s3.get_object(Bucket='velog-practice', Key=(list(folder_name)[0]+'/'+file_name))
        tmp_content = log_file['Body'].read().decode('utf-8')
        log_content = literal_eval(tmp_content)

여기서 get_object가 사용되었는데 흐름상 알수 있듯이 해당 파일 속의 내용을 읽는 속성이다. 이때 byte 타입으로 기록되기 때문에 decoding을 해주어야 하며, 단순 string 형태이기 때문에 dictionary 형태를 원한다면 형변환을 해주어야 한다. 따라서 literal_eval을 사용하였다.

5. mongoDB에 저장하기

나는 반복문을 통해 s3내용을 읽을때마다 mongoDB에 저장하는걸 택했다. 따라서 위의 반복문에 이 코드를 추가한다.

        db.velog_practice.insert_one(log_content)

6. 저장된것 확인하기

tool로 확인할수도 있지만 귀찮으니 명령어로 확인하자.

for row in list(db.velog_practice.find({})):
    print("db에 저장된 data==========> : ", row)

db에 저장된 data==========> :  {'_id': ObjectId('60cf5e051ea5f74dca0ab836'), 'name': 'purple5', 'age': 4, 'hobby': 'hiking', 'time': '2021-06-20-17-00-00'}
db에 저장된 data==========> :  {'_id': ObjectId('60cf5e051ea5f74dca0ab837'), 'name': 'red5', 'age': 1, 'hobby': 'dancing', 'time': '2021-06-20-17-00-45'}
db에 저장된 data==========> :  {'_id': ObjectId('60cf5e051ea5f74dca0ab838'), 'name': 'yellow5', 'age': 2, 'hobby': 'reading', 'time': '2021-06-20-17-00-30'}
db에 저장된 data==========> :  {'_id': ObjectId('60cf5e051ea5f74dca0ab839'), 'name': 'purple', 'age': 4, 'hobby': 'hiking', 'time': '2021-06-20-12-00-00'}
db에 저장된 data==========> :  {'_id': ObjectId('60cf5e051ea5f74dca0ab83a'), 'name': 'red', 'age': 1, 'hobby': 'dancing', 'time': '2021-06-20-12-00-30'}
db에 저장된 data==========> :  {'_id': ObjectId('60cf5e051ea5f74dca0ab83b'), 'name': 'yellow', 'age': 2, 'hobby': 'reading', 'time': '2021-06-20-12-00-20'}

------------------------------

끝!!!

그런데 일할때랑 혼자 연습할때랑 다른점이있다...! 연습때는 list_objects로 s3 버킷 내 모든 objects들을 불러올때 folder만 불러와지진 않은듯..? 이거때문에 구분하는 고생을 한건데.. 다시 확인해 보았다.

이를 위해 연습때는 aws 사이트에서 폴더생성없이 바로 file명에 "/"를 붙여 폴더 속에 파일로 생성되게 했었다. 이번에는 비교를 위해 aws 사이트에서 폴더를 생성하고, 그 속에 log 파일을 넣은 뒤 확인해 보았다.

# list_objects로 확인 결과
['2021-06-20-PM05/green5.log', '2021-06-20-PM05/purple5.log', '2021-06-20-PM05/red5.log', '2021-06-20-PM05/yellow5.log', 
'2021-06-20-PM12/green.log', '2021-06-20-PM12/purple.log', '2021-06-20-PM12/red.log', '2021-06-20-PM12/yellow.log', 
'check_folder/', 'check_folder/check.log']

즉, aws내에서 임의로 폴더를 생성하고, 그 속에 file을 넣을 경우 list_objects로 읽을 시 folder만도 같이 읽힌다. 이와 달리 s3에 없로드 시 "/"사용을 통해 folder가 자동으로 생성되고, 그 속에 file이 저장되게 하면 list_objects사용 시 정확히 내가 넣은 file들만 읽힌다. 단, 폴더명/파일명으로 읽힌다.

오.. 코드 수정할 수 있겠는걸? 월요일이 기대된다! 헷! 🥰

그래서!! 원하는 조건으로 dictionary형태를 만들고 해당 형태의 내용을 담은 file로 s3에 업로드 되기까지 코드로 작성해버렸다.

1. txt 파일 만들기

알고리즘을 풀때 이와 같은 코드를 많이 작성했었다.

import sys
sys.stdin = open("파일명", "rt")
n = input()
m = input()

위 코드는 "파일명"의 내용을 한줄 읽고, n값에 대입하는 것이다. n 다음에 m에는 두번째 줄의 내용이 담긴다.

txt 파일을 작성할 때는 sys.stdout을 사용한다.

sys.stdout = open("폴더명/파일명.txt", "a")

"폴더명"에 해당하는 폴더는 사전에 생성해 두어야 한다. 이후 폴더명/파일명으로 지정해 놓으면 그 폴더 안에 "파일명"으로 txt파일이 자동으로 생성된다. 물론 txt 대신 다른 확장자명 쓰면 그걸로 생성된다.

작성될 파일까지 지정해 주었는데 어떻게.. 저장하지..? 싶으면 print문으로 한다!!!!

import sys
import datetime

sys.stdout = open('velog/velogpractice.txt', 'a')

date = datetime.datetime(2021, 6, 20)

def create_log(date):
  ex = [{"name": "purple", "age": 4, "hobby": "hiking"}, {"name": "green", "age": 3, "hobby": "singing"},
        {"name": "yellow", "age": 2, "hobby": "reading"}, {"name": "red", "age": 1, "hobby": "dancing"}]

  for i, row in enumerate(ex):
    row['time'] = date+datetime.timedelta(minutes=10*i)
    print(row)

create_log(date)

위 코드로 작성된 파일은 velog라는 폴더 내 velogpractice라는 txt 파일에 내용이 저장되어 있다. 순서는 위에서 아래이다.

[velog/velogpractice.txt]

{'name': 'purple', 'age': 4, 'hobby': 'hiking', 'time': '2021-06-20-12-00-00'}
{'name': 'green', 'age': 3, 'hobby': 'singing', 'time': '2021-06-20-12-00-10'}
{'name': 'yellow', 'age': 2, 'hobby': 'reading', 'time': '2021-06-20-12-00-20'}
{'name': 'red', 'age': 1, 'hobby': 'dancing', 'time': '2021-06-20-12-00-30'}

2. txt파일 읽어오기

s3업로드 하기 위해 txt파일 내 정보를 읽어와야 한다.

굳이 txt파일로 안만들고 바로 s3에 저장할수도 있지만 나에게는 s3에 저장 과정이 필요했기 때문에 이렇게 했다.!!!

이때에도 txt파일에 저장된 한줄씩 읽으면서 바로 s3에 저장할 것이기 때문에 다음과 같이 코드를 작성했다.

# txt파일 읽어오기
sys.stdin=open("velog/velogpractice.txt", "rt")

while True:
  n = str(input())
  save_to_s3_velog(n)

이제 읽어온 한줄은 바로 save_to_s3_velog라는 메소드로 실행될 것이다.

3. s3에 저장하기

특별히 제목을 가공하지 않는다면 저장 자체는 어렵지 않다.! 가공이 항상..문제야.. 그리고 난 가공을 한다. 😃 그게 중요한게아니니 가공 과정은 생략한다.

def save_to_s3_velog(data):
    bucket = 'velog-practice'
    s3 = boto3.client('s3', aws_access_key_id, aws_secret_access_key)
    s3.put_object(Body=data, Bucket=bucket, Key=name, ContentType='text/plain')

Body S3에 저장되는것은 모두 byte 타입이다.
ContentType 이를 설정해주지 않으면 aws 사이트에서 해당 파일을 열기 했을때 바로 안열리고 download가 된다. 이.. 차이뿐인가..?
put_object s3에 저장하는 속성이다.

---------------------------------

끝!

이제 다음 포스팅에서 s3에 저장된 file의 내용을 읽어 mongoDB에 저장하는걸 다뤄보자.

lambda의 기능! 호출이 들어올때만 실행되는 함수임을 기억하면 이런 일도 가능하구나...! 싶다.

먼저 이전 내용은 중구난방이었기에 다시한번 API Gateway와 lambda를 연결해보도록 하자.

IAM 권한 설정

AWS 서비스를 사용하는데 권한을 부여할 역활을 생성해야 한다. 이거 중요,, 개거생 했당!

** IAM ?? ** IAM 역할은 신뢰하는 개체에 권한을 부여하는 안전한 방법이다.

내가 사용할 서비스는 API Gateway와 lambda이다. lambda의 트리거로 API Gateway를 연결할 것인데 이때 lambda를 동작하는 역활에게 API Gateway에 대한 여러 권한을 부여해 주어야 한다.

lambda를 사용하면서 API Gateway에 대한 권한을 가진 역활을 생성한다. 이때 어떤 API Gateway권한을 허용할 것인지 검색하면 4가지 옵션이 나온다.

• AmazonAPIGatewayAdministrator
• AmazonAPIGatewayInvokeFullAccess
• AmazonAPIGatewayPushToCloudWatchLogs
• AmazonAugmentedAIIntegratedAPIAccess

이중에서 AmazonAPIGatewayPushToCloudWatchLogs 정책을 연결해줄것...!!!!!!!!

역할 이름은 lambda_main_iam이라고 지었다. (역할이 14개라 헷갈려서...)

lambda 함수 생성하기

함수이름은 favorite_fruit라고 지었다!

그리고 나는 lambda함수를 python으로 작성할 것이고, 버전은 3.7이기 때문에 해당하는 언어를 선택했다.

그리고 중요한 기본 실행 역할 변경 아까 만든 IAM을 지정해 준다.

함수를 생성하면 내가 지정한 함수이름으로 만들어진 폴더 안에 lambda_function.py라는 파일이 만들어져 있고 그 안에 예제 lambda코드가 작성되어 있다.

먼저 이 내용을 건드리지 말고 API Gateway와 연결 후 테스트 해 보도록 하자!

API Gateway 생성하기

REST API를 생성할것이기 때문에 해당 옵션을 선택해 생성하도록 하자! (사실 다른건 잘 모른다)

엔드포인트 유형도 3가지가 있는데 일단 지역으로 선택...! 최적화된 에지도 해봤는데 사실 엄청 간단하게만 작동해봐서 다른점은 아직 모르게따

그리고 나서 URL경로를 만들어 준다.! 간단하게 /fruit/{fruit_name} 으로 fruit_name의 값을 path parameter로 받는 형태로 작성하였고, method는 GET만 작성하였다.

그리고 나서 method의 통합 포인트로 아까 만든 lambda함수를 연결하도록 한다. (lambda함수의 arn주소를 복붙하면 자동으로 lambda함수 이름으로 작성된다.)

내용을 저장한다고 하면 이처럼 해당 API Gateway에 lambda함수에 대한 권한을 추가한다고 알람이 뜬다!

mapping template 설정

lambda함수로 들어온 내용을 가공없이 그대로 출력하게 하기 위해 다음과 같이 설정하도록 한다.!

먼저 메소드 화면에서 통합 요청을 들어간다. 그리고 content/type으로 application/json을 선택하고 메소드 요청 패스스루를 선택하면 다음의 코드가 자동을 작성된다. 저장만 하면 끝!

lambda 트리거로 API Gateway 지정됨.

다시 lambda 함수 내용을 보면 트리거로 방금 생성한 API Gateway가 지정되어있는걸 확인할 수 있다.

테스트하기 (API Gateway test)

먼저 API Gateway에서 제공하는 테스트를 사용해 보자! 아직 lambda함수 코드가 예제코드이기 때문에 큰 에러없이 "Hello from Lambda!" 가 출력될 것이다.

이를 lambda기능의 모니터링을 통해 CloudWatch에서 로그를 확인해 보자!

print문이 없기 때문에 log에도 별다른 출력문이 찍히지 않는다!

이제 path parameter에 대한 값이 출력되도록 코드를 수정해 보자. 이를 위해선 lambda_handler의 parameter값인 event의 활용이 필요하다.

먼저 event라는 값에는 어떤것이 담기는지 확인해 보자

헐 아무것도 없다. 있어야되는데 없다. 정책 연결을 제대로 안해주었기 때문이다!!!!!!!

🔥☠️ 정책 설정하기 - 대실패 KEYERROR

앞전에 IAM 만들때 API Gateway에 대한 정책을 하나만 연결했다. 그것만 하면 되는줄알았다. 그치만 event가 제대로 찍히지 않으니 다른 정책도 연결해 주어야 하나보다!! 이때 계속해서 event에 key가 없어 event속의 정보를 얻어내려 할때마다 KeyError가 나더라..........

하나씩 추가해보자

AmazonAPIGatewayAdministrator

결과 : event 안찍힘

AmazonAPIGatewayInvokeFullAccess

결과 : 안찍힘

AmazonAugmentedAIIntegratedAPIAccess

결과 : 안찍힘

lambda에 대한 정책도 추가로 연결해보자

AWSLambda_FullAccess

결과 : 안찍힘

왜 또 안되...!

🔥☠️ 정책 설정하기 - API Gateway, lambda 재생성

되야하는데 안되는것 같아 일단 다시 만들어보기로 했다.

방금 여러 정책이 추가된 역할을 사용해서 lambda와 api gateway를 다시 만들어보자!

먼저 lambda는 re_fruit라는 이름으로 다시 만들었고, API Gateway의 경우 아까 만든 API에서 리소스만 새로 추가하여 만들었다

그리고 나서 lambda함수에서 event를 출력하도록 코드를 수정하고 test를 진행해 보았다.

path parameter입력 후

이 외에도 IP주소를 출력하게 할수도 있고 등등 다양한 값을 출력할 수 있다! 어떤 attribute가 있는지는 aws 문서에 나와있다!

최종 형태 (log 기록 확인용)

예를들어 두가지 케이스에 대해 각각 log가 잘 찍히는지 확인하고 싶다고 가정하자. 그러면 배포된 API의 URL을 어딘가에 입력하고, 입력된 곳을 load되면 log가 기록될 것이다. 이때 그 log가 case1의 것인지, case2의 것인지 바로 판별하고 싶을때!!! 를 위해서 path parameter를 지정해 준 것이다.

case1 의 url

 https://@주소~~.ap-northeast-2.amazonaws.com/dev/fruit/apple

case1 의 url

 https://@주소~~.ap-northeast-2.amazonaws.com/dev/fruit/banana

간단하게 POSTMAN으로 확인해 보자!!

CASE 1 : apple

lambda의 함수를 다음과 같이 작성하였다.

def lambda_handler(event, context):
    print ("fruit name :", event['parmas']['path']['fruit'])
    return event['parmas']['path']['fruit']

여기서 print문은 log에 기록될 것이고 return값은 postman의 response에 띄워질 것이다.

CASE 2 : banana

끝!

API Gateway로 RESTful API를 생성하고, 이를 배포하여 lambda와 연동해 해당 url이 load될때마다 lambda가 실행되는것을 확인할 수 있었다.!!

아직도 너무나 어려운 정책 설정... 다양한 케이스로 사용해보고 얼른 익혀야겠다.!

>>> import os
>>> os.environ
environ({'PATH': '/Users/@username/~~~', 'SHELL': '/bin/zsh', 'USER': @username, ...이하생략...})

환경변수 => dictionary

없는 값을 호출하면 똑같이 KeyError발생

>>> import os
>>> os.environ['ENV']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/os.py", line 681, in __getitem__
    raise KeyError(key) from None
KeyError: 'ENV'

1. os.environ.get()

기본으로 없으면 값을 가져오지 않는데 사용자 설정으로 값이 없을 경우 특정 값을 사용할 수 있다.

>>> import os
>>> os.environ.get('ENV')
>>> #아무것도 없음
>>> os.environ.get('ENV', 'NOTHING')
>>> NOTHING

2. os.getenv()

os.environ.get()과 같은 기능이다.

>>> import os
>>> os.getenv('ENV')
>>> os.getenv('ENV', 'NOTHING')
'NOTHING'

특정 프로젝트에서는 환경변수를 지정해 주기도 한다. 어떤 환경변수를 지정했는지 까먹을때 이 코드를 써보도록 하자! (해본적 없어서 잘 되는지는 모름! ㅎ)

여기서는 vim도 안쓰고 pycharm이나 intelliJ를 사용하기때문에 터미널로 뭔가 작업하진 않을것 같지만 pycharm에서도 내장 terminal은 쓴다구..!!

다시한번 꾸며보자!

0. 환경

• iterm2
• homebrew 설치!
• zsh이 기본 shell

- iterm2 download
- Home brew download
brew install zsh

1. highlighting / autosuggestions

유용하게 쓰이는 기능 두가지 이다. 명령어 highlighting과 자동완성제공기능!

# brew install zsh 이후 진행
brew install zsh-syntax-highlighting
brew install zsh-autosuggestions

2. ~/.zshrc 수정

zshrc 파일은 음.. zsh의 config 파일 같은것...? 여기에 환경변수도 저장하고 플러그인도 입력하고, alias도 저장하는 등 여러 환경설정을 진행한다.

vi ~/.zshrc로 방금 설치한 두가지 플러그인을 등록한다.

# ~/.zshrc
source /opt/homebrew/Cellar/zsh-syntax-highlighting/0.7.1/share/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh
source /opt/homebrew/Cellar/zsh-autosuggestions/0.7.0/share/zsh-autosuggestions/zsh-autosuggestions.zsh

이때.. 저거 .zsh파일 두개가 어딨는지 한참을 찾았다!! ㅠㅠ homebrew로 설치했으니 저기 하위폴더 어딘가에 있겠지. .하면서 찾았다.

3. THEME : powerline 적용

그리고 나서 테마를 적용할 powerline을 git clone으로 받아온다. 현재는 10k 버전까지 나와있지만 9k 를 받아보자…!

git clone https://hithub.com/powerline/fonts.git /tmp/powerline9k0fonts && cd $_

위 명령어를 입력하면 powerline9k를 git clone 과 동시에 해당 위치로 이동 된다. 해당 위치에서 다음의 명령어를 입력한다.

sh ./install.sh

4. oh-my-zsh 설치

oh-my-zsh은 ZSH에 가장 널리 사용되는 플러그인 프레임 워크이며 많은 내장 플러그인과 테마도 제공된다.

먼저 설치 명령어는 다음과 같다.

sh -c "$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"

oh-my-zsh을 사용하면 편리한점들이 많다.

1. 상위 폴더 이동하기

예를들면 기존 bash가 기본 shell일 경우 상위 폴더의 이동은 다음과 같다.

# 상위
cd ..

# 두개 위
cd ../..

하지만 oh-my-zsh이 적용된 zsh쉘을 사용하면 다음과 같이 이동할 수 있다.

# 상위
cd ..

# 두개 위
cd …

2. tap키로 명령어 자동완성시키기

명령어를 입력할때 예를들면 rainbow를 쳐야한다고 가정하자. rain까지 치고 tap키를 누르면 rain으로 시작하는 여러 명령어들이 후보로 보여지는데 이때 후보가 rainbow 단 한가지 라면 해당 명령어가 자동완성 된다 아주 편하다!

이거말고도 많다!

5. 테마 적용하기

터미널 테마를 적용해보자. vi ~/.zshrc로 들어가면 다음과 같은 변수가 있을 것이다

ZSH_THEME = “powerline9k/powerline9k”

여기를 적용할 테마로 변경해주자! 보통 agnoster를 많이 쓰니까 나도 이걸로 저장한다.

ZSH_THEME = “agnoster”

그리고 터미널에 계속해서 username이 뜨는데 길기만하고 보기싫다! 하면 다음과 같은 변수도 저장해준다

# DEFAULT_USER을 명시함으로써 이름 가리기
DEFAULT_USER = “chaehyun”

이때 내 username을 입력하면 된다.

그리고 나서 source ~/.zshrc로 수정사항을 반영시켜준다. (혹은 그냥 teminal을 껐다 켜도 된다.)

6. Font 깨짐 수정

캡쳐본은 없지만 위의 것을 다 적용하고 나면 일부 폰트가 깨져서 ?박스가 뜨더라! Iterm2 환경설정에서 font를 powerline9k에 맞게 변경해주면 된다.

그럼 끝!

+) 테마 import하기

색상변경으로 커스텀 하거나 여러 테마가 저장되어있는 폴더를 다운받아서 Import 해주어도 된다!

http://github.com/mbadolato/iTerm2-Color-Schemes

에서 다운받으면 된다.

powerline10k

터미널에서 위치바의 모양이 맘에들지않는다면...! 내 원래 설정대로 하고싶다면..! powerline9k가 아닌 powerline10k로 설치하면 된다! 끝!

1. mongodb 실행

지난번 언급했던 것 처럼 brew를 통해 mongodb server를 실행시킨다. 그리고 mongodb client역시 실행시켜 준다.

...아래 명령어 중략...

이제 mongodb 커맨드를 입력할수 있는 shell이 활성화 되었다.

# mongo
>

--------------------------------

2. DB 생성

+) 현재 사용중인 DB 확인

생성하기 전에 현재 사용중인 DB가 무엇인지 확인해 보자

> db
test

test라는 db가 있는걸 확인할 수 있다. 난.. 아무것도 안만든거같은데...? 저번에 설치하면서 만들었나보다..

진짜로 만들어보자! mongodb에서 DB를 생성하는 명령어를 입력해 준다. 그리고 현재 사용중인 db를 확인해보자.

use $사용할db이름

> use mongo_practice1
switched to db mongo_practice1
> db
mongo_practice1

보다싶이 use명령어로 mongodb를 생성하면 생성과 동시에 해당 db가 활성되 된다.

+) DB list 확인

현재 어떤 db가 존재하는지 확인해 보자

> show dbs
admin     0.000GB
config    0.000GB
dbsparta  0.000GB
local     0.000GB

기존에 있던 test와 방금 내가 만든 mongo_practice1이 목록에 없다!

최소 한개이상의 document를 생성해야 List목록에 보이기 때문이다

3. mongoDB의 C.R.U.D

document를 생성한다는 것은 즉, CRUD에서 Create를 한다는 의미이다. 이를 위해선 먼저 mongoDB의 CRUD 명령어를 알아야 한다.

참고 사이트 : https://myjamong.tistory.com/57?category=835222

- 생성 : Create(insert)

이때 collection명을 새로 입력하면 해당 collection이 즉시 생성됨가 동시에 그 collection의 document가 작성된다.

db.$collection.insert({key:value})

- 조회 : Read(find)

전체조회 db.$collection.find()

조건에 따른 조회 db.$collection.find({key:value})

<조건에 따른 조회 예시>

- 갱신 : Update

전체 document 수정 db.$collection.update({기존 document를 특정 지을 key:value}, {새로변경할 내용의 key:value})

특정 값 수정 or 새로운 값 생성 db.$collection.update({기존 document를 특정 지을 key:value}, {$set : {추가할 key : 추가할 value})

- 삭제 : Delete

특정 field 삭제 (update 사용 - unset) db.$collection.update({기존 document를 특정 지을 key:value}, {$unset : {삭제할 key : 해당 value})

특정 document삭제 db.$collection.remove({조건 key : 해당 value})

특정 collection 삭제 db.$collection.update({})

4. document 생성하기

위 명령어를 토대로 mongo_practice1에 새로운 collection과 document를 생성해보자

이름 / 생년월일 / 이메일 / 취미(1~3개) / 코로나백신접종유무(T/F)

> use mongo_practice1
> db.users.insert({name : "jello", birth : 950403, email : "jello@test.com", hobby : ["hiking", "watch movie"], vaccination : False})

값으로 boolean값을 바로 사용할수 있을줄 알았다! 그런데 에러가 발생했다.

uncaught exception: ReferenceError: False is not defined :

간단하다. 대문자 말고 소문자로 입력하면 된다.

> use mongo_practice1
> db.users.insert({name : "jello", birth : 950403, email : "jello@test.com", hobby : ["hiking", "watch movie"], vaccination : false})
WriteResult({ "nInserted" : 1 })

이후 확인!

> use mongo_practice1
> db.users.find()
{ "_id" : ObjectId("60bcd8101abf6cdd64bfc938"), "name" : "jello", "birth" : 950403, "email" : "jello@test.com", "hobby" : [ "hiking", "watch movie" ], "vaccination" : false }
> show dbs
admin            0.000GB
config           0.000GB
dbsparta         0.000GB
local            0.000GB
mongo_practice1  0.000GB

💡 참고로 mongoDB는 document의 id로 _id라는 이름에 값이 자동 생성된다!

몇개를 더 만들어보자

> db.users.find()
{ "_id" : ObjectId("60bcd8101abf6cdd64bfc938"), "name" : "jello", "birth" : 950403, "email" : "jello@test.com", "hobby" : [ "hiking", "watch movie" ], "vaccination" : false }
{ "_id" : ObjectId("60bcd9b91abf6cdd64bfc939"), "name" : "보라돌이", "birth" : 901105, "email" : "purple@test.com", "hobby" : [ "talking", "listening music" ], "vaccination" : false }
{ "_id" : ObjectId("60bcd9d91abf6cdd64bfc93a"), "name" : "뚜비", "birth" : 930705, "email" : "green@test.com", "hobby" : [ "dancing" ], "vaccination" : true }
{ "_id" : ObjectId("60bcd9fd1abf6cdd64bfc93b"), "name" : "나나", "birth" : 940205, "email" : "yellow@test.com", "hobby" : [ "walking, singing" ], "vaccination" : true }
{ "_id" : ObjectId("60bcda181abf6cdd64bfc93c"), "name" : "뽀", "birth" : 200605, "email" : "red@test.com", "hobby" : [ "dancing" ], "vaccination" : false }

😢 자세히보면 나나의 hobby에서 따옴표에 오타가 있다.. 근데 왜 에러가 안나....? 진짜 입력한대로 다 저장되는거니,,,?

바로 수정해주자!

> use mongo_practice1 #이건그냥 보험삼아 해주는것. 혹여나 다른db 쓰고있을경우도 있으니 습관처럼 입력하자
> db.users.update({name:"나나"}, {$set : {hobby : ["walking", "singing"]}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.users.find()
{ "_id" : ObjectId("60bcd8101abf6cdd64bfc938"), "name" : "jello", "birth" : 950403, "email" : "jello@test.com", "hobby" : [ "hiking", "watch movie" ], "vaccination" : false }
{ "_id" : ObjectId("60bcd9b91abf6cdd64bfc939"), "name" : "보라돌이", "birth" : 901105, "email" : "purple@test.com", "hobby" : [ "talking", "listening music" ], "vaccination" : false }
{ "_id" : ObjectId("60bcd9d91abf6cdd64bfc93a"), "name" : "뚜비", "birth" : 930705, "email" : "green@test.com", "hobby" : [ "dancing" ], "vaccination" : true }
{ "_id" : ObjectId("60bcd9fd1abf6cdd64bfc93b"), "name" : "나나", "birth" : 940205, "email" : "yellow@test.com", "hobby" : [ "walking", "singing" ], "vaccination" : true }
{ "_id" : ObjectId("60bcda181abf6cdd64bfc93c"), "name" : "뽀", "birth" : 200605, "email" : "red@test.com", "hobby" : [ "dancing" ], "vaccination" : false }

+) 이것저것 수행

1. 조건에 해당하는 여러 document수정하기

마치 Django의 ORM에서 filter를 통해 queryset에 해당하는 모든 객체의 값을 수정한것 처럼 조건에 해당하는 여러 객체의 값을 갱신할 수 있다.

백신을 맞은 객체에 대해 가장 좋아하는 과일 : strawberry field를 생성해 준다.

> use mongo_practice1
> db.users.update({vaccination : true}, {fruit : "strawberry"}, {multi : true})

여러가지 조건에 대해 수정할 것이기 때문에 multi의 값에 true라고 지정해 주어야 한다 안하면 가장 처음의 객체에만 수정사항이 반영된다.

☠️ 실수..

... 흠.. 실수했다. 먼저 $set 명령어를 쓰지 않아 해당하는 document의 내용이 싹 갈아엎어졌다. 그나마 multi값을 주지 않았기에 가장 먼저 해당되는 객체만 수정되었다.

> db.users.update({vaccination : true}, {fruit : "strawberry"})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.users.find()
{ "_id" : ObjectId("60bcd8101abf6cdd64bfc938"), "name" : "jello", "birth" : 950403, "email" : "jello@test.com", "hobby" : [ "hiking", "watch movie" ], "vaccination" : false }
{ "_id" : ObjectId("60bcd9b91abf6cdd64bfc939"), "name" : "보라돌이", "birth" : 901105, "email" : "purple@test.com", "hobby" : [ "talking", "listening music" ], "vaccination" : false }
{ "_id" : ObjectId("60bcd9d91abf6cdd64bfc93a"), "fruit" : "strawberry" }
{ "_id" : ObjectId("60bcd9fd1abf6cdd64bfc93b"), "name" : "나나", "birth" : 940205, "email" : "yellow@test.com", "hobby" : [ "walking", "singing" ], "vaccination" : true }
{ "_id" : ObjectId("60bcda181abf6cdd64bfc93c"), "name" : "뽀", "birth" : 200605, "email" : "red@test.com", "hobby" : [ "dancing" ], "vaccination" : false }

다시 원상복구 하고 제대로 갱신해 보자

> db.users.update({fruit:"strawberry"}, {name : "뚜비", birth : 930705, email : "green@test.com", hobby : ["dancing"], vaccination : true})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.users.find()
{ "_id" : ObjectId("60bcd8101abf6cdd64bfc938"), "name" : "jello", "birth" : 950403, "email" : "jello@test.com", "hobby" : [ "hiking", "watch movie" ], "vaccination" : false }
{ "_id" : ObjectId("60bcd9b91abf6cdd64bfc939"), "name" : "보라돌이", "birth" : 901105, "email" : "purple@test.com", "hobby" : [ "talking", "listening music" ], "vaccination" : false }
{ "_id" : ObjectId("60bcd9d91abf6cdd64bfc93a"), "name" : "뚜비", "birth" : 930705, "email" : "green@test.com", "hobby" : [ "dancing" ], "vaccination" : true }
{ "_id" : ObjectId("60bcd9fd1abf6cdd64bfc93b"), "name" : "나나", "birth" : 940205, "email" : "yellow@test.com", "hobby" : [ "walking", "singing" ], "vaccination" : true }
{ "_id" : ObjectId("60bcda181abf6cdd64bfc93c"), "name" : "뽀", "birth" : 200605, "email" : "red@test.com", "hobby" : [ "dancing" ], "vaccination" : false }

> db.users.update({vaccination : true}, {$set : {fruit : "strawberry"}}, {multi : true})
WriteResult({ "nMatched" : 2, "nUpserted" : 0, "nModified" : 2 })
> db.users.find()
{ "_id" : ObjectId("60bcd8101abf6cdd64bfc938"), "name" : "jello", "birth" : 950403, "email" : "jello@test.com", "hobby" : [ "hiking", "watch movie" ], "vaccination" : false }
{ "_id" : ObjectId("60bcd9b91abf6cdd64bfc939"), "name" : "보라돌이", "birth" : 901105, "email" : "purple@test.com", "hobby" : [ "talking", "listening music" ], "vaccination" : false }
{ "_id" : ObjectId("60bcd9d91abf6cdd64bfc93a"), "name" : "뚜비", "birth" : 930705, "email" : "green@test.com", "hobby" : [ "dancing" ], "vaccination" : true, "fruit" : "strawberry" }
{ "_id" : ObjectId("60bcd9fd1abf6cdd64bfc93b"), "name" : "나나", "birth" : 940205, "email" : "yellow@test.com", "hobby" : [ "walking", "singing" ], "vaccination" : true, "fruit" : "strawberry" }
{ "_id" : ObjectId("60bcda181abf6cdd64bfc93c"), "name" : "뽀", "birth" : 200605, "email" : "red@test.com", "hobby" : [ "dancing" ], "vaccination" : false }

2. GUI로 확인해보기

전에 Studio 3T를 설치해두었다. 내 로컬 mongoDB와 연결하고 확인해보자!

data type을 보면 ObjectId / String / Double / Array / Bool 형태가 있음을 확인할 수 있다.

--------------------------------

5. DB 삭제하기

더이상 필요없는 DB는 삭제하자!

> use #삭제할db이름
> db.dropDatabase()

아직 mongo_practice1은 삭제안해...!!🔥

프로젝트 주소 : https://github.com/JELLO-Kim/Labs_forum.git

과제를 수행하면서 다음과 같은 조건이 있었다. [DB 설정]

1. 내장형 DB사용
2. Docker사용 : DB종류 제한 X

내장형 DB의 경우 sqllite를 사용하면 될것 같지만 요새 Docker에 대해 조금 알아보기도 했고, 마침 docker-compose까지 구현해보고 싶었기에 2번의 방법을 사용하기로 하였다. 지옥의 시작

그리고 글을 정리하면서 도움을 받았던 글! : sayxoung님의 블로그

Docker compose

Docker compose란 여러 개의 docker를 정의하고 실행하는 툴을 의미한다. 내가 하려는 것도 docker를 이용해서 API image와 DB image를 하나의 container로 실행하려고 하는 것이다.

DB의 이미지화

이전에 프로젝트 JELLOgram으로 했던 것은 API를 image로 빌드하여 DB를 제외한 나머지를 모두 도커로 실행하도록 한것이다. 빌드된 이미지를 실행하게 되면 그 안에 저장된 내 로컬DB에 대한 것도 함께 연결되는것이었다.

즉, API = 도커 / DB = local DB 의 형태였다.

하지만 과제나 배포와 같은 상황에서 API만 도커로 실행하는것은 의미가 없다. (연결된 DB는 작성자의 로컬 디비인데..? 아니면 RDS로?)

** RDS 는? ** RDS를 사용해 DB를 관리할 수도 있다. 하지만 배포를 할땐 DB에 접속할 비밀번호를 공유해야 한다. 내 비밀번호를 깃헙에 올린순 없다..

따라서 DB도 이미지로 빌드! 그리고 API 이미지랑 같이 실행!하는 방법이 Docker compose인 것이다.

----------------------------

Requirements

먼저 docker-compose의 설치가 필요하다. 나같은 경우 지난번 Docker를 설치할때 함께 설치해주었었다.

🔥 너무 옛날 버전이면 이후 제대로 실행되지 않는다! 주기적으로 업데이트를 진행해 줄 것!

pip install docker-compose

그리고 나서 API를 위한 Dockerfile과 docker-compose를 위한 docker-compose.yml 파일을 만들어 준다.

Dockerfile

이의 경우 지난번 블로깅을 통해 기록해 놓았다. 이중에서 다른 점은 gunicorn으로 실행하지 않는 것 runserver의 조건은 Dockerfile이 아닌 이후에 작성할 docker-compose.yml에 작성한다.

docker-compose.yml

확장자명 .yml을 주의하자! (참고로 yml 파일을 vscode로 열어보면 귀여운 핑크고래가 보인다 ㅎㅎ Dockerfile은 파란고래!)

한줄씩 살펴보자

공통 부분

• version : Docker의 버전이다. 3.X 도 있지만 3이라고만 표기하면 해당 버전들 중 가장 최신 버전이 적용된다.
• services : 코드의 시작
• forum / db : app과 db를 정의한다. 이름지어주는것은 자유지만 간단하게 명시했다!

forum :

• build: context: . dockerfile: ./Dockerfile : 적용될 Dockerfile의 위치와 이름
• command : Docker이미지가 빌드되고 실행될때 수행될 명령어들이다. 저기에 있는 wait-for-it에 관한것은 아래에서 다루도록 한다. / mm -> mg -> runserver 해주어서 이미지가 빌드되면 바로 서버가 가동된다.
• volumes : 실행되는 위치를 의미한다. 이미지가 실행될때 해당 위치가 형성된다.
• ports : 허용하는 포트정보
• depends_on : 도커의 이미지들끼리는 서로 인지하지 못한다 때문에 app의 이미지 정보에 db와 관련이 있음을 명시해 주어야 한다. 이때 사용하는 것이 depends_on : db 이다.

db :

• image : mysql ver5.7로 이미지를 만든다.
• environment : 생성된 mysql의 환경설정이다. 여기서 db의 이름 / db접속 비밀번호를 지정해 준다.
• command : DB가 생성될때 실행되는 명령어들이다. 나의 경우 DB의 data들이 한국어이기 때문에 utf8mb4설정을 진행해 준다.
• volumes : DB가 생성될때 sql파일을 사용해 자동으로 data를 채워준다. 따라서 경로에 맞게 최상위 directory에 data라는 폴더를 만들고 그 안에 sql 파일을 저장한다. (이름은 상관없다! 자동으로 sql파일을 사용해 data를 넣어준다)
• expose : port 번호를 의미한다. 도커 내부에서만 실행할 것이기 때문에 ports 8000:8000 으로 작성한것과 차이는 딱히 없는것 같다.

wait-for-it.sh

이 파일의 경우 작성된 코드들을 건들일 필요는 없다. 이미 잘 작성되어있기 때문에 공유하면 된다. 위에서 우리가 의도한 것은 docker-compose로 app과 db의 이미지를 함께실행하는 것이다. 하지만 app의 이미지가 실행될때 mm, mg를 수행한다. 알다싶이 이를 수행하기 위해선 DB가 먼저 준비되어 있어야 한다.

따라서 이미지가 실행될때 DB의 이미지가 먼저 실행된 후 app의 이미지가 실행되도록 app의 command에 wait-for-it를 입력했던 것!

실행하기

위의 파일들을 모두 작성한 후 requirements.txt도 꼼꼼히 기록한다. => 놓치면 바로 에러난다.

그리고 나서 githup에 코드를 모두 올린 후 새로운 폴더에서 해당 프로젝트를 clone받아 온다.

git clone $프로젝트

cd $프로젝트_최상위_directory

docker-compose up

이거면 끝! 에러가 나지 않는 다면 서버가 가동될 것이고, 빠르게 httpie test로 데이터를 확인해 볼 수 있다!

🔥 ERRORs

requirements.txt

이거저거 건드리다가 requirements를 제대로 작성하지 않았다. Django를 빼먹은 것. 어쩐지 Django를 실행할 수 없다고 뜨더라.. 잊지말자!

permission denied #1 : 임시 해결

db image는 문제가 없었는데 app image가 제대로 빌드되지 않았다. 계속해서 script와 관련해 permission denied라고 뜨는것.

이를 해결하기 위해선 wait-for-it.sh 파일의 권한을 풀어주어야 하는데 처음에는 docker-compose.yml의 command에 해당 명령어를 입력했었다.

# docker-compose.yml
command: >
    bash -c ” RUN chmod +x ./wait-for-it.sh
    && ./wait-for-it.sh db:3306 -t 15
    && python manage.py makemigrations
    && python manage.py migrate
    && python manage.py runserver 0.0.0.0:8000"

그런데 이렇게 입력하고 나니 RUN 명령어를 인식하지 못한다고 뜬다! 그래서 해당 줄을 제거하고 일단 docker-compose를 실행하기 전 해당 환경에서 직접 권한을 풀어주었다.

# docker 실행할 환경
chmod +x ./ wait-for-it.sh

그리고 나서 실행! 굿!

permission denied #2 : 해결!

수정!!!!! 2021.05.19 코드를 수정해서 다시 진행해 보았다.

# docker-compose.yml
command: >
    bash -c ”chmod +x ./wait-for-it.sh
    && ./wait-for-it.sh db:3306 -t 15
    && python manage.py makemigrations
    && python manage.py migrate
    && python manage.py runserver 0.0.0.0:8000"

RUN을 빼고 실행하니 docker가 실행되면서 다음과 같은 메세지가 출력되더라.

forum_1  | wait-for-it.sh: waiting 15 seconds for db:3306
...
#생략
...
forum_1  | wait-for-it.sh: db:3306 is available after 7 seconds
forum_1  | No changes detected
forum_1  | Operations to perform:
forum_1  | Apply all migrations: admin, auth, contenttypes, questions, sessions, users
forum_1  | Running migrations:
forum_1  | No migrations to apply.
forum_1  | Watching for file changes with StatReloader

실행 성공!

🛠 주의!

DB에 대한 정보를 settings.py 혹은 보안설정으로 my_settings.py 에 기록했던것을 기억하는가!

docker를 이용해 DB도 이미지로 빌드하게 되면 해당 프로젝트의 연결되는 DB는 내 로컬 / RDS 가 아닌 docker image실행으로 만들어진 이미지 속의 DB이다. 때문에 docker-compose파일에서 지정한 DB이름과 비밀번호로 settings.py도 수정한다. 또한 SECRET_KEY의 경우에도 실무에서는 회사 내에서만 공유하겠지만 일단 나는 배포 / 과제제출 용이기 때문에 공개하기로 한다! (임의의 string으로 지정했다.)

🙆‍♀️ 실행 성공

docker-compose가 무사히 실행된 화면 & httpie 확인 화면 & docker app으로 보는 container 상태

이후 docker를 종료하고 다시 실행해 보았다. 이때는 터미널에서 실행하려 하니 해당 container가 존재하지 않는다고 해서... 읭? docker app에서 실행해 주었다.

#안됌
❯ docker start labs_forum
Error response from daemon: No such container: labs_forum
Error: failed to start containers: labs_forum

통신 확인 완료!!

🏷 image로 만든 DB 확인

docker container로 실행된 db image를 확인해 보자

docker exec -t {db container이름} bash
mysql -u root -p
password > {docker-compose 작성할때 입력한 password 입력}

----------------------------

끝!

꼬박 하루가 걸린 docker-compose 였다! 처음 코드를 열어봤을때 진짜 무슨..말이고.. 했는데 하나하나 뜻을 보니 이 코드는 어디서, 왜 필요한지 이해하면서 점점 재밌어 졌다!

이제 DB도 도커로 관리!

메모리 캐싱

"메모리 캐싱"을 하는 이유는 무엇?? 이라고 하면 다음과 같다.

• 서비스 요청의 증가 (매우많이)
• DB요청이 매우 많아진다 => DB server의 부하가 증가한다
• 🔥 메모리 캐시 적용 🔥
• 성능 및 처리 속도가 향상된다. (DB Read의 부하 감소 가능)

그렇다면 DB server의 부하란 무엇인가?

DB server 부하

---------------------------

성능 알아보기 :

측정 대상은 지난 1차 프로젝트때 작성한 "Sweethome" 의 posting 관련 로직이다.

1. loadtest

먼저 npm install로 설치되는 loadtest를 통해 간단히 호출에 걸리는 시간을 알아보자. 설치방법은 공식문서를 참고하였다. npm install loadtest로는 가동이 안되어서 sudo npm install -g loadtest로 설치해주었다.

1) 단일 쓰레드 환경

설치 후 python manage.py runserver로 서버를 켠 뒤 명령어를 통해 loadtest 결과 확인.

loadtest -n 10 http://127.0.0.1:8000/posting

결과 : 24초

10명의 유저 말고 100명의 유저일때를 가정해 테스트해 보았다.

결과 : 245초

2) 멀티 쓰레드 환경

gunicorn 을 사용해 멀티쓰레드 환경일때도 확인해 보았다.

loadtest -n 10 http://0.0.0.0:8000/posting

결과 : 5초

100명일때도 확인해 보았다.

결과 : 58초

약 5배의 속도차이를 보였다.

2. locust

다음은 locust를 통해 확인해 보았다.

당시 코드를 보면 다음과 같다.

이왕 성능체크하는거 prefetch_related와 select_related를 사용하기 전과도 비교해 보도록 하자. 그래서 코드를 다음과 같이 수정하였다.

1) file 작성

부하성능을 알아보기 위해 선택한 것은 locust를 사용하는 방법이다. 이는 python에서 제공하는 모듈로 간단히 pip install locust를 통해 설치할 수 있다.

이후 locust를 실행시킬 명령어들이 작성된 파일을 작성한다.

기본적인 틀은 공식문서를 참고했다.

# locust_test.py
from locust import User, task, between

class PostingReadTest(User):
    wait_time = between(1, 2.5)

    @task
    def my_task(self):
        self.client.get("/posting")

locust attribute

wait_time

wait_time 이라는 메소드는 증가되는 user들 간의 딜레이 타임을 의미한다.즉, 새로운 요청이 어느 시간 간격으로 들어오는지를 나타낸다. 이 메소드는 3가지의 built in 속성이 있다.

• constant : 고정된 시간
• between : min과 max를 지정해 그 시간 사이의 랜덤한 시간
• constant_pacing : 최소 지정된 시간에 한번씩은 실행되도록 지정한 시간

이중에서 내가 사용한 것은 between이다. (실제로 user는 규칙적인 시간 텀을 두고 들어오지 않으니)

@task

@task는 task를 지정하는 가장 쉬운 방법인 task decorator를 의미한다. 이를 사용하면 선택적으로 로직의 구현 비중을 조절할 수 있다. (=weight를 지정할 수 있다.) 예를 들어 다음과 같은 코드가 있다고 가정하자.

# locusttest.py
from locust import User, task, between

class MyUser(User):
    wait_time = between(5, 15)

    @task(3)
    def task1(self):
        pass

    @task(6)
    def task2(self):
        pass

이런식으로 작성된 locust 코드가 있다면 @task로 묶인 함수에 대해서 task1이 3번 호출될동안 task2는 6번 호출되도록 한다.

class : User

class에 사용된 parameter로 User라는 것이 사용되었다. 이는 locust의 클래스인데 이로 인해 내가 작성한 class는 User 클래스를 상속받게 된다. Locust는 테스트되는 동안 각 user에 대해 User class의 instance 하나를 생성한다.

class : HttpUser

HttpUser class는 User class보다 더 흔하게 사용된다. User와 달리 HttpUser에는 client 속성이 추가되어 있는데 이를 통해서 HTTP request로 테스트가 가능하다.

여기서 client는 HttpSession의 instance이다.또한 HttpSession은 requests.Session의 하위 클래스이다. _추가적인 공부가 필요한 부분_

client속성은 모든 HTTP methods를 포함한다! GET / POST / PUT 등... 즉, 위에서 말했던 것 처럼 method에 맞는 HTTP request 테스트가 가능하다.

🔥 Error 발생

위에서 작성한 코드대로 locust를 실행했더니 다음과 같은 에러가 발생했다.

AttributeError: 'NoneType' object has no attribute 'get'

위 코드에서 get이 사용된 부분은 client이다. 즉, client에 아무것도 담기지 않은것 같다.

때문에 기존에 User class를 상속받도록 작성한 것 대신 위에서 작성한 것 처럼 client 속성을 갖고 있는 HttpUser 클래스를 상속받게 하였다.

# locusttest.py
from locust import HttpUser, task, between

class MyUser(HttpUser):
    wait_time = between(5, 15)

    @task(3)
    def task1(self):
        pass

    @task(6)
    def task2(self):
        pass

2) 실행

첫 시도는 단순히 locustfile이 작성된 위치에서 (참고로 해당 파일도 프로젝트의 root directory에 작성하였다.) 실행하였다.

locust -f locust_test.py

결과는 모두 fail이 떴다.

Failures 항목을 보니 어떤 유형의 에러인지 확인 할 수 있었다.

ConnectionError라고 떴다. 생각해보니 가동중인 server가 없는데 어떤 경로로 test를 할수 있을지 의문이 들었고, 테스트 하고자 하는 프로젝트의 서버를 가동하였다. runserver 이후 다시 test 하였다.

python manage.py runserver
locust -f locust_test.py

#1 .all()

테스트 환경은 다음과 같다.

• 총 user : 100명
• 초당 증가하는 user : 5명
• host : http://localhost:8000

locust test 차트양상은 다음과 같다.

test통계와 error상황은 다음과 같다.

100명의 user가 호출하는 상황에서 통신 실패율이 약 90%... 엉망진창 통신 속도는 평균 4468ms를 기록하였다. 내 로직이 부하를 견디지 못한걸로 보여진다.

#2 ~~_related.all()

프로젝트 당시 DB 성능 개선을 위해 작성했던 대로 다시 test를 진행해 보았다. 당시에 초점을 둔 곳은 DB자체를 호출하는 횟수를 줄이기 위함이었다.

아니 대체..;;

test결과통계와 error는 다음과 같다.

#3 멀티스레드 환경에서 실행해보기 (gunicorn)

너무나도 높은 실패율로 인해 redis를 적용하기 전 좀더 개선할 수 있는 방법을 생각하다가. python runserver로 할 시 단일 스레드 환경에서 실행하므로, gunicorn을 사용해 개발환경에 적합한 멀티스레드 환경에서 실행한다. 라는 말이 생각나 이 환경에서 다시 test해보았다.

그러기 위해선 먼저 해당 프로젝트를 gunicorn 환경에 맞게 setting 해주어야 한다.

case1 : user 100명

🥰 깔끔!

case2 : user 100000명

중간에 fail이 심하게 뜨고, 노트북 발열이 너무 심해서 중단! 대략 user 4000명까지 fail 없이 호출되는 것 처럼 보인다. 이후 redis를 사용해 user가 5000명인 상황에서 비교해 보도록 하자!

노트북 성능이라던가 여러가지 추가로 업그레이드가 필요한 부분인거 같다! 욕심이었나!

3) Error

EC2로 서버를 가동하고, DB는 내 로컬 DB로 사용하고자 했을때 다음과 같은 에러가 발생했다.

pymysql.err.OperationalError: (2003, "Can't connect to MySQL server on

이말은 즉, 보안에 의해서 DB가 외부에서부터 접속이 안되기 때문이다. 따라서 VPC 보안그룹까지 모두 설정했던 RDS로 DB를 연결해 주어 테스트를 진행하였다.

4) 추가 사항

gunicorn을 사용해 locust test를 진행할때 환경은 다음과 같았다.

• EC2 로 runserver (gunicorn 사용 / Ubuntu 환경)
• 로컬환경 터미널에서 locust 실행

처음에는 locust 실행도 ubuntu 로 하려 했는데 ip주소를 제대로 변경하지 않아서인지 페이지에 접속이안되었다. 그래서 Ip 주소를 수정하려다가 혹시나 하여 로컬환경 터미널에서 locust를 실행했더니 그래도 잘 연결이 되더라!

이후 runserver 하는 프로젝트 위치와, locustfile의 위치가 달라도 제대로 실행이 될까? 하여 확인해 보았다.

예상 결과 : 어찌되었든 runserver하는 프로젝트로 연결이 될 것이다.

결과 : 정답!

locustfile에 대한 것을 git으로 관리하지 않고자 할때 해당 file들만 따로 폴더에 관리하는 것도 방법일것 같다! (물론 gitignore에 올려도 되긴 하지만)

---------------------------

Redis

그렇다면 Redis는 무엇인가? 하면 다음과 같다.

• Remote dictionary server의 약자로 대용량 처리 관련 기술이다.

Redis에 대한 설명은 이곳에 정말정말 잘 나와있다.! 나도 여기서 참고했다. https://goodgid.github.io/Redis/#redis%EB%9E%80

위의 글을 간단히 요약하자면

Redis는 NoSQL임과 동시에 In-memory솔루션으로 분리되는 Cache솔루션이며, Key-Value 방식의 구현이 가능해 빠른 속도의 데이터 처리가 가능하다. 또한 만료일을 지정하지 않은 이상 영구적인 데이터 보존이 가능하다. (디스크에 데이터를 저장하거나, 다른 서버에 복사본을 남길 수 있기 때문) 따라서 서버가 종료되고 다시 가동이 되어도 그대로 데이터를 유지할 수 있다.

MySQL과 비교하면 약 10배 빠른처리 속도를 자랑한다! 따라서 기존에 MySQL로 작성된 DB성능을 업그레이드하는데 Redis를 사용하는 것이다. (내 모든 프로젝트들은 모두 MySQL로 작성되었다.)

django에서 cache 세팅하기

내용은 RealPython 문서를 참고했다. 가상환경에서 pip install redis로 설치해준뒤 Django에서도 redis를 사용할 수 있도록 pip install django-redis도 설치해 준다.

그리고 나서 my_settings.py에 기존에 DB에 대한 정보만 있던것에 Cach에 대한 정보도 기입해준다.

#my_settings.py
CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/1",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient"
        }
    }
}

loadtest로 호출 속도 확인하기

🔥 기존의 로직은 불러오는 데이터가 너무 많아 빠르게 테스트 결과를 확인하기에 적합하지 않다고 판단하여 로직을 간단하게 수정하였다.

수정한 로직은 다음과 같다. db에 저장된 posting들 중 게시글의 'content'만 가져오도록 한다. 기억으론 한 40여개 정도의 데이터가 있던걸로 기억한다.

이 상태에서 Loadtest를 통해 100명의 user가 있다는 전제 하에 호출 속도를 확인해 보았다.

결과 : 약 8.7초

이후 cache를 적용해 수정한 뒤 loadtest로 호출 속도를 확인하였다. 이때 django에서 제공해주는 cache를 import 하면 된다.

똑같이 100명의 user가 있다는 조건에서 test해보았다.

결과 : 약 0.5초

1) loadtest 결과

django-redis를 통해 caching을 적용한 결과 호출 속도가 10배 이상 빨라진걸 확인할 수 있었다.!

2) locust 결과

locust를 이용해서도 결과를 확인해보고자 하였고 이때는 원래의 로직 그대 (두개의 외부 class를 각각 inner join과 outer join하는 값 있음)로 하려고 했다. 하지만 제대로 된 test인지도 파악이 안되는 상태에서 다음과 같은 에러가 자꾸 발생하면서 실패율이 90프로가 나왔다... cache를 사용해도ㅠㅠ

django.db.utils.OperationalError: (1040, 'Too many connections')

이는 MySQL 자체에서 처리 가능한 connection의 수를 넘겼다는 말 이라던데 일단 그래서 User가 100명이 아닌 50명인 경우로두고 test 하였을땐 cache를 사용하지 않아도 모두 성공적인 호출을 불러왔고 rmp차이도 cache를 사용했을때와 사용하지 않았을때 변화가 없었다.

그래서 test용으로 작성한 간단한 로직으로 다시 test해 보았다. 100명일 경우 cache를 사용하지 않아도 fail이 뜨지 않았기에 user를 200명으로 가정하고 test를 진행하였다.

redis 사용 전

호출 속도 : 1693ms

redis 사용 후

호출 속도 : 5ms

결과적으로 호출 실패도 없어졌고, 호출 속도도 향상했을음 확인할 수 있었다!!!

---------------------------

끝 🔥

django에서 redis를 사용하기 위해선 django의 cache를 꼭 import 해준다는 개념이 아직은 이해가 잘 안된다. 또한 cache로 메모리에 저장된 데이터를 확인하는 방법을 알고자 하였는데 redis-cli에 접속이 잘 안되서 확인하지 못했다! 데이터는 만료기한이 있거나 임의로 삭제해 주지 않는 한 계속 저장된다고 해서 cache.delete('posts') 로직이 실행되도록 해주었는데 제대로 삭제가 되었는지는 모르겠다.

좀더 공부해서 저장된 cache를 확인해 보도록 하자!

Web

1세대 : 정적인 웹

• HTML과 CSS로만 구성된 웹.
• 사용자와의 interaction은 불가능 하고 단지 정보 전달의 용도로 사용되었다.

2세대 : 동적인 웹

• Javascript의 사용으로 Server로부터 필요한 데이터터를 주고받을수 있는 동적인 사용이 가능해 졌고, 사용자와의 interaction이 가능해졌다.
• 🔥 그러나 JS는 "일부"에서만 사용되었고, HTML과 JS에 대한 데이터를 하나의 서버에서 모두 전송해주는 형태였다. (구분 X)

3세대 : SPA (Single Page Application)

• SPA의 개념의 등장. 즉, 하나의 Page로 전체 사이트를 구현할 수 있게 되었다.
• 또한 HTML태그 자체를 JS가 동적으로 생성할수 있게 되었고 HTML/JS부분과 data 부분이 구조적으로 분리되면서 FrontEnd와 BackEnd가 구별되기 시작했다.
• 이후 FE에서는 좀더 효율적인 Framework 혹은 Library들이 많이 탄생했다.

Modern Web

• 규모가 커진 형태 (사용자와의 Interaction 중요성 증가 + 웹 서비스의 복잡성 증가 + 사용자 수, data의 양 증가) => 때문에 시스템 부하(동시접속자, 방대한 데이터의 양)와관련된 문제들이 발생했고 이를 해결하기 위해 System architecture가 발전했다.
• FE 서버와 BE 서버의 분리 발생

-------------------------------

CSR vs SSR

1. CSR

CSR은 Client Side Render라는 뜻으로 Cleint측에서 RENDERING 되는 형식이다.

여기서 또 하나 필요한 개념으로 CRA가 있다.

CRA (Create React App)

완전 Front 영역. 나는 아무것도 알지 못한다. 그치만 개념은 이해할수 있지. 나는 지성인이니까
"아무런 초기 설정이 없어도 CRA를 통해 React 기반의 SPA 사이트를 구현할 수 있다."
즉, React를 통해 app을 만듬으로써 초기설정 없이 빠르게 결과물을 만들어낼수 있다는 개념이다.
그러나 CRA 방식으로 build한 프로젝트는 검색에 잘 걸리지 않는다

그 이유는 CRA를 통해 만들어진 project는 오직 CSR(Client Side Render)로 실행되기 때문이다.

** CSR방식에서 구글봇의 작동법 ** 말그래도 Cleint 측에서 rendering이 됨을 듯한다. 웹 페이지에 접속하면 HTML, JS, CSS확장자의 file이 차례로 응답된다.

• 제일 먼저 응답된 HTML 파일에 의해서 내용이 비어있는 웹 페이지가 형성된다. (안에 data 없음)
• 🔥 구글로 예를들면 구글봇이 웹 페이지를 분석해 해당 페이지의 data정보를 알아낸다. BUT 내용없음! 정보 획득 X
• 이후 응답된 JS 파일의 다운로드가 완료되고 JS 파일이 dom을 비어있는 HTML에 그려진다 (RENDERING)
• 이미 구글봇은 떠난 후..

CSR을 사용함으로써 장점도 있다.

1. BackEnd 호출을 최소화 할 수 있다
   • 최초 호출 시에만 HTML과 JS, CSS를 요청하고 이후엔 요구되는 데이터 만큼만 통신한다. (by JSON)
2. routing (라우팅, 새로운 페이지로 이동하는 것) 을 하더라도 HTML의 변화는 X! JS가 새로운 페이지를 그려낸다.

자투리 정보 : SEO (Search Engine Optimization)

SEO란 웹 페이지 검색엔진이 자료를 수집하고 순위를 매기는 방식에 맞게 웹 페이지를 구성해서 검색 결과의 상위에 나올수 있도록 하는 작업을 말한다.

출처 : wikipedia

커머스 사이트와 같은 "검색"이 곧 매출과 직결되는 사업분야의 경우 SEO 성능이 매우매우 중요하다!

2. SSR

이와 달리 SSR은 Server Side Render라는 뜻으로 Server에서 RENDERING이 되어 응답을 보내는 형식이다.

** SSR방식에서 구글봇의 작동법 ** 이미 Rendering이 되어 FE에 보내지는것!

• 응답된 HTML파일에 Rendering된 JS의 내용이 채워진 채 웹 페이지가 형성된다.
• 🔥 구글봇이 해당 웹 페이지에 존재하는 data의 정보를 수집한다. => 검색에 걸리는 효과!

SSR이 나오게 된 계기는 "SPA의 형식을 지키면서도 검색에 자주 노출되게 하기 위한 방법"을 찾았던 점이다. 즉, SPA도 챙기면서 SEO까지 챙기기 위한 방법으로 나온것이 SSR 방식이다.

SSR의 장점

위에서 말했듯 CSR방식에 비해 SEO 측면에서 유리하다 => 검색엔진에게 보여줄 data를 마련할 수 있다.

또한 전체적으로 사용자에게 보여주는 콘텐츠 구성이 완료 되는 시점이 더 빠르다. 비록 CSR방식에 비해 페이지를 구성하는 속도는 느려지지만 !

SSR의 주의점

Server 측에서 rendering되어 data가 전해지기 때문에 페이지를 잘못 구성할 경우 CSR에 비해 서버 부하가 더 크고, 때문에 첫 로딩이 매우 느려질 수 있다

-------------------------------

MPA vs SPA

1. MPA

MPA란 Multi Page Application이라는 뜻으로 말그대로 "여러장의 페이지"로 구성된 application을 뜻한다.

현재 우리가 사용하고 있는 "사이트"하나를 생각해보면 해당 사이트가 "한 페이지"로 구성된건 아니라고 생각한다! (당장 구글만 봐도 검색창, 검색 후 창 등.. 페이지가 진짜 많아 보인다)

하지만 이러한 구성이 모두 MPA인것은 아니다. 이후에 나올 SPA에서 다루도록 한다.

다시 MPA로 돌아가서 말하면 MPA는 정적 웹사이트로 구현된 HTML 파일이 여러개 존재하고, 페이지간 이동하면서 화면이 깜빡이는걸 볼 수 있다. (서로 다른 HTML 파일로 이동됨)

2. SPA

SPA란 Single Page Application이라는 뜻으로 "하나의 페이지"로 구성된 application을 뜻한다. 즉, 하나의 HTML 파일로 구성되어 있다는 뜻.

그렇다면 우리가 보는 "페이지 간의 이동"은 어떻게 SPA로 설명할까??

바로 JS에서 HTML 태그를 생성해 내기 때문에 SPA구조가 될수 있기 때문이다. 즉, 페이지를 이동하게 되면 기존에 있던 HTML 파일에 JS의 특정함수로 생성된 새로운 HTML 태그들로 채워진다는 것이다. 때문에 페이지간 이동시 화면이 깜빡이지 않는다.

-------------------------------

MPA & SPA & CSR & SSR ?

그렇다면 현재 웹 기준으로 네가지의 관계성은??

현재웹 기준으로 한다면 SSR은 SPA로 구성된 SSR방식을 뜻하며, 이에 따라 SPA형식의 결과물은 CSR과 SSR방식으로 나뉜다!

CSR + SSR

가능하다! 효율이 더욱 높아지는 방법인데 이를 위한 모듈 하나 없을까. 바로 "Next.js"와 같은 훌륭한 framework들이 이미 존재한다.

더 자세한 개념은 지금상태보다 더 깊은 FE지식을 요하기 때문에 일단 "가능하다"라는 것!!

자투리 정보 : hydration

hydration이란 **Server에서 전송한 `정적 문서`를 데이터 변경에 반응할 수있는 `동적 형태`로 변환하는 _클라이언트 측 프로세스_**를 뜻한다.
이는 render와 동일하지만, dom이 이미 그려져 있는 상태이기 때문에 event listener만 부착하는 식으로 작동한다.

-------------------------------

끝!

BE로 공부하고 있는 지금 React나 dom에 대한 개념은 잘 모르지만 SSR과 CSR에 따른 SEO효율의 차이와 기존의 문제점을 극복하기 위해 현재 사용하는 방식 (SSR + CSR)에 대해서 알수 있었다.! 🥰

** - 객체 지향 프로그래밍 : OOP (Object-Oriented Programming)** ** - 절차 지향 프로그래밍 : POP (Procedure-Oriented Programmin)** ** +) 함수형 프로그래밍 **

객체 지향 프로그래밍 (OOP)

객체 지향 프로그래밍이란 개념은 1960년대에 나타났다. "모든 데이터를 객체(Object)로 취급하고 처리 요청을 받은 객체가 자기 안에 있는 기능을 가지고 처리한다."

이렇게 탄생한 OOP는 캡슐화 / 상속 / 다형성 의 특징을 갖고 있으며 모듈 재사용이 가능해 확장 및 유지보수에 상대정으로 용이하다. (자세한 특징은 아래에 추가)

클래스 기반 객체 지향 프로그래밍

객체지향 프로그래밍을 따르는 언어는 대표적으로 Java나 Python, C++ 이 있다. 특히나 python에서 이제껏 내가 사용했고 흔히들 사용되는 방법은 클래스 기반의 객체지향 프로그래밍 기법이다.

객체와 관련된 코드를 분리할 수 있게 하는 것이 객체 지향 프로그래밍의 핵심이다. 이때 코드를 더욱 효율적으로 관리하기 위해 클래스 라는 구조가 탄생한 것이다. 즉, 클래스는 객체를 조금 더 효율적으로 생성하기 위해 만들어진 구문이다!

** class, object, instance ** object와 instance는 지칭하는것의 상태에 따라 구분된다.

• Class: 같은 종류의 집단에 속하는 attribute(속성)과 behavior(행위)를 정의한 것.
• Object : 클래스의 정의대로 만들어진 실체.
• instance : class에 의해서 만들어진 객체(object). 객체가 메모리에 할당된 것. "인스턴스<객체"로 볼 수 있고, 각각의 인스턴스들은 독립적이다.
  >
• 객체가 메모리에 할당되어 실제 사용될 때 인스턴스라고 한다.* 즉 인스턴스는 객체에 포함된다고 볼 수 있다.

1. OOP의 특징

위에서 말했듯 객체지향 프로그래밍에는 캡슐화 / 상속 / 다형성 이라는 특징이 있는데 이 외에도 몇가지 특징이 더 있다.

참고 자료 : wikipedia

1) 자료 추상화

자료추상화는 "불필요한 정보는 숨기고 중요한 정보만을 표현함으로써 프로그램을 간단히 만드는 것"_이다. 이런 방법을 통해 정의된 자료형을 추상 자료형이라고 하는데 _"추상 자료형은 자료형의 자료 표현과 자료형의 연산을 캡슐화한 것으로 접근 제어를 통해서 자료형의 정보를 은닉할 수 있다"

객체 지향 프로그래밍에서는 일반적으로 다음과 같이 정의한다.

• 추상 자료형 : 클래스
• 추상 자료형의 instance : 객체
• 추상 자료형에서 정의된 연산 : 메소드(함수)
• 메소드의 호출 : 생성자

2) 상속&다중상속

상속은 "새로운 class가 기존 class의 자료와 연산을 이용할수 있게 하는 것" 으로 다중상속은 "class가 2개 이상의 class로부터 상속받게 하는 것" 을 의미한다.

** 다중상속 지원 언어 ? ** python 의 경우 다중상속이 가능하지만 JAVA는 지원하지 않는다.

3) 다형성

다형성 이란 "어떤 한 요소에 여러 개념을 넣어 놓는 것으로 오버라이딩 혹은 오버로딩을 의미한다."

** 오버라이딩 / 오버로딩 ? **

오버라이딩이란 상속 관계에 있는 부모 클래스에서 이미 정의된 메소드를 자식 클래스에서 같은 시그니쳐를 갖는 메소드로 다시 정의하는 것. 오버로딩이란 서로 다른 시그니처를 갖는 여러 메소드를 하나의 이름으로 정의하는 것.

시그니쳐 ? 메소드의 정의에서 메소드 이름과 매개변수 리스트의 조합을 의미한다.

다형 개념을 통해서 프로그램 안의 객체 간의 관계를 조직적으로 나타낼 수 있다.

4) 동적 바인딩

동적 바인딩이란 실행 시간 중에 일어나거나 실행 과정에서 변경될수 있는 바인딩으로 프로그램의 한 개체나 기호를 실행 과정에 여러 속성이나 연산에 바인딩함으로써 다형 개념을 실현하는 것이다.

컴파일 시간에 완료되어 변화하지 않는 정적 바인딩과 대비된다.

** 바인딩 ? ** 바인딩이란 프로그램의 어떤 기본 단위가 가질 수 있는 구성요소의 구체적인 값, 성격을 확정하는 것을 의미한다.

동적바인딩을 나타내는 대표적인 예시가 인터프리터 언어인 Python이다.

# python 예시
a = 123

python의 경우 변수의 자료형을 미리 선언하지 않고 실행시간에 변수의 자료형을 결정한다. 그 외에 a는 변수명, 123은 변수의 자료값 으로 할당, 즉 "바인딩" 된다.

함수의 동적 바인딩은 실행파일을 만들 때 호출할 함수의 메모리 주소가 확정되지 않고 보류 상태로 있다가 이후 실제 실행 시간에 호출할 함수의 주소가 결정 된다. 때문에 주소를 저장할 공간을 미리 확보해야 한다.

보통의 가상 함수들이 "동적 바인딩"을 구현하는데 실행 될지 안될지 확정되지 않은 함수를 위해 저장공간을 미리 마련해야한다는 점 때문에 메모리 관리에 있어선 비효율적일 수 있다.

가상 함수 ? 객체 지향 프로그래밍에서 가상 함수는 상속하는 클래스 내에서 같은 시그니처의 함수로 오버라이딩 될 수 있는 함수 또는 메소드이다. OOP의 다형성에서 중요한 부분이다

출처 : wikipedia

2. OOP를 쓰는 이유?

wikipedia의 말이다. 읽으면서 아! 그렇구나! 싶었다.

소프트웨어 공학의 관점에서 바라볼때 SW의 질을 향상시키기 위해선 강한 응집력과 약간 결합력을 지향해야 한다. OOP의 경우 class를 이용해 모아둔 data를 사용함으로써 응집력을 강화하고, class간 독자적인 존재로 결합력을 약하게 한다. 때문에 OOP를 지향하는 것이라고 생각한다!

------------------------

함수형 프로그래밍

함수형 프로그래밍이란 자료 처리를 수학적 함수의 계산으로 취급하고 상태와 가변 데이터를 멀리하는 프로그래밍 패러다임의 하나이다. 즉, 프로그램은 함수의 계산이라고 프로그래밍을 정의하며 명령형 프로그래밍에서는 상태를 바꾸는 것을 강조하는 것과 달리 함수형 프로그래밍에서는 함수의 응용을 강조한다.

이와 관련하여 언어의 종류도 함수형인지 명령형인지 나눌 수 있다.

** 명령형 언어 ? ** 명령형 언어는 식의 값이 부분식의 계산 순서에 의존적이게 되어 이로 인해서 부작용이 발생할 수 있다. 또한 함수의 호출 순서에 종속적인 특징을 갖는다.

** 함수형 언어 ? ** 함수형 언어는 독립적인 변수를 사용한다. 따라서 입력값이 같으면 항상 같은 결과값을 반환한다.이러한 점을 들어 함수형 언어는 참조투명성이 있다고 할수 있다. 참조투명성의 보장으로 인해서 함수형 언어는 간결하고 이해하기 쉬운 특징을 가지며 프로그램의 형식적인 분석과 조작이 용이하다.

함수형 언어만 함수형 프로그래밍이 가능한 것은 아니다. 명령형 언어에는 대표적으로 python과 C++이 있다. 그치만 나도 사용했고, 많은 이들도 python으로 함수형 프로그래밍을 구현하고 있다.

이처럼 함수형 언어로 별도로 설계되지 않은 언어도 함수형 프로그래밍이 가능하다

1. 함수형 프로그래밍의 장점

명확한 장점이 두가지 있다.

1) 코드의 용도를 구분할 수 있다.

2) 코드를 재사용 할 수 있다.

함수형 프로그래밍에 관한 내용 추가중

프로젝트 명 : jellogram

Docker

Docker에 대한 전반적인 이해를 쉽게 해주었던 글이 있다!! 모두 읽어보시는걸 추천드립니다. https://khj93.tistory.com/entry/Docker-Docker-%EA%B0%9C%EB%85%90

아래 개념적인 내용은 해당 게시글을 읽고 정리한 글이다.

1. Docker 란?

Docker는 가상화 기술이다. 이 기술은 Docker라는 회사가 개발한 container virtualization으로 해당 기술품은 기존에도 많이 존재했지만 Docker가 많이 사용되면서 사람들이 container virtualization 기술을 아예 Docker라고 부르게 되었고 Docker = container virtualization 로 고착된 것이다. 원래는 그런 의미가 아님! 상처에 붙이는 밴드를 흔히들 "데일밴드"라고 부르는 거랑 같은 격이다

Docker를 이용하면 container 가상화 실행 환경 위에 application 배포 엔진을 추가하여 언제 어디서든 코드가 실행될수 있도록 제공한다. 이점을 이용해 요즘엔 MSA나 CI/CD 와 함께 사용되는데 때문에 하나의 container당 하나의 application이나 프로세스를 실행하는 것이 권장된다.

VM (Hypervisor) VS Container 가상화 (Docker)

_사진 출처 : https://khj93.tistory.com/entry/Docker-Docker-%EA%B0%9C%EB%85%90 _

좌측이 VM 모식도 이고 우측이 container 가상화 모식도이다.

** VM ? ** 하나의 물리적 시스템에서 각각 자체 운영 체제(OS)와 application을 운영할수 있다. 단, VM은 서로에 대해서 알지 못하고, host의 OS도 알지 못한다. (완전 독립적!) 때문에 실제 하드웨어간의 조정을 위해 "hypervisor"라고 불리는 경량 소프트웨어 계층이 필요하다. hypersivor 계층이 VM을 각각 분리하여 서로간에 간섭을 막는다.
<대표 장점>

• 물리적 서버의 리소스를 더 효율적으로 운용할 수 있다. : 한 서버에 한 OS가동시 낭비되는 리소스(CPU, 메모리, 스토리지 등..) 가 존재하지만 한 서버에 여러개의 OS를 가동하면 idle상태로 낭비시키지 않고 필요한 OS에 리소스(예를 들면 CPU)가 할당되어 효율적인 운용이 가능하다. / 중저가의 하드웨어 여러개를 운용하는 것보다 고가의 하드웨어로 한 서버에 여러개의 OS를 운용하는것이 더욱 효율적이다.

정리하자면 Host OS엔진 위해 가상화를 시키기 위한 Hypervisor 엔진, 그리고 그 위에 Guest OS를 가동시키는 것과 달리 컨테이너 기반 가상화는 Docker 엔진 위에 Application 실행에 필요한 바이너리만 올라가게 된다. 때문에 OS위의 OS동작으로 인해 속도가 느린 VM에 비해 성능의 효율이 더 뛰어나다는 장점이 있다.

container를 사용한다는 것은 VM을 생성하는 것이 아니라 Host OS가 사용하는 리소스를 분리하여 여러 환경을 만들 수 있도록 하는 것이다.

2. Docker의 구조

4가지 부분으로 구성되어 있다.

• client와 server(=docker engine)
• image
• registries
• containers

1) cilent와 server

여기서 server는 docker의 engine이라고도 불린다. 둘은 같은 Host이거나, 혹은 다른 Host일때도 함께 운용될 수 있다.

2) image

Dockr의 이미지를 그림으로 표현하면 다음과 같다.

해당 이미지에 저장된 값을 토대로 환경이 셋팅되는것인데 해당 image에는 container를 실행할 수 있는 실행파일, 설정값 등을 갖고 있다.

이 이미지를 활용해 배포한다면 프로젝트에 필요한 환경까지 모두 공유가 가능해지는 것이다. 단순히 서버와 DB를 공유하는것에서 끝나는것이 아닌! 세팅까지!

3) registries

docker의 image를 저장하는 repository이다. (=Githup의 repo)

4) contaiers

docker의 Image를 실행시키는 가상화 공간이다. 원래 docker container는 두개 이상의 프로세스를 실행 할 수 있지만 권장사항에서는 하나의 container당 하나의 process만 실행하는것을 권장한다.

------------------------

Docker 사용하기 연습 ver.

Step 1. Docker 설치

나의 경우 MacOS이기 때문에 Docker 사이트에서 프로그램을 다운로드 하였다. https://docker.com

EC2 에서 Docker 설치하기

EC2는 Ubuntu 운영체제이다! 따라서 프로그램 설치가 아니라 terminal에서 명령어를 입력해 설치를 진행해 주어야 한다. 이후 진행할 예정

Step 1-2. Docker 목록 확인

먼저 지난번에 실습하면서 Docker image를 만든적이 있다 해당 Docker는 이용중지상태인데 가동시키지 않은 상태에서 현재 실행중인 컨테이너와 실행이 종료된 상태의 컨테이너 목록을 살펴보자

# 실행중인 container 목록
docker ps

# 실행종료된것 포함 모든 container 목록
docker ps -a

# 생성&다운로드 된 image 목록
docker images

# 모든 image 목록
docker images -a

명령문을 살펴보면 -a 라는 의미가 all 같다!

내 터미널에 명령어를 입력하면 다음과 같다.

그때 docker_train 이라는 이름으로 생성했었다

Step 2. Docker file

Docker file에 대한 개념을 잡아야 한다. 이는 image 생성의 출발점으로 image를 구성하기 위한 명령어들을 작성하여 image를 구성할 수 있다. 즉, Docker File을 읽을 수 있다면 해당 Image가 어떻게 구성되어 있는지 알 수 있다.

따라서 Docker File을 작성해서 image를 생성하도록 한다

#./Dockerfile
FROM python:3
#기반이 될 이미지

# 작업디렉토리(default)설정
WORKDIR /usr/src/app

## Install packages
#현재 패키지 설치 정보를 도커 이미지에 복사
COPY requirements.txt ./
#설치정보를 읽어 들여서 패키지를 설치
RUN pip install -r requirements.txt

## Copy all src files
#현재경로에 존재하는 모든 소스파일을 이미지에 복사
COPY . .


## Run the application on the port 8080
#8000번 포트를 외부에 개방하도록 설정
EXPOSE 8000


#CMD ["python", "./setup.py", "runserver", "--host=0.0.0.0", "-p 8080"]
#gunicorn을 사용해서 서버를 실행
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "docker_train.wsgi:application"]

Step 2-2. dockerignore

gitignore와 같이 dockeringore도 작성해서 이미지 작성시 이미지에 들어가지 않을 내용을 선별할 수 있다.

# vi dockerignore

npn-debug.log
Dockerfile*
docker-compose*
.dockerignore
.git
.gitignore
.vscode

# 그 외 추가할 사항등 입력 후 :wq

Step 3. 이미지 빌드하기

위에서 Docker File을 작성하였다면 해당 file이 있는 위치에서 다음의 명령어를 입력한다

docker build -t [만들려는 이미지 이름]

# 권장 방식
docker build -t [도커허브에 가입한 계정명/이미지명(프로젝트명을 권장한다)] : [버전(0.0.0 이런형태 권장)]
ex) docker build -t chyun403/docker_train:0.1.0

Step 4. 빌드된 이미지 실행시키기

docker run --name '컨테이너 명' -d'데몬으로 실행하기 위한 옵션' -p '호스트 포트':'컨테이너 포트' '이미지명'
ex) docker run --name docker_train -d -p 8000:8000 chyun403/docker_train:0.1.0

Docker Flow

명령어를 통해 Docker의 pull부터 실행까지 방법에 대한 것이다. 참고한 사이트에 더 많은 명령어들이 있다! 출처 : khj93.tistory

1)Docker image pull

docker pull [이미지 이름]

2)Docker image list 확인

docker images

참고로 이미 빌드된 이미지로 컨테이너에서 실행이 되고있다면 해당 컨테이너를 먼저 삭제한 후 이미지 삭제가 가능하다.

3) Docker image 삭제하기

docker rmi [이미지 이름]

4) Docker image push

docker push [레지스트리url/이미지:버전]

5) Docker image로 컨테이너 실행시키기

docker run <옵션> <이미지 이름, ID> <명령> <매개변수>

docker run --name [컨테이너이름] -d [데몬으로 실행하기 위한 옵션] -p [호스트 포트]:[컨테이너 포트] [이미지이름]

# 예시 
docker run --name [컨테이너이름] -v [호스트경로]:[컨테이너경로] -p [호스트포트]:[컨테이너포트] -d 이미지:버전

------------------------

Docker 실행하기 실습 ver.

진행할 프로젝트 : jellogram server : nohup으로 gunicorn을 이용해서 가동 (Ubuntu)

1) Dockerfile 작성

#./Dockerfile
FROM python:3
#기반이 될 이미지

# 작업디렉토리(default)설정
WORKDIR /usr/src/app

## Install packages
#현재 패키지 설치 정보를 도커 이미지에 복사
COPY requirements.txt ./
#설치정보를 읽어 들여서 패키지를 설치
RUN pip install -r requirements.txt

## Copy all src files
#현재경로에 존재하는 모든 소스파일을 이미지에 복사
COPY . .


## Run the application on the port 8080
#8000번 포트를 외부에 개방하도록 설정
EXPOSE 8000

#CMD ["python", "./setup.py", "runserver", "--host=0.0.0.0", "-p 8080"]
#gunicorn을 사용해서 서버를 실행
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "jellogram.wsgi:application"]

2) Dockerfile을 기반으로 이미지 빌드하기

docker build -t chyun403/jellogram_g:0.1.0 .

Dockerfile에 입력한 대로 [n/5]만큼 설치되는걸 확인할 수 있다.

2-1) 이미지 목록 확인

❯ docker images -a
REPOSITORY              TAG       IMAGE ID       CREATED         SIZE
chyun403/jellogram_g    0.1.0     2ed9fab3474a   9 minutes ago   1GB
chyun403/docker_train   0.1       0a40a7b73545   2 months ago    932MB

3) 빌드된 이미지 실행하기 : Container

docker run -d -p 8000:8000 --name kch chyun403/jellogram_g:0.1.0

** -d **

gunicorn으로 서버를 가동시켰을때 background에서도 가동하기 위해 nohup을 사용했었다! 여기서 입력한 명령어 중 -d는 데몬화 한다는 의미로 백그라운드에서 서버를 가동하도록 한다는 의미이다. 즉, docker안에 있는 gunicorn 설정이 백그라운드에서도 가동되도록 하겠다는 의미이다. (docker 프로세스 자체가 백그라운드에서 실행되는 의미가 아님!)

** -p **

port forwarding이라는 의미이다. Dockerfile에서 EXPOSE 8000으로 입력해주었는데 이는 내가 띄울 Docker 서버에 8000 포트를 연다는 의미이다. -p @@@@:#### 에서 앞 @는 내 컴퓨터에서 호출하는 포트번호 이고 뒤 #은 가상환경이 받아들이는 포트번호이다. 따라서 Dockerfile에 설정한 대로 8000은 뒤 #에 입력되어야 하고, 만약 내 컴퓨터에서 이미 포트번호 8000번을 사용한다면 다른 번호를 지정해서 앞 @에 입력해 주면 된다.

만약 -p 9000:8000 이라면 내 컴퓨터에서 포트번호 9000으로 호출하면 가상환경의 포트번호 8000으로 들어가게 된다는 의미이다.

** --name [컨테이너이름] **

원래 docker에서 랜덤하게 의미없는 이름으로 '_'로 구분하면서 자동으로 지정해준다. (왜냐면 나중되면 docker OS 를 진짜 많이 만들어야 하는데 그때마다 naming하기가 버겁기 때문)

< random 하게 이름 생성 됐을 경우 >

docker run -d -p 8000:8000 chyun403/jellogram_g:0.1.0

<내가 이름을 지정해주었을 경우>

docker run -d -p 8000:8000 --name jello0512 chyun403/jellogram_g:0.1.0

참고로 --name [컨테이너 명]의 위치는 무관하다 따라서 다음의 명령어도 똑같이 기능한다.

docker run --name jello0512 -d -p 8000:8000 chyun403/jellogram_g:0.1.0

3-2) 실행되고 있는 container 목록 확인

❯ docker ps -a
CONTAINER ID   IMAGE                        COMMAND                  CREATED         STATUS                    PORTS                    NAMES
08fdf94dae7c   chyun403/jellogram_g:0.1.0   "gunicorn --bind 0.0…"   2 minutes ago   Created                   0.0.0.0:8000->8000/tcp   jello0512
3958fbd0aff0   chyun403/jellogram_g:0.1.0   "gunicorn --bind 0.0…"   4 minutes ago   Created                   0.0.0.0:8000->8000/tcp   angry_heyrovsky
d65e82315f3f   chyun403/docker_train:0.1    "gunicorn --bind 0.0…"   2 months ago    Exited (0) 2 months ago                            docker_train

4) 통신으로 확인하기

Docker를 통해 background에서 gunicorn으로 서버가 가동되는것 까지 세팅되도록 했다! 바로 통신으로 확인해 본다.

# 실행 명령어
❯ docker run -d -p 8000:8000 --name jellogram chyun403/jellogram:0.1.0

컨테이너 생성 확인

postman으로 확인

🐳 docker 실행 ~ 통신확인 ~ docker 종료

🔥 에러 발생

이미지를 빌드하고 빌드한 이미지를 실행시키고자 하면 다음과 같은 에러가 발생했다.

docker: Error response from daemon: OCI runtime create failed: container_linux.go:367: starting container process caused: exec: "gunicorn": executable file not found in $PATH: unknown.

말그대로 gunicorn이 없다고 하는것 같은데 구글링도 하면서 혹시몰라 requirements.txt를 확인해보았다.

gunicorn이 없었다. ....

처음엔 container만 삭제하고 gunicorn을 requirements.txt에 추가한 뒤다시 실행하면 될거라 생각했지만 같은 에러가 발생했다.

다시 생각해보니 이미지를 만든 그 시점에 대한 환경으로 계속해서 같은 실행이 반복되었던 것 때문에 환경이 변한다면 변화할때마다 이미지를 새로 생성해 주어야 한다

기존의 컨테이너와 이미지를 모두 삭제한 후

• requirements.txt에 gunicorn 추가
• 새로 이미지 빌드
• 빌드된 이미지 실행

을 진행하였고 postman으로 통신을 확인할 수 있었다.

통신까지 확인한 후에는 컨테이너 실행을 종료 시켜주었다 (삭제 아님!)

------------------------

EC2에서 Docker 실행하기

EC2는 우분투! 우분투 명령어를 사용해 내 환경에 docker를 설치해준다. 가상환경 켜.. 제발..

sudo apt update
sudo apt install apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"
sudo apt update
apt-cache policy docker-ce

sudo apt install docker-ce

참고로.. 마지막 명령어 직전까지 또 base 에서 해버렸다. 인간은 똑같은 실수를 반복한다지...

이후 혹시나 싶어서 MacOS에서 만들었던 container를 start해보려니 그런 container는 없다고 한다.

따라서 imgae build부터 다시 실행해 준다.

이후 docker run으로 실행시켜 새로운 container를 생성후 통신으로 확인한다!

🔥 참고로 http://localhost:8000 으로 통신해도 값은 나오더라!

------------------------

끝!

확실히 혼자서 진행해보니 Docker를 어떻게 사용하는지, 왜 사용하는지, 사용했을때의 효과로 무엇이 있는지 좀더 느끼기 쉬웠다!

가상환경을 셋팅해줄 필요가 없다는것. pip install -r이 필요가 없으니! 또한 그때그때 OS에 맞춰 번역까지 해주니 OS에 제한되는것 없이 업데이트가 가능하다는 점. 등 Docker에 대한 기본적인 개념을 알 수 있었다.

이후 프로젝트를 진행하면서 새로운 모듈을 더 설치하게 될텐데 주기적으로 docker로 배포를 진행하면서 관리해보도록 하자!

먼저 처음 시도한 것은 postman으로 계속 test하면서 form-data의 key에 또다른 'filename'이라는 키값을 지정한 것이었다.

결과는 실패. 두개의 사진 중 두번째로 들어간 7clock.jpeg만 업로드 되었다.

list로 받기

위 문제를 해결하기 위해 가장 먼저 떠오른 것은 해당 값을 list로 받는것. list속 객체 형태로 받아야 할것 같다. 먼저 처음 들어온 이미지의 key이름이 filename이었는데 이를 filename1로 변경하고 이후 하나씩 늘어날때마다 숫자도 늘려주도록 해보자.

=> 이렇게 하는게 프론트에서도 기능이 될지 모르겠다! 이미지를 업로드할때마다 숫자가 하나씩 증가되게 키값을 설정하는게 되지..않을까...?

일단 백엔드 로직에서 이를 해결하기 위해선

[f'filename{i} for i in range(1, len(request.FILES)+1)']

대충~~ 이런식으로 진행해야 될것 같다.

1차 시도

for i in range (1, len(request.FILES)+1):
  file = request.FILES[f'filename{i}']
  url_generator = str(uuid.uuid4())
  s3_client.upload_fileobj(
    file,
    # 이하 생략

먼저 업로드된 이미지가 2개일때 request.FILES로 들어온 값을 확인해 보았다.

성공...😳

RDS와 S3를 모두 확인해 보았다.

굿!

반복문을 이용해 하나씩 순차적으로 저장해 주는 방법을 택했는데 다행히 잘 작동하였다.

혹시 이후에 반복문 말고 같은 키값으로 저장하는 방법을 알게된다면 내용을 추가하겠다!