❓
물음표살인마 블로그
  • README
  • ALGORITHM
    • Sieve of Eratosthenes
    • Lcm, Gcd
    • Sorting Array
    • Round Up
    • Binary Search
    • Union Find
  • Books
    • CS Note for Interview
      • Ch1. Design Pattern & Programming paradigm
        • 1.1.1 Singleton Pattern
        • 1.1.2 Factory Pattern
        • 1.1.4 Observer Pattern
        • 1.1.5 Proxty Pattern & Proxy Server
        • 1.1.8 Model-View-Controller Pattern
        • 1.2.1 Declarative and Functional Programming
        • 1.2.2 Object Oriented Programming
      • Ch2. Network
        • 2.2.1 TCP/IP Four-Layer Model
        • 2.2.1-1 TCP 3, 4 way handshake
        • 2.3 Network Devices L4, L7
        • 2.4.1 ARP, RARP
        • 2.4.2 Hop By Hop Communication
        • 2.4.3 IP Addressing Scheme
      • Ch3. Operating System
        • 3.1.1 Roles and Structure of Operating Systems
        • 3.2.1 Memory Hierarchy
        • 3.2.2 Memory Management
        • 3.3.1 Processes and Compilation Process
        • 3.3.3 Memory Structure of a Process
        • 3.3.4 Process Control Block (PCB)
        • 3.3.5 Multiprocessing
        • 3.3.6 Threads and Multithreading
        • 3.3.7 Shared Resources and Critical Sections
        • 3.3.8 Deadlock
        • 3.4 CPU Scheduling Algorithm
      • Ch4. Database
        • 4.1 Database Basic
        • 4.2 Normalization
        • 4.3 Transaction and Integrity
        • 4.4 Types of Databases
        • 4.5 Indexes
        • 4.6 Types of Joins
        • 4.7 Principles of Joins
      • Ch5. Data Structure
    • Learning the Basics of Large-Scale System Design through Virtual Interview Cases
      • 1. Scalability based on user counts(1/2)
      • 1. Scalability based on user counts(2/2)
      • 2.Back-of-the-envelope estimation
      • 3. Strategies for System Design Interviews
      • 4. Rate Limiter
      • 5. Consistent Hashing
      • 6. Key-Value System Design
      • 7. Designing a Unique ID Generator for Distributed Systems
      • 8. Designing a URL Shortener
      • 9. Designing a Web Crawler
      • 10. Notification System Design
      • 11. Designing a News Feed System
      • 12. Chat System Design
      • 13. AutoComplete
      • 14. Design YouTube
      • 15. Design Google Drive
      • Loadbalancer Algorithms
      • Cache tier
      • CDN, Content Delivery Network
      • Stateless Web tier
    • Computer System A programmer's perspective
    • Effective Java
      • Item 1. Consider Static Factory Methods Instead of Constructors
      • Item 2. Consider a Builder When Faced with Many Constructor Parameters
      • Item 3. Ensure Singleton with Private Constructor or Enum Type
      • Item 4. Enforce Noninstantiability with a Private Constructor
      • Item 5. Prefer Dependency Injection to Hardwiring Resources
      • Item 6. Avoid Creating Unnecessary Objects
      • Item 7. Eliminate Obsolete Object References
      • Item 8. Avoid Finalizers and Cleaners
      • Item 9.Prefer try-with-resources to try-finally
      • Item10. Adhering to General Rules When Overriding equals
        • Handling Transitivity Issues
        • Ensuring Consistency
      • Item11. Override hashCode When You Override equals
      • Item12. Always Override toString
        • Always Override toString
      • Item13. Override Clone Judiciously
      • Item14. Consider Implementing Comparable
      • Item15. Minimize the Accessibility of Classes and Members
      • Item16. Accessor Methods Over Public Fields
      • Item17. Minimize Mutability
      • Item18. Composition over inherentance
      • Item19. Design and Document for Inheritance, or Else Prohibit It
      • Item20. Prefer Interfaces to Abstract Classes
      • Item21. Design Interfaces with Implementations in Mind
      • Item22. Use Interfaces Only to define Types
      • Item23. Prefer Class Hierarchies to Tagged Classes
      • Item24. Favor Static Member Classes Over Non-Static
      • Item28. Use Lists Instead of Arrays
      • Item29. Prefer Generic Types
      • Item30. Favor Generic Methods
    • Head First Design Patterns
      • Ch1. Strategy Pattern
      • Ch2. Observer Pattern
        • Ver1. Ch2. Observer Pattern
      • Ch3. Decorator Pattern
        • Ch3. Decorator Pattern
      • Ch4. Factory Pattern
      • Ch5. Singleton Pattern
      • Ch6. Command Pattern
      • Ch7. Adapter and Facade Pattern
      • Ch8. Template Method Pattern
    • Digging Deep into JVM
      • Chapter 2. Java Memory Area & Memory Overflow
      • Chapter 3. Garbage Collector & Memory Allocation Strategy (1/2)
      • Chapter 3. Garbage Collector & Memory Allocation Strategy (2/2)
      • Chapter 5. Optimization Practice
      • Chapter 6. Class file structure
  • Interview Practices
    • Restful API Practices
      • Url Shortener API
      • Event Ticket Reservation API
      • Course Management API
      • Search posts by tags API
      • Online Code platform API
      • Simple Task Management API
      • Event Participation API
      • Review System API
      • Car management API
      • Online Library
    • Naver Computer Science
      • Process & Thread
      • TCP & UDP
      • Spring & Servlet
      • Filter & Interceptor & AOP
      • Equals() & ==
      • Dependency Injection
  • F-Lab
    • Week1
      • Client & Server
      • HTTP
      • TCP/UDP
      • REST API
      • Questions
        • Object Oriented Programming
        • HTTP
        • Process & Thread
        • Data Structure
    • Week2
      • OSI 7 layer
      • Web vs WAS
    • Week3
      • RDB vs NoSQL
      • RDB Index
      • Cache
      • Redis
      • Messaging Queue
    • Week4
      • Project - Ecommerce
    • Week5
      • ERD - 1
    • Week6
      • Ecommerce - 2
      • Role
      • pw hashing && Salt
      • CreatedAt, ModifiedAt
      • JWT
      • Copy of ERD - 1
    • Week7
      • Vault (HashiCorp Vault)
    • Week 8
      • Api Endpoints
  • Week10
    • Product Create Workflow
  • TOY Project
    • CodeMentor
      • Implementation of Kafka
      • Implementation of K8s
      • Communication between servers in msa
  • JAVA
    • Java 101
      • JVM Structure
      • Java Compiles and Execution Method
      • Override, Overload
      • Interface vs Abstract Class
      • Primitive vs Object Type
      • Identity and equality
      • String, StringBuilder, StringBuffer
      • Checked Exceptions and Unchecked Exceptions
      • Java 8 methods
      • Try-with-reources
      • Strong Coupling and Loose Coupling
      • Serialization and Deserialization
      • Concurrency Programming in Java
      • Mutable vs Immutable
      • JDK vs JRE
    • Java Questions
      • Week 1(1/2) - Basic Java
      • Week 1(2/2) - OOP
      • Week 2(1/2) - String, Exception, Generic
      • Week2(2/2) Lambda, Stream, Annotation, Reflection
      • Week3(1/2) Collections
      • Week3(2/2) Threads
      • Week4 Java Concurrency Programming
      • Week5 JVM & GC
    • Batch delete instead of Cascade
    • Checked vs Unchecked Exception
    • Thread
    • Memory Visibility
    • Synchronized && ReentrantLock
    • Producer & Consumer
    • BlockingQueue
    • CAS (Compare and Set)
  • SPRING
    • Spring Questions
      • Spring Framework
      • Spring MVC & Web Request
      • AOP (Aspect-Oriented Programming)
      • Spring Boot
      • ORM & Data Access
      • Security
      • ETC
    • using profile name as variable
    • Template Method Pattern
    • Strategy Pattern
    • Proxy Pattern
    • @Transactional
    • Ioc container, di practice
  • Programming Paradigm
    • Declarative vs Imperative
  • JPA
    • Template Page
  • PYTHON
    • Icecream
  • FASTAPI
    • Template Page
  • COMPUTER SCIENCE
    • Computer Architecture 101
      • 3 components of a computer
      • RAM vs ROM
      • CPU vs GPU
      • SIMD
      • Two's complement
      • Harvard Architecture vs. von Neumann Architecture
      • The structure of a CPU.
      • Instruction cycle (CPU operation method)
      • Instruction pipelining
      • Bus
      • Memory area
      • Memory hierarchy structure
        • Reason for using memory hierarchy structure
      • Cache memory
      • L1, L2, L3 Cache
      • Locality of reference (cache)
      • Fixed-point vs Floating-point
        • epresentation of infinity and NaN (Not a Number) in floating-point
      • RISC vs CISC
      • Hamming code
      • Compiler
      • Linking
      • Compiler vs Interpreter
      • Mutex vs Semaphore
      • 32bit CPU and 64bit CPU
      • Local vs Static Variable
      • Page
  • OS
    • Operating System 101
      • Operating system
        • The role of the operating system
        • The composition of the operating system.
      • Process
        • In Linux, are all processes except the initial process child processes?
        • Zombie process, orphan process
        • (Linux) Daemon process
        • Process address space
        • Where are uninitialized variables stored?
        • Determination of the size of the Stack and Heap
        • Access speed of Stack vs Heap
        • Reason for memory space partitioning
        • Process of compiling a process
        • sudo kill -9 $CURRENT_PID
      • Thread
        • Composition of a thread's address space
      • Process vs Thread
        • Creation of processes and threads in Linux
      • Multiprocessing
        • Web Browser
        • Implementation of multiprocessing
        • Application areas of multiprocessing
      • Multithreading
        • Application areas of multithreading
      • Interrupt
        • HW / SW Interrupt
        • Method of handling interrupts
        • Occurrence of two or more interrupts simultaneously
      • Polling
      • Dual Mode
        • Reason for distinguishing between user mode and kernel mode
      • System call
        • Differentiation between system calls
        • Types of system calls
        • Execution process of a system call
      • Process Control Block (PCB)
        • PCB의 구조
        • 쓰레드는 PCB를 갖고 있을까?
        • 프로세스 메모리 구조
      • Context switching
        • Timing of context switching
        • Registers saved during context switching
        • Context switching in processes
        • Context switching in threads
        • Difference between context switching in processes and threads
        • Information of the current process during context switching
      • Interprocess Communication (IPC)
        • Cases where IPC is used
        • Process address space in IPC Shared Memory technique
        • Types of IPC
    • Operating System Questions
      • Week1 OS & How Computer Systems Work
      • Week2(1/2) Process
      • Week2(2/2) Thread
      • Week3 CPU Scheduling
      • Week4 Process Synchronize
      • Week5 Virtual Memory
  • LINUX
    • Template Page
  • SERVER
    • Template Page
  • NETWORK
    • Network 101
      • https://www.google.com
      • TCP vs UDP
      • Http vs Https
      • TLS Handshake 1.2
      • HTTP Method
      • CORS & SOP
      • Web Server Software
    • Network Questions
      • Week1 Computer Network Basic
      • Week2(1/3) Application Layer Protocol - HTTP
      • Week2(2/3) Application Layer Protocol - HTTPS
      • Week2(3/3) Application Layer Protocol - DNS
      • Week3 Application Layer
      • Week4 Transport Layer - UDP, TCP
      • Week5 Network Layer - IP Protocol
    • Blocking, NonBlocking and Sync, Async
    • HTTP 0.9-3.0
  • DATABASE
    • Database Questions
      • Week1 DBMS, RDBMS basics
      • Week2 SQL
      • Week3 Index
      • Week4 Anomaly, Functional Dependency, Normalization
      • Week5 DB Transaction, Recovery
    • Normalization
      • 1st Normal Form
      • 2nd Normal Form
      • 3rd Normal Form
    • Ensuring Data Consistency, Atomicity and UX Optimization (feat.Firebase)
    • Redis: Remote Dictionary Server
    • Enhancing Query Performance - User list
  • DATA STRUCTURE
    • Array vs Linked List
    • Counting Sort
  • GIT, Github
    • git clone, invalid path error
  • INFRA
    • Template Page
  • AWS
    • Server Log Archive Pipeline
    • Image Processing using Lambda
  • DOCKER
    • Docker commands
    • Python Executable Environment
    • Docker and VM
  • docker-compose
    • Kafka, Multi Broker
  • KUBERNATES
    • !Encountered Errors
      • my-sql restarts
      • kafka producer: disconnected
    • Kubernetes Components
    • Helm
      • Helm commands
    • Pod network
    • Service network
      • deployment.yaml
      • services.yaml
    • Service type
      • Cluster IP
      • NodePort
    • service-name-headless?
    • kube-proxy
    • Template Page
  • GraphQL
    • Template Page
  • WEB
    • Template Page
  • Reviews
    • Graphic Intern Review
    • Kakao Brain Pathfinder Review
    • JSCODE 자바 1기 Review
  • 😁Dev Jokes
    • Image
      • Plot twist
      • Priorities
      • SQL join guide
      • Google is generous
      • Genie dislikes cloud
      • buggy bugs
      • last day of unpaid internship
      • what if clients know how to inspect
      • its just game
      • how i wrote my achievement on resume
      • self explanatory
      • chr(sum(range(ord(min(str(not))))))
Powered by GitBook
On this page
  • 단일서버
  • 데이터베이스
  • 1. 어떤 데이터베이스를 사용할 것인가?
  • 2. 수직적 규모 확장 vs 수평적 규모 확장
  • 3. 로드밸런서
  • 4. 데이터베이스 다중화
  • 5. 로드밸런서와 데이터베이스 다중화를 고려한 설계안
  • 캐시
  • 1. 캐시 계층
  • 2. 캐시 사용 시 유의할 점
  • 콘텐츠 전송 네트워크 (CDN)
  • 1. CDN과 캐시가 추가된 설계
  • 2. CDN 사용 시 고려해야 할 사항
  1. Books
  2. Learning the Basics of Large-Scale System Design through Virtual Interview Cases

1. Scalability based on user counts(1/2)

사용자 수에 따른 규모 확장성

PreviousLearning the Basics of Large-Scale System Design through Virtual Interview CasesNext1. Scalability based on user counts(2/2)

Last updated 8 months ago

단일서버

단일 서버는 초기 웹 애플리케이션이나 스타트업에서 많이 사용됩니다. 이 서버는 웹 서버, 애플리케이션 서버, 데이터베이스 서버 등의 모든 컴퓨팅 자원을 한 곳에 통합합니다.

  • 초기 단계의 시스템:

    • 대부분의 스타트업이나 소규모 프로젝트는 단일 서버로 시작합니다. 이는 시스템의 단순성과 낮은 초기 비용 때문에 선택됩니다.

  • 단일 서버의 장점:

    • 단순성: 모든 구성 요소가 하나의 서버에 통합되어 있어 관리가 용이합니다.

    • 비용 효율성: 추가적인 인프라가 필요 없으므로 초기 비용이 저렴합니다.

    • 빠른 배포: 초기 설정과 배포가 빠르게 이루어질 수 있습니다.

  • 단일 서버의 단점:

    • 확장성의 한계: 서버의 자원이 한정되어 있어 트래픽 증가 시 성능 저하가 발생할 수 있습니다.

    • 단일 장애 지점: 서버 장애 시 전체 시스템이 다운될 수 있습니다.

    • 유지보수 어려움: 트래픽 증가에 따라 점점 더 많은 성능 최적화와 유지보수가 필요합니다.

데이터베이스

1. 어떤 데이터베이스를 사용할 것인가?

데이터베이스는 시스템의 특성과 요구사항에 따라 선택해야 합니다. 대표적인 데이터베이스 유형은 다음과 같습니다:

  • 관계형 데이터베이스 (RDBMS):

    • 예: MySQL, PostgreSQL

    • 특징: ACID(Atomicity, Consistency, Isolation, Durability) 속성을 지원하여 데이터 일관성이 보장됩니다.

    • 장점: 복잡한 쿼리와 트랜잭션 관리가 용이합니다.

    • 단점: 수평적 확장이 어렵고, 대규모 데이터 처리에 한계가 있을 수 있습니다.

  • NoSQL 데이터베이스:

    • 예: MongoDB, Cassandra

    • 특징: 스키마리스 구조를 가지며, 대규모 데이터와 높은 읽기/쓰기 성능에 최적화되어 있습니다.

    • 장점: 수평적 확장이 용이하고, 다양한 데이터 모델(Key-Value, Document, Column-Family 등)을 지원합니다.

    • 단점: 트랜잭션 관리가 복잡할 수 있으며, 데이터 일관성 보장이 어려울 수 있습니다.

예를 들어, 전자상거래 웹사이트에서 수직적 확장은 기존 데이터베이스 서버의 CPU와 메모리를 업그레이드하는 것입니다. 수평적 확장은 고객 주문 데이터를 여러 데이터베이스 서버에 분산 저장하여 각 서버가 병렬로 처리할 수 있도록 합니다.

2. 수직적 규모 확장 vs 수평적 규모 확장

  • 수직적 확장 (Vertical Scaling):

    • 정의: 기존 서버의 하드웨어 성능(CPU, RAM, Storage 등)을 업그레이드하여 처리 능력을 향상시키는 방식입니다.

    • 장점: 구현이 간단하며, 기존 애플리케이션의 수정이 거의 필요 없습니다.

    • 단점: 하드웨어 업그레이드에 한계가 있으며, 비용이 기하급수적으로 증가할 수 있습니다.

  • 수평적 확장 (Horizontal Scaling):

    • 정의: 여러 서버를 추가하여 시스템의 성능을 향상시키는 방법입니다. 데이터베이스 샤딩이나 파티셔닝을 통해 데이터를 여러 서버에 분산 저장하고, 트래픽을 분산 처리합니다.

    • 장점: 무한한 확장 가능성을 제공하며, 고가용성과 장애 복구에 유리합니다.

    • 단점: 시스템 복잡성이 증가하며, 데이터 일관성 유지가 어려울 수 있습니다.

3. 로드밸런서

  • 기능:

    • 클라이언트 요청을 여러 서버에 분산시켜 시스템의 성능과 가용성을 높이고, 서버 간 부하를 균등하게 유지합니다.

  • 장점:

    • 고가용성: 하나의 서버가 다운되더라도 다른 서버가 요청을 처리할 수 있습니다.

    • 성능향상: 각 서버에 고르게 트래픽을 분산시킵니다. (병목 현상을 줄입니다.)

  • 단점:

    • 설정 및 관리 복잡성: 적절한 설정과 유지보수가 필요합니다.

    • 단일 장애 지점 가능성: 로드밸런서 자체가 장애를 일으키면 전체 시스템이 영향을 받을 수 있습니다.

로드밸런서는 주로 네트워크 레벨에서 동작하며, 하드웨어 장비 또는 소프트웨어로 구현할 수 있습니다. 소프트웨어 로드밸런서로는 NGINX, HAProxy 등이 있습니다.

4. 데이터베이스 다중화

데이터베이스 다중화는 여러 데이터베이스 서버를 구성하여 성능과 가용성을 높이는 방법입니다.

  • 데이터베이스 복제:

    • 데이터를 여러 서버에 복제하여 읽기 성능을 향상시키고, 데이터 손실을 방지합니다.

    • 유형: 마스터-슬레이브 복제, 멀티-마스터 복제

    • 장점: 읽기 성능 향상, 데이터 손실 방지

    • 단점: 데이터 일관성 유지의 어려움

  • 샤딩:

    • 데이터를 여러 샤드로 분할하여 저장하고, 각 샤드는 독립적인 데이터베이스 인스턴스를 가집니다.

    • 장점: 수평적 확장이 용이하며, 대규모 데이터를 효율적으로 관리할 수 있습니다.

    • 단점: 샤드 간 데이터 조인이 어려우며, 샤딩 전략 설계가 복잡할 수 있습니다.

예를 들어, 소셜 네트워크 서비스에서 마스터-슬레이브 복제를 사용하면 사용자가 게시물을 작성할 때 마스터 데이터베이스가 처리하고, 다른 사용자가 게시물을 조회할 때 슬레이브 데이터베이스가 처리하여 성능을 최적화할 수 있습니다.

5. 로드밸런서와 데이터베이스 다중화를 고려한 설계안

캐시

캐시는 데이터베이스의 부하를 줄이고 응답 속도를 향상시키기 위해 사용됩니다. 캐시 계층은 자주 요청되는 데이터를 메모리에 저장하여 빠르게 접근할 수 있도록 합니다.

  • 기능:

    • 자주 사용되는 데이터를 메모리에 저장하여 데이터베이스의 부하를 줄이고, 응답 시간을 단축합니다.

  • 사용 예:

    • Redis, Memcached

  • 장점:

    • 빠른 데이터 접근: 메모리에서 직접 데이터를 읽기 때문에 응답 속도가 매우 빠릅니다.

    • 데이터베이스 부하 감소: 자주 사용되는 데이터를 캐시에 저장함으로써 데이터베이스에 대한 읽기 요청을 줄입니다.

  • 단점:

    • 데이터 일관성 문제: 데이터베이스와 캐시 사이의 데이터 일관성을 유지하는 것이 중요합니다.

    • 캐시 만료 전략: TTL(Time To Live) 설정을 통해 캐시 데이터를 주기적으로 갱신합니다.

1. 캐시 계층

  • 클라이언트 측 캐시: 웹 브라우저나 모바일 애플리케이션에서 데이터를 캐시합니다. HTML, CSS, JavaScript 파일과 같은 정적 리소스를 캐시하여 페이지 로딩 속도를 향상시킵니다.

  • 서버 측 캐시: 웹 서버나 애플리케이션 서버에서 데이터를 캐시합니다. 자주 요청되는 데이터베이스 쿼리 결과나 API 응답을 캐시하여 서버 부하를 줄이고 응답 속도를 높입니다.

  • 분산 캐시: 여러 서버에서 캐시 데이터를 공유하여 고가용성과 확장성을 제공합니다. 분산 캐시는 대규모 시스템에서 효과적으로 사용됩니다.

2. 캐시 사용 시 유의할 점

  • 일관성 유지(캐시 무효화 전략):

    • 데이터베이스와 캐시 간의 일관성을 유지하기 위한 전략이 필요합니다. 예를 들어, 데이터베이스 업데이트 시 캐시를 무효화하거나 갱신하는 방법을 사용합니다.

  • 캐시 용량 관리:

    • 캐시의 용량을 초과하지 않도록 주기적으로 캐시 데이터를 관리해야 합니다. LRU(Least Recently Used) 알고리즘을 사용하여 오래 사용되지 않은 캐시 데이터를 제거하는 방법이 있습니다.

  • 적절한 캐시 만료 시간 설정:

    • 캐시 데이터의 유효 기간을 적절히 설정하여 최신 데이터를 유지할 수 있도록 합니다. 만료기간이 너무 짧으면 캐시의 효과가 감소하고, 너무 길면 오래된 데이터를 제공할 수 있습니다.

  • 장애 대처:

    • 캐시 서버를 한 대만 두는 경우 해당 서버는 단일 장애 지점(Single Point of Faiure, SPOF)가 되어버릴 가능성이 있다. 이를 피하기 위해ㅐ 여러 지역에 걸쳐 캐시 서버를 분산시켜야 한다.

콘텐츠 전송 네트워크 (CDN)

CDN은 전 세계 여러 지점에 캐시 서버를 두어 사용자에게 콘텐츠를 빠르게 전달합니다. CDN은 다음과 같은 기능을 제공합니다:

  • 정적 콘텐츠 배포: 이미지, CSS, JavaScript 파일과 같은 정적 콘텐츠를 캐시하여 서버의 부하를 줄이고, 사용자가 지리적으로 가까운 캐시 서버에서 콘텐츠를 받아 응답 시간을 단축합니다.

  • 트래픽 부하 분산: 트래픽을 여러 캐시 서버로 분산시켜 서버의 부하를 줄이고, 높은 트래픽을 효율적으로 처리합니다.

  • 가용성 향상: 하나의 캐시 서버에 장애가 발생하더라도 다른 캐시 서버에서 콘텐츠를 제공하여 서비스 가용성을 높입니다.

1. CDN과 캐시가 추가된 설계

2. CDN 사용 시 고려해야 할 사항

  • 지리적 분산:

    • CDN은 전 세계에 분산된 서버 네트워크를 사용하여 사용자에게 가장 가까운 서버에서 콘텐츠를 제공합니다. 이는 콘텐츠 전송 속도를 크게 향상시킵니다.

  • 비용:

    • CDN 서비스의 비용을 고려해야 합니다. 트래픽 양에 따라 비용이 달라질 수 있습니다.

  • 캐시 정책:

    • CDN의 캐시 정책을 설정하여 최신 콘텐츠를 사용자에게 제공할 수 있도록 합니다. 이는 캐시 만료 시간(TTL) 및 캐시 무효화 전략을 포함합니다.

  • 보안:

    • CDN 사용 시 데이터 전송의 보안도 고려해야 합니다. SSL 인증서 적용 및 DDoS 공격 방어 기능 등을 확인해야 합니다.